diff --git a/slang_backend.cpp b/slang_backend.cpp
index 27a72f9..b6ed635 100644
--- a/slang_backend.cpp
+++ b/slang_backend.cpp
@@ -20,6 +20,7 @@
 #include <vector>
 
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclGroup.h"
 
@@ -420,22 +421,28 @@
 
   for (clang::DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; I++) {
     clang::FunctionDecl *FD = llvm::dyn_cast<clang::FunctionDecl>(*I);
-    // Process any non-static function declarations
-    if (FD && FD->isGlobal()) {
-      // Check that we don't have any array parameters being misintrepeted as
-      // kernel pointers due to the C type system's array to pointer decay.
-      size_t numParams = FD->getNumParams();
-      for (size_t i = 0; i < numParams; i++) {
-        const clang::ParmVarDecl *PVD = FD->getParamDecl(i);
-        clang::QualType QT = PVD->getOriginalType();
-        if (QT->isArrayType()) {
-          mContext->ReportError(
-              PVD->getTypeSpecStartLoc(),
-              "exported function parameters may not have array type: %0")
-              << QT;
-        }
+    if (FD) {
+      if (!FD->hasAttr<clang::UsedAttr>() && mContext->isReferencedByReducePragma(FD)) {
+        // Handle forward reference from pragma (see RSReducePragmaHandler::HandlePragma
+        // for backward reference).
+        FD->addAttr(clang::UsedAttr::CreateImplicit(mContext->getASTContext()));
       }
-      AnnotateFunction(FD);
+      if (FD->isGlobal()) {
+        // Check that we don't have any array parameters being misinterpreted as
+        // kernel pointers due to the C type system's array to pointer decay.
+        size_t numParams = FD->getNumParams();
+        for (size_t i = 0; i < numParams; i++) {
+          const clang::ParmVarDecl *PVD = FD->getParamDecl(i);
+          clang::QualType QT = PVD->getOriginalType();
+          if (QT->isArrayType()) {
+            mContext->ReportError(
+                PVD->getTypeSpecStartLoc(),
+                "exported function parameters may not have array type: %0")
+                << QT;
+          }
+        }
+        AnnotateFunction(FD);
+      }
     }
 
     if (getTargetAPI() == SLANG_DEVELOPMENT_TARGET_API) {
@@ -461,6 +468,9 @@
 void Backend::HandleTranslationUnitPre(clang::ASTContext &C) {
   clang::TranslationUnitDecl *TUDecl = C.getTranslationUnitDecl();
 
+  if (!mContext->processReducePragmas())
+    return;
+
   // If we have an invalid RS/FS AST, don't check further.
   if (!mASTChecker.Validate()) {
     return;
@@ -825,20 +835,24 @@
        I != E; ++I) {
     ExportReduceNewInfo.clear();
 
-    addString(0, (*I)->getNameReduce());
-    addString(1, (*I)->getNameInitializer());
+    int Idx = 0;
+
+    addString(Idx++, (*I)->getNameReduce());
+
+    addOperand(Idx++, llvm::MDString::get(mLLVMContext, llvm::utostr_32((*I)->getAccumulatorTypeSize())));
 
     llvm::SmallVector<llvm::Metadata *, 2> Accumulator;
     Accumulator.push_back(
       llvm::MDString::get(mLLVMContext, (*I)->getNameAccumulator()));
     Accumulator.push_back(llvm::MDString::get(
       mLLVMContext,
-      llvm::utostr_32(0))); // TODO: emit actual accumulator signature bits
-    addOperand(2, llvm::MDTuple::get(mLLVMContext, Accumulator));
+      llvm::utostr_32((*I)->getAccumulatorSignatureMetadata())));
+    addOperand(Idx++, llvm::MDTuple::get(mLLVMContext, Accumulator));
 
-    addString(3, (*I)->getNameCombiner(), false);
-    addString(4, (*I)->getNameOutConverter(), false);
-    addString(5, (*I)->getNameHalter(), false);
+    addString(Idx++, (*I)->getNameInitializer(), false);
+    addString(Idx++, (*I)->getNameCombiner(), false);
+    addString(Idx++, (*I)->getNameOutConverter(), false);
+    addString(Idx++, (*I)->getNameHalter(), false);
 
     mExportReduceNewMetadata->addOperand(
       llvm::MDTuple::get(mLLVMContext, ExportReduceNewInfo));
@@ -910,9 +924,8 @@
     M->setDataLayout("e-p:32:32-i64:64-v128:64:128-n32-S64");
   }
 
-  if (!mContext->processExports()) {
+  if (!mContext->processExports())
     return;
-  }
 
   if (mContext->hasExportVar())
     dumpExportVarInfo(M);
diff --git a/slang_rs_context.cpp b/slang_rs_context.cpp
index 870521d..1da42b7 100644
--- a/slang_rs_context.cpp
+++ b/slang_rs_context.cpp
@@ -110,11 +110,7 @@
     return true;
   }
 
-  if (FD->getStorageClass() != clang::SC_None) {
-    fprintf(stderr, "RSContext::processExportFunc : cannot export extern or "
-                    "static function '%s'\n", FD->getName().str().c_str());
-    return false;
-  }
+  slangAssert(FD->getStorageClass() == clang::SC_None);
 
   // Specialized function
   if (RSSpecialFunc::isSpecialRSFunc(mTargetAPI, FD)) {
@@ -296,6 +292,28 @@
   return valid;
 }
 
+bool RSContext::processReducePragmas() {
+  bool valid = true;
+  for (auto I = export_reduce_new_begin(), E = export_reduce_new_end(); I != E; ++I) {
+    if (! (*I)->analyzeTranslationUnit())
+      valid = false;
+  }
+  return valid;
+}
+
+bool RSContext::isReferencedByReducePragma(const clang::FunctionDecl *FD) const {
+  // This is an inefficient linear search.  If this turns out to be a
+  // problem in practice, then processReducePragmas() could build a
+  // set or hash table or something similar containing all function
+  // names mentioned in a reduce pragma and searchable in O(c) or
+  // O(log(n)) time rather than the currently-implemented O(n) search.
+  for (auto I = export_reduce_new_begin(), E = export_reduce_new_end(); I != E; ++I) {
+    if ((*I)->matchName(FD->getName()))
+      return true;
+  }
+  return false;
+}
+
 bool RSContext::insertExportType(const llvm::StringRef &TypeName,
                                  RSExportType *ET) {
   ExportTypeMap::value_type *NewItem =
diff --git a/slang_rs_context.h b/slang_rs_context.h
index 91fdef4..694b737 100644
--- a/slang_rs_context.h
+++ b/slang_rs_context.h
@@ -21,6 +21,7 @@
 #include <list>
 #include <map>
 #include <string>
+#include <unordered_set>
 #include <vector>
 
 #include "clang/Lex/Preprocessor.h"
@@ -44,6 +45,7 @@
   class QualType;
   class SourceManager;
   class TypeDecl;
+  class FunctionDecl;
 }   // namespace clang
 
 namespace slang {
@@ -67,6 +69,10 @@
   typedef std::vector<RSExportForEach*> ExportForEachVector;
   typedef std::list<RSExportReduce*> ExportReduceList;
   typedef std::list<RSExportReduceNew*> ExportReduceNewList;
+
+  // WARNING: Sorted by pointer value, resulting in unpredictable order
+  typedef std::unordered_set<RSExportType*> ExportReduceNewResultTypeSet;
+
   typedef llvm::StringMap<RSExportType*> ExportTypeMap;
 
  private:
@@ -111,6 +117,7 @@
   ExportForEachVector mExportForEach;
   ExportReduceList mExportReduce;
   ExportReduceNewList mExportReduceNew;
+  ExportReduceNewResultTypeSet mExportReduceNewResultType;
   ExportTypeMap mExportTypes;
 
   clang::QualType mAllocationType;
@@ -244,6 +251,18 @@
   void addExportReduceNew(RSExportReduceNew *ReduceNew) {
     mExportReduceNew.push_back(ReduceNew);
   }
+  bool processReducePragmas();
+  bool isReferencedByReducePragma(const clang::FunctionDecl *FD) const;
+
+  // If the type has already been inserted, has no effect.
+  void insertExportReduceNewResultType(RSExportType *Type) { mExportReduceNewResultType.insert(Type); }
+
+  template <class Compare>
+  std::vector<RSExportType *> getReduceNewResultTypesByName(Compare Comp) const {
+    std::vector<RSExportType *> Return(mExportReduceNewResultType.begin(), mExportReduceNewResultType.end());
+    std::sort(Return.begin(), Return.end(), Comp);
+    return Return;
+  }
 
   typedef ExportTypeMap::iterator export_type_iterator;
   typedef ExportTypeMap::const_iterator const_export_type_iterator;
diff --git a/slang_rs_export_reduce.cpp b/slang_rs_export_reduce.cpp
index e927bd0..9133476 100644
--- a/slang_rs_export_reduce.cpp
+++ b/slang_rs_export_reduce.cpp
@@ -17,6 +17,7 @@
 #include "slang_rs_export_reduce.h"
 
 #include <algorithm>
+#include <sstream>
 #include <string>
 
 #include "clang/AST/Attr.h"
@@ -25,8 +26,11 @@
 #include "slang_assert.h"
 #include "slang_rs_context.h"
 #include "slang_rs_export_type.h"
+#include "slang_rs_object_ref_count.h"
+#include "slang_rs_special_kernel_param.h"
 #include "slang_version.h"
 
+#include "bcinfo/MetadataExtractor.h"
 
 namespace {
 
@@ -181,6 +185,24 @@
   return KernelAttrOrNull && KernelAttrOrNull->getKernelKind().equals("reduce");
 }
 
+///////////////////////////////////////////////////////////////////////////////////////
+
+const char RSExportReduceNew::KeyReduce[] = "reduce";
+const char RSExportReduceNew::KeyInitializer[] = "initializer";
+const char RSExportReduceNew::KeyAccumulator[] = "accumulator";
+const char RSExportReduceNew::KeyCombiner[] = "combiner";
+const char RSExportReduceNew::KeyOutConverter[] = "outconverter";
+const char RSExportReduceNew::KeyHalter[] = "halter";
+
+bool RSExportReduceNew::matchName(const llvm::StringRef &Candidate) const {
+  return
+      Candidate.equals(mNameInitializer)  ||
+      Candidate.equals(mNameAccumulator)  ||
+      Candidate.equals(mNameCombiner)     ||
+      Candidate.equals(mNameOutConverter) ||
+      Candidate.equals(mNameHalter);
+}
+
 RSExportReduceNew *RSExportReduceNew::Create(RSContext *Context,
                                              const clang::SourceLocation Location,
                                              const llvm::StringRef &NameReduce,
@@ -202,4 +224,730 @@
   return RNE;
 }
 
+const char *RSExportReduceNew::getKey(FnIdent Kind) {
+  switch (Kind) {
+    default:
+      slangAssert(!"Unknown FnIdent");
+      // and fall through
+    case FN_IDENT_INITIALIZER:
+      return KeyInitializer;
+    case FN_IDENT_ACCUMULATOR:
+      return KeyAccumulator;
+    case FN_IDENT_COMBINER:
+      return KeyCombiner;
+    case FN_IDENT_OUT_CONVERTER:
+      return KeyOutConverter;
+    case FN_IDENT_HALTER:
+      return KeyHalter;
+  }
+}
+
+// This data is needed during analyzeTranslationUnit() but not afterwards.
+// Breaking it out into a struct makes it easy for analyzeTranslationUnit()
+// to call a number of helper functions that all need access to this data.
+struct RSExportReduceNew::StateOfAnalyzeTranslationUnit {
+
+  typedef std::function<std::string (const char *Key, const std::string &Name)> DiagnosticDescriptionType;
+
+  StateOfAnalyzeTranslationUnit(
+      RSContext &anRSContext,
+      clang::Preprocessor &aPP,
+      clang::ASTContext &anASTContext,
+      const DiagnosticDescriptionType &aDiagnosticDescription) :
+
+      RSC(anRSContext),
+      PP(aPP),
+      ASTC(anASTContext),
+      DiagnosticDescription(aDiagnosticDescription),
+
+      Ok(true),
+
+      FnInitializer(nullptr),
+      FnAccumulator(nullptr),
+      FnCombiner(nullptr),
+      FnOutConverter(nullptr),
+      FnHalter(nullptr),
+
+      FnInitializerParam(nullptr),
+      FnInitializerParamTy(),
+
+      FnAccumulatorOk(true),
+      FnAccumulatorParamFirst(nullptr),
+      FnAccumulatorParamFirstTy(),
+      FnAccumulatorIndexOfFirstSpecialParameter(0),
+
+      FnOutConverterOk(true),
+      FnOutConverterParamFirst(nullptr),
+      FnOutConverterParamFirstTy()
+  { }
+
+  /*-- Convenience ------------------------------------------*/
+
+  RSContext                       &RSC;
+  clang::Preprocessor             &PP;
+  clang::ASTContext               &ASTC;
+  const DiagnosticDescriptionType  DiagnosticDescription;
+
+  /*-- Actual state -----------------------------------------*/
+
+  bool Ok;
+
+  clang::FunctionDecl *FnInitializer;
+  clang::FunctionDecl *FnAccumulator;
+  clang::FunctionDecl *FnCombiner;
+  clang::FunctionDecl *FnOutConverter;
+  clang::FunctionDecl *FnHalter;
+
+  clang::ParmVarDecl  *FnInitializerParam;
+  clang::QualType      FnInitializerParamTy;
+
+  bool                 FnAccumulatorOk;
+  clang::ParmVarDecl  *FnAccumulatorParamFirst;
+  clang::QualType      FnAccumulatorParamFirstTy;
+  size_t               FnAccumulatorIndexOfFirstSpecialParameter;
+
+  bool                 FnOutConverterOk;  // also true if no outconverter
+  clang::ParmVarDecl  *FnOutConverterParamFirst;
+  clang::QualType      FnOutConverterParamFirstTy;
+};
+
+// does update S.Ok
+clang::FunctionDecl *RSExportReduceNew::lookupFunction(StateOfAnalyzeTranslationUnit &S,
+                                                       const char *Kind, const llvm::StringRef &Name) {
+  if (Name.empty())
+    return nullptr;
+
+  clang::TranslationUnitDecl *TUDecl = getRSContext()->getASTContext().getTranslationUnitDecl();
+  slangAssert(TUDecl);
+
+  clang::FunctionDecl *Ret = nullptr;
+  const clang::IdentifierInfo *II = S.PP.getIdentifierInfo(Name);
+  if (II) {
+    for (auto Decl : TUDecl->lookup(II)) {
+      clang::FunctionDecl *FDecl = Decl->getAsFunction();
+      if (!FDecl || !FDecl->isThisDeclarationADefinition())
+        continue;
+      if (Ret) {
+        S.RSC.ReportError(mLocation,
+                          "duplicate function definition for '%0(%1)' for '#pragma rs %2(%3)' (%4, %5)")
+            << Kind << Name << KeyReduce << mNameReduce
+            << Ret->getLocation().printToString(S.PP.getSourceManager())
+            << FDecl->getLocation().printToString(S.PP.getSourceManager());
+        S.Ok = false;
+        return nullptr;
+      }
+      Ret = FDecl;
+    }
+  }
+  if (!Ret) {
+    // Either the identifier lookup failed, or we never found the function definition.
+    S.RSC.ReportError(mLocation,
+                      "could not find function definition for '%0(%1)' for '#pragma rs %2(%3)'")
+        << Kind << Name << KeyReduce << mNameReduce;
+    S.Ok = false;
+    return nullptr;
+  }
+  if (Ret) {
+    // Must have internal linkage
+    if (Ret->getFormalLinkage() != clang::InternalLinkage) {
+      S.RSC.ReportError(Ret->getLocation(), "%0 must be static")
+          << S.DiagnosticDescription(Kind, Name);
+      S.Ok = false;
+    }
+  }
+  if (Ret == nullptr)
+    S.Ok = false;
+  return Ret;
+}
+
+// updates S.Ok; and, depending on Kind, possibly S.FnAccumulatorOk or S.FnOutConverterOk
+void RSExportReduceNew::notOk(StateOfAnalyzeTranslationUnit &S, FnIdent Kind) {
+    S.Ok = false;
+    if (Kind == FN_IDENT_ACCUMULATOR) {
+      S.FnAccumulatorOk = false;
+    } else if (Kind == FN_IDENT_OUT_CONVERTER) {
+      S.FnOutConverterOk = false;
+    }
+}
+
+// updates S.Ok; and, depending on Kind, possibly S.FnAccumulatorOk or S.FnOutConverterOk
+void RSExportReduceNew::checkVoidReturn(StateOfAnalyzeTranslationUnit &S,
+                                        FnIdent Kind, clang::FunctionDecl *Fn) {
+  slangAssert(Fn);
+  const clang::QualType ReturnTy = Fn->getReturnType().getCanonicalType();
+  if (!ReturnTy->isVoidType()) {
+    S.RSC.ReportError(Fn->getLocation(),
+                      "%0 must return void not '%1'")
+        << S.DiagnosticDescription(getKey(Kind), Fn->getName()) << ReturnTy.getAsString();
+    notOk(S, Kind);
+  }
+}
+
+// updates S.Ok; and, depending on Kind, possibly S.FnAccumulatorOk or S.FnOutConverterOk
+void RSExportReduceNew::checkPointeeConstQualified(StateOfAnalyzeTranslationUnit &S,
+                                                   FnIdent Kind, const llvm::StringRef &Name,
+                                                   const clang::ParmVarDecl *Param, bool ExpectedQualification) {
+  const clang::QualType ParamQType = Param->getType();
+  slangAssert(ParamQType->isPointerType());
+  const clang::QualType PointeeQType = ParamQType->getPointeeType();
+  if (PointeeQType.isConstQualified() != ExpectedQualification) {
+    S.RSC.ReportError(Param->getLocation(),
+                      "%0 parameter '%1' (type '%2') must%3 point to const-qualified type")
+        << S.DiagnosticDescription(getKey(Kind), Name)
+        << Param->getName() << ParamQType.getAsString()
+        << (ExpectedQualification ? "" : " not");
+    notOk(S, Kind);
+  }
+}
+
+// Process "void mNameInitializer(compType *accum)"
+void RSExportReduceNew::analyzeInitializer(StateOfAnalyzeTranslationUnit &S) {
+  if (!S.FnInitializer) // initializer is always optional
+    return;
+
+  // Must return void
+  checkVoidReturn(S, FN_IDENT_INITIALIZER, S.FnInitializer);
+
+  // Must have exactly one parameter
+  if (S.FnInitializer->getNumParams() != 1) {
+    S.RSC.ReportError(S.FnInitializer->getLocation(),
+                      "%0 must take exactly 1 parameter (found %1)")
+        << S.DiagnosticDescription(KeyInitializer, mNameInitializer)
+        << S.FnInitializer->getNumParams();
+    S.Ok = false;
+    return;
+  }
+
+  // Parameter must not be a special parameter
+  S.FnInitializerParam = S.FnInitializer->getParamDecl(0);
+  if (isSpecialKernelParameter(S.FnInitializerParam->getName())) {
+    S.RSC.ReportError(S.FnInitializer->getLocation(),
+                      "%0 cannot take special parameter '%1'")
+        << S.DiagnosticDescription(KeyInitializer, mNameInitializer)
+        << S.FnInitializerParam->getName();
+    S.Ok = false;
+    return;
+  }
+
+  // Parameter must be of pointer type
+  S.FnInitializerParamTy = S.FnInitializerParam->getType().getCanonicalType();
+  if (!S.FnInitializerParamTy->isPointerType()) {
+    S.RSC.ReportError(S.FnInitializer->getLocation(),
+                      "%0 parameter '%1' must be of pointer type not '%2'")
+        << S.DiagnosticDescription(KeyInitializer, mNameInitializer)
+        << S.FnInitializerParam->getName() << S.FnInitializerParamTy.getAsString();
+    S.Ok = false;
+    return;
+  }
+
+  // Parameter must not point to const-qualified
+  checkPointeeConstQualified(S, FN_IDENT_INITIALIZER, mNameInitializer, S.FnInitializerParam, false);
+}
+
+// Process "void mNameAccumulator(compType *accum, in1Type in1, …, inNType inN[, specialarguments])"
+void RSExportReduceNew::analyzeAccumulator(StateOfAnalyzeTranslationUnit &S) {
+  slangAssert(S.FnAccumulator);
+
+  // Must return void
+  checkVoidReturn(S, FN_IDENT_ACCUMULATOR, S.FnAccumulator);
+
+  // Must have initial parameter of same type as initializer parameter
+  // (if there is an initializer), followed by at least 1 input
+
+  if (S.FnAccumulator->getNumParams() < 2) {
+    S.RSC.ReportError(S.FnAccumulator->getLocation(),
+                      "%0 must take at least 2 parameters")
+        << S.DiagnosticDescription(KeyAccumulator, mNameAccumulator);
+    S.Ok = S.FnAccumulatorOk = false;
+    return;
+  }
+
+  S.FnAccumulatorParamFirst = S.FnAccumulator->getParamDecl(0);
+  S.FnAccumulatorParamFirstTy = S.FnAccumulatorParamFirst->getType().getCanonicalType();
+
+  // First parameter must be of pointer type
+  if (!S.FnAccumulatorParamFirstTy->isPointerType()) {
+    S.RSC.ReportError(S.FnAccumulator->getLocation(),
+                      "%0 parameter '%1' must be of pointer type not '%2'")
+        << S.DiagnosticDescription(KeyAccumulator, mNameAccumulator)
+        << S.FnAccumulatorParamFirst->getName() << S.FnAccumulatorParamFirstTy.getAsString();
+    S.Ok = S.FnAccumulatorOk = false;
+    return;
+  }
+
+  // If there is an initializer with a pointer-typed parameter (as
+  // opposed to an initializer with a bad parameter list), then
+  // accumulator first parameter must be of same type as initializer
+  // parameter
+  if (S.FnInitializer &&
+      !S.FnInitializerParamTy.isNull() &&
+      S.FnInitializerParamTy->isPointerType() &&
+      !S.FnAccumulator->getASTContext().hasSameUnqualifiedType(
+          S.FnInitializerParamTy->getPointeeType().getCanonicalType(),
+          S.FnAccumulatorParamFirstTy->getPointeeType().getCanonicalType())) {
+    // <accumulator> parameter '<baz>' (type '<tbaz>') and initializer <goo>() parameter '<gaz>' (type '<tgaz>')
+    //   must be pointers to the same type
+    S.RSC.ReportError(S.FnAccumulator->getLocation(),
+                      "%0 parameter '%1' (type '%2') and %3 %4() parameter '%5' (type '%6')"
+                      " must be pointers to the same type")
+        << S.DiagnosticDescription(KeyAccumulator, mNameAccumulator)
+        << S.FnAccumulatorParamFirst->getName() << S.FnAccumulatorParamFirstTy.getAsString()
+        << KeyInitializer << mNameInitializer
+        << S.FnInitializerParam->getName() << S.FnInitializerParamTy.getAsString();
+    S.Ok = S.FnAccumulatorOk = false;
+  }
+
+  if (S.FnAccumulatorOk && S.FnAccumulatorParamFirstTy->getPointeeType()->isFunctionType()) {
+    S.RSC.ReportError(S.FnAccumulator->getLocation(),
+                      "%0 parameter '%1' (type '%2') must not be pointer to function type")
+        << S.DiagnosticDescription(KeyAccumulator, mNameAccumulator)
+        << S.FnAccumulatorParamFirst->getName() << S.FnAccumulatorParamFirstTy.getAsString();
+    S.Ok = S.FnAccumulatorOk = false;
+  }
+
+  if (S.FnAccumulatorOk && S.FnAccumulatorParamFirstTy->getPointeeType()->isIncompleteType()) {
+    S.RSC.ReportError(S.FnAccumulator->getLocation(),
+                      "%0 parameter '%1' (type '%2') must not be pointer to incomplete type")
+        << S.DiagnosticDescription(KeyAccumulator, mNameAccumulator)
+        << S.FnAccumulatorParamFirst->getName() << S.FnAccumulatorParamFirstTy.getAsString();
+    S.Ok = S.FnAccumulatorOk = false;
+  }
+
+  if (S.FnAccumulatorOk &&
+      HasRSObjectType(S.FnAccumulatorParamFirstTy->getPointeeType().getCanonicalType().getTypePtr())) {
+    S.RSC.ReportError(S.FnAccumulator->getLocation(),
+                      "%0 parameter '%1' (type '%2') must not be pointer to data containing an object type")
+        << S.DiagnosticDescription(KeyAccumulator, mNameAccumulator)
+        << S.FnAccumulatorParamFirst->getName() << S.FnAccumulatorParamFirstTy.getAsString();
+    S.Ok = S.FnAccumulatorOk = false;
+  }
+
+  // Parameter must not point to const-qualified
+  checkPointeeConstQualified(S, FN_IDENT_ACCUMULATOR, mNameAccumulator, S.FnAccumulatorParamFirst, false);
+
+  // Analyze special parameters
+  S.Ok &= (S.FnAccumulatorOk &= processSpecialKernelParameters(
+                                  &S.RSC,
+                                  std::bind(S.DiagnosticDescription, KeyAccumulator, mNameAccumulator),
+                                  S.FnAccumulator,
+                                  &S.FnAccumulatorIndexOfFirstSpecialParameter,
+                                  &mAccumulatorSignatureMetadata));
+
+  // Must have at least an accumulator and an input.
+  // If we get here we know there are at least 2 arguments; so the only problem case is
+  // where we have an accumulator followed immediately by a special parameter.
+  if (S.FnAccumulatorIndexOfFirstSpecialParameter < 2) {
+    slangAssert(S.FnAccumulatorIndexOfFirstSpecialParameter < S.FnAccumulator->getNumParams());
+    S.RSC.ReportError(S.FnAccumulator->getLocation(),
+                      "%0 must have at least 1 input ('%1' is a special parameter)")
+        << S.DiagnosticDescription(KeyAccumulator, mNameAccumulator)
+        << S.FnAccumulator->getParamDecl(S.FnAccumulatorIndexOfFirstSpecialParameter)->getName();
+    S.Ok = S.FnAccumulatorOk = false;
+    return;
+  }
+
+  if (S.FnAccumulatorOk) {
+    mAccumulatorSignatureMetadata |= bcinfo::MD_SIG_In;
+    mAccumulatorTypeSize = S.ASTC.getTypeSizeInChars(S.FnAccumulatorParamFirstTy->getPointeeType()).getQuantity();
+    for (size_t ParamIdx = 1; ParamIdx < S.FnAccumulatorIndexOfFirstSpecialParameter; ++ParamIdx) {
+      const clang::ParmVarDecl *const Param = S.FnAccumulator->getParamDecl(ParamIdx);
+      mAccumulatorIns.push_back(Param);
+      const clang::QualType ParamQType = Param->getType().getCanonicalType();
+      const clang::Type *ParamType = ParamQType.getTypePtr();
+
+      RSExportType *ParamEType = nullptr;
+      if (ParamQType->isPointerType()) {
+        S.RSC.ReportError(Param->getLocation(),
+                          "%0 parameter '%1' (type '%2') must not be a pointer")
+            << S.DiagnosticDescription(KeyAccumulator, mNameAccumulator)
+            << Param->getName() << ParamQType.getAsString();
+        S.Ok = false;
+      } else if (HasRSObjectType(ParamType)) {
+        S.RSC.ReportError(Param->getLocation(),
+                          "%0 parameter '%1' (type '%2') must not contain an object type")
+            << S.DiagnosticDescription(KeyAccumulator, mNameAccumulator)
+            << Param->getName() << ParamQType.getAsString();
+        S.Ok = false;
+      } else if (RSExportType::ValidateType(&S.RSC, S.ASTC, ParamQType, Param, Param->getLocStart(),
+                                            S.RSC.getTargetAPI(),
+                                            false /* IsFilterscript */,
+                                            true /* IsExtern */)) {
+        // TODO: Better diagnostics on validation or creation failure?
+        ParamEType = RSExportType::Create(&S.RSC, ParamType, NotLegacyKernelArgument);
+        S.Ok &= (ParamEType != nullptr);
+      } else {
+        S.Ok = false;
+      }
+      mAccumulatorInTypes.push_back(ParamEType); // possibly nullptr
+    }
+  }
+}
+
+// Process "void combinename(compType *accum, const compType *val)"
+void RSExportReduceNew::analyzeCombiner(StateOfAnalyzeTranslationUnit &S) {
+  if (S.FnCombiner) {
+    // Must return void
+    checkVoidReturn(S, FN_IDENT_COMBINER, S.FnCombiner);
+
+    // Must have exactly two parameters, of same type as first accumulator parameter
+
+    if (S.FnCombiner->getNumParams() != 2) {
+      S.RSC.ReportError(S.FnCombiner->getLocation(),
+                        "%0 must take exactly 2 parameters (found %1)")
+          << S.DiagnosticDescription(KeyCombiner, mNameCombiner)
+          << S.FnCombiner->getNumParams();
+      S.Ok = false;
+      return;
+    }
+
+    if (S.FnAccumulatorParamFirstTy.isNull() || !S.FnAccumulatorParamFirstTy->isPointerType()) {
+      // We're already in an error situation.  We could compare
+      // against the initializer parameter type instead of the first
+      // accumulator parameter type (we'd have to check for the
+      // availability of a parameter type there, too), but it does not
+      // seem worth the effort.
+      //
+      // Likewise, we could compare the two combiner parameter types
+      // against each other.
+      slangAssert(!S.Ok);
+      return;
+    }
+
+    for (int ParamIdx = 0; ParamIdx < 2; ++ParamIdx) {
+      const clang::ParmVarDecl *const FnCombinerParam = S.FnCombiner->getParamDecl(ParamIdx);
+      const clang::QualType FnCombinerParamTy = FnCombinerParam->getType().getCanonicalType();
+      if (!FnCombinerParamTy->isPointerType() ||
+          !S.FnCombiner->getASTContext().hasSameUnqualifiedType(
+              S.FnAccumulatorParamFirstTy->getPointeeType().getCanonicalType(),
+              FnCombinerParamTy->getPointeeType().getCanonicalType())) {
+        // <combiner> parameter '<baz>' (type '<tbaz>')
+        //   and accumulator <goo>() parameter '<gaz>' (type '<tgaz>') must be pointers to the same type
+        S.RSC.ReportError(S.FnCombiner->getLocation(),
+                          "%0 parameter '%1' (type '%2') and %3 %4() parameter '%5' (type '%6')"
+                          " must be pointers to the same type")
+            << S.DiagnosticDescription(KeyCombiner, mNameCombiner)
+            << FnCombinerParam->getName() << FnCombinerParamTy.getAsString()
+            << KeyAccumulator << mNameAccumulator
+            << S.FnAccumulatorParamFirst->getName() << S.FnAccumulatorParamFirstTy.getAsString();
+        S.Ok = false;
+      } else {
+        // Check const-qualification
+        checkPointeeConstQualified(S, FN_IDENT_COMBINER, mNameCombiner, FnCombinerParam, ParamIdx==1);
+      }
+    }
+
+    return;
+  }
+
+  // Ensure accumulator properties permit omission of combiner.
+
+  if (!S.FnAccumulatorOk) {
+    // Couldn't fully analyze accumulator, so cannot see whether it permits omission of combiner.
+    return;
+  }
+
+  if (mAccumulatorIns.size() != 1 ||
+      S.FnAccumulatorIndexOfFirstSpecialParameter != S.FnAccumulator->getNumParams())
+  {
+    S.RSC.ReportError(S.FnAccumulator->getLocation(),
+                      "%0 must have exactly 1 input"
+                      " and no special parameters in order for the %1 to be omitted")
+        << S.DiagnosticDescription(KeyAccumulator, mNameAccumulator)
+        << KeyCombiner;
+    S.Ok = false;
+    return;
+  }
+
+  const clang::ParmVarDecl *const FnAccumulatorParamInput = S.FnAccumulator->getParamDecl(1);
+  const clang::QualType FnAccumulatorParamInputTy = FnAccumulatorParamInput->getType().getCanonicalType();
+  if (!S.FnAccumulator->getASTContext().hasSameUnqualifiedType(
+          S.FnAccumulatorParamFirstTy->getPointeeType().getCanonicalType(),
+          FnAccumulatorParamInputTy.getCanonicalType())) {
+    S.RSC.ReportError(S.FnAccumulator->getLocation(),
+                      "%0 parameter '%1' (type '%2')"
+                      " must be pointer to the type of parameter '%3' (type '%4')"
+                      " in order for the %5 to be omitted")
+        << S.DiagnosticDescription(KeyAccumulator, mNameAccumulator)
+        << S.FnAccumulatorParamFirst->getName() << S.FnAccumulatorParamFirstTy.getAsString()
+        << FnAccumulatorParamInput->getName() << FnAccumulatorParamInputTy.getAsString()
+        << KeyCombiner;
+    S.Ok = false;
+  }
+}
+
+// Process "void outconvertname(resultType *result, const compType *accum)"
+void RSExportReduceNew::analyzeOutConverter(StateOfAnalyzeTranslationUnit &S) {
+  if (!S.FnOutConverter) // outconverter is always optional
+    return;
+
+  // Must return void
+  checkVoidReturn(S, FN_IDENT_OUT_CONVERTER, S.FnOutConverter);
+
+  // Must have exactly two parameters
+  if (S.FnOutConverter->getNumParams() != 2) {
+    S.RSC.ReportError(S.FnOutConverter->getLocation(),
+                      "%0 must take exactly 2 parameters (found %1)")
+        << S.DiagnosticDescription(KeyOutConverter, mNameOutConverter)
+        << S.FnOutConverter->getNumParams();
+    S.Ok = S.FnOutConverterOk = false;
+    return;
+  }
+
+  // Parameters must not be special and must be of pointer type;
+  // and second parameter must match first accumulator parameter
+  for (int ParamIdx = 0; ParamIdx < 2; ++ParamIdx) {
+    clang::ParmVarDecl *const FnOutConverterParam = S.FnOutConverter->getParamDecl(ParamIdx);
+
+    if (isSpecialKernelParameter(FnOutConverterParam->getName())) {
+      S.RSC.ReportError(S.FnOutConverter->getLocation(),
+                        "%0 cannot take special parameter '%1'")
+          << S.DiagnosticDescription(KeyOutConverter, mNameOutConverter)
+          << FnOutConverterParam->getName();
+      S.Ok = S.FnOutConverterOk = false;
+      continue;
+    }
+
+    const clang::QualType FnOutConverterParamTy = FnOutConverterParam->getType().getCanonicalType();
+
+    if (!FnOutConverterParamTy->isPointerType()) {
+      S.RSC.ReportError(S.FnOutConverter->getLocation(),
+                        "%0 parameter '%1' must be of pointer type not '%2'")
+          << S.DiagnosticDescription(KeyOutConverter, mNameOutConverter)
+          << FnOutConverterParam->getName() << FnOutConverterParamTy.getAsString();
+      S.Ok = S.FnOutConverterOk = false;
+      continue;
+    }
+
+    // Check const-qualification
+    checkPointeeConstQualified(S, FN_IDENT_OUT_CONVERTER, mNameOutConverter, FnOutConverterParam, ParamIdx==1);
+
+    if (ParamIdx == 0) {
+      S.FnOutConverterParamFirst = FnOutConverterParam;
+      S.FnOutConverterParamFirstTy = FnOutConverterParamTy;
+      continue;
+    }
+
+    if (S.FnAccumulatorParamFirstTy.isNull() || !S.FnAccumulatorParamFirstTy->isPointerType()) {
+      // We're already in an error situation.  We could compare
+      // against the initializer parameter type instead of the first
+      // accumulator parameter type (we'd have to check for the
+      // availability of a parameter type there, too), but it does not
+      // seem worth the effort.
+      slangAssert(!S.Ok);
+      continue;
+    }
+
+    if (!S.FnOutConverter->getASTContext().hasSameUnqualifiedType(
+            S.FnAccumulatorParamFirstTy->getPointeeType().getCanonicalType(),
+            FnOutConverterParamTy->getPointeeType().getCanonicalType())) {
+      // <outconverter> parameter '<baz>' (type '<tbaz>')
+      //   and accumulator <goo>() parameter '<gaz>' (type '<tgaz>') must be pointers to the same type
+      S.RSC.ReportError(S.FnOutConverter->getLocation(),
+                        "%0 parameter '%1' (type '%2') and %3 %4() parameter '%5' (type '%6')"
+                        " must be pointers to the same type")
+          << S.DiagnosticDescription(KeyOutConverter, mNameOutConverter)
+          << FnOutConverterParam->getName() << FnOutConverterParamTy.getAsString()
+          << KeyAccumulator << mNameAccumulator
+          << S.FnAccumulatorParamFirst->getName() << S.FnAccumulatorParamFirstTy.getAsString();
+      S.Ok = S.FnOutConverterOk = false;
+    }
+  }
+}
+
+void RSExportReduceNew::analyzeHalter(StateOfAnalyzeTranslationUnit &S) {
+  if (!S.FnHalter) // halter is always optional
+    return;
+
+  // Must return bool
+  const clang::QualType ReturnTy = S.FnHalter->getReturnType().getCanonicalType();
+  if (!ReturnTy->isBooleanType()) {
+    S.RSC.ReportError(S.FnHalter->getLocation(),
+                    "%0 must return bool not '%1'")
+        << S.DiagnosticDescription(KeyHalter, mNameHalter) << ReturnTy.getAsString();
+    S.Ok = false;
+  }
+
+  // Must have exactly one parameter
+  if (S.FnHalter->getNumParams() != 1) {
+    S.RSC.ReportError(S.FnHalter->getLocation(),
+                      "%0 must take exactly 1 parameter (found %1)")
+        << S.DiagnosticDescription(KeyHalter, mNameHalter)
+        << S.FnHalter->getNumParams();
+    S.Ok = false;
+    return;
+  }
+
+  // Parameter must not be a special parameter
+  const clang::ParmVarDecl *const FnHalterParam = S.FnHalter->getParamDecl(0);
+  if (isSpecialKernelParameter(FnHalterParam->getName())) {
+    S.RSC.ReportError(S.FnHalter->getLocation(),
+                      "%0 cannot take special parameter '%1'")
+        << S.DiagnosticDescription(KeyHalter, mNameHalter)
+        << FnHalterParam->getName();
+    S.Ok = false;
+    return;
+  }
+
+  // Parameter must be same type as first accumulator parameter
+
+  if (S.FnAccumulatorParamFirstTy.isNull() || !S.FnAccumulatorParamFirstTy->isPointerType()) {
+    // We're already in an error situation.  We could compare against
+    // the initializer parameter type or the first combiner parameter
+    // type instead of the first accumulator parameter type (we'd have
+    // to check for the availability of a parameter type there, too),
+    // but it does not seem worth the effort.
+    slangAssert(!S.Ok);
+    return;
+  }
+
+  const clang::QualType FnHalterParamTy = FnHalterParam->getType().getCanonicalType();
+  if (!FnHalterParamTy->isPointerType() ||
+      !S.FnHalter->getASTContext().hasSameUnqualifiedType(
+          S.FnAccumulatorParamFirstTy->getPointeeType().getCanonicalType(),
+          FnHalterParamTy->getPointeeType().getCanonicalType())) {
+    // <halter> parameter '<baz>' (type '<tbaz>')
+    //   and accumulator <goo>() parameter '<gaz>' (type '<tgaz>') must be pointers to the same type
+    S.RSC.ReportError(S.FnHalter->getLocation(),
+                      "%0 parameter '%1' (type '%2') and %3 %4() parameter '%5' (type '%6')"
+                      " must be pointers to the same type")
+        << S.DiagnosticDescription(KeyHalter, mNameHalter)
+        << FnHalterParam->getName() << FnHalterParamTy.getAsString()
+        << KeyAccumulator << mNameAccumulator
+        << S.FnAccumulatorParamFirst->getName() << S.FnAccumulatorParamFirstTy.getAsString();
+    S.Ok = false;
+    return;
+  }
+
+  // Parameter must point to const-qualified
+  checkPointeeConstQualified(S, FN_IDENT_HALTER, mNameHalter, FnHalterParam, true);
+}
+
+void RSExportReduceNew::analyzeResultType(StateOfAnalyzeTranslationUnit &S) {
+  if (!(S.FnAccumulatorOk && S.FnOutConverterOk)) {
+    // No idea what the result type is
+    slangAssert(!S.Ok);
+    return;
+  }
+
+  struct ResultInfoType {
+    const clang::QualType QType;
+    clang::VarDecl *const Decl;
+    const char *FnKey;
+    const std::string &FnName;
+    std::function<std::string ()> UnlessOutConverter;
+  } ResultInfo =
+        S.FnOutConverter
+        ? ResultInfoType({ S.FnOutConverterParamFirstTy, S.FnOutConverterParamFirst,
+                           KeyOutConverter, mNameOutConverter,
+                           []() { return std::string(""); }})
+        : ResultInfoType({ S.FnAccumulatorParamFirstTy,  S.FnAccumulatorParamFirst,
+                           KeyAccumulator,  mNameAccumulator,
+                           []() { return std::string(" unless ") + KeyOutConverter + " is provided"; }});
+  const clang::QualType PointeeQType = ResultInfo.QType->getPointeeType();
+
+  if (PointeeQType->isPointerType()) {
+    S.RSC.ReportError(ResultInfo.Decl->getLocation(),
+                      "%0 parameter '%1' (type '%2') must not point to a pointer%3")
+        << S.DiagnosticDescription(ResultInfo.FnKey, ResultInfo.FnName)
+        << ResultInfo.Decl->getName() << ResultInfo.QType.getAsString()
+        << ResultInfo.UnlessOutConverter();
+  } else if (PointeeQType->isIncompleteType()) {
+    S.RSC.ReportError(ResultInfo.Decl->getLocation(),
+                      "%0 parameter '%1' (type '%2') must not point to an incomplete type%3")
+        << S.DiagnosticDescription(ResultInfo.FnKey, ResultInfo.FnName)
+        << ResultInfo.Decl->getName() << ResultInfo.QType.getAsString()
+        << ResultInfo.UnlessOutConverter();
+  } else if (HasRSObjectType(PointeeQType.getTypePtr())) {
+    S.RSC.ReportError(ResultInfo.Decl->getLocation(),
+                      "%0 parameter '%1' (type '%2') must not point to data containing an object type%3")
+        << S.DiagnosticDescription(ResultInfo.FnKey, ResultInfo.FnName)
+        << ResultInfo.Decl->getName() << ResultInfo.QType.getAsString()
+        << ResultInfo.UnlessOutConverter();
+  } else if (RSExportType::ValidateType(&S.RSC, S.ASTC, PointeeQType,
+                                        ResultInfo.Decl, ResultInfo.Decl->getLocStart(),
+                                        S.RSC.getTargetAPI(),
+                                        false /* IsFilterscript */,
+                                        true /* IsExtern */)) {
+    // TODO: Better diagnostics on validation or creation failure?
+    if ((mResultType = RSExportType::Create(&S.RSC, PointeeQType.getTypePtr(),
+                                            NotLegacyKernelArgument, ResultInfo.Decl)) != nullptr) {
+      const RSExportType *CheckType = mResultType;
+      const char *ArrayErrorPhrase = "";
+      if (mResultType->getClass() == RSExportType::ExportClassConstantArray) {
+        CheckType = static_cast<const RSExportConstantArrayType *>(mResultType)->getElementType();
+        ArrayErrorPhrase = "n array of";
+      }
+      switch (CheckType->getClass()) {
+        case RSExportType::ExportClassMatrix:
+          // Not supported for now -- what does a matrix result type mean?
+          S.RSC.ReportError(ResultInfo.Decl->getLocation(),
+                            "%0 parameter '%1' (type '%2') must not point to a%3 matrix type%4")
+              << S.DiagnosticDescription(ResultInfo.FnKey, ResultInfo.FnName)
+              << ResultInfo.Decl->getName() << ResultInfo.QType.getAsString()
+              << ArrayErrorPhrase
+              << ResultInfo.UnlessOutConverter();
+          mResultType = nullptr;
+          break;
+        case RSExportType::ExportClassVector: {
+          const RSExportVectorType *const EVT = static_cast<const RSExportVectorType *>(CheckType);
+          if (EVT->getType() == DataTypeFloat16) {
+            // Not supported for now -- how is this handled?
+            S.RSC.ReportError(ResultInfo.Decl->getLocation(),
+                              "%0 parameter '%1' (type '%2') must not point to a%3 half* vector%4")
+                << S.DiagnosticDescription(ResultInfo.FnKey, ResultInfo.FnName)
+                << ResultInfo.Decl->getName() << ResultInfo.QType.getAsString()
+                << ArrayErrorPhrase
+                << ResultInfo.UnlessOutConverter();
+            mResultType = nullptr;
+          }
+          break;
+        }
+        default:
+          // All's well
+          break;
+      }
+    }
+  }
+
+  if (mResultType)
+    S.RSC.insertExportReduceNewResultType(mResultType);
+  else
+    S.Ok = false;
+}
+
+bool RSExportReduceNew::analyzeTranslationUnit() {
+
+  RSContext &RSC = *getRSContext();
+  clang::Preprocessor &PP = RSC.getPreprocessor();
+
+  StateOfAnalyzeTranslationUnit S(
+      RSC, PP, RSC.getASTContext(),
+      [&RSC, &PP, this] (const char *Key, const std::string &Name) {
+        std::ostringstream Description;
+        Description
+            << Key << " " << Name << "()"
+            << " for '#pragma rs " << KeyReduce << "(" << mNameReduce << ")'"
+            << " (" << mLocation.printToString(PP.getSourceManager()) << ")";
+        return Description.str();
+      });
+
+  S.FnInitializer  = lookupFunction(S, KeyInitializer,  mNameInitializer);
+  S.FnAccumulator  = lookupFunction(S, KeyAccumulator,  mNameAccumulator);
+  S.FnCombiner     = lookupFunction(S, KeyCombiner,     mNameCombiner);
+  S.FnOutConverter = lookupFunction(S, KeyOutConverter, mNameOutConverter);
+  S.FnHalter       = lookupFunction(S, KeyHalter,       mNameHalter);
+
+  if (!S.Ok)
+    return false;
+
+  analyzeInitializer(S);
+  analyzeAccumulator(S);
+  analyzeCombiner(S);
+  analyzeOutConverter(S);
+  analyzeHalter(S);
+  analyzeResultType(S);
+
+  return S.Ok;
+}
+
 }  // namespace slang
diff --git a/slang_rs_export_reduce.h b/slang_rs_export_reduce.h
index 665ba27..f97b141 100644
--- a/slang_rs_export_reduce.h
+++ b/slang_rs_export_reduce.h
@@ -94,6 +94,32 @@
   std::string mNameOutConverter;
   std::string mNameHalter;
 
+  // constituent function identity
+  enum FnIdent {
+    FN_IDENT_INITIALIZER,
+    FN_IDENT_ACCUMULATOR,
+    FN_IDENT_COMBINER,
+    FN_IDENT_OUT_CONVERTER,
+    FN_IDENT_HALTER
+  };
+  static const char *getKey(FnIdent Kind);
+
+  // signature information for accumulator function
+  unsigned int mAccumulatorSignatureMetadata;
+
+  // size of accumulator data type (compType), in bytes
+  unsigned int mAccumulatorTypeSize;
+
+  // input information for accumulator function
+  static const int kAccumulatorInsSmallSize = 4;
+  typedef llvm::SmallVectorImpl<const clang::ParmVarDecl*> InVec;
+  llvm::SmallVector<const clang::ParmVarDecl*, kAccumulatorInsSmallSize> mAccumulatorIns;
+  typedef llvm::SmallVectorImpl<const RSExportType*> InTypeVec;
+  llvm::SmallVector<const RSExportType*, kAccumulatorInsSmallSize> mAccumulatorInTypes;
+
+  // result information
+  RSExportType *mResultType;
+
   RSExportReduceNew(RSContext *Context,
                     const clang::SourceLocation Location,
                     const llvm::StringRef &NameReduce,
@@ -109,13 +135,44 @@
       mNameAccumulator(NameAccumulator),
       mNameCombiner(NameCombiner),
       mNameOutConverter(NameOutConverter),
-      mNameHalter(NameHalter) {
+      mNameHalter(NameHalter),
+      mAccumulatorSignatureMetadata(0),
+      mAccumulatorTypeSize(0),
+      mResultType(nullptr) {
   }
 
   RSExportReduceNew(const RSExportReduceNew &) = delete;
   void operator=(const RSExportReduceNew &) = delete;
 
+  struct StateOfAnalyzeTranslationUnit;
+
+  static void notOk(StateOfAnalyzeTranslationUnit &S, FnIdent Kind);
+
+  static void checkPointeeConstQualified(StateOfAnalyzeTranslationUnit &S,
+                                         FnIdent Kind, const llvm::StringRef &Name,
+                                         const clang::ParmVarDecl *Param, bool ExpectedQualification);
+
+  static void checkVoidReturn(StateOfAnalyzeTranslationUnit &S, FnIdent Kind, clang::FunctionDecl *Fn);
+
+  clang::FunctionDecl *lookupFunction(StateOfAnalyzeTranslationUnit &S,
+                                      const char *Kind, const llvm::StringRef &Name);
+
+  void analyzeInitializer(StateOfAnalyzeTranslationUnit &S);
+  void analyzeAccumulator(StateOfAnalyzeTranslationUnit &S);
+  void analyzeCombiner(StateOfAnalyzeTranslationUnit &S);
+  void analyzeOutConverter(StateOfAnalyzeTranslationUnit &S);
+  void analyzeHalter(StateOfAnalyzeTranslationUnit &S);
+  void analyzeResultType(StateOfAnalyzeTranslationUnit &S);
+
  public:
+
+  static const char KeyReduce[];
+  static const char KeyInitializer[];
+  static const char KeyAccumulator[];
+  static const char KeyCombiner[];
+  static const char KeyOutConverter[];
+  static const char KeyHalter[];
+
   static RSExportReduceNew *Create(RSContext *Context,
                                    const clang::SourceLocation Location,
                                    const llvm::StringRef &NameReduce,
@@ -133,6 +190,20 @@
   const std::string &getNameCombiner() const { return mNameCombiner; }
   const std::string &getNameOutConverter() const { return mNameOutConverter; }
   const std::string &getNameHalter() const { return mNameHalter; }
+
+  unsigned int getAccumulatorSignatureMetadata() const { return mAccumulatorSignatureMetadata; }
+
+  unsigned int getAccumulatorTypeSize() const { return mAccumulatorTypeSize; }
+
+  const InVec &getAccumulatorIns() const { return mAccumulatorIns; }
+  const InTypeVec &getAccumulatorInTypes() const { return mAccumulatorInTypes; }
+
+  const RSExportType *getResultType() const { return mResultType; }
+
+  // Does one of this reduction's constituent function names match Candidate?
+  bool matchName(const llvm::StringRef &Candidate) const;
+
+  bool analyzeTranslationUnit();
 };  // RSExportReduceNew
 
 }  // namespace slang
diff --git a/slang_rs_object_ref_count.cpp b/slang_rs_object_ref_count.cpp
index 4edae11..51c9779 100644
--- a/slang_rs_object_ref_count.cpp
+++ b/slang_rs_object_ref_count.cpp
@@ -622,14 +622,12 @@
   return DestructorLoop;
 }
 
-static unsigned CountRSObjectTypes(clang::ASTContext &C,
-                                   const clang::Type *T,
-                                   clang::SourceLocation Loc) {
+static unsigned CountRSObjectTypes(const clang::Type *T) {
   slangAssert(T);
   unsigned RSObjectCount = 0;
 
   if (T->isArrayType()) {
-    return CountRSObjectTypes(C, T->getArrayElementTypeNoTypeQual(), Loc);
+    return CountRSObjectTypes(T->getArrayElementTypeNoTypeQual());
   }
 
   DataType DT = RSExportPrimitiveType::GetRSSpecificType(T);
@@ -646,7 +644,7 @@
          FI++) {
       const clang::FieldDecl *FD = *FI;
       const clang::Type *FT = RSExportType::GetTypeOfDecl(FD);
-      if (CountRSObjectTypes(C, FT, Loc)) {
+      if (CountRSObjectTypes(FT)) {
         slangAssert(false && "can't have unions with RS object types!");
         return 0;
       }
@@ -665,7 +663,7 @@
        FI++) {
     const clang::FieldDecl *FD = *FI;
     const clang::Type *FT = RSExportType::GetTypeOfDecl(FD);
-    if (CountRSObjectTypes(C, FT, Loc)) {
+    if (CountRSObjectTypes(FT)) {
       // Sub-structs should only count once (as should arrays, etc.)
       RSObjectCount++;
     }
@@ -688,7 +686,7 @@
   slangAssert(RSExportPrimitiveType::GetRSSpecificType(BaseType) ==
               DataTypeUnknown);
 
-  unsigned FieldsToDestroy = CountRSObjectTypes(C, BaseType, Loc);
+  unsigned FieldsToDestroy = CountRSObjectTypes(BaseType);
   slangAssert(FieldsToDestroy != 0);
 
   unsigned StmtCount = 0;
@@ -751,7 +749,7 @@
                                                      RSObjectMember,
                                                      Loc);
       }
-    } else if (FT->isStructureType() && CountRSObjectTypes(C, FT, Loc)) {
+    } else if (FT->isStructureType() && CountRSObjectTypes(FT)) {
       // In this case, we have a nested struct. We may not end up filling all
       // of the spaces in StmtArray (sub-structs should handle themselves
       // with separate compound statements).
@@ -1025,7 +1023,7 @@
   slangAssert(!RSExportPrimitiveType::IsRSObjectType(T));
 
   // Keep an extra slot for the original copy (memcpy)
-  unsigned FieldsToSet = CountRSObjectTypes(C, T, Loc) + 1;
+  unsigned FieldsToSet = CountRSObjectTypes(T) + 1;
 
   unsigned StmtCount = 0;
   clang::Stmt **StmtArray = new clang::Stmt*[FieldsToSet];
@@ -1044,7 +1042,7 @@
     const clang::Type *FT = RSExportType::GetTypeOfDecl(FD);
     const clang::Type *OrigType = FT;
 
-    if (!CountRSObjectTypes(C, FT, Loc)) {
+    if (!CountRSObjectTypes(FT)) {
       // Skip to next if we don't have any viable RS object types
       continue;
     }
@@ -1488,8 +1486,7 @@
         getCurrentScope()->AppendRSObjectInit(VD, DS, DT, InitExpr);
         // ... but, only add to the list of RS objects if we have some
         // non-matrix RS object fields.
-        if (CountRSObjectTypes(mCtx, VD->getType().getTypePtr(),
-                               VD->getLocation())) {
+        if (CountRSObjectTypes(VD->getType().getTypePtr())) {
           getCurrentScope()->addRSObject(VD);
         }
       }
@@ -1516,7 +1513,7 @@
 void RSObjectRefCount::VisitBinAssign(clang::BinaryOperator *AS) {
   clang::QualType QT = AS->getType();
 
-  if (CountRSObjectTypes(mCtx, QT.getTypePtr(), AS->getExprLoc())) {
+  if (CountRSObjectTypes(QT.getTypePtr())) {
     getCurrentScope()->ReplaceRSObjectAssignment(AS);
   }
 }
@@ -1555,7 +1552,7 @@
           E = DC->decls_end(); I != E; I++) {
     clang::VarDecl *VD = llvm::dyn_cast<clang::VarDecl>(*I);
     if (VD) {
-      if (CountRSObjectTypes(mCtx, VD->getType().getTypePtr(), loc)) {
+      if (CountRSObjectTypes(VD->getType().getTypePtr())) {
         if (!FD) {
           // Only create FD if we are going to use it.
           FD = clang::FunctionDecl::Create(mCtx, DC, loc, loc, N, T, nullptr,
@@ -1585,4 +1582,8 @@
   return FD;
 }
 
+bool HasRSObjectType(const clang::Type *T) {
+  return CountRSObjectTypes(T) != 0;
+}
+
 }  // namespace slang
diff --git a/slang_rs_object_ref_count.h b/slang_rs_object_ref_count.h
index eb200b8..d6be50f 100644
--- a/slang_rs_object_ref_count.h
+++ b/slang_rs_object_ref_count.h
@@ -32,6 +32,9 @@
 
 namespace slang {
 
+// Recursive check
+bool HasRSObjectType(const clang::Type *T);
+
 // This class provides the overall reference counting mechanism for handling
 // local variables of RS object types (rs_font, rs_allocation, ...). This
 // class ensures that appropriate functions (rsSetObject, rsClearObject) are
diff --git a/slang_rs_pragma_handler.cpp b/slang_rs_pragma_handler.cpp
index e9ff991..f46df08 100644
--- a/slang_rs_pragma_handler.cpp
+++ b/slang_rs_pragma_handler.cpp
@@ -19,6 +19,9 @@
 #include <sstream>
 #include <string>
 
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Attr.h"
+
 #include "clang/Basic/TokenKinds.h"
 
 #include "clang/Lex/LiteralSupport.h"
@@ -135,12 +138,6 @@
     //   combiner(combinename)
     //   outconverter(outconvertname)
     //   halter(haltname)
-    const char NameReduce[] = "reduce";
-    const char NameInitializer[] = "initializer";
-    const char NameAccumulator[] = "accumulator";
-    const char NameCombiner[] = "combiner";
-    const char NameOutConverter[] = "outconverter";
-    const char NameHalter[] = "halter";
 
     const clang::SourceLocation PragmaLocation = FirstToken.getLocation();
 
@@ -150,12 +147,12 @@
     // token) and all the "keyword(value)" contributions
     //
     // TODO: Remove halter from initial release
-    KeywordValueMapType KeywordValueMap({std::make_pair(NameReduce, ""),
-                                         std::make_pair(NameInitializer, ""),
-                                         std::make_pair(NameAccumulator, ""),
-                                         std::make_pair(NameCombiner, ""),
-                                         std::make_pair(NameOutConverter, ""),
-                                         std::make_pair(NameHalter, "")});
+    KeywordValueMapType KeywordValueMap({std::make_pair(RSExportReduceNew::KeyReduce, ""),
+                                         std::make_pair(RSExportReduceNew::KeyInitializer, ""),
+                                         std::make_pair(RSExportReduceNew::KeyAccumulator, ""),
+                                         std::make_pair(RSExportReduceNew::KeyCombiner, ""),
+                                         std::make_pair(RSExportReduceNew::KeyOutConverter, ""),
+                                         std::make_pair(RSExportReduceNew::KeyHalter, "")});
     while (PragmaToken.is(clang::tok::identifier)) {
       if (!ProcessKeywordAndValue(PP, PragmaToken, KeywordValueMap))
         return;
@@ -171,19 +168,12 @@
       return;
     }
 
-    // Make sure we have an initializer and an accumulator
-    if (KeywordValueMap[NameInitializer].empty()) {
-      PP.Diag(PragmaLocation, PP.getDiagnostics().getCustomDiagID(
-                                  clang::DiagnosticsEngine::Error,
-                                  "missing '%0' for '#pragma rs %1'"))
-          << NameInitializer << getName();
-      return;
-    }
-    if (KeywordValueMap[NameAccumulator].empty()) {
+    // Make sure we have an accumulator
+    if (KeywordValueMap[RSExportReduceNew::KeyAccumulator].empty()) {
       PP.Diag(PragmaLocation, PP.getDiagnostics().getCustomDiagID(
                                 clang::DiagnosticsEngine::Error,
                                 "missing '%0' for '#pragma rs %1'"))
-          << NameAccumulator << getName();
+          << RSExportReduceNew::KeyAccumulator << getName();
       return;
     }
 
@@ -194,12 +184,12 @@
     for (auto I = mContext->export_reduce_new_begin(),
               E = mContext->export_reduce_new_end();
          I != E; ++I) {
-      if ((*I)->getNameReduce() == KeywordValueMap[NameReduce]) {
+      if ((*I)->getNameReduce() == KeywordValueMap[RSExportReduceNew::KeyReduce]) {
         PP.Diag(PragmaLocation, PP.getDiagnostics().getCustomDiagID(
                                   clang::DiagnosticsEngine::Error,
                                   "reduction kernel '%0' declared multiple "
                                   "times (first one is at %1)"))
-            << KeywordValueMap[NameReduce]
+            << KeywordValueMap[RSExportReduceNew::KeyReduce]
             << (*I)->getLocation().printToString(PP.getSourceManager());
         return;
       }
@@ -215,18 +205,46 @@
       return;
     }
 
+    // Handle backward reference from pragma (see Backend::HandleTopLevelDecl for forward reference).
+    MarkUsed(PP, KeywordValueMap[RSExportReduceNew::KeyInitializer]);
+    MarkUsed(PP, KeywordValueMap[RSExportReduceNew::KeyAccumulator]);
+    MarkUsed(PP, KeywordValueMap[RSExportReduceNew::KeyCombiner]);
+    MarkUsed(PP, KeywordValueMap[RSExportReduceNew::KeyOutConverter]);
+    MarkUsed(PP, KeywordValueMap[RSExportReduceNew::KeyHalter]);
+
     mContext->addExportReduceNew(RSExportReduceNew::Create(mContext, PragmaLocation,
-                                                           KeywordValueMap[NameReduce],
-                                                           KeywordValueMap[NameInitializer],
-                                                           KeywordValueMap[NameAccumulator],
-                                                           KeywordValueMap[NameCombiner],
-                                                           KeywordValueMap[NameOutConverter],
-                                                           KeywordValueMap[NameHalter]));
+                                                           KeywordValueMap[RSExportReduceNew::KeyReduce],
+                                                           KeywordValueMap[RSExportReduceNew::KeyInitializer],
+                                                           KeywordValueMap[RSExportReduceNew::KeyAccumulator],
+                                                           KeywordValueMap[RSExportReduceNew::KeyCombiner],
+                                                           KeywordValueMap[RSExportReduceNew::KeyOutConverter],
+                                                           KeywordValueMap[RSExportReduceNew::KeyHalter]));
   }
 
  private:
   typedef std::map<std::string, std::string> KeywordValueMapType;
 
+  void MarkUsed(clang::Preprocessor &PP, const std::string &FunctionName) {
+    if (FunctionName.empty())
+      return;
+
+    clang::ASTContext &ASTC = mContext->getASTContext();
+    clang::TranslationUnitDecl *TUDecl = ASTC.getTranslationUnitDecl();
+    slangAssert(TUDecl);
+    if (const clang::IdentifierInfo *II = PP.getIdentifierInfo(FunctionName)) {
+      for (auto Decl : TUDecl->lookup(II)) {
+        clang::FunctionDecl *FDecl = Decl->getAsFunction();
+        if (!FDecl || !FDecl->isThisDeclarationADefinition())
+          continue;
+        if (!FDecl->hasAttr<clang::UsedAttr>()) {
+          // Handle backward reference from pragma (see RSReducePragmaHandler::HandlePragma
+          // for forward reference).
+          FDecl->addAttr(clang::UsedAttr::CreateImplicit(ASTC));
+        }
+      }
+    }
+  }
+
   // Return comma-separated list of all keys in the map
   static std::string ListKeywords(const KeywordValueMapType &KeywordValueMap) {
     std::string Ret;
@@ -552,7 +570,7 @@
 
   // For #pragma rs reduce
   PP.AddPragmaHandler(
-      "rs", new RSReducePragmaHandler("reduce", RsContext));
+      "rs", new RSReducePragmaHandler(RSExportReduceNew::KeyReduce, RsContext));
 
   // For #pragma rs set_reflect_license
   PP.AddPragmaHandler(
diff --git a/tests/F_reduce_general_bad_accumulator/reduce_general_bad_accumulator.rs b/tests/F_reduce_general_bad_accumulator/reduce_general_bad_accumulator.rs
new file mode 100644
index 0000000..1f426f0
--- /dev/null
+++ b/tests/F_reduce_general_bad_accumulator/reduce_general_bad_accumulator.rs
@@ -0,0 +1,61 @@
+// -target-api 0 -Wall
+#pragma version(1)
+#pragma rs java_package_name(accum)
+
+// Several checks for bad accumulator DATA TYPE (not bad accumulator FUNCTION)
+
+/////////////////////////////////////////////////////////////////////////////
+// accumulator cannot be incomplete array
+/////////////////////////////////////////////////////////////////////////////
+
+typedef int IntA[]; // incomplete (unknown element count)
+
+#pragma rs reduce(redIntA) accumulator(AccumIntA) combiner(CombIntA)
+static void AccumIntA(IntA *accum, int val) { }
+static void CombIntA(IntA *accum, const IntA *val) { }
+
+// outconverter does not help
+#pragma rs reduce(redIntAOut) accumulator(AccumIntA) combiner(CombIntA) outconverter(OutIntA)
+static void OutIntA(int *out, const IntA *val) { }
+
+/////////////////////////////////////////////////////////////////////////////
+// accumulator cannot be incomplete struct
+/////////////////////////////////////////////////////////////////////////////
+
+struct Incomplete;
+
+#pragma rs reduce(redStructIncomplete) accumulator(AccumStructIncomplete) combiner(CombStructIncomplete)
+static void AccumStructIncomplete(struct Incomplete *accum, int val) { }
+static void CombStructIncomplete(struct Incomplete *accum, const struct Incomplete *other) { }
+
+// outconverter does not help
+#pragma rs reduce(redStructIncompleteOut) accumulator(AccumStructIncomplete) combiner(CombStructIncomplete) \
+  outconverter(OutStructIncomplete)
+static void OutStructIncomplete(int *out, const struct Incomplete *val) { }
+
+/////////////////////////////////////////////////////////////////////////////
+// accumulator cannot be function
+/////////////////////////////////////////////////////////////////////////////
+
+typedef void Fn(void);
+
+#pragma rs reduce(redFn) accumulator(AccumFn) combiner(CombineFn)
+static void AccumFn(Fn *accum, int val) { }
+static void CombineFn(Fn *accum, const Fn *other) { }
+
+// outconverter does not help
+#pragma rs reduce(redFnOut) accumulator(AccumFn) combiner(CombineFn) outconverter(OutFn)
+static void OutFn(int *out, const Fn *val) { }
+
+/////////////////////////////////////////////////////////////////////////////
+// accumulator cannot be object
+/////////////////////////////////////////////////////////////////////////////
+
+#pragma rs reduce(redObj) accumulator(AccumObj) combiner(CombineObj)
+static void AccumObj(rs_element *accum, int val) { }
+static void CombineObj(rs_element *accum, const rs_element *other) { }
+
+// outconverter does not help
+#pragma rs reduce(redObjOut) accumulator(AccumObj) combiner(CombineObj) outconverter(OutObj)
+static void OutObj(int *out, const rs_element *val) { }
+
diff --git a/tests/F_reduce_general_bad_accumulator/stderr.txt.expect b/tests/F_reduce_general_bad_accumulator/stderr.txt.expect
new file mode 100644
index 0000000..356155a
--- /dev/null
+++ b/tests/F_reduce_general_bad_accumulator/stderr.txt.expect
@@ -0,0 +1,13 @@
+reduce_general_bad_accumulator.rs:44:34: warning: 'const' qualifier on function type 'Fn' (aka 'void (void)') has unspecified behavior
+reduce_general_bad_accumulator.rs:48:29: warning: 'const' qualifier on function type 'Fn' (aka 'void (void)') has unspecified behavior
+reduce_general_bad_accumulator.rs:14:13: error: accumulator AccumIntA() for '#pragma rs reduce(redIntA)' (reduce_general_bad_accumulator.rs:13:12) parameter 'accum' (type 'int (*)[]') must not be pointer to incomplete type
+reduce_general_bad_accumulator.rs:14:13: error: accumulator AccumIntA() for '#pragma rs reduce(redIntAOut)' (reduce_general_bad_accumulator.rs:18:12) parameter 'accum' (type 'int (*)[]') must not be pointer to incomplete type
+reduce_general_bad_accumulator.rs:28:13: error: accumulator AccumStructIncomplete() for '#pragma rs reduce(redStructIncomplete)' (reduce_general_bad_accumulator.rs:27:12) parameter 'accum' (type 'struct Incomplete *') must not be pointer to incomplete type
+reduce_general_bad_accumulator.rs:28:13: error: accumulator AccumStructIncomplete() for '#pragma rs reduce(redStructIncompleteOut)' (reduce_general_bad_accumulator.rs:32:12) parameter 'accum' (type 'struct Incomplete *') must not be pointer to incomplete type
+reduce_general_bad_accumulator.rs:43:13: error: accumulator AccumFn() for '#pragma rs reduce(redFn)' (reduce_general_bad_accumulator.rs:42:12) parameter 'accum' (type 'void (*)(void)') must not be pointer to function type
+reduce_general_bad_accumulator.rs:44:44: error: combiner CombineFn() for '#pragma rs reduce(redFn)' (reduce_general_bad_accumulator.rs:42:12) parameter 'other' (type 'Fn *') must point to const-qualified type
+reduce_general_bad_accumulator.rs:43:13: error: accumulator AccumFn() for '#pragma rs reduce(redFnOut)' (reduce_general_bad_accumulator.rs:47:12) parameter 'accum' (type 'void (*)(void)') must not be pointer to function type
+reduce_general_bad_accumulator.rs:44:44: error: combiner CombineFn() for '#pragma rs reduce(redFnOut)' (reduce_general_bad_accumulator.rs:47:12) parameter 'other' (type 'Fn *') must point to const-qualified type
+reduce_general_bad_accumulator.rs:48:39: error: outconverter OutFn() for '#pragma rs reduce(redFnOut)' (reduce_general_bad_accumulator.rs:47:12) parameter 'val' (type 'Fn *') must point to const-qualified type
+reduce_general_bad_accumulator.rs:55:13: error: accumulator AccumObj() for '#pragma rs reduce(redObj)' (reduce_general_bad_accumulator.rs:54:12) parameter 'accum' (type 'struct rs_element *') must not be pointer to data containing an object type
+reduce_general_bad_accumulator.rs:55:13: error: accumulator AccumObj() for '#pragma rs reduce(redObjOut)' (reduce_general_bad_accumulator.rs:59:12) parameter 'accum' (type 'struct rs_element *') must not be pointer to data containing an object type
diff --git a/tests/P_reduce_general/stdout.txt.expect b/tests/F_reduce_general_bad_accumulator/stdout.txt.expect
similarity index 100%
copy from tests/P_reduce_general/stdout.txt.expect
copy to tests/F_reduce_general_bad_accumulator/stdout.txt.expect
diff --git a/tests/F_reduce_general_bad_function/reduce_general_bad_function.rs b/tests/F_reduce_general_bad_function/reduce_general_bad_function.rs
new file mode 100644
index 0000000..36b323e
--- /dev/null
+++ b/tests/F_reduce_general_bad_function/reduce_general_bad_function.rs
@@ -0,0 +1,303 @@
+// -target-api 0 -Wall
+#pragma version(1)
+#pragma rs java_package_name(fn)
+
+// Various ways particular reduction consituent functions can fail semantic checks.
+// Also see reduce_general_bad_accumulator.rs for accumulator data type checks.
+
+// trivial accumulator for use multiple times later
+static void AccumInt(int *accum, int val) { }
+
+/////////////////////////////////////////////////////////////////////////////
+// initializer
+/////////////////////////////////////////////////////////////////////////////
+
+// initializer must take exactly 1 parameter
+#pragma rs reduce(init0) initializer(init0) accumulator(AccumInt)
+static void init0() { }
+
+// initializer must take exactly 1 parameter
+#pragma rs reduce(init2) initializer(init2) accumulator(AccumInt)
+static void init2(int *a, int *b) { }
+
+// initializer cannot take special parameter
+#pragma rs reduce(init_special1) initializer(init_special1) accumulator(AccumInt)
+static void init_special1(int *x) { }
+
+// initializer must take exactly 1 parameter
+#pragma rs reduce(init2_special1) initializer(init2_special1) accumulator(AccumInt)
+static void init2_special1(int *a, int *x) { }
+
+// initializer must take exactly 1 parameter
+#pragma rs reduce(init2_special0) initializer(init2_special0) accumulator(AccumInt)
+static void init2_special0(int *x, int *a) { }
+
+// initializer must take pointer parameter
+#pragma rs reduce(init_noptr) initializer(init_noptr) accumulator(AccumInt)
+static void init_noptr(int a) { }
+
+// initializer may be overloadable . . .
+#pragma rs reduce(init_over) initializer(init_over) accumulator(AccumInt)
+static __attribute__((overloadable)) void init_over(int *accum) { }
+
+// . . . but initializer must not have duplicate definitions
+#pragma rs reduce(init_dup) initializer(init_dup) accumulator(AccumInt)
+static __attribute__((overloadable)) void init_dup(int *accum) { }
+static __attribute__((overloadable)) void init_dup(unsigned int *accum) { }
+
+// initializer must be present
+#pragma rs reduce(init_missing) initializer(init_missing) accumulator(AccumInt)
+
+// initializer must be static
+#pragma rs reduce(init_nonstatic) initializer(init_nonstatic) accumulator(AccumInt)
+void init_nonstatic(int *accum) { }
+
+// initializer must return void
+#pragma rs reduce(init_nonvoid) initializer(init_nonvoid) accumulator(AccumInt)
+static int init_nonvoid(int *accum) { return 0; }
+
+// initializer parameter must point to non-const
+#pragma rs reduce(init_const) initializer(init_const) accumulator(AccumInt)
+static void init_const(const int *accum) { }
+
+// . . . but initializer parameter VALUE can be const
+#pragma rs reduce(init_valconst) initializer(init_valconst) accumulator(AccumInt)
+static void init_valconst(int *const accum) { }
+
+/////////////////////////////////////////////////////////////////////////////
+// accumulator
+/////////////////////////////////////////////////////////////////////////////
+
+// accumulator must take at least 2 parameters
+#pragma rs reduce(accum0) accumulator(accum0)
+static void accum0() { }
+
+// accumulator must take at least 2 parameters
+#pragma rs reduce(accum1) accumulator(accum1)
+static void accum1(int a) { }
+
+// accumulator first parameter must be of pointer type
+#pragma rs reduce(accum_noptr) accumulator(accum_noptr)
+static void accum_noptr(int accum, int val) { }
+
+// accumulator and initializer must take pointers to same type
+#pragma rs reduce(accum_vs_init) initializer(avi_init) accumulator(avi_accum)
+static void avi_init(int *accum) { }
+static void avi_accum(double *accum, int val) { }
+
+// accumulator must have at least 1 input
+#pragma rs reduce(accum_special) accumulator(accum_special)
+static void accum_special(int *accum, int x) { }
+
+// accumulator input must not be a pointer . . .
+#pragma rs reduce(accum_ptr) accumulator(accum_ptr) combiner(comb_ptr)
+static void accum_ptr(int *accum, char *val) { }
+static void comb_ptr(int *accum, const int *other) { }
+
+// . . . including a pointer from array decay
+#pragma rs reduce(accum_arr) accumulator(accum_arr) combiner(comb_arr)
+typedef char CharArray[10];
+static void accum_arr(int *accum, CharArray val) { }
+static void comb_arr(int *accum, const int *other) { }
+
+// accumulator input must not contain object type
+#pragma rs reduce(accum_obj) accumulator(accum_obj) combiner(comb_obj)
+static void accum_obj(int *accum, int val, rs_element elem) { }
+static void comb_obj(int *accum, const int *other) { }
+
+// accumulator may be overloadable . . .
+#pragma rs reduce(accum_over) accumulator(accum_over)
+static __attribute__((overloadable)) void accum_over(int *accum, int val) { }
+
+// . . . but accumulator must not have duplicate definitions
+#pragma rs reduce(accum_dup) accumulator(accum_dup)
+static __attribute__((overloadable)) void accum_dup(int *accum, int val) { }
+static __attribute__((overloadable)) void accum_dup(uint *accum, uint val) { }
+
+// accumulator must be present
+#pragma rs reduce(accum_missing) accumulator(accum_missing)
+
+// accumulator must be static
+#pragma rs reduce(accum_nonstatic) accumulator(accum_nonstatic)
+void accum_nonstatic(int *accum, int val) { }
+
+// accumulator must return void
+#pragma rs reduce(accum_nonvoid) accumulator(accum_nonvoid)
+static int accum_nonvoid(int *accum, int val) { return 0; }
+
+// first accumulator parameter must point to non-const . . .
+#pragma rs reduce(accum_const) accumulator(accum_const)
+static void accum_const(const int *accum, int val) { }
+
+// . . . but accumulator parameter VALUES can be const
+#pragma rs reduce(accum_valconst) accumulator(accum_valconst)
+static void accum_valconst(int *const accum, const int val) { }
+
+/////////////////////////////////////////////////////////////////////////////
+// combiner
+/////////////////////////////////////////////////////////////////////////////
+
+// combiner must take exactly 2 parameters
+#pragma rs reduce(comb0) accumulator(AccumInt) combiner(comb0)
+static void comb0() { }
+
+// combiner must take exactly 2 parameters
+#pragma rs reduce(comb1) accumulator(AccumInt) combiner(comb1)
+static void comb1(int *accum) { }
+
+// combiner must take exactly 2 parameters
+#pragma rs reduce(comb3) accumulator(AccumInt) combiner(comb3)
+static void comb3(int *accum, const int *otherA, int otherB) { }
+
+// combiner and accumulator must take pointers to same type
+#pragma rs reduce(comb_vs_accum) accumulator(cva_accum) combiner(cva_comb)
+static void cva_accum(int *accum, char val) { }
+static void cva_comb(unsigned *accum, const unsigned *other) { }
+
+// accumulator must have 1 input and no specials to omit combiner
+#pragma rs reduce(accum_2in) accumulator(accum_2in)
+static void accum_2in(int *accum, int in1, int in2) { }
+
+// accumulator must have 1 input and no specials to omit combiner
+#pragma rs reduce(accum_special_1in) accumulator(accum_special_1in)
+static void accum_special_1in(int *accum, int in1, int x) { }
+
+// accumulator parameter types must agree to omit combiner
+#pragma rs reduce(accum_types) accumulator(accum_types)
+static void accum_types(int *accum, unsigned val) { }
+
+// combiner may be overloadable . . .
+#pragma rs reduce(comb_over) accumulator(AccumInt) combiner(comb_over)
+static __attribute__((overloadable)) void comb_over(int *accum, const int *other) { }
+
+// . . . but combiner must not have duplicate definitions
+#pragma rs reduce(comb_dup) accumulator(AccumInt) combiner(comb_dup)
+static __attribute__((overloadable)) void comb_dup(int *accum, const int *other) { }
+static __attribute__((overloadable)) void comb_dup(uint *accum, const uint *other) { }
+
+// combiner must be present
+#pragma rs reduce(comb_missing) accumulator(AccumInt) combiner(comb_missing)
+
+// combiner must be static
+#pragma rs reduce(comb_nonstatic) accumulator(AccumInt) combiner(comb_nonstatic)
+void comb_nonstatic(int *accum, const int *other) { }
+
+// combiner must return void
+#pragma rs reduce(comb_nonvoid) accumulator(AccumInt) combiner(comb_nonvoid)
+static int comb_nonvoid(int *accum, const int *other) { return 0; }
+
+// first combiner parameter must point to non-const and second to const . . .
+#pragma rs reduce(comb_const) accumulator(AccumInt) combiner(comb_const)
+static void comb_const(const int *accum, int *other) { }
+
+// . . . but combiner parameter VALUES can be const
+#pragma rs reduce(comb_valconst) accumulator(AccumInt) combiner(comb_valconst)
+static void comb_valconst(int *const accum, const int *other) { }
+
+/////////////////////////////////////////////////////////////////////////////
+// outconverter
+/////////////////////////////////////////////////////////////////////////////
+
+// outconverter must take exactly 2 parameters
+#pragma rs reduce(out0) accumulator(AccumInt) outconverter(out0)
+static void out0() { }
+
+// outconverter must take exactly 2 parameters
+#pragma rs reduce(out1) accumulator(AccumInt) outconverter(out1)
+static void out1(char *out) { }
+
+// outconverter must take exactly 2 parameters
+#pragma rs reduce(out3) accumulator(AccumInt) outconverter(out3)
+static void out3(char *out, const int *val, int foo) { }
+
+// outconverter cannot take special parameter
+#pragma rs reduce(out_special) accumulator(AccumInt) outconverter(out_special)
+static void out_special(char *out, const int *y) { }
+
+// outconverter must take pointer
+#pragma rs reduce(out_ptr1) accumulator(AccumInt) outconverter(out_ptr1)
+static void out_ptr1(int out, const int *val) { }
+
+// outconverter must take pointer
+#pragma rs reduce(out_ptr2) accumulator(AccumInt) outconverter(out_ptr2)
+static void out_ptr2(int *out, const int val) { }
+
+// outconverter and accumulator must take pointers to same type
+#pragma rs reduce(out_vs_accum) accumulator(AccumInt) outconverter(ova_out)
+static void ova_out(int *out, const double *val) { }
+
+// outconverter may be overloadable . . .
+#pragma rs reduce(out_over) accumulator(AccumInt) outconverter(out_over)
+static __attribute__((overloadable)) void out_over(double *accum, const int *val) { }
+
+// . . . but outconverter  must not have duplicate definitions
+#pragma rs reduce(out_dup) accumulator(AccumInt) outconverter(out_dup)
+static __attribute__((overloadable)) void out_dup(double *out, const int *val) { }
+static __attribute__((overloadable)) void out_dup(float *out, const int *val) { }
+
+// ouconverter must be present
+#pragma rs reduce(out_missing) accumulator(AccumInt) outconverter(out_missing)
+
+// outconverter must be static
+#pragma rs reduce(out_nonstatic) accumulator(AccumInt) outconverter(out_nonstatic)
+void out_nonstatic(int *out, const int *val) { }
+
+// outconverter must return void
+#pragma rs reduce(out_nonvoid) accumulator(AccumInt) outconverter(out_nonvoid)
+static int out_nonvoid(int *out, const int *val) { return 0; }
+
+// first outconverter parameter must point to non-const and second to const . . .
+#pragma rs reduce(out_const) accumulator(AccumInt) outconverter(out_const)
+static void out_const(const int *out, int *val) { }
+
+// . . . but outconverter parameter VALUES can be const
+#pragma rs reduce(out_valconst) accumulator(AccumInt) outconverter(out_valconst)
+static void out_valconst(int *const out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////////
+// halter
+/////////////////////////////////////////////////////////////////////////////
+
+// halter must return bool
+#pragma rs reduce(halt_void) accumulator(AccumInt) halter(halt_void)
+static void halt_void(const int *accum) { }
+
+// halter must return bool
+#pragma rs reduce(halt_int) accumulator(AccumInt) halter(halt_int)
+static int halt_int(const int *accum) { return 0; }
+
+// halter must take exactly 1 parameter
+#pragma rs reduce(halt0) accumulator(AccumInt) halter(halt0)
+static bool halt0() { return false; }
+
+// halter must take exactly 1 parameter
+#pragma rs reduce(halt2) accumulator(AccumInt) halter(halt2)
+static bool halt2(const int *accum, const int *accum2) { return false; }
+
+// halter cannot take special parameter
+#pragma rs reduce(halt_special) accumulator(AccumInt) halter(halt_special)
+static bool halt_special(const int *context) { return false; }
+
+// halter and accumulator must take pointers to same type
+#pragma rs reduce(halt_vs_accum) accumulator(AccumInt) halter(hva_halt)
+static bool hva_halt(const unsigned *accum) { return false; }
+
+// halter may be overloadable . . .
+#pragma rs reduce(halt_over) accumulator(AccumInt) halter(halt_over)
+static __attribute__((overloadable)) bool halt_over(const int *accum) { return false; }
+
+// . . . but halter must not have duplicate definitions
+#pragma rs reduce(halt_dup) accumulator(AccumInt) halter(halt_dup)
+static __attribute__((overloadable)) bool halt_dup(const int *accum) { return false; }
+static __attribute__((overloadable)) bool halt_dup(const unsigned int *accum) { return false; }
+
+// halter must be present
+#pragma rs reduce(halt_missing) accumulator(AccumInt) halter(halt_missing)
+
+// halter must be static
+#pragma rs reduce(halt_nonstatic) accumulator(AccumInt) halter(halt_nonstatic)
+bool halt_nonstatic(const int *accum) { return false; }
+
+// halter parameter must point to const
+#pragma rs reduce(halt_const) accumulator(AccumInt) halter(halt_const)
+static bool halt_const(int *accum) { return false; }
diff --git a/tests/F_reduce_general_bad_function/stderr.txt.expect b/tests/F_reduce_general_bad_function/stderr.txt.expect
new file mode 100644
index 0000000..ac74748
--- /dev/null
+++ b/tests/F_reduce_general_bad_function/stderr.txt.expect
@@ -0,0 +1,61 @@
+reduce_general_bad_function.rs:17:13: error: initializer init0() for '#pragma rs reduce(init0)' (reduce_general_bad_function.rs:16:12) must take exactly 1 parameter (found 0)
+reduce_general_bad_function.rs:21:13: error: initializer init2() for '#pragma rs reduce(init2)' (reduce_general_bad_function.rs:20:12) must take exactly 1 parameter (found 2)
+reduce_general_bad_function.rs:25:13: error: initializer init_special1() for '#pragma rs reduce(init_special1)' (reduce_general_bad_function.rs:24:12) cannot take special parameter 'x'
+reduce_general_bad_function.rs:29:13: error: initializer init2_special1() for '#pragma rs reduce(init2_special1)' (reduce_general_bad_function.rs:28:12) must take exactly 1 parameter (found 2)
+reduce_general_bad_function.rs:33:13: error: initializer init2_special0() for '#pragma rs reduce(init2_special0)' (reduce_general_bad_function.rs:32:12) must take exactly 1 parameter (found 2)
+reduce_general_bad_function.rs:37:13: error: initializer init_noptr() for '#pragma rs reduce(init_noptr)' (reduce_general_bad_function.rs:36:12) parameter 'a' must be of pointer type not 'int'
+reduce_general_bad_function.rs:44:12: error: duplicate function definition for 'initializer(init_dup)' for '#pragma rs reduce(init_dup)' (reduce_general_bad_function.rs:45:43, reduce_general_bad_function.rs:46:43)
+reduce_general_bad_function.rs:49:12: error: could not find function definition for 'initializer(init_missing)' for '#pragma rs reduce(init_missing)'
+reduce_general_bad_function.rs:53:6: error: initializer init_nonstatic() for '#pragma rs reduce(init_nonstatic)' (reduce_general_bad_function.rs:52:12) must be static
+reduce_general_bad_function.rs:57:12: error: initializer init_nonvoid() for '#pragma rs reduce(init_nonvoid)' (reduce_general_bad_function.rs:56:12) must return void not 'int'
+reduce_general_bad_function.rs:61:35: error: initializer init_const() for '#pragma rs reduce(init_const)' (reduce_general_bad_function.rs:60:12) parameter 'accum' (type 'const int *') must not point to const-qualified type
+reduce_general_bad_function.rs:73:13: error: accumulator accum0() for '#pragma rs reduce(accum0)' (reduce_general_bad_function.rs:72:12) must take at least 2 parameters
+reduce_general_bad_function.rs:77:13: error: accumulator accum1() for '#pragma rs reduce(accum1)' (reduce_general_bad_function.rs:76:12) must take at least 2 parameters
+reduce_general_bad_function.rs:81:13: error: accumulator accum_noptr() for '#pragma rs reduce(accum_noptr)' (reduce_general_bad_function.rs:80:12) parameter 'accum' must be of pointer type not 'int'
+reduce_general_bad_function.rs:86:13: error: accumulator avi_accum() for '#pragma rs reduce(accum_vs_init)' (reduce_general_bad_function.rs:84:12) parameter 'accum' (type 'double *') and initializer avi_init() parameter 'accum' (type 'int *') must be pointers to the same type
+reduce_general_bad_function.rs:90:13: error: accumulator accum_special() for '#pragma rs reduce(accum_special)' (reduce_general_bad_function.rs:89:12) must have at least 1 input ('x' is a special parameter)
+reduce_general_bad_function.rs:94:41: error: accumulator accum_ptr() for '#pragma rs reduce(accum_ptr)' (reduce_general_bad_function.rs:93:12) parameter 'val' (type 'char *') must not be a pointer
+reduce_general_bad_function.rs:100:45: error: accumulator accum_arr() for '#pragma rs reduce(accum_arr)' (reduce_general_bad_function.rs:98:12) parameter 'val' (type 'char *') must not be a pointer
+reduce_general_bad_function.rs:105:55: error: accumulator accum_obj() for '#pragma rs reduce(accum_obj)' (reduce_general_bad_function.rs:104:12) parameter 'elem' (type 'struct rs_element') must not contain an object type
+reduce_general_bad_function.rs:113:12: error: duplicate function definition for 'accumulator(accum_dup)' for '#pragma rs reduce(accum_dup)' (reduce_general_bad_function.rs:114:43, reduce_general_bad_function.rs:115:43)
+reduce_general_bad_function.rs:118:12: error: could not find function definition for 'accumulator(accum_missing)' for '#pragma rs reduce(accum_missing)'
+reduce_general_bad_function.rs:122:6: error: accumulator accum_nonstatic() for '#pragma rs reduce(accum_nonstatic)' (reduce_general_bad_function.rs:121:12) must be static
+reduce_general_bad_function.rs:126:12: error: accumulator accum_nonvoid() for '#pragma rs reduce(accum_nonvoid)' (reduce_general_bad_function.rs:125:12) must return void not 'int'
+reduce_general_bad_function.rs:130:36: error: accumulator accum_const() for '#pragma rs reduce(accum_const)' (reduce_general_bad_function.rs:129:12) parameter 'accum' (type 'const int *') must not point to const-qualified type
+reduce_general_bad_function.rs:142:13: error: combiner comb0() for '#pragma rs reduce(comb0)' (reduce_general_bad_function.rs:141:12) must take exactly 2 parameters (found 0)
+reduce_general_bad_function.rs:146:13: error: combiner comb1() for '#pragma rs reduce(comb1)' (reduce_general_bad_function.rs:145:12) must take exactly 2 parameters (found 1)
+reduce_general_bad_function.rs:150:13: error: combiner comb3() for '#pragma rs reduce(comb3)' (reduce_general_bad_function.rs:149:12) must take exactly 2 parameters (found 3)
+reduce_general_bad_function.rs:155:13: error: combiner cva_comb() for '#pragma rs reduce(comb_vs_accum)' (reduce_general_bad_function.rs:153:12) parameter 'accum' (type 'unsigned int *') and accumulator cva_accum() parameter 'accum' (type 'int *') must be pointers to the same type
+reduce_general_bad_function.rs:155:13: error: combiner cva_comb() for '#pragma rs reduce(comb_vs_accum)' (reduce_general_bad_function.rs:153:12) parameter 'other' (type 'const unsigned int *') and accumulator cva_accum() parameter 'accum' (type 'int *') must be pointers to the same type
+reduce_general_bad_function.rs:159:13: error: accumulator accum_2in() for '#pragma rs reduce(accum_2in)' (reduce_general_bad_function.rs:158:12) must have exactly 1 input and no special parameters in order for the combiner to be omitted
+reduce_general_bad_function.rs:163:13: error: accumulator accum_special_1in() for '#pragma rs reduce(accum_special_1in)' (reduce_general_bad_function.rs:162:12) must have exactly 1 input and no special parameters in order for the combiner to be omitted
+reduce_general_bad_function.rs:167:13: error: accumulator accum_types() for '#pragma rs reduce(accum_types)' (reduce_general_bad_function.rs:166:12) parameter 'accum' (type 'int *') must be pointer to the type of parameter 'val' (type 'unsigned int') in order for the combiner to be omitted
+reduce_general_bad_function.rs:174:12: error: duplicate function definition for 'combiner(comb_dup)' for '#pragma rs reduce(comb_dup)' (reduce_general_bad_function.rs:175:43, reduce_general_bad_function.rs:176:43)
+reduce_general_bad_function.rs:179:12: error: could not find function definition for 'combiner(comb_missing)' for '#pragma rs reduce(comb_missing)'
+reduce_general_bad_function.rs:183:6: error: combiner comb_nonstatic() for '#pragma rs reduce(comb_nonstatic)' (reduce_general_bad_function.rs:182:12) must be static
+reduce_general_bad_function.rs:187:12: error: combiner comb_nonvoid() for '#pragma rs reduce(comb_nonvoid)' (reduce_general_bad_function.rs:186:12) must return void not 'int'
+reduce_general_bad_function.rs:191:35: error: combiner comb_const() for '#pragma rs reduce(comb_const)' (reduce_general_bad_function.rs:190:12) parameter 'accum' (type 'const int *') must not point to const-qualified type
+reduce_general_bad_function.rs:191:47: error: combiner comb_const() for '#pragma rs reduce(comb_const)' (reduce_general_bad_function.rs:190:12) parameter 'other' (type 'int *') must point to const-qualified type
+reduce_general_bad_function.rs:203:13: error: outconverter out0() for '#pragma rs reduce(out0)' (reduce_general_bad_function.rs:202:12) must take exactly 2 parameters (found 0)
+reduce_general_bad_function.rs:207:13: error: outconverter out1() for '#pragma rs reduce(out1)' (reduce_general_bad_function.rs:206:12) must take exactly 2 parameters (found 1)
+reduce_general_bad_function.rs:211:13: error: outconverter out3() for '#pragma rs reduce(out3)' (reduce_general_bad_function.rs:210:12) must take exactly 2 parameters (found 3)
+reduce_general_bad_function.rs:215:13: error: outconverter out_special() for '#pragma rs reduce(out_special)' (reduce_general_bad_function.rs:214:12) cannot take special parameter 'y'
+reduce_general_bad_function.rs:219:13: error: outconverter out_ptr1() for '#pragma rs reduce(out_ptr1)' (reduce_general_bad_function.rs:218:12) parameter 'out' must be of pointer type not 'int'
+reduce_general_bad_function.rs:223:13: error: outconverter out_ptr2() for '#pragma rs reduce(out_ptr2)' (reduce_general_bad_function.rs:222:12) parameter 'val' must be of pointer type not 'const int'
+reduce_general_bad_function.rs:227:13: error: outconverter ova_out() for '#pragma rs reduce(out_vs_accum)' (reduce_general_bad_function.rs:226:12) parameter 'val' (type 'const double *') and accumulator AccumInt() parameter 'accum' (type 'int *') must be pointers to the same type
+reduce_general_bad_function.rs:234:12: error: duplicate function definition for 'outconverter(out_dup)' for '#pragma rs reduce(out_dup)' (reduce_general_bad_function.rs:235:43, reduce_general_bad_function.rs:236:43)
+reduce_general_bad_function.rs:239:12: error: could not find function definition for 'outconverter(out_missing)' for '#pragma rs reduce(out_missing)'
+reduce_general_bad_function.rs:243:6: error: outconverter out_nonstatic() for '#pragma rs reduce(out_nonstatic)' (reduce_general_bad_function.rs:242:12) must be static
+reduce_general_bad_function.rs:247:12: error: outconverter out_nonvoid() for '#pragma rs reduce(out_nonvoid)' (reduce_general_bad_function.rs:246:12) must return void not 'int'
+reduce_general_bad_function.rs:251:34: error: outconverter out_const() for '#pragma rs reduce(out_const)' (reduce_general_bad_function.rs:250:12) parameter 'out' (type 'const int *') must not point to const-qualified type
+reduce_general_bad_function.rs:251:44: error: outconverter out_const() for '#pragma rs reduce(out_const)' (reduce_general_bad_function.rs:250:12) parameter 'val' (type 'int *') must point to const-qualified type
+reduce_general_bad_function.rs:263:13: error: halter halt_void() for '#pragma rs reduce(halt_void)' (reduce_general_bad_function.rs:262:12) must return bool not 'void'
+reduce_general_bad_function.rs:267:12: error: halter halt_int() for '#pragma rs reduce(halt_int)' (reduce_general_bad_function.rs:266:12) must return bool not 'int'
+reduce_general_bad_function.rs:271:13: error: halter halt0() for '#pragma rs reduce(halt0)' (reduce_general_bad_function.rs:270:12) must take exactly 1 parameter (found 0)
+reduce_general_bad_function.rs:275:13: error: halter halt2() for '#pragma rs reduce(halt2)' (reduce_general_bad_function.rs:274:12) must take exactly 1 parameter (found 2)
+reduce_general_bad_function.rs:279:13: error: halter halt_special() for '#pragma rs reduce(halt_special)' (reduce_general_bad_function.rs:278:12) cannot take special parameter 'context'
+reduce_general_bad_function.rs:283:13: error: halter hva_halt() for '#pragma rs reduce(halt_vs_accum)' (reduce_general_bad_function.rs:282:12) parameter 'accum' (type 'const unsigned int *') and accumulator AccumInt() parameter 'accum' (type 'int *') must be pointers to the same type
+reduce_general_bad_function.rs:290:12: error: duplicate function definition for 'halter(halt_dup)' for '#pragma rs reduce(halt_dup)' (reduce_general_bad_function.rs:291:43, reduce_general_bad_function.rs:292:43)
+reduce_general_bad_function.rs:295:12: error: could not find function definition for 'halter(halt_missing)' for '#pragma rs reduce(halt_missing)'
+reduce_general_bad_function.rs:299:6: error: halter halt_nonstatic() for '#pragma rs reduce(halt_nonstatic)' (reduce_general_bad_function.rs:298:12) must be static
+reduce_general_bad_function.rs:303:29: error: halter halt_const() for '#pragma rs reduce(halt_const)' (reduce_general_bad_function.rs:302:12) parameter 'accum' (type 'int *') must point to const-qualified type
diff --git a/tests/P_reduce_general/stdout.txt.expect b/tests/F_reduce_general_bad_function/stdout.txt.expect
similarity index 100%
copy from tests/P_reduce_general/stdout.txt.expect
copy to tests/F_reduce_general_bad_function/stdout.txt.expect
diff --git a/tests/F_reduce_general_bad_result/reduce_general_bad_result.rs b/tests/F_reduce_general_bad_result/reduce_general_bad_result.rs
new file mode 100644
index 0000000..7c1fdc9
--- /dev/null
+++ b/tests/F_reduce_general_bad_result/reduce_general_bad_result.rs
@@ -0,0 +1,427 @@
+// -target-api 0 -Wall
+#pragma version(1)
+#pragma rs java_package_name(export)
+
+// trivial accumulator for use multiple times later
+static void AccumInt(int *accum, int val) { }
+
+// NOTE: union and bitfield errors are only emitted once per type, so
+//       we have multiple types here to ensure that we issue errors
+//       in multiple contexts.
+
+// NOTE: accumulator data type is restricted in certain ways regardless
+//       of result type; we do not test that here.  This is covered
+//       in the test case reduce_general_bad_accumulator.rs.
+
+/////////////////////////////////////////////////////////////////////////
+
+// result type cannot be a vector of half
+#pragma rs reduce(redHalf3) accumulator(AccumHalf3)
+static void AccumHalf3(half3 *accum, half3 val) { }
+
+// problem is result type, not accumulator type, so outconverter can fix this
+#pragma rs reduce(redHalf3OutFix) accumulator(AccumHalf3) outconverter(OutHalf3Fix)
+static void OutHalf3Fix(half *out, const half3 *val) { }
+
+// problem is result type, not accumulator type, so outconverter can break this
+#pragma rs reduce(redHalf3OutBreak) accumulator(AccumInt) outconverter(OutHalf3Break)
+static void OutHalf3Break(half3 *out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////
+
+typedef half4 Half4Array5[5];
+
+// result type cannot be an array of vector of half
+#pragma rs reduce(redHalf4A5) accumulator(AccumHalf4A5) combiner(CombHalf4A5)
+static void AccumHalf4A5(Half4Array5 *accum, short val) { }
+static void CombHalf4A5(Half4Array5 *accum, const Half4Array5 *other) { }
+
+// problem is result type, not accumulator type, so outconverter can fix this
+#pragma rs reduce(redHalf4A5OutFix) accumulator(AccumHalf4A5) combiner(CombHalf4A5) \
+  outconverter(OutHalf4A5Fix)
+static void OutHalf4A5Fix(half *out, const Half4Array5 *val) { }
+
+// problem is result type, not accumulator type, so outconverter can break this
+#pragma rs reduce(redHalf4A5OutBreak) accumulator(AccumInt) outconverter(OutHalf4A5Break)
+static void OutHalf4A5Break(Half4Array5 *out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////
+
+typedef unsigned int UIntA916[9][16];
+
+// result type cannot be multidimensional array
+#pragma rs reduce(redUInt2dA) accumulator(AccumUInt2dA) combiner(CombUInt2dA)
+static void AccumUInt2dA(UIntA916 *accum, int val) { }
+static void CombUInt2dA(UIntA916 *accum, const UIntA916 *val) { }
+
+// problem is result type, not accumulator type, so outconverter can fix this
+#pragma rs reduce(redUInt2dAOutFix) accumulator(AccumUInt2dA) combiner(CombUInt2dA) \
+  outconverter(OutUInt2dAFix)
+static void OutUInt2dAFix(uint *out, const UIntA916 *val) { }
+
+// problem is result type, not accumulator type, so outconverter can break this
+#pragma rs reduce(redUInt2dAOutBreak) accumulator(AccumInt) outconverter(OutUInt2dABreak)
+static void OutUInt2dABreak(UIntA916 *out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////
+
+union UnionShortDouble {
+  short s;
+  double d;
+};
+
+union UnionCharInt {
+  char c;
+  int i;
+};
+
+union UnionLongFloat {
+  long l;
+  float f;
+};
+
+// result type cannot be union
+#pragma rs reduce(redUnionShortDouble) accumulator(AccumUnionShortDouble) \
+  combiner(CombineUnionShortDouble)
+static void AccumUnionShortDouble(union UnionShortDouble *accum, short s, double d) { }
+static void CombineUnionShortDouble(union UnionShortDouble *accum,
+                                    const union UnionShortDouble *other) { }
+
+// problem is result type, not accumulator type, so outconverter can fix this
+#pragma rs reduce(redUnionCharIntOutFix) accumulator(AccumUnionCharInt) \
+  combiner(CombineUnionCharInt) outconverter(OutUnionCharIntFix)
+static void AccumUnionCharInt(union UnionCharInt *accum, short s, double d) { }
+static void CombineUnionCharInt(union UnionCharInt *accum, const union UnionCharInt *other) { }
+static void OutUnionCharIntFix(int *out, const union UnionCharInt *val) { }
+
+// problem is result type, not accumulator type, so outconverter can break this
+#pragma rs reduce(redUnionLongFloatOutBreak) accumulator(AccumInt) \
+  outconverter(OutUnionLongFloatBreak)
+static void OutUnionLongFloatBreak(union UnionLongFloat *out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////
+
+union UnionIntFloat {
+  short s;
+  double d;
+};
+typedef union UnionIntFloat UnionIntFloatArray[10];
+
+union UnionDoubleFloat {
+  double d;
+  float f;
+};
+typedef union UnionDoubleFloat UnionDoubleFloatArray[10];
+
+union UnionCharLong {
+  char c;
+  long l;
+};
+typedef union UnionCharLong UnionCharLongArray[10];
+
+// cannot export array of union
+#pragma rs reduce(redUnionIntFloatArray) accumulator(AccumUnionIntFloatArray) \
+  combiner(CombineUnionIntFloatArray)
+static void AccumUnionIntFloatArray(UnionIntFloatArray *accum, int val) { }
+static void CombineUnionIntFloatArray(UnionIntFloatArray *accum,
+                                      const UnionIntFloatArray *other) { }
+
+// problem is result type, not accumulator type, so outconverter can fix this
+#pragma rs reduce(redUnionDoubleFloatArrayOutFix) accumulator(AccumUnionDoubleFloatArray) \
+  combiner(CombineUnionDoubleFloatArray) outconverter(OutUnionDoubleFloatArrayFix)
+static void AccumUnionDoubleFloatArray(UnionDoubleFloatArray *accum, short s, double d) { }
+static void CombineUnionDoubleFloatArray(UnionDoubleFloatArray *accum,
+                                           const UnionDoubleFloatArray *other) { }
+static void OutUnionDoubleFloatArrayFix(int *out, const UnionDoubleFloatArray *val) { }
+
+// problem is result type, not accumulator type, so outconverter can break this
+#pragma rs reduce(redUnionCharLongArrayOutBreak) accumulator(AccumInt) \
+  outconverter(OutUnionCharLongArrayBreak)
+static void OutUnionCharLongArrayBreak(UnionCharLongArray *out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////
+
+struct Bits1 {
+  int b:1;
+};
+
+struct Bits11 {
+  int c:1;
+  int d:1;
+};
+
+struct Bits111 {
+  int e:1;
+  int f:1;
+  int g:1;
+};
+
+// cannot export struct with bitfield
+#pragma rs reduce(redBits) accumulator(AccumBits) combiner(CombineBits)
+static void AccumBits(struct Bits1 *accum, int val) { }
+static void CombineBits(struct Bits1 *accum, const struct Bits1 *other) { }
+
+// problem is result type, not accumulator type, so outconverter can fix this
+#pragma rs reduce(redBitsOutFix) accumulator(AccumBitsOutFix) combiner(CombineBitsOutFix) \
+  outconverter(OutBitsFix)
+static void AccumBitsOutFix(struct Bits11 *accum, int val) { }
+static void CombineBitsOutFix(struct Bits11 *accum, const struct Bits11 *other) { }
+static void OutBitsFix(int *out, const struct Bits11 *val) { }
+
+// problem is result type, not accumulator type, so outconverter can break this
+#pragma rs reduce(redBitsOutBreak) accumulator(AccumInt) outconverter(OutBitsBreak)
+static void OutBitsBreak(struct Bits111 *out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////
+
+struct Bits2 {
+  int b:2;
+};
+typedef struct Bits2 Bits2Array[10];
+
+struct Bits22 {
+  int c:2;
+  int d:2;
+};
+typedef struct Bits22 Bits22Array[10];
+
+struct Bits222 {
+  int e:2;
+  int f:2;
+  int g:2;
+};
+typedef struct Bits222 Bits222Array[10];
+
+// cannot export array of struct with bitfield
+#pragma rs reduce(redBitsArray) accumulator(AccumBitsArray) combiner(CombineBitsArray)
+static void AccumBitsArray(Bits2Array *accum, int val) { }
+static void CombineBitsArray(Bits2Array *accum, const Bits2Array *other) { }
+
+// problem is result type, not accumulator type, so outconverter can fix this
+#pragma rs reduce(redBitsArrayOutFix) accumulator(AccumBitsArrayOutFix) \
+  combiner(CombineBitsArrayOutFix) outconverter(OutBitsArrayFix)
+static void AccumBitsArrayOutFix(Bits22Array *accum, int val) { }
+static void CombineBitsArrayOutFix(Bits22Array *accum, const Bits22Array *other) { }
+static void OutBitsArrayFix(int *out, const Bits22Array *val) { }
+
+// problem is result type, not accumulator type, so outconverter can break this
+#pragma rs reduce(redBitsArrayOutBreak) accumulator(AccumInt) outconverter(OutBitsArrayBreak)
+static void OutBitsArrayBreak(Bits222Array *out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////
+
+// result type cannot be matrix
+#pragma rs reduce(redMat) accumulator(AccumMat)
+static void AccumMat(rs_matrix2x2 *accum, rs_matrix2x2 val) { }
+
+// problem is result type, not accumulator type, so outconverter can fix this
+#pragma rs reduce(redMatOutFix) accumulator(AccumMat) outconverter(OutMatFix)
+static void OutMatFix(int *out, const rs_matrix2x2 *val) { }
+
+// problem is result type, not accumulator type, so outconverter can break this
+#pragma rs reduce(redMatOutBreak) accumulator(AccumInt) outconverter(OutMatBreak)
+static void OutMatBreak(rs_matrix2x2 *out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////
+
+typedef rs_matrix2x2 ArrayMatrix2x2[10];
+
+// result type cannot be array of matrix
+#pragma rs reduce(redMatArray) accumulator(AccumMatArray) combiner(CombineMatArray)
+static void AccumMatArray(ArrayMatrix2x2 *accum, rs_matrix2x2 val) { }
+static void CombineMatArray(ArrayMatrix2x2 *accum, const ArrayMatrix2x2 *other) { }
+
+// problem is result type, not accumulator type, so outconverter can fix this
+#pragma rs reduce(redMatArrayOutFix) accumulator(AccumMatArray) combiner(CombineMatArray) \
+  outconverter(OutMatArrayFix)
+static void OutMatArrayFix(int *out, const ArrayMatrix2x2 *val) { }
+
+// problem is result type, not accumulator type, so outconverter can break this
+#pragma rs reduce(redMatArrayOutBreak) accumulator(AccumInt) outconverter(OutMatArrayBreak)
+static void OutMatArrayBreak(ArrayMatrix2x2 *out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////
+
+// result type cannot be object type
+#pragma rs reduce(redAlloc) accumulator(AccumInt) outconverter(OutAlloc)
+static void OutAlloc(rs_allocation *out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////
+
+typedef rs_allocation AllocArray[10];
+
+// result type cannot be array of object type
+#pragma rs reduce(redAllocArray) accumulator(AccumAllocArray) outconverter(OutAllocArray)
+static void AccumAllocArray(int *accum, int val) { }
+static void OutAllocArray(AllocArray *out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////
+
+struct StructObj1 {
+  int f;
+  rs_element e;
+};
+
+// result type cannot be struct containing object type
+#pragma rs reduce(redStructObj) accumulator(AccumStructObj) outconverter(OutStructObj)
+static void AccumStructObj(int *accum, int val) { }
+static void OutStructObj(struct StructObj1 *out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////
+
+struct StructObj2 {
+  rs_type t;
+  float f;
+};
+typedef struct StructObj2 StructObj2Array[10];
+
+// result type cannot be array of struct containing object type
+#pragma rs reduce(redStructObjArray) accumulator(AccumStructObjArray) \
+  outconverter(OutStructObjArray)
+static void AccumStructObjArray(int *accum, int val) { }
+static void OutStructObjArray(StructObj2Array *out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////
+
+typedef char *Ptr;
+
+// result type cannot be pointer
+#pragma rs reduce(redPtr) accumulator(AccumPtr) combiner(CombPtr)
+static void AccumPtr(Ptr *accum, char val) { }
+static void CombPtr(Ptr *accum, const Ptr *other) { }
+
+// problem is result type, not accumulator type, so outconverter can fix this
+#pragma rs reduce(redPtrOutFix) accumulator(AccumPtr) combiner(CombPtr) \
+  outconverter(OutPtrFix)
+static void OutPtrFix(int *out, const Ptr *val) { }
+
+// problem is result type, not accumulator type, so outconverter can break this
+#pragma rs reduce(redPtrOutBreak) accumulator(AccumInt) outconverter(OutPtrBreak)
+static void OutPtrBreak(Ptr *out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////
+
+typedef Ptr PtrArray7[7];
+
+// cannot export array of pointer
+#pragma rs reduce(redPtrArray7) accumulator(AccumPtrArray7) combiner(CombPtrArray7)
+static void AccumPtrArray7(PtrArray7 *accum, int val) { }
+static void CombPtrArray7(PtrArray7 *accum, const PtrArray7 *other) { }
+
+// problem is result type, not accumulator type, so outconverter can fix this
+#pragma rs reduce(redPtrArray7OutFix) accumulator(AccumPtrArray7) combiner(CombPtrArray7) \
+  outconverter(OutPtrArray7Fix)
+static void OutPtrArray7Fix(int *out, const PtrArray7 *val) { }
+
+// problem is result type, not accumulator type, so outconverter can break this
+#pragma rs reduce(redPtrArray7OutBreak) accumulator(AccumInt) outconverter(OutPtrArray7Break)
+static void OutPtrArray7Break(PtrArray7 *out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////
+
+struct StructPtr1 {
+  Ptr p;
+  double d;
+};
+
+struct StructPtr11 {
+  Ptr p;
+  double d;
+  int i;
+};
+
+struct StructPtr111 {
+  Ptr p;
+  double d;
+  int i;
+  float f;
+};
+
+// cannot export struct containing pointer
+#pragma rs reduce(redStructPtr) accumulator(AccumStructPtr) combiner(CombStructPtr)
+static void AccumStructPtr(struct StructPtr1 *accum, int val) { }
+static void CombStructPtr(struct StructPtr1 *accum, const struct StructPtr1 *other) { }
+
+// problem is result type, not accumulator type, so outconverter can fix this
+#pragma rs reduce(redStructPtrOutFix) accumulator(AccumStructPtrOutFix) \
+  combiner(CombStructPtrOutFix) outconverter(OutStructPtrFix)
+static void AccumStructPtrOutFix(struct StructPtr11 *accum, int val) { }
+static void CombStructPtrOutFix(struct StructPtr11 *accum, const struct StructPtr11 *other) { }
+static void OutStructPtrFix(int *out, const struct StructPtr11 *val) { }
+
+// problem is result type, not accumulator type, so outconverter can break this
+#pragma rs reduce(redStructPtrOutBreak) accumulator(AccumInt) outconverter(OutStructPtrBreak)
+static void OutStructPtrBreak(struct StructPtr111 *out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////
+
+struct StructPtr2 {
+  float f;
+  Ptr p;
+};
+typedef struct StructPtr2 StructPtr2Array[7];
+
+struct StructPtr22 {
+  float f;
+  Ptr p;
+  char c;
+};
+typedef struct StructPtr22 StructPtr22Array[7];
+
+struct StructPtr222 {
+  float f;
+  Ptr p;
+  char c;
+  double d;
+};
+typedef struct StructPtr222 StructPtr222Array[7];
+
+// cannot export struct containing pointer
+#pragma rs reduce(redStructPtrArray) accumulator(AccumStructPtrArray) combiner(CombStructPtrArray)
+static void AccumStructPtrArray(StructPtr2Array *accum, int val) { }
+static void CombStructPtrArray(StructPtr2Array *accum, const StructPtr2Array *other) { }
+
+// problem is result type, not accumulator type, so outconverter can fix this
+#pragma rs reduce(redStructPtrArrayOutFix) accumulator(AccumStructPtrArrayOutFix) \
+  combiner(CombStructPtrArrayOutFix) outconverter(OutStructPtrArrayFix)
+static void AccumStructPtrArrayOutFix(StructPtr22Array *accum, int val) { }
+static void CombStructPtrArrayOutFix(StructPtr22Array *accum, const StructPtr22Array *other) { }
+static void OutStructPtrArrayFix(int *out, const StructPtr22Array *val) { }
+
+// problem is result type, not accumulator type, so outconverter can break this
+#pragma rs reduce(redStructPtrArrayOutBreak) accumulator(AccumInt) \
+  outconverter(OutStructPtrArrayBreak)
+static void OutStructPtrArrayBreak(StructPtr22Array *out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////
+
+typedef void Fn(void);
+
+// cannot export function type
+//
+// NOTE: Not suitable as accumulator data type, regardless of whether
+//       we have outconverter; that's tested in reduce_general_bad_accumulator.rs.
+#pragma rs reduce(redFn) accumulator(AccumInt) outconverter(OutFn)
+static void OutFn(Fn *out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////
+
+struct Incomplete;
+
+// result type cannot be incomplete type
+//
+// NOTE: Not suitable as accumulator data type, regardless of whether
+//       we have outconverter; that's tested in reduce_general_bad_accumulator.rs.
+#pragma rs reduce(redStructIncomplete) accumulator(AccumInt) outconverter(OutStructIncomplete)
+static void OutStructIncomplete(struct Incomplete *out, const int *val) { }
+
+/////////////////////////////////////////////////////////////////////////
+
+typedef int IntA[]; // incomplete (unknown element count)
+
+// result type cannot be incomplete type
+//
+// NOTE: Not suitable as accumulator data type, regardless of whether
+//       we have outconverter; that's tested in reduce_general_bad_accumulator.rs.
+#pragma rs reduce(redArrayIncomplete) accumulator(AccumInt) outconverter(OutArrayIncomplete)
+static void OutArrayIncomplete(IntA *out, const int *val) { }
diff --git a/tests/F_reduce_general_bad_result/stderr.txt.expect b/tests/F_reduce_general_bad_result/stderr.txt.expect
new file mode 100644
index 0000000..2b4ce24
--- /dev/null
+++ b/tests/F_reduce_general_bad_result/stderr.txt.expect
@@ -0,0 +1,33 @@
+reduce_general_bad_result.rs:20:31: error: accumulator AccumHalf3() for '#pragma rs reduce(redHalf3)' (reduce_general_bad_result.rs:19:12) parameter 'accum' (type '__fp16 * __attribute__((ext_vector_type(3)))') must not point to a half* vector unless outconverter is provided
+reduce_general_bad_result.rs:28:34: error: outconverter OutHalf3Break() for '#pragma rs reduce(redHalf3OutBreak)' (reduce_general_bad_result.rs:27:12) parameter 'out' (type '__fp16 * __attribute__((ext_vector_type(3)))') must not point to a half* vector
+reduce_general_bad_result.rs:36:39: error: accumulator AccumHalf4A5() for '#pragma rs reduce(redHalf4A5)' (reduce_general_bad_result.rs:35:12) parameter 'accum' (type '__fp16 (*)[5] __attribute__((ext_vector_type(4)))') must not point to an array of half* vector unless outconverter is provided
+reduce_general_bad_result.rs:46:42: error: outconverter OutHalf4A5Break() for '#pragma rs reduce(redHalf4A5OutBreak)' (reduce_general_bad_result.rs:45:12) parameter 'out' (type '__fp16 (*)[5] __attribute__((ext_vector_type(4)))') must not point to an array of half* vector
+reduce_general_bad_result.rs:54:36: error: multidimensional arrays cannot be exported: 'accum'
+reduce_general_bad_result.rs:64:39: error: multidimensional arrays cannot be exported: 'out'
+reduce_general_bad_result.rs:68:7: error: unions cannot be exported: 'UnionShortDouble'
+reduce_general_bad_result.rs:78:7: error: unions cannot be exported: 'UnionLongFloat'
+reduce_general_bad_result.rs:104:7: error: unions cannot be exported: 'UnionIntFloat'
+reduce_general_bad_result.rs:116:7: error: unions cannot be exported: 'UnionCharLong'
+reduce_general_bad_result.rs:145:7: error: bit fields are not able to be exported: 'Bits1.b'
+reduce_general_bad_result.rs:154:7: error: bit fields are not able to be exported: 'Bits111.e'
+reduce_general_bad_result.rs:178:7: error: bit fields are not able to be exported: 'Bits2.b'
+reduce_general_bad_result.rs:189:7: error: bit fields are not able to be exported: 'Bits222.e'
+reduce_general_bad_result.rs:215:36: error: accumulator AccumMat() for '#pragma rs reduce(redMat)' (reduce_general_bad_result.rs:214:12) parameter 'accum' (type 'rs_matrix2x2 *') must not point to a matrix type unless outconverter is provided
+reduce_general_bad_result.rs:223:39: error: outconverter OutMatBreak() for '#pragma rs reduce(redMatOutBreak)' (reduce_general_bad_result.rs:222:12) parameter 'out' (type 'rs_matrix2x2 *') must not point to a matrix type
+reduce_general_bad_result.rs:231:43: error: accumulator AccumMatArray() for '#pragma rs reduce(redMatArray)' (reduce_general_bad_result.rs:230:12) parameter 'accum' (type 'rs_matrix2x2 (*)[10]') must not point to an array of matrix type unless outconverter is provided
+reduce_general_bad_result.rs:241:46: error: outconverter OutMatArrayBreak() for '#pragma rs reduce(redMatArrayOutBreak)' (reduce_general_bad_result.rs:240:12) parameter 'out' (type 'rs_matrix2x2 (*)[10]') must not point to an array of matrix type
+reduce_general_bad_result.rs:247:37: error: outconverter OutAlloc() for '#pragma rs reduce(redAlloc)' (reduce_general_bad_result.rs:246:12) parameter 'out' (type 'struct rs_allocation *') must not point to data containing an object type
+reduce_general_bad_result.rs:256:39: error: outconverter OutAllocArray() for '#pragma rs reduce(redAllocArray)' (reduce_general_bad_result.rs:254:12) parameter 'out' (type 'struct rs_allocation (*)[10]') must not point to data containing an object type
+reduce_general_bad_result.rs:268:45: error: outconverter OutStructObj() for '#pragma rs reduce(redStructObj)' (reduce_general_bad_result.rs:266:12) parameter 'out' (type 'struct StructObj1 *') must not point to data containing an object type
+reduce_general_bad_result.rs:282:48: error: outconverter OutStructObjArray() for '#pragma rs reduce(redStructObjArray)' (reduce_general_bad_result.rs:279:12) parameter 'out' (type 'struct StructObj2 (*)[10]') must not point to data containing an object type
+reduce_general_bad_result.rs:290:27: error: accumulator AccumPtr() for '#pragma rs reduce(redPtr)' (reduce_general_bad_result.rs:289:12) parameter 'accum' (type 'char **') must not point to a pointer unless outconverter is provided
+reduce_general_bad_result.rs:300:30: error: outconverter OutPtrBreak() for '#pragma rs reduce(redPtrOutBreak)' (reduce_general_bad_result.rs:299:12) parameter 'out' (type 'char **') must not point to a pointer
+reduce_general_bad_result.rs:308:28: error: structures containing pointers cannot be used as the type of an exported global variable or the parameter to an exported function: 'accum'
+reduce_general_bad_result.rs:318:31: error: structures containing pointers cannot be used as the type of an exported global variable or the parameter to an exported function: 'out'
+reduce_general_bad_result.rs:342:28: error: structures containing pointers cannot be used as the type of an exported global variable or the parameter to an exported function: 'accum'
+reduce_general_bad_result.rs:354:31: error: structures containing pointers cannot be used as the type of an exported global variable or the parameter to an exported function: 'out'
+reduce_general_bad_result.rs:381:33: error: structures containing pointers cannot be used as the type of an exported global variable or the parameter to an exported function: 'accum'
+reduce_general_bad_result.rs:394:36: error: structures containing pointers cannot be used as the type of an exported global variable or the parameter to an exported function: 'out'
+reduce_general_bad_result.rs:405:23: error: function types cannot be exported: 'out'
+reduce_general_bad_result.rs:416:52: error: outconverter OutStructIncomplete() for '#pragma rs reduce(redStructIncomplete)' (reduce_general_bad_result.rs:415:12) parameter 'out' (type 'struct Incomplete *') must not point to an incomplete type
+reduce_general_bad_result.rs:427:38: error: outconverter OutArrayIncomplete() for '#pragma rs reduce(redArrayIncomplete)' (reduce_general_bad_result.rs:426:12) parameter 'out' (type 'int (*)[]') must not point to an incomplete type
diff --git a/tests/P_reduce_general/stdout.txt.expect b/tests/F_reduce_general_bad_result/stdout.txt.expect
similarity index 100%
copy from tests/P_reduce_general/stdout.txt.expect
copy to tests/F_reduce_general_bad_result/stdout.txt.expect
diff --git a/tests/F_reduce_general_parse/reduce_general_parse.rs b/tests/F_reduce_general_parse/reduce_general_parse.rs
index 6c9b410..5566b1a 100644
--- a/tests/F_reduce_general_parse/reduce_general_parse.rs
+++ b/tests/F_reduce_general_parse/reduce_general_parse.rs
@@ -18,3 +18,9 @@
 #pragma rs reduce(baz) accumulator(baccum) initializer(binit) accumulator(baccum2)
 #pragma rs reduce(goo) something(wrong)
 #pragma rs reduce(goo) initializer(gi) accumulator(ga) (
+
+static void init(int *accum) { }
+static void accum(int *accum, int val) { }
+
+static void binit(int *accum) { }
+static void baccum(int *accum, int val) { }
diff --git a/tests/F_reduce_general_parse/stderr.txt.expect b/tests/F_reduce_general_parse/stderr.txt.expect
index 24ace35..fc64dd8 100644
--- a/tests/F_reduce_general_parse/stderr.txt.expect
+++ b/tests/F_reduce_general_parse/stderr.txt.expect
@@ -4,7 +4,7 @@
 reduce_general_parse.rs:8:19: error: missing name after 'reduce(' for '#pragma rs reduce'
 reduce_general_parse.rs:9:22: error: missing ')' after 'reduce(foo' for '#pragma rs reduce'
 reduce_general_parse.rs:10:25: error: missing ')' after 'reduce(foo' for '#pragma rs reduce'
-reduce_general_parse.rs:11:12: error: missing 'initializer' for '#pragma rs reduce'
+reduce_general_parse.rs:11:12: error: missing 'accumulator' for '#pragma rs reduce'
 reduce_general_parse.rs:12:36: error: missing name after 'initializer(' for '#pragma rs reduce'
 reduce_general_parse.rs:13:12: error: missing 'accumulator' for '#pragma rs reduce'
 reduce_general_parse.rs:15:12: error: reduction kernel 'foo' declared multiple times (first one is at reduce_general_parse.rs:14:12)
diff --git a/tests/F_reduce_general_void/reduce_general_void.rs b/tests/F_reduce_general_void/reduce_general_void.rs
new file mode 100644
index 0000000..c5acced
--- /dev/null
+++ b/tests/F_reduce_general_void/reduce_general_void.rs
@@ -0,0 +1,22 @@
+// -target-api 0 -Wall
+#pragma version(1)
+#pragma rs java_package_name(voidptr)
+
+// void is not a suitable accumulator data type or result type; and
+// note that an input cannot be a pointer
+
+// accumulator must not be void
+#pragma rs reduce(voidA) initializer(voidA_init) accumulator(voidA_accum) combiner(voidA_comb)
+static void voidA_init(void *accum) { }
+static void voidA_accum(void *accum, int val) { }
+static void voidA_comb(void *accum, const void *other) { }
+
+// input must not be void*
+#pragma rs reduce(voidI) accumulator(voidI_accum) combiner(voidI_comb)
+static void voidI_accum(int *accum, void *val) { }
+static void voidI_comb(int *accum, const int *other) { }
+
+// result type must not be void
+#pragma rs reduce(voidO) accumulator(voidO_accum) outconverter(voidO_out)
+static void voidO_accum(int *accum, int val) { }
+static void voidO_out(void *out, const int *val) { }
diff --git a/tests/F_reduce_general_void/stderr.txt.expect b/tests/F_reduce_general_void/stderr.txt.expect
new file mode 100644
index 0000000..973cae8
--- /dev/null
+++ b/tests/F_reduce_general_void/stderr.txt.expect
@@ -0,0 +1,3 @@
+reduce_general_void.rs:11:13: error: accumulator voidA_accum() for '#pragma rs reduce(voidA)' (reduce_general_void.rs:9:12) parameter 'accum' (type 'void *') must not be pointer to incomplete type
+reduce_general_void.rs:16:43: error: accumulator voidI_accum() for '#pragma rs reduce(voidI)' (reduce_general_void.rs:15:12) parameter 'val' (type 'void *') must not be a pointer
+reduce_general_void.rs:22:29: error: outconverter voidO_out() for '#pragma rs reduce(voidO)' (reduce_general_void.rs:20:12) parameter 'out' (type 'void *') must not point to an incomplete type
diff --git a/tests/P_reduce_general/stdout.txt.expect b/tests/F_reduce_general_void/stdout.txt.expect
similarity index 100%
copy from tests/P_reduce_general/stdout.txt.expect
copy to tests/F_reduce_general_void/stdout.txt.expect
diff --git a/tests/P_reduce_general/reduce_general.rs b/tests/P_reduce_general/reduce_general.rs
deleted file mode 100644
index 869ee21..0000000
--- a/tests/P_reduce_general/reduce_general.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-// -target-api 0 -Wall -Werror
-#pragma version(1)
-#pragma rs java_package_name(all)
-
-#pragma rs reduce(addint) \
-  initializer(aiInit) accumulator(aiAccum)
-
-#pragma rs reduce(dp) \
-  initializer(dpInit) accumulator(dpAccum) combiner(dpSum)
-
-#pragma rs reduce(findMinAndMax) \
-  initializer(fMMInit) accumulator(fMMAccumulator) \
-  combiner(fMMCombiner) outconverter(fMMOutConverter)
-
-#pragma rs reduce(fz) \
-  initializer(fzInit) \
-  accumulator(fzAccum) combiner(fzCombine) \
-       halter(fzFound)
-
-#pragma rs reduce(fz2) \
-  initializer(fz2Init) \
-  accumulator(fz2Accum) combiner(fz2Combine) \
-  halter(fz2Found)
-
-#pragma rs reduce(histogram) initializer(hsgInit) \
-  accumulator(hsgAccum) combiner(hsgCombine)
-
-#pragma rs reduce(mode) initializer(hsgInit) \
-  accumulator(hsgAccum) combiner(hsgCombine) \
-  outconverter(modeOutConvert)
-
-void dummy() {}
diff --git a/tests/P_reduce_general_examples/reduce_general_examples.rs b/tests/P_reduce_general_examples/reduce_general_examples.rs
new file mode 100644
index 0000000..93cf8cd
--- /dev/null
+++ b/tests/P_reduce_general_examples/reduce_general_examples.rs
@@ -0,0 +1,155 @@
+// -target-api 0 -Wall -Werror
+#pragma version(1)
+#pragma rs java_package_name(examples)
+
+/////////////////////////////////////////////////////////////////////////
+
+#pragma rs reduce(addint) \
+  accumulator(aiAccum)
+
+static void aiAccum(int *accum, int val) { *accum += val; }
+
+/////////////////////////////////////////////////////////////////////////
+
+#pragma rs reduce(mpyint) \
+  initializer(mpyInit) accumulator(mpyAccum)
+
+static void mpyInit(int *accum) { *accum = 1; }
+
+static void mpyAccum(int *accum, int val) { *accum *= val; }
+
+/////////////////////////////////////////////////////////////////////////
+
+#pragma rs reduce(dp) \
+  accumulator(dpAccum) combiner(dpSum)
+
+static void dpAccum(float *accum, float in1, float in2) {
+  *accum += in1*in2;
+}
+
+// combiner function
+static void dpSum(float *accum, const float *val) { *accum += *val; }
+
+/////////////////////////////////////////////////////////////////////////
+
+#pragma rs reduce(findMinAndMax) \
+  initializer(fMMInit) accumulator(fMMAccumulator) \
+  combiner(fMMCombiner) outconverter(fMMOutConverter)
+
+// this is just a compilation test
+#define INFINITY 0.0f
+
+typedef struct {
+  float val;
+  int idx;
+} IndexedVal;
+
+typedef struct {
+  IndexedVal min, max;
+} MinAndMax;
+
+static void fMMInit(MinAndMax *accum) {
+  static const MinAndMax r = { { INFINITY, -1 }, { -INFINITY, -1 } };
+  *accum = r;
+}
+
+static void fMMAccumulator(MinAndMax *accum, float in, int x) {
+  IndexedVal me;
+  me.val = in;
+  me.idx = x;
+
+  if (me.val < accum->min.val)
+    accum->min = me;
+  if (me.val > accum->max.val)
+    accum->max = me;
+}
+
+static void fMMCombiner(MinAndMax *accum,
+                        const MinAndMax *val) {
+  fMMAccumulator(accum, val->min.val, val->min.idx);
+  fMMAccumulator(accum, val->max.val, val->max.idx);
+}
+
+static void fMMOutConverter(int2 *result,
+                            const MinAndMax *val) {
+  result->x = val->min.idx;
+  result->y = val->max.idx;
+}
+
+/////////////////////////////////////////////////////////////////////////
+
+#pragma rs reduce(fz) \
+  initializer(fzInit) \
+  accumulator(fzAccum) combiner(fzCombine) \
+  halter(fzFound)
+
+static void fzInit(int *accumIdx) { *accumIdx = -1; }
+
+static void fzAccum(int *accumIdx,
+                    int inVal, int x /* special arg */) {
+  if (inVal==0) *accumIdx = x;
+}
+
+static void fzCombine(int *accumIdx, const int *accumIdx2) {
+  if (*accumIdx2 >= 0) *accumIdx = *accumIdx2;
+}
+
+// halter function
+static bool fzFound(const int *accumIdx) {
+  return *accumIdx >= 0;
+}
+
+/////////////////////////////////////////////////////////////////////////
+
+#pragma rs reduce(fz2) \
+  initializer(fz2Init) \
+  accumulator(fz2Accum) combiner(fz2Combine) \
+  halter(fz2Found)
+
+static void fz2Init(int2 *accum) { accum->x = accum->y = -1; }
+
+static void fz2Accum(int2 *accum,
+                     int inVal,
+                     int x /* special arg */,
+                     int y /* special arg */) {
+  if (inVal==0) {
+    accum->x = x;
+    accum->y = y;
+  }
+}
+
+static void fz2Combine(int2 *accum, const int2 *accum2) {
+  if (accum2->x >= 0) *accum = *accum2;
+}
+
+// halter function
+static bool fz2Found(const int2 *accum) {
+  return accum->x >= 0;
+}
+
+/////////////////////////////////////////////////////////////////////////
+
+#pragma rs reduce(histogram) \
+  accumulator(hsgAccum) combiner(hsgCombine)
+
+#define BUCKETS 256
+typedef uint32_t Histogram[BUCKETS];
+
+static void hsgAccum(Histogram *h, uchar in) { ++(*h)[in]; }
+
+static void hsgCombine(Histogram *accum, const Histogram *addend) {
+  for (int i = 0; i < BUCKETS; ++i)
+    (*accum)[i] += (*addend)[i];
+}
+
+#pragma rs reduce(mode) \
+  accumulator(hsgAccum) combiner(hsgCombine) \
+  outconverter(modeOutConvert)
+
+static void modeOutConvert(int2 *result, const Histogram *h) {
+  uint32_t mode = 0;
+  for (int i = 1; i < BUCKETS; ++i)
+    if ((*h)[i] > (*h)[mode]) mode = i;
+  result->x = mode;
+  result->y = (*h)[mode];
+}
diff --git a/tests/P_reduce_general/stderr.txt.expect b/tests/P_reduce_general_examples/stderr.txt.expect
similarity index 100%
copy from tests/P_reduce_general/stderr.txt.expect
copy to tests/P_reduce_general_examples/stderr.txt.expect
diff --git a/tests/P_reduce_general/stdout.txt.expect b/tests/P_reduce_general_examples/stdout.txt.expect
similarity index 100%
copy from tests/P_reduce_general/stdout.txt.expect
copy to tests/P_reduce_general_examples/stdout.txt.expect
diff --git a/tests/P_reduce_general_examples_explicit/reduce_general_examples_explicit.rs b/tests/P_reduce_general_examples_explicit/reduce_general_examples_explicit.rs
new file mode 100644
index 0000000..9abea80
--- /dev/null
+++ b/tests/P_reduce_general_examples_explicit/reduce_general_examples_explicit.rs
@@ -0,0 +1,71 @@
+// -target-api 0 -Wall -Werror
+#pragma version(1)
+#pragma rs java_package_name(examples)
+
+// These are alternative versions of some of the test cases from
+// reduce_general_examples.rs, except that this test case contains
+// explicit definitions for functions that were omitted from the other
+// test case.
+
+/////////////////////////////////////////////////////////////////////////
+
+#pragma rs reduce(addint_init) \
+  initializer(aiiInit) accumulator(aiiAccum)
+
+static void aiiInit(int *accum) { *accum = 0; } // unnecessary
+
+static void aiiAccum(int *accum, int val) { *accum += val; }
+
+/////////////////////////////////////////////////////////////////////////
+
+#pragma rs reduce(addint_comb) \
+  accumulator(aicAccum) combiner(aicComb)
+
+static void aicAccum(int *accum, int val) { *accum += val; }
+
+static void aicComb(int *accum, const int *other) { *accum += *other; } // unnecessary
+
+/////////////////////////////////////////////////////////////////////////
+
+#pragma rs reduce(addint_init_comb) \
+  initializer(aiicInit) accumulator(aiicAccum) combiner(aiicComb)
+
+static void aiicInit(int *accum) { *accum = 0; } // unnecessary
+
+static void aiicAccum(int *accum, int val) { *accum += val; }
+
+static void aiicComb(int *accum, const int *other) { *accum += *other; } // unnecessary
+
+/////////////////////////////////////////////////////////////////////////
+
+#pragma rs reduce(dp_init) \
+  initializer(dpiInit) accumulator(dpiAccum) combiner(dpiSum)
+
+static void dpiInit(float *accum) { *accum = 0.0f; } // unnecessary
+
+static void dpiAccum(float *accum, float in1, float in2) {
+  *accum += in1*in2;
+}
+
+// combiner function
+static void dpiSum(float *accum, const float *val) { *accum += *val; }
+
+/////////////////////////////////////////////////////////////////////////
+
+#pragma rs reduce(histogram_init) \
+  initializer(hsgiInit) accumulator(hsgiAccum) combiner(hsgiCombine)
+
+#define BUCKETS 256
+typedef uint32_t Histogram[BUCKETS];
+
+static void hsgiInit(Histogram *h) {
+  for (int i = 0; i < BUCKETS; ++i)
+    (*h)[i] = 0;
+}
+
+static void hsgiAccum(Histogram *h, uchar in) { ++(*h)[in]; }
+
+static void hsgiCombine(Histogram *accum, const Histogram *addend) {
+  for (int i = 0; i < BUCKETS; ++i)
+    (*accum)[i] += (*addend)[i];
+}
diff --git a/tests/P_reduce_general/stderr.txt.expect b/tests/P_reduce_general_examples_explicit/stderr.txt.expect
similarity index 100%
copy from tests/P_reduce_general/stderr.txt.expect
copy to tests/P_reduce_general_examples_explicit/stderr.txt.expect
diff --git a/tests/P_reduce_general/stdout.txt.expect b/tests/P_reduce_general_examples_explicit/stdout.txt.expect
similarity index 100%
copy from tests/P_reduce_general/stdout.txt.expect
copy to tests/P_reduce_general_examples_explicit/stdout.txt.expect
diff --git a/tests/P_reduce_general_input/gen-input.pl b/tests/P_reduce_general_input/gen-input.pl
new file mode 100755
index 0000000..a2f6c37
--- /dev/null
+++ b/tests/P_reduce_general_input/gen-input.pl
@@ -0,0 +1,60 @@
+#!/usr/bin/perl -w
+
+# Generate trivial test cases to exercise input types.
+
+use strict;
+
+my @basicTypes = ("half", "float", "double",
+                  "char", "short", "int", "long",
+                  "uchar", "ushort", "uint", "ulong",
+                  "bool",
+                  "rs_matrix2x2", "rs_matrix3x3", "rs_matrix4x4",
+                  "MyStruct");
+
+my @specialParameters = ("context", "x", "y", "z");
+my $specialParameterPowerSetCardinality = 2 ** (1 + $#specialParameters);
+
+# 1 signifies non-vector
+# 3 is not supported for exported types
+my @vecLengths = (1, 2, 4);
+
+print "// -target-api 0 -Wall -Werror\n";
+print "#pragma version(1)\n";
+print "#pragma rs java_package_name(input)\n\n";
+print "// This test case was created by $0.\n";
+print "// It exercises various legal combinations of inputs and special parameters,\n";
+print "//  so that we can ensure\n";
+print "// (a) We do not choke when compiling them\n";
+print "// (b) We reflect them correctly\n\n";
+print "// One example struct type\n";
+print "typedef struct MyStruct { float f; double d; } MyStruct;\n\n";
+print "// Trivial combiner shared by all test cases\n";
+print "static void combiner(int *accum, const int *other) { }\n";
+
+foreach my $basicType (@basicTypes) {
+  foreach my $vecLen (@vecLengths) {
+
+    # There are no bool vectors or struct vectors
+    next if ($vecLen > 1) && (($basicType eq "bool") || ($basicType eq "MyStruct"));
+
+    # There are no matrix or object vectors
+    next if ($vecLen > 1) && (substr($basicType, 0, 3) eq "rs_");
+
+    my $eltName = $basicType;
+    $eltName .= $vecLen if ($vecLen > 1);
+
+    for (my $specials = 0; $specials < $specialParameterPowerSetCardinality; ++$specials) {
+      my $reduceName = "my_${eltName}_${specials}";
+      my $accumName = "${reduceName}_accum";
+      print "\n";
+      print "#pragma rs reduce(${reduceName}) accumulator(${accumName}) combiner(combiner)\n";
+      print "static void ${accumName}(int *accum, ${eltName} in";
+      for (my $special = 0; $special <= $#specialParameters; ++$special) {
+        if ($specials & 2**$special) {
+          print ", " . ($special ? "uint" : "rs_kernel_context") . " ${specialParameters[$special]}";
+        }
+      }
+      print ") { }\n";
+    }
+  }
+}
diff --git a/tests/P_reduce_general_input/reduce_general_input.rs b/tests/P_reduce_general_input/reduce_general_input.rs
new file mode 100644
index 0000000..b27d298
--- /dev/null
+++ b/tests/P_reduce_general_input/reduce_general_input.rs
@@ -0,0 +1,1839 @@
+// -target-api 0 -Wall -Werror
+#pragma version(1)
+#pragma rs java_package_name(input)
+
+// This test case was created by ./gen-input.pl.
+// It exercises various legal combinations of inputs and special parameters,
+//  so that we can ensure
+// (a) We do not choke when compiling them
+// (b) We reflect them correctly
+
+// One example struct type
+typedef struct MyStruct { float f; double d; } MyStruct;
+
+// Trivial combiner shared by all test cases
+static void combiner(int *accum, const int *other) { }
+
+#pragma rs reduce(my_half_0) accumulator(my_half_0_accum) combiner(combiner)
+static void my_half_0_accum(int *accum, half in) { }
+
+#pragma rs reduce(my_half_1) accumulator(my_half_1_accum) combiner(combiner)
+static void my_half_1_accum(int *accum, half in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_2) accumulator(my_half_2_accum) combiner(combiner)
+static void my_half_2_accum(int *accum, half in, uint x) { }
+
+#pragma rs reduce(my_half_3) accumulator(my_half_3_accum) combiner(combiner)
+static void my_half_3_accum(int *accum, half in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_half_4) accumulator(my_half_4_accum) combiner(combiner)
+static void my_half_4_accum(int *accum, half in, uint y) { }
+
+#pragma rs reduce(my_half_5) accumulator(my_half_5_accum) combiner(combiner)
+static void my_half_5_accum(int *accum, half in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_half_6) accumulator(my_half_6_accum) combiner(combiner)
+static void my_half_6_accum(int *accum, half in, uint x, uint y) { }
+
+#pragma rs reduce(my_half_7) accumulator(my_half_7_accum) combiner(combiner)
+static void my_half_7_accum(int *accum, half in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_half_8) accumulator(my_half_8_accum) combiner(combiner)
+static void my_half_8_accum(int *accum, half in, uint z) { }
+
+#pragma rs reduce(my_half_9) accumulator(my_half_9_accum) combiner(combiner)
+static void my_half_9_accum(int *accum, half in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_half_10) accumulator(my_half_10_accum) combiner(combiner)
+static void my_half_10_accum(int *accum, half in, uint x, uint z) { }
+
+#pragma rs reduce(my_half_11) accumulator(my_half_11_accum) combiner(combiner)
+static void my_half_11_accum(int *accum, half in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_half_12) accumulator(my_half_12_accum) combiner(combiner)
+static void my_half_12_accum(int *accum, half in, uint y, uint z) { }
+
+#pragma rs reduce(my_half_13) accumulator(my_half_13_accum) combiner(combiner)
+static void my_half_13_accum(int *accum, half in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_half_14) accumulator(my_half_14_accum) combiner(combiner)
+static void my_half_14_accum(int *accum, half in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_half_15) accumulator(my_half_15_accum) combiner(combiner)
+static void my_half_15_accum(int *accum, half in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_half2_0) accumulator(my_half2_0_accum) combiner(combiner)
+static void my_half2_0_accum(int *accum, half2 in) { }
+
+#pragma rs reduce(my_half2_1) accumulator(my_half2_1_accum) combiner(combiner)
+static void my_half2_1_accum(int *accum, half2 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_2) accumulator(my_half2_2_accum) combiner(combiner)
+static void my_half2_2_accum(int *accum, half2 in, uint x) { }
+
+#pragma rs reduce(my_half2_3) accumulator(my_half2_3_accum) combiner(combiner)
+static void my_half2_3_accum(int *accum, half2 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_half2_4) accumulator(my_half2_4_accum) combiner(combiner)
+static void my_half2_4_accum(int *accum, half2 in, uint y) { }
+
+#pragma rs reduce(my_half2_5) accumulator(my_half2_5_accum) combiner(combiner)
+static void my_half2_5_accum(int *accum, half2 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_half2_6) accumulator(my_half2_6_accum) combiner(combiner)
+static void my_half2_6_accum(int *accum, half2 in, uint x, uint y) { }
+
+#pragma rs reduce(my_half2_7) accumulator(my_half2_7_accum) combiner(combiner)
+static void my_half2_7_accum(int *accum, half2 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_half2_8) accumulator(my_half2_8_accum) combiner(combiner)
+static void my_half2_8_accum(int *accum, half2 in, uint z) { }
+
+#pragma rs reduce(my_half2_9) accumulator(my_half2_9_accum) combiner(combiner)
+static void my_half2_9_accum(int *accum, half2 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_half2_10) accumulator(my_half2_10_accum) combiner(combiner)
+static void my_half2_10_accum(int *accum, half2 in, uint x, uint z) { }
+
+#pragma rs reduce(my_half2_11) accumulator(my_half2_11_accum) combiner(combiner)
+static void my_half2_11_accum(int *accum, half2 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_half2_12) accumulator(my_half2_12_accum) combiner(combiner)
+static void my_half2_12_accum(int *accum, half2 in, uint y, uint z) { }
+
+#pragma rs reduce(my_half2_13) accumulator(my_half2_13_accum) combiner(combiner)
+static void my_half2_13_accum(int *accum, half2 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_half2_14) accumulator(my_half2_14_accum) combiner(combiner)
+static void my_half2_14_accum(int *accum, half2 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_half2_15) accumulator(my_half2_15_accum) combiner(combiner)
+static void my_half2_15_accum(int *accum, half2 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_half4_0) accumulator(my_half4_0_accum) combiner(combiner)
+static void my_half4_0_accum(int *accum, half4 in) { }
+
+#pragma rs reduce(my_half4_1) accumulator(my_half4_1_accum) combiner(combiner)
+static void my_half4_1_accum(int *accum, half4 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_2) accumulator(my_half4_2_accum) combiner(combiner)
+static void my_half4_2_accum(int *accum, half4 in, uint x) { }
+
+#pragma rs reduce(my_half4_3) accumulator(my_half4_3_accum) combiner(combiner)
+static void my_half4_3_accum(int *accum, half4 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_half4_4) accumulator(my_half4_4_accum) combiner(combiner)
+static void my_half4_4_accum(int *accum, half4 in, uint y) { }
+
+#pragma rs reduce(my_half4_5) accumulator(my_half4_5_accum) combiner(combiner)
+static void my_half4_5_accum(int *accum, half4 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_half4_6) accumulator(my_half4_6_accum) combiner(combiner)
+static void my_half4_6_accum(int *accum, half4 in, uint x, uint y) { }
+
+#pragma rs reduce(my_half4_7) accumulator(my_half4_7_accum) combiner(combiner)
+static void my_half4_7_accum(int *accum, half4 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_half4_8) accumulator(my_half4_8_accum) combiner(combiner)
+static void my_half4_8_accum(int *accum, half4 in, uint z) { }
+
+#pragma rs reduce(my_half4_9) accumulator(my_half4_9_accum) combiner(combiner)
+static void my_half4_9_accum(int *accum, half4 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_half4_10) accumulator(my_half4_10_accum) combiner(combiner)
+static void my_half4_10_accum(int *accum, half4 in, uint x, uint z) { }
+
+#pragma rs reduce(my_half4_11) accumulator(my_half4_11_accum) combiner(combiner)
+static void my_half4_11_accum(int *accum, half4 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_half4_12) accumulator(my_half4_12_accum) combiner(combiner)
+static void my_half4_12_accum(int *accum, half4 in, uint y, uint z) { }
+
+#pragma rs reduce(my_half4_13) accumulator(my_half4_13_accum) combiner(combiner)
+static void my_half4_13_accum(int *accum, half4 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_half4_14) accumulator(my_half4_14_accum) combiner(combiner)
+static void my_half4_14_accum(int *accum, half4 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_half4_15) accumulator(my_half4_15_accum) combiner(combiner)
+static void my_half4_15_accum(int *accum, half4 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_float_0) accumulator(my_float_0_accum) combiner(combiner)
+static void my_float_0_accum(int *accum, float in) { }
+
+#pragma rs reduce(my_float_1) accumulator(my_float_1_accum) combiner(combiner)
+static void my_float_1_accum(int *accum, float in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_2) accumulator(my_float_2_accum) combiner(combiner)
+static void my_float_2_accum(int *accum, float in, uint x) { }
+
+#pragma rs reduce(my_float_3) accumulator(my_float_3_accum) combiner(combiner)
+static void my_float_3_accum(int *accum, float in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_float_4) accumulator(my_float_4_accum) combiner(combiner)
+static void my_float_4_accum(int *accum, float in, uint y) { }
+
+#pragma rs reduce(my_float_5) accumulator(my_float_5_accum) combiner(combiner)
+static void my_float_5_accum(int *accum, float in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_float_6) accumulator(my_float_6_accum) combiner(combiner)
+static void my_float_6_accum(int *accum, float in, uint x, uint y) { }
+
+#pragma rs reduce(my_float_7) accumulator(my_float_7_accum) combiner(combiner)
+static void my_float_7_accum(int *accum, float in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_float_8) accumulator(my_float_8_accum) combiner(combiner)
+static void my_float_8_accum(int *accum, float in, uint z) { }
+
+#pragma rs reduce(my_float_9) accumulator(my_float_9_accum) combiner(combiner)
+static void my_float_9_accum(int *accum, float in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_float_10) accumulator(my_float_10_accum) combiner(combiner)
+static void my_float_10_accum(int *accum, float in, uint x, uint z) { }
+
+#pragma rs reduce(my_float_11) accumulator(my_float_11_accum) combiner(combiner)
+static void my_float_11_accum(int *accum, float in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_float_12) accumulator(my_float_12_accum) combiner(combiner)
+static void my_float_12_accum(int *accum, float in, uint y, uint z) { }
+
+#pragma rs reduce(my_float_13) accumulator(my_float_13_accum) combiner(combiner)
+static void my_float_13_accum(int *accum, float in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_float_14) accumulator(my_float_14_accum) combiner(combiner)
+static void my_float_14_accum(int *accum, float in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_float_15) accumulator(my_float_15_accum) combiner(combiner)
+static void my_float_15_accum(int *accum, float in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_float2_0) accumulator(my_float2_0_accum) combiner(combiner)
+static void my_float2_0_accum(int *accum, float2 in) { }
+
+#pragma rs reduce(my_float2_1) accumulator(my_float2_1_accum) combiner(combiner)
+static void my_float2_1_accum(int *accum, float2 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_2) accumulator(my_float2_2_accum) combiner(combiner)
+static void my_float2_2_accum(int *accum, float2 in, uint x) { }
+
+#pragma rs reduce(my_float2_3) accumulator(my_float2_3_accum) combiner(combiner)
+static void my_float2_3_accum(int *accum, float2 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_float2_4) accumulator(my_float2_4_accum) combiner(combiner)
+static void my_float2_4_accum(int *accum, float2 in, uint y) { }
+
+#pragma rs reduce(my_float2_5) accumulator(my_float2_5_accum) combiner(combiner)
+static void my_float2_5_accum(int *accum, float2 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_float2_6) accumulator(my_float2_6_accum) combiner(combiner)
+static void my_float2_6_accum(int *accum, float2 in, uint x, uint y) { }
+
+#pragma rs reduce(my_float2_7) accumulator(my_float2_7_accum) combiner(combiner)
+static void my_float2_7_accum(int *accum, float2 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_float2_8) accumulator(my_float2_8_accum) combiner(combiner)
+static void my_float2_8_accum(int *accum, float2 in, uint z) { }
+
+#pragma rs reduce(my_float2_9) accumulator(my_float2_9_accum) combiner(combiner)
+static void my_float2_9_accum(int *accum, float2 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_float2_10) accumulator(my_float2_10_accum) combiner(combiner)
+static void my_float2_10_accum(int *accum, float2 in, uint x, uint z) { }
+
+#pragma rs reduce(my_float2_11) accumulator(my_float2_11_accum) combiner(combiner)
+static void my_float2_11_accum(int *accum, float2 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_float2_12) accumulator(my_float2_12_accum) combiner(combiner)
+static void my_float2_12_accum(int *accum, float2 in, uint y, uint z) { }
+
+#pragma rs reduce(my_float2_13) accumulator(my_float2_13_accum) combiner(combiner)
+static void my_float2_13_accum(int *accum, float2 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_float2_14) accumulator(my_float2_14_accum) combiner(combiner)
+static void my_float2_14_accum(int *accum, float2 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_float2_15) accumulator(my_float2_15_accum) combiner(combiner)
+static void my_float2_15_accum(int *accum, float2 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_float4_0) accumulator(my_float4_0_accum) combiner(combiner)
+static void my_float4_0_accum(int *accum, float4 in) { }
+
+#pragma rs reduce(my_float4_1) accumulator(my_float4_1_accum) combiner(combiner)
+static void my_float4_1_accum(int *accum, float4 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_2) accumulator(my_float4_2_accum) combiner(combiner)
+static void my_float4_2_accum(int *accum, float4 in, uint x) { }
+
+#pragma rs reduce(my_float4_3) accumulator(my_float4_3_accum) combiner(combiner)
+static void my_float4_3_accum(int *accum, float4 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_float4_4) accumulator(my_float4_4_accum) combiner(combiner)
+static void my_float4_4_accum(int *accum, float4 in, uint y) { }
+
+#pragma rs reduce(my_float4_5) accumulator(my_float4_5_accum) combiner(combiner)
+static void my_float4_5_accum(int *accum, float4 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_float4_6) accumulator(my_float4_6_accum) combiner(combiner)
+static void my_float4_6_accum(int *accum, float4 in, uint x, uint y) { }
+
+#pragma rs reduce(my_float4_7) accumulator(my_float4_7_accum) combiner(combiner)
+static void my_float4_7_accum(int *accum, float4 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_float4_8) accumulator(my_float4_8_accum) combiner(combiner)
+static void my_float4_8_accum(int *accum, float4 in, uint z) { }
+
+#pragma rs reduce(my_float4_9) accumulator(my_float4_9_accum) combiner(combiner)
+static void my_float4_9_accum(int *accum, float4 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_float4_10) accumulator(my_float4_10_accum) combiner(combiner)
+static void my_float4_10_accum(int *accum, float4 in, uint x, uint z) { }
+
+#pragma rs reduce(my_float4_11) accumulator(my_float4_11_accum) combiner(combiner)
+static void my_float4_11_accum(int *accum, float4 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_float4_12) accumulator(my_float4_12_accum) combiner(combiner)
+static void my_float4_12_accum(int *accum, float4 in, uint y, uint z) { }
+
+#pragma rs reduce(my_float4_13) accumulator(my_float4_13_accum) combiner(combiner)
+static void my_float4_13_accum(int *accum, float4 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_float4_14) accumulator(my_float4_14_accum) combiner(combiner)
+static void my_float4_14_accum(int *accum, float4 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_float4_15) accumulator(my_float4_15_accum) combiner(combiner)
+static void my_float4_15_accum(int *accum, float4 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_double_0) accumulator(my_double_0_accum) combiner(combiner)
+static void my_double_0_accum(int *accum, double in) { }
+
+#pragma rs reduce(my_double_1) accumulator(my_double_1_accum) combiner(combiner)
+static void my_double_1_accum(int *accum, double in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_double_2) accumulator(my_double_2_accum) combiner(combiner)
+static void my_double_2_accum(int *accum, double in, uint x) { }
+
+#pragma rs reduce(my_double_3) accumulator(my_double_3_accum) combiner(combiner)
+static void my_double_3_accum(int *accum, double in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_double_4) accumulator(my_double_4_accum) combiner(combiner)
+static void my_double_4_accum(int *accum, double in, uint y) { }
+
+#pragma rs reduce(my_double_5) accumulator(my_double_5_accum) combiner(combiner)
+static void my_double_5_accum(int *accum, double in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_double_6) accumulator(my_double_6_accum) combiner(combiner)
+static void my_double_6_accum(int *accum, double in, uint x, uint y) { }
+
+#pragma rs reduce(my_double_7) accumulator(my_double_7_accum) combiner(combiner)
+static void my_double_7_accum(int *accum, double in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_double_8) accumulator(my_double_8_accum) combiner(combiner)
+static void my_double_8_accum(int *accum, double in, uint z) { }
+
+#pragma rs reduce(my_double_9) accumulator(my_double_9_accum) combiner(combiner)
+static void my_double_9_accum(int *accum, double in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_double_10) accumulator(my_double_10_accum) combiner(combiner)
+static void my_double_10_accum(int *accum, double in, uint x, uint z) { }
+
+#pragma rs reduce(my_double_11) accumulator(my_double_11_accum) combiner(combiner)
+static void my_double_11_accum(int *accum, double in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_double_12) accumulator(my_double_12_accum) combiner(combiner)
+static void my_double_12_accum(int *accum, double in, uint y, uint z) { }
+
+#pragma rs reduce(my_double_13) accumulator(my_double_13_accum) combiner(combiner)
+static void my_double_13_accum(int *accum, double in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_double_14) accumulator(my_double_14_accum) combiner(combiner)
+static void my_double_14_accum(int *accum, double in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_double_15) accumulator(my_double_15_accum) combiner(combiner)
+static void my_double_15_accum(int *accum, double in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_double2_0) accumulator(my_double2_0_accum) combiner(combiner)
+static void my_double2_0_accum(int *accum, double2 in) { }
+
+#pragma rs reduce(my_double2_1) accumulator(my_double2_1_accum) combiner(combiner)
+static void my_double2_1_accum(int *accum, double2 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_double2_2) accumulator(my_double2_2_accum) combiner(combiner)
+static void my_double2_2_accum(int *accum, double2 in, uint x) { }
+
+#pragma rs reduce(my_double2_3) accumulator(my_double2_3_accum) combiner(combiner)
+static void my_double2_3_accum(int *accum, double2 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_double2_4) accumulator(my_double2_4_accum) combiner(combiner)
+static void my_double2_4_accum(int *accum, double2 in, uint y) { }
+
+#pragma rs reduce(my_double2_5) accumulator(my_double2_5_accum) combiner(combiner)
+static void my_double2_5_accum(int *accum, double2 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_double2_6) accumulator(my_double2_6_accum) combiner(combiner)
+static void my_double2_6_accum(int *accum, double2 in, uint x, uint y) { }
+
+#pragma rs reduce(my_double2_7) accumulator(my_double2_7_accum) combiner(combiner)
+static void my_double2_7_accum(int *accum, double2 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_double2_8) accumulator(my_double2_8_accum) combiner(combiner)
+static void my_double2_8_accum(int *accum, double2 in, uint z) { }
+
+#pragma rs reduce(my_double2_9) accumulator(my_double2_9_accum) combiner(combiner)
+static void my_double2_9_accum(int *accum, double2 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_double2_10) accumulator(my_double2_10_accum) combiner(combiner)
+static void my_double2_10_accum(int *accum, double2 in, uint x, uint z) { }
+
+#pragma rs reduce(my_double2_11) accumulator(my_double2_11_accum) combiner(combiner)
+static void my_double2_11_accum(int *accum, double2 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_double2_12) accumulator(my_double2_12_accum) combiner(combiner)
+static void my_double2_12_accum(int *accum, double2 in, uint y, uint z) { }
+
+#pragma rs reduce(my_double2_13) accumulator(my_double2_13_accum) combiner(combiner)
+static void my_double2_13_accum(int *accum, double2 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_double2_14) accumulator(my_double2_14_accum) combiner(combiner)
+static void my_double2_14_accum(int *accum, double2 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_double2_15) accumulator(my_double2_15_accum) combiner(combiner)
+static void my_double2_15_accum(int *accum, double2 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_double4_0) accumulator(my_double4_0_accum) combiner(combiner)
+static void my_double4_0_accum(int *accum, double4 in) { }
+
+#pragma rs reduce(my_double4_1) accumulator(my_double4_1_accum) combiner(combiner)
+static void my_double4_1_accum(int *accum, double4 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_double4_2) accumulator(my_double4_2_accum) combiner(combiner)
+static void my_double4_2_accum(int *accum, double4 in, uint x) { }
+
+#pragma rs reduce(my_double4_3) accumulator(my_double4_3_accum) combiner(combiner)
+static void my_double4_3_accum(int *accum, double4 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_double4_4) accumulator(my_double4_4_accum) combiner(combiner)
+static void my_double4_4_accum(int *accum, double4 in, uint y) { }
+
+#pragma rs reduce(my_double4_5) accumulator(my_double4_5_accum) combiner(combiner)
+static void my_double4_5_accum(int *accum, double4 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_double4_6) accumulator(my_double4_6_accum) combiner(combiner)
+static void my_double4_6_accum(int *accum, double4 in, uint x, uint y) { }
+
+#pragma rs reduce(my_double4_7) accumulator(my_double4_7_accum) combiner(combiner)
+static void my_double4_7_accum(int *accum, double4 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_double4_8) accumulator(my_double4_8_accum) combiner(combiner)
+static void my_double4_8_accum(int *accum, double4 in, uint z) { }
+
+#pragma rs reduce(my_double4_9) accumulator(my_double4_9_accum) combiner(combiner)
+static void my_double4_9_accum(int *accum, double4 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_double4_10) accumulator(my_double4_10_accum) combiner(combiner)
+static void my_double4_10_accum(int *accum, double4 in, uint x, uint z) { }
+
+#pragma rs reduce(my_double4_11) accumulator(my_double4_11_accum) combiner(combiner)
+static void my_double4_11_accum(int *accum, double4 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_double4_12) accumulator(my_double4_12_accum) combiner(combiner)
+static void my_double4_12_accum(int *accum, double4 in, uint y, uint z) { }
+
+#pragma rs reduce(my_double4_13) accumulator(my_double4_13_accum) combiner(combiner)
+static void my_double4_13_accum(int *accum, double4 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_double4_14) accumulator(my_double4_14_accum) combiner(combiner)
+static void my_double4_14_accum(int *accum, double4 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_double4_15) accumulator(my_double4_15_accum) combiner(combiner)
+static void my_double4_15_accum(int *accum, double4 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_char_0) accumulator(my_char_0_accum) combiner(combiner)
+static void my_char_0_accum(int *accum, char in) { }
+
+#pragma rs reduce(my_char_1) accumulator(my_char_1_accum) combiner(combiner)
+static void my_char_1_accum(int *accum, char in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_2) accumulator(my_char_2_accum) combiner(combiner)
+static void my_char_2_accum(int *accum, char in, uint x) { }
+
+#pragma rs reduce(my_char_3) accumulator(my_char_3_accum) combiner(combiner)
+static void my_char_3_accum(int *accum, char in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_char_4) accumulator(my_char_4_accum) combiner(combiner)
+static void my_char_4_accum(int *accum, char in, uint y) { }
+
+#pragma rs reduce(my_char_5) accumulator(my_char_5_accum) combiner(combiner)
+static void my_char_5_accum(int *accum, char in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_char_6) accumulator(my_char_6_accum) combiner(combiner)
+static void my_char_6_accum(int *accum, char in, uint x, uint y) { }
+
+#pragma rs reduce(my_char_7) accumulator(my_char_7_accum) combiner(combiner)
+static void my_char_7_accum(int *accum, char in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_char_8) accumulator(my_char_8_accum) combiner(combiner)
+static void my_char_8_accum(int *accum, char in, uint z) { }
+
+#pragma rs reduce(my_char_9) accumulator(my_char_9_accum) combiner(combiner)
+static void my_char_9_accum(int *accum, char in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_char_10) accumulator(my_char_10_accum) combiner(combiner)
+static void my_char_10_accum(int *accum, char in, uint x, uint z) { }
+
+#pragma rs reduce(my_char_11) accumulator(my_char_11_accum) combiner(combiner)
+static void my_char_11_accum(int *accum, char in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_char_12) accumulator(my_char_12_accum) combiner(combiner)
+static void my_char_12_accum(int *accum, char in, uint y, uint z) { }
+
+#pragma rs reduce(my_char_13) accumulator(my_char_13_accum) combiner(combiner)
+static void my_char_13_accum(int *accum, char in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_char_14) accumulator(my_char_14_accum) combiner(combiner)
+static void my_char_14_accum(int *accum, char in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_char_15) accumulator(my_char_15_accum) combiner(combiner)
+static void my_char_15_accum(int *accum, char in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_char2_0) accumulator(my_char2_0_accum) combiner(combiner)
+static void my_char2_0_accum(int *accum, char2 in) { }
+
+#pragma rs reduce(my_char2_1) accumulator(my_char2_1_accum) combiner(combiner)
+static void my_char2_1_accum(int *accum, char2 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_2) accumulator(my_char2_2_accum) combiner(combiner)
+static void my_char2_2_accum(int *accum, char2 in, uint x) { }
+
+#pragma rs reduce(my_char2_3) accumulator(my_char2_3_accum) combiner(combiner)
+static void my_char2_3_accum(int *accum, char2 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_char2_4) accumulator(my_char2_4_accum) combiner(combiner)
+static void my_char2_4_accum(int *accum, char2 in, uint y) { }
+
+#pragma rs reduce(my_char2_5) accumulator(my_char2_5_accum) combiner(combiner)
+static void my_char2_5_accum(int *accum, char2 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_char2_6) accumulator(my_char2_6_accum) combiner(combiner)
+static void my_char2_6_accum(int *accum, char2 in, uint x, uint y) { }
+
+#pragma rs reduce(my_char2_7) accumulator(my_char2_7_accum) combiner(combiner)
+static void my_char2_7_accum(int *accum, char2 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_char2_8) accumulator(my_char2_8_accum) combiner(combiner)
+static void my_char2_8_accum(int *accum, char2 in, uint z) { }
+
+#pragma rs reduce(my_char2_9) accumulator(my_char2_9_accum) combiner(combiner)
+static void my_char2_9_accum(int *accum, char2 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_char2_10) accumulator(my_char2_10_accum) combiner(combiner)
+static void my_char2_10_accum(int *accum, char2 in, uint x, uint z) { }
+
+#pragma rs reduce(my_char2_11) accumulator(my_char2_11_accum) combiner(combiner)
+static void my_char2_11_accum(int *accum, char2 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_char2_12) accumulator(my_char2_12_accum) combiner(combiner)
+static void my_char2_12_accum(int *accum, char2 in, uint y, uint z) { }
+
+#pragma rs reduce(my_char2_13) accumulator(my_char2_13_accum) combiner(combiner)
+static void my_char2_13_accum(int *accum, char2 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_char2_14) accumulator(my_char2_14_accum) combiner(combiner)
+static void my_char2_14_accum(int *accum, char2 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_char2_15) accumulator(my_char2_15_accum) combiner(combiner)
+static void my_char2_15_accum(int *accum, char2 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_char4_0) accumulator(my_char4_0_accum) combiner(combiner)
+static void my_char4_0_accum(int *accum, char4 in) { }
+
+#pragma rs reduce(my_char4_1) accumulator(my_char4_1_accum) combiner(combiner)
+static void my_char4_1_accum(int *accum, char4 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_2) accumulator(my_char4_2_accum) combiner(combiner)
+static void my_char4_2_accum(int *accum, char4 in, uint x) { }
+
+#pragma rs reduce(my_char4_3) accumulator(my_char4_3_accum) combiner(combiner)
+static void my_char4_3_accum(int *accum, char4 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_char4_4) accumulator(my_char4_4_accum) combiner(combiner)
+static void my_char4_4_accum(int *accum, char4 in, uint y) { }
+
+#pragma rs reduce(my_char4_5) accumulator(my_char4_5_accum) combiner(combiner)
+static void my_char4_5_accum(int *accum, char4 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_char4_6) accumulator(my_char4_6_accum) combiner(combiner)
+static void my_char4_6_accum(int *accum, char4 in, uint x, uint y) { }
+
+#pragma rs reduce(my_char4_7) accumulator(my_char4_7_accum) combiner(combiner)
+static void my_char4_7_accum(int *accum, char4 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_char4_8) accumulator(my_char4_8_accum) combiner(combiner)
+static void my_char4_8_accum(int *accum, char4 in, uint z) { }
+
+#pragma rs reduce(my_char4_9) accumulator(my_char4_9_accum) combiner(combiner)
+static void my_char4_9_accum(int *accum, char4 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_char4_10) accumulator(my_char4_10_accum) combiner(combiner)
+static void my_char4_10_accum(int *accum, char4 in, uint x, uint z) { }
+
+#pragma rs reduce(my_char4_11) accumulator(my_char4_11_accum) combiner(combiner)
+static void my_char4_11_accum(int *accum, char4 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_char4_12) accumulator(my_char4_12_accum) combiner(combiner)
+static void my_char4_12_accum(int *accum, char4 in, uint y, uint z) { }
+
+#pragma rs reduce(my_char4_13) accumulator(my_char4_13_accum) combiner(combiner)
+static void my_char4_13_accum(int *accum, char4 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_char4_14) accumulator(my_char4_14_accum) combiner(combiner)
+static void my_char4_14_accum(int *accum, char4 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_char4_15) accumulator(my_char4_15_accum) combiner(combiner)
+static void my_char4_15_accum(int *accum, char4 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_short_0) accumulator(my_short_0_accum) combiner(combiner)
+static void my_short_0_accum(int *accum, short in) { }
+
+#pragma rs reduce(my_short_1) accumulator(my_short_1_accum) combiner(combiner)
+static void my_short_1_accum(int *accum, short in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_2) accumulator(my_short_2_accum) combiner(combiner)
+static void my_short_2_accum(int *accum, short in, uint x) { }
+
+#pragma rs reduce(my_short_3) accumulator(my_short_3_accum) combiner(combiner)
+static void my_short_3_accum(int *accum, short in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_short_4) accumulator(my_short_4_accum) combiner(combiner)
+static void my_short_4_accum(int *accum, short in, uint y) { }
+
+#pragma rs reduce(my_short_5) accumulator(my_short_5_accum) combiner(combiner)
+static void my_short_5_accum(int *accum, short in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_short_6) accumulator(my_short_6_accum) combiner(combiner)
+static void my_short_6_accum(int *accum, short in, uint x, uint y) { }
+
+#pragma rs reduce(my_short_7) accumulator(my_short_7_accum) combiner(combiner)
+static void my_short_7_accum(int *accum, short in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_short_8) accumulator(my_short_8_accum) combiner(combiner)
+static void my_short_8_accum(int *accum, short in, uint z) { }
+
+#pragma rs reduce(my_short_9) accumulator(my_short_9_accum) combiner(combiner)
+static void my_short_9_accum(int *accum, short in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_short_10) accumulator(my_short_10_accum) combiner(combiner)
+static void my_short_10_accum(int *accum, short in, uint x, uint z) { }
+
+#pragma rs reduce(my_short_11) accumulator(my_short_11_accum) combiner(combiner)
+static void my_short_11_accum(int *accum, short in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_short_12) accumulator(my_short_12_accum) combiner(combiner)
+static void my_short_12_accum(int *accum, short in, uint y, uint z) { }
+
+#pragma rs reduce(my_short_13) accumulator(my_short_13_accum) combiner(combiner)
+static void my_short_13_accum(int *accum, short in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_short_14) accumulator(my_short_14_accum) combiner(combiner)
+static void my_short_14_accum(int *accum, short in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_short_15) accumulator(my_short_15_accum) combiner(combiner)
+static void my_short_15_accum(int *accum, short in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_short2_0) accumulator(my_short2_0_accum) combiner(combiner)
+static void my_short2_0_accum(int *accum, short2 in) { }
+
+#pragma rs reduce(my_short2_1) accumulator(my_short2_1_accum) combiner(combiner)
+static void my_short2_1_accum(int *accum, short2 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_2) accumulator(my_short2_2_accum) combiner(combiner)
+static void my_short2_2_accum(int *accum, short2 in, uint x) { }
+
+#pragma rs reduce(my_short2_3) accumulator(my_short2_3_accum) combiner(combiner)
+static void my_short2_3_accum(int *accum, short2 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_short2_4) accumulator(my_short2_4_accum) combiner(combiner)
+static void my_short2_4_accum(int *accum, short2 in, uint y) { }
+
+#pragma rs reduce(my_short2_5) accumulator(my_short2_5_accum) combiner(combiner)
+static void my_short2_5_accum(int *accum, short2 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_short2_6) accumulator(my_short2_6_accum) combiner(combiner)
+static void my_short2_6_accum(int *accum, short2 in, uint x, uint y) { }
+
+#pragma rs reduce(my_short2_7) accumulator(my_short2_7_accum) combiner(combiner)
+static void my_short2_7_accum(int *accum, short2 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_short2_8) accumulator(my_short2_8_accum) combiner(combiner)
+static void my_short2_8_accum(int *accum, short2 in, uint z) { }
+
+#pragma rs reduce(my_short2_9) accumulator(my_short2_9_accum) combiner(combiner)
+static void my_short2_9_accum(int *accum, short2 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_short2_10) accumulator(my_short2_10_accum) combiner(combiner)
+static void my_short2_10_accum(int *accum, short2 in, uint x, uint z) { }
+
+#pragma rs reduce(my_short2_11) accumulator(my_short2_11_accum) combiner(combiner)
+static void my_short2_11_accum(int *accum, short2 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_short2_12) accumulator(my_short2_12_accum) combiner(combiner)
+static void my_short2_12_accum(int *accum, short2 in, uint y, uint z) { }
+
+#pragma rs reduce(my_short2_13) accumulator(my_short2_13_accum) combiner(combiner)
+static void my_short2_13_accum(int *accum, short2 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_short2_14) accumulator(my_short2_14_accum) combiner(combiner)
+static void my_short2_14_accum(int *accum, short2 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_short2_15) accumulator(my_short2_15_accum) combiner(combiner)
+static void my_short2_15_accum(int *accum, short2 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_short4_0) accumulator(my_short4_0_accum) combiner(combiner)
+static void my_short4_0_accum(int *accum, short4 in) { }
+
+#pragma rs reduce(my_short4_1) accumulator(my_short4_1_accum) combiner(combiner)
+static void my_short4_1_accum(int *accum, short4 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_2) accumulator(my_short4_2_accum) combiner(combiner)
+static void my_short4_2_accum(int *accum, short4 in, uint x) { }
+
+#pragma rs reduce(my_short4_3) accumulator(my_short4_3_accum) combiner(combiner)
+static void my_short4_3_accum(int *accum, short4 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_short4_4) accumulator(my_short4_4_accum) combiner(combiner)
+static void my_short4_4_accum(int *accum, short4 in, uint y) { }
+
+#pragma rs reduce(my_short4_5) accumulator(my_short4_5_accum) combiner(combiner)
+static void my_short4_5_accum(int *accum, short4 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_short4_6) accumulator(my_short4_6_accum) combiner(combiner)
+static void my_short4_6_accum(int *accum, short4 in, uint x, uint y) { }
+
+#pragma rs reduce(my_short4_7) accumulator(my_short4_7_accum) combiner(combiner)
+static void my_short4_7_accum(int *accum, short4 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_short4_8) accumulator(my_short4_8_accum) combiner(combiner)
+static void my_short4_8_accum(int *accum, short4 in, uint z) { }
+
+#pragma rs reduce(my_short4_9) accumulator(my_short4_9_accum) combiner(combiner)
+static void my_short4_9_accum(int *accum, short4 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_short4_10) accumulator(my_short4_10_accum) combiner(combiner)
+static void my_short4_10_accum(int *accum, short4 in, uint x, uint z) { }
+
+#pragma rs reduce(my_short4_11) accumulator(my_short4_11_accum) combiner(combiner)
+static void my_short4_11_accum(int *accum, short4 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_short4_12) accumulator(my_short4_12_accum) combiner(combiner)
+static void my_short4_12_accum(int *accum, short4 in, uint y, uint z) { }
+
+#pragma rs reduce(my_short4_13) accumulator(my_short4_13_accum) combiner(combiner)
+static void my_short4_13_accum(int *accum, short4 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_short4_14) accumulator(my_short4_14_accum) combiner(combiner)
+static void my_short4_14_accum(int *accum, short4 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_short4_15) accumulator(my_short4_15_accum) combiner(combiner)
+static void my_short4_15_accum(int *accum, short4 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_int_0) accumulator(my_int_0_accum) combiner(combiner)
+static void my_int_0_accum(int *accum, int in) { }
+
+#pragma rs reduce(my_int_1) accumulator(my_int_1_accum) combiner(combiner)
+static void my_int_1_accum(int *accum, int in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_int_2) accumulator(my_int_2_accum) combiner(combiner)
+static void my_int_2_accum(int *accum, int in, uint x) { }
+
+#pragma rs reduce(my_int_3) accumulator(my_int_3_accum) combiner(combiner)
+static void my_int_3_accum(int *accum, int in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_int_4) accumulator(my_int_4_accum) combiner(combiner)
+static void my_int_4_accum(int *accum, int in, uint y) { }
+
+#pragma rs reduce(my_int_5) accumulator(my_int_5_accum) combiner(combiner)
+static void my_int_5_accum(int *accum, int in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_int_6) accumulator(my_int_6_accum) combiner(combiner)
+static void my_int_6_accum(int *accum, int in, uint x, uint y) { }
+
+#pragma rs reduce(my_int_7) accumulator(my_int_7_accum) combiner(combiner)
+static void my_int_7_accum(int *accum, int in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_int_8) accumulator(my_int_8_accum) combiner(combiner)
+static void my_int_8_accum(int *accum, int in, uint z) { }
+
+#pragma rs reduce(my_int_9) accumulator(my_int_9_accum) combiner(combiner)
+static void my_int_9_accum(int *accum, int in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_int_10) accumulator(my_int_10_accum) combiner(combiner)
+static void my_int_10_accum(int *accum, int in, uint x, uint z) { }
+
+#pragma rs reduce(my_int_11) accumulator(my_int_11_accum) combiner(combiner)
+static void my_int_11_accum(int *accum, int in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_int_12) accumulator(my_int_12_accum) combiner(combiner)
+static void my_int_12_accum(int *accum, int in, uint y, uint z) { }
+
+#pragma rs reduce(my_int_13) accumulator(my_int_13_accum) combiner(combiner)
+static void my_int_13_accum(int *accum, int in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_int_14) accumulator(my_int_14_accum) combiner(combiner)
+static void my_int_14_accum(int *accum, int in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_int_15) accumulator(my_int_15_accum) combiner(combiner)
+static void my_int_15_accum(int *accum, int in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_int2_0) accumulator(my_int2_0_accum) combiner(combiner)
+static void my_int2_0_accum(int *accum, int2 in) { }
+
+#pragma rs reduce(my_int2_1) accumulator(my_int2_1_accum) combiner(combiner)
+static void my_int2_1_accum(int *accum, int2 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_int2_2) accumulator(my_int2_2_accum) combiner(combiner)
+static void my_int2_2_accum(int *accum, int2 in, uint x) { }
+
+#pragma rs reduce(my_int2_3) accumulator(my_int2_3_accum) combiner(combiner)
+static void my_int2_3_accum(int *accum, int2 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_int2_4) accumulator(my_int2_4_accum) combiner(combiner)
+static void my_int2_4_accum(int *accum, int2 in, uint y) { }
+
+#pragma rs reduce(my_int2_5) accumulator(my_int2_5_accum) combiner(combiner)
+static void my_int2_5_accum(int *accum, int2 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_int2_6) accumulator(my_int2_6_accum) combiner(combiner)
+static void my_int2_6_accum(int *accum, int2 in, uint x, uint y) { }
+
+#pragma rs reduce(my_int2_7) accumulator(my_int2_7_accum) combiner(combiner)
+static void my_int2_7_accum(int *accum, int2 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_int2_8) accumulator(my_int2_8_accum) combiner(combiner)
+static void my_int2_8_accum(int *accum, int2 in, uint z) { }
+
+#pragma rs reduce(my_int2_9) accumulator(my_int2_9_accum) combiner(combiner)
+static void my_int2_9_accum(int *accum, int2 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_int2_10) accumulator(my_int2_10_accum) combiner(combiner)
+static void my_int2_10_accum(int *accum, int2 in, uint x, uint z) { }
+
+#pragma rs reduce(my_int2_11) accumulator(my_int2_11_accum) combiner(combiner)
+static void my_int2_11_accum(int *accum, int2 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_int2_12) accumulator(my_int2_12_accum) combiner(combiner)
+static void my_int2_12_accum(int *accum, int2 in, uint y, uint z) { }
+
+#pragma rs reduce(my_int2_13) accumulator(my_int2_13_accum) combiner(combiner)
+static void my_int2_13_accum(int *accum, int2 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_int2_14) accumulator(my_int2_14_accum) combiner(combiner)
+static void my_int2_14_accum(int *accum, int2 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_int2_15) accumulator(my_int2_15_accum) combiner(combiner)
+static void my_int2_15_accum(int *accum, int2 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_int4_0) accumulator(my_int4_0_accum) combiner(combiner)
+static void my_int4_0_accum(int *accum, int4 in) { }
+
+#pragma rs reduce(my_int4_1) accumulator(my_int4_1_accum) combiner(combiner)
+static void my_int4_1_accum(int *accum, int4 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_int4_2) accumulator(my_int4_2_accum) combiner(combiner)
+static void my_int4_2_accum(int *accum, int4 in, uint x) { }
+
+#pragma rs reduce(my_int4_3) accumulator(my_int4_3_accum) combiner(combiner)
+static void my_int4_3_accum(int *accum, int4 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_int4_4) accumulator(my_int4_4_accum) combiner(combiner)
+static void my_int4_4_accum(int *accum, int4 in, uint y) { }
+
+#pragma rs reduce(my_int4_5) accumulator(my_int4_5_accum) combiner(combiner)
+static void my_int4_5_accum(int *accum, int4 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_int4_6) accumulator(my_int4_6_accum) combiner(combiner)
+static void my_int4_6_accum(int *accum, int4 in, uint x, uint y) { }
+
+#pragma rs reduce(my_int4_7) accumulator(my_int4_7_accum) combiner(combiner)
+static void my_int4_7_accum(int *accum, int4 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_int4_8) accumulator(my_int4_8_accum) combiner(combiner)
+static void my_int4_8_accum(int *accum, int4 in, uint z) { }
+
+#pragma rs reduce(my_int4_9) accumulator(my_int4_9_accum) combiner(combiner)
+static void my_int4_9_accum(int *accum, int4 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_int4_10) accumulator(my_int4_10_accum) combiner(combiner)
+static void my_int4_10_accum(int *accum, int4 in, uint x, uint z) { }
+
+#pragma rs reduce(my_int4_11) accumulator(my_int4_11_accum) combiner(combiner)
+static void my_int4_11_accum(int *accum, int4 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_int4_12) accumulator(my_int4_12_accum) combiner(combiner)
+static void my_int4_12_accum(int *accum, int4 in, uint y, uint z) { }
+
+#pragma rs reduce(my_int4_13) accumulator(my_int4_13_accum) combiner(combiner)
+static void my_int4_13_accum(int *accum, int4 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_int4_14) accumulator(my_int4_14_accum) combiner(combiner)
+static void my_int4_14_accum(int *accum, int4 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_int4_15) accumulator(my_int4_15_accum) combiner(combiner)
+static void my_int4_15_accum(int *accum, int4 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_long_0) accumulator(my_long_0_accum) combiner(combiner)
+static void my_long_0_accum(int *accum, long in) { }
+
+#pragma rs reduce(my_long_1) accumulator(my_long_1_accum) combiner(combiner)
+static void my_long_1_accum(int *accum, long in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_long_2) accumulator(my_long_2_accum) combiner(combiner)
+static void my_long_2_accum(int *accum, long in, uint x) { }
+
+#pragma rs reduce(my_long_3) accumulator(my_long_3_accum) combiner(combiner)
+static void my_long_3_accum(int *accum, long in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_long_4) accumulator(my_long_4_accum) combiner(combiner)
+static void my_long_4_accum(int *accum, long in, uint y) { }
+
+#pragma rs reduce(my_long_5) accumulator(my_long_5_accum) combiner(combiner)
+static void my_long_5_accum(int *accum, long in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_long_6) accumulator(my_long_6_accum) combiner(combiner)
+static void my_long_6_accum(int *accum, long in, uint x, uint y) { }
+
+#pragma rs reduce(my_long_7) accumulator(my_long_7_accum) combiner(combiner)
+static void my_long_7_accum(int *accum, long in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_long_8) accumulator(my_long_8_accum) combiner(combiner)
+static void my_long_8_accum(int *accum, long in, uint z) { }
+
+#pragma rs reduce(my_long_9) accumulator(my_long_9_accum) combiner(combiner)
+static void my_long_9_accum(int *accum, long in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_long_10) accumulator(my_long_10_accum) combiner(combiner)
+static void my_long_10_accum(int *accum, long in, uint x, uint z) { }
+
+#pragma rs reduce(my_long_11) accumulator(my_long_11_accum) combiner(combiner)
+static void my_long_11_accum(int *accum, long in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_long_12) accumulator(my_long_12_accum) combiner(combiner)
+static void my_long_12_accum(int *accum, long in, uint y, uint z) { }
+
+#pragma rs reduce(my_long_13) accumulator(my_long_13_accum) combiner(combiner)
+static void my_long_13_accum(int *accum, long in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_long_14) accumulator(my_long_14_accum) combiner(combiner)
+static void my_long_14_accum(int *accum, long in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_long_15) accumulator(my_long_15_accum) combiner(combiner)
+static void my_long_15_accum(int *accum, long in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_long2_0) accumulator(my_long2_0_accum) combiner(combiner)
+static void my_long2_0_accum(int *accum, long2 in) { }
+
+#pragma rs reduce(my_long2_1) accumulator(my_long2_1_accum) combiner(combiner)
+static void my_long2_1_accum(int *accum, long2 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_long2_2) accumulator(my_long2_2_accum) combiner(combiner)
+static void my_long2_2_accum(int *accum, long2 in, uint x) { }
+
+#pragma rs reduce(my_long2_3) accumulator(my_long2_3_accum) combiner(combiner)
+static void my_long2_3_accum(int *accum, long2 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_long2_4) accumulator(my_long2_4_accum) combiner(combiner)
+static void my_long2_4_accum(int *accum, long2 in, uint y) { }
+
+#pragma rs reduce(my_long2_5) accumulator(my_long2_5_accum) combiner(combiner)
+static void my_long2_5_accum(int *accum, long2 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_long2_6) accumulator(my_long2_6_accum) combiner(combiner)
+static void my_long2_6_accum(int *accum, long2 in, uint x, uint y) { }
+
+#pragma rs reduce(my_long2_7) accumulator(my_long2_7_accum) combiner(combiner)
+static void my_long2_7_accum(int *accum, long2 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_long2_8) accumulator(my_long2_8_accum) combiner(combiner)
+static void my_long2_8_accum(int *accum, long2 in, uint z) { }
+
+#pragma rs reduce(my_long2_9) accumulator(my_long2_9_accum) combiner(combiner)
+static void my_long2_9_accum(int *accum, long2 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_long2_10) accumulator(my_long2_10_accum) combiner(combiner)
+static void my_long2_10_accum(int *accum, long2 in, uint x, uint z) { }
+
+#pragma rs reduce(my_long2_11) accumulator(my_long2_11_accum) combiner(combiner)
+static void my_long2_11_accum(int *accum, long2 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_long2_12) accumulator(my_long2_12_accum) combiner(combiner)
+static void my_long2_12_accum(int *accum, long2 in, uint y, uint z) { }
+
+#pragma rs reduce(my_long2_13) accumulator(my_long2_13_accum) combiner(combiner)
+static void my_long2_13_accum(int *accum, long2 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_long2_14) accumulator(my_long2_14_accum) combiner(combiner)
+static void my_long2_14_accum(int *accum, long2 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_long2_15) accumulator(my_long2_15_accum) combiner(combiner)
+static void my_long2_15_accum(int *accum, long2 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_long4_0) accumulator(my_long4_0_accum) combiner(combiner)
+static void my_long4_0_accum(int *accum, long4 in) { }
+
+#pragma rs reduce(my_long4_1) accumulator(my_long4_1_accum) combiner(combiner)
+static void my_long4_1_accum(int *accum, long4 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_long4_2) accumulator(my_long4_2_accum) combiner(combiner)
+static void my_long4_2_accum(int *accum, long4 in, uint x) { }
+
+#pragma rs reduce(my_long4_3) accumulator(my_long4_3_accum) combiner(combiner)
+static void my_long4_3_accum(int *accum, long4 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_long4_4) accumulator(my_long4_4_accum) combiner(combiner)
+static void my_long4_4_accum(int *accum, long4 in, uint y) { }
+
+#pragma rs reduce(my_long4_5) accumulator(my_long4_5_accum) combiner(combiner)
+static void my_long4_5_accum(int *accum, long4 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_long4_6) accumulator(my_long4_6_accum) combiner(combiner)
+static void my_long4_6_accum(int *accum, long4 in, uint x, uint y) { }
+
+#pragma rs reduce(my_long4_7) accumulator(my_long4_7_accum) combiner(combiner)
+static void my_long4_7_accum(int *accum, long4 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_long4_8) accumulator(my_long4_8_accum) combiner(combiner)
+static void my_long4_8_accum(int *accum, long4 in, uint z) { }
+
+#pragma rs reduce(my_long4_9) accumulator(my_long4_9_accum) combiner(combiner)
+static void my_long4_9_accum(int *accum, long4 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_long4_10) accumulator(my_long4_10_accum) combiner(combiner)
+static void my_long4_10_accum(int *accum, long4 in, uint x, uint z) { }
+
+#pragma rs reduce(my_long4_11) accumulator(my_long4_11_accum) combiner(combiner)
+static void my_long4_11_accum(int *accum, long4 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_long4_12) accumulator(my_long4_12_accum) combiner(combiner)
+static void my_long4_12_accum(int *accum, long4 in, uint y, uint z) { }
+
+#pragma rs reduce(my_long4_13) accumulator(my_long4_13_accum) combiner(combiner)
+static void my_long4_13_accum(int *accum, long4 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_long4_14) accumulator(my_long4_14_accum) combiner(combiner)
+static void my_long4_14_accum(int *accum, long4 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_long4_15) accumulator(my_long4_15_accum) combiner(combiner)
+static void my_long4_15_accum(int *accum, long4 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_uchar_0) accumulator(my_uchar_0_accum) combiner(combiner)
+static void my_uchar_0_accum(int *accum, uchar in) { }
+
+#pragma rs reduce(my_uchar_1) accumulator(my_uchar_1_accum) combiner(combiner)
+static void my_uchar_1_accum(int *accum, uchar in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_2) accumulator(my_uchar_2_accum) combiner(combiner)
+static void my_uchar_2_accum(int *accum, uchar in, uint x) { }
+
+#pragma rs reduce(my_uchar_3) accumulator(my_uchar_3_accum) combiner(combiner)
+static void my_uchar_3_accum(int *accum, uchar in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_uchar_4) accumulator(my_uchar_4_accum) combiner(combiner)
+static void my_uchar_4_accum(int *accum, uchar in, uint y) { }
+
+#pragma rs reduce(my_uchar_5) accumulator(my_uchar_5_accum) combiner(combiner)
+static void my_uchar_5_accum(int *accum, uchar in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_uchar_6) accumulator(my_uchar_6_accum) combiner(combiner)
+static void my_uchar_6_accum(int *accum, uchar in, uint x, uint y) { }
+
+#pragma rs reduce(my_uchar_7) accumulator(my_uchar_7_accum) combiner(combiner)
+static void my_uchar_7_accum(int *accum, uchar in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_uchar_8) accumulator(my_uchar_8_accum) combiner(combiner)
+static void my_uchar_8_accum(int *accum, uchar in, uint z) { }
+
+#pragma rs reduce(my_uchar_9) accumulator(my_uchar_9_accum) combiner(combiner)
+static void my_uchar_9_accum(int *accum, uchar in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_uchar_10) accumulator(my_uchar_10_accum) combiner(combiner)
+static void my_uchar_10_accum(int *accum, uchar in, uint x, uint z) { }
+
+#pragma rs reduce(my_uchar_11) accumulator(my_uchar_11_accum) combiner(combiner)
+static void my_uchar_11_accum(int *accum, uchar in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_uchar_12) accumulator(my_uchar_12_accum) combiner(combiner)
+static void my_uchar_12_accum(int *accum, uchar in, uint y, uint z) { }
+
+#pragma rs reduce(my_uchar_13) accumulator(my_uchar_13_accum) combiner(combiner)
+static void my_uchar_13_accum(int *accum, uchar in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_uchar_14) accumulator(my_uchar_14_accum) combiner(combiner)
+static void my_uchar_14_accum(int *accum, uchar in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_uchar_15) accumulator(my_uchar_15_accum) combiner(combiner)
+static void my_uchar_15_accum(int *accum, uchar in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_uchar2_0) accumulator(my_uchar2_0_accum) combiner(combiner)
+static void my_uchar2_0_accum(int *accum, uchar2 in) { }
+
+#pragma rs reduce(my_uchar2_1) accumulator(my_uchar2_1_accum) combiner(combiner)
+static void my_uchar2_1_accum(int *accum, uchar2 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_2) accumulator(my_uchar2_2_accum) combiner(combiner)
+static void my_uchar2_2_accum(int *accum, uchar2 in, uint x) { }
+
+#pragma rs reduce(my_uchar2_3) accumulator(my_uchar2_3_accum) combiner(combiner)
+static void my_uchar2_3_accum(int *accum, uchar2 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_uchar2_4) accumulator(my_uchar2_4_accum) combiner(combiner)
+static void my_uchar2_4_accum(int *accum, uchar2 in, uint y) { }
+
+#pragma rs reduce(my_uchar2_5) accumulator(my_uchar2_5_accum) combiner(combiner)
+static void my_uchar2_5_accum(int *accum, uchar2 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_uchar2_6) accumulator(my_uchar2_6_accum) combiner(combiner)
+static void my_uchar2_6_accum(int *accum, uchar2 in, uint x, uint y) { }
+
+#pragma rs reduce(my_uchar2_7) accumulator(my_uchar2_7_accum) combiner(combiner)
+static void my_uchar2_7_accum(int *accum, uchar2 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_uchar2_8) accumulator(my_uchar2_8_accum) combiner(combiner)
+static void my_uchar2_8_accum(int *accum, uchar2 in, uint z) { }
+
+#pragma rs reduce(my_uchar2_9) accumulator(my_uchar2_9_accum) combiner(combiner)
+static void my_uchar2_9_accum(int *accum, uchar2 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_uchar2_10) accumulator(my_uchar2_10_accum) combiner(combiner)
+static void my_uchar2_10_accum(int *accum, uchar2 in, uint x, uint z) { }
+
+#pragma rs reduce(my_uchar2_11) accumulator(my_uchar2_11_accum) combiner(combiner)
+static void my_uchar2_11_accum(int *accum, uchar2 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_uchar2_12) accumulator(my_uchar2_12_accum) combiner(combiner)
+static void my_uchar2_12_accum(int *accum, uchar2 in, uint y, uint z) { }
+
+#pragma rs reduce(my_uchar2_13) accumulator(my_uchar2_13_accum) combiner(combiner)
+static void my_uchar2_13_accum(int *accum, uchar2 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_uchar2_14) accumulator(my_uchar2_14_accum) combiner(combiner)
+static void my_uchar2_14_accum(int *accum, uchar2 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_uchar2_15) accumulator(my_uchar2_15_accum) combiner(combiner)
+static void my_uchar2_15_accum(int *accum, uchar2 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_uchar4_0) accumulator(my_uchar4_0_accum) combiner(combiner)
+static void my_uchar4_0_accum(int *accum, uchar4 in) { }
+
+#pragma rs reduce(my_uchar4_1) accumulator(my_uchar4_1_accum) combiner(combiner)
+static void my_uchar4_1_accum(int *accum, uchar4 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_2) accumulator(my_uchar4_2_accum) combiner(combiner)
+static void my_uchar4_2_accum(int *accum, uchar4 in, uint x) { }
+
+#pragma rs reduce(my_uchar4_3) accumulator(my_uchar4_3_accum) combiner(combiner)
+static void my_uchar4_3_accum(int *accum, uchar4 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_uchar4_4) accumulator(my_uchar4_4_accum) combiner(combiner)
+static void my_uchar4_4_accum(int *accum, uchar4 in, uint y) { }
+
+#pragma rs reduce(my_uchar4_5) accumulator(my_uchar4_5_accum) combiner(combiner)
+static void my_uchar4_5_accum(int *accum, uchar4 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_uchar4_6) accumulator(my_uchar4_6_accum) combiner(combiner)
+static void my_uchar4_6_accum(int *accum, uchar4 in, uint x, uint y) { }
+
+#pragma rs reduce(my_uchar4_7) accumulator(my_uchar4_7_accum) combiner(combiner)
+static void my_uchar4_7_accum(int *accum, uchar4 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_uchar4_8) accumulator(my_uchar4_8_accum) combiner(combiner)
+static void my_uchar4_8_accum(int *accum, uchar4 in, uint z) { }
+
+#pragma rs reduce(my_uchar4_9) accumulator(my_uchar4_9_accum) combiner(combiner)
+static void my_uchar4_9_accum(int *accum, uchar4 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_uchar4_10) accumulator(my_uchar4_10_accum) combiner(combiner)
+static void my_uchar4_10_accum(int *accum, uchar4 in, uint x, uint z) { }
+
+#pragma rs reduce(my_uchar4_11) accumulator(my_uchar4_11_accum) combiner(combiner)
+static void my_uchar4_11_accum(int *accum, uchar4 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_uchar4_12) accumulator(my_uchar4_12_accum) combiner(combiner)
+static void my_uchar4_12_accum(int *accum, uchar4 in, uint y, uint z) { }
+
+#pragma rs reduce(my_uchar4_13) accumulator(my_uchar4_13_accum) combiner(combiner)
+static void my_uchar4_13_accum(int *accum, uchar4 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_uchar4_14) accumulator(my_uchar4_14_accum) combiner(combiner)
+static void my_uchar4_14_accum(int *accum, uchar4 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_uchar4_15) accumulator(my_uchar4_15_accum) combiner(combiner)
+static void my_uchar4_15_accum(int *accum, uchar4 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_ushort_0) accumulator(my_ushort_0_accum) combiner(combiner)
+static void my_ushort_0_accum(int *accum, ushort in) { }
+
+#pragma rs reduce(my_ushort_1) accumulator(my_ushort_1_accum) combiner(combiner)
+static void my_ushort_1_accum(int *accum, ushort in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_2) accumulator(my_ushort_2_accum) combiner(combiner)
+static void my_ushort_2_accum(int *accum, ushort in, uint x) { }
+
+#pragma rs reduce(my_ushort_3) accumulator(my_ushort_3_accum) combiner(combiner)
+static void my_ushort_3_accum(int *accum, ushort in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_ushort_4) accumulator(my_ushort_4_accum) combiner(combiner)
+static void my_ushort_4_accum(int *accum, ushort in, uint y) { }
+
+#pragma rs reduce(my_ushort_5) accumulator(my_ushort_5_accum) combiner(combiner)
+static void my_ushort_5_accum(int *accum, ushort in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_ushort_6) accumulator(my_ushort_6_accum) combiner(combiner)
+static void my_ushort_6_accum(int *accum, ushort in, uint x, uint y) { }
+
+#pragma rs reduce(my_ushort_7) accumulator(my_ushort_7_accum) combiner(combiner)
+static void my_ushort_7_accum(int *accum, ushort in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_ushort_8) accumulator(my_ushort_8_accum) combiner(combiner)
+static void my_ushort_8_accum(int *accum, ushort in, uint z) { }
+
+#pragma rs reduce(my_ushort_9) accumulator(my_ushort_9_accum) combiner(combiner)
+static void my_ushort_9_accum(int *accum, ushort in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_ushort_10) accumulator(my_ushort_10_accum) combiner(combiner)
+static void my_ushort_10_accum(int *accum, ushort in, uint x, uint z) { }
+
+#pragma rs reduce(my_ushort_11) accumulator(my_ushort_11_accum) combiner(combiner)
+static void my_ushort_11_accum(int *accum, ushort in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_ushort_12) accumulator(my_ushort_12_accum) combiner(combiner)
+static void my_ushort_12_accum(int *accum, ushort in, uint y, uint z) { }
+
+#pragma rs reduce(my_ushort_13) accumulator(my_ushort_13_accum) combiner(combiner)
+static void my_ushort_13_accum(int *accum, ushort in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_ushort_14) accumulator(my_ushort_14_accum) combiner(combiner)
+static void my_ushort_14_accum(int *accum, ushort in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_ushort_15) accumulator(my_ushort_15_accum) combiner(combiner)
+static void my_ushort_15_accum(int *accum, ushort in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_ushort2_0) accumulator(my_ushort2_0_accum) combiner(combiner)
+static void my_ushort2_0_accum(int *accum, ushort2 in) { }
+
+#pragma rs reduce(my_ushort2_1) accumulator(my_ushort2_1_accum) combiner(combiner)
+static void my_ushort2_1_accum(int *accum, ushort2 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_2) accumulator(my_ushort2_2_accum) combiner(combiner)
+static void my_ushort2_2_accum(int *accum, ushort2 in, uint x) { }
+
+#pragma rs reduce(my_ushort2_3) accumulator(my_ushort2_3_accum) combiner(combiner)
+static void my_ushort2_3_accum(int *accum, ushort2 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_ushort2_4) accumulator(my_ushort2_4_accum) combiner(combiner)
+static void my_ushort2_4_accum(int *accum, ushort2 in, uint y) { }
+
+#pragma rs reduce(my_ushort2_5) accumulator(my_ushort2_5_accum) combiner(combiner)
+static void my_ushort2_5_accum(int *accum, ushort2 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_ushort2_6) accumulator(my_ushort2_6_accum) combiner(combiner)
+static void my_ushort2_6_accum(int *accum, ushort2 in, uint x, uint y) { }
+
+#pragma rs reduce(my_ushort2_7) accumulator(my_ushort2_7_accum) combiner(combiner)
+static void my_ushort2_7_accum(int *accum, ushort2 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_ushort2_8) accumulator(my_ushort2_8_accum) combiner(combiner)
+static void my_ushort2_8_accum(int *accum, ushort2 in, uint z) { }
+
+#pragma rs reduce(my_ushort2_9) accumulator(my_ushort2_9_accum) combiner(combiner)
+static void my_ushort2_9_accum(int *accum, ushort2 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_ushort2_10) accumulator(my_ushort2_10_accum) combiner(combiner)
+static void my_ushort2_10_accum(int *accum, ushort2 in, uint x, uint z) { }
+
+#pragma rs reduce(my_ushort2_11) accumulator(my_ushort2_11_accum) combiner(combiner)
+static void my_ushort2_11_accum(int *accum, ushort2 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_ushort2_12) accumulator(my_ushort2_12_accum) combiner(combiner)
+static void my_ushort2_12_accum(int *accum, ushort2 in, uint y, uint z) { }
+
+#pragma rs reduce(my_ushort2_13) accumulator(my_ushort2_13_accum) combiner(combiner)
+static void my_ushort2_13_accum(int *accum, ushort2 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_ushort2_14) accumulator(my_ushort2_14_accum) combiner(combiner)
+static void my_ushort2_14_accum(int *accum, ushort2 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_ushort2_15) accumulator(my_ushort2_15_accum) combiner(combiner)
+static void my_ushort2_15_accum(int *accum, ushort2 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_ushort4_0) accumulator(my_ushort4_0_accum) combiner(combiner)
+static void my_ushort4_0_accum(int *accum, ushort4 in) { }
+
+#pragma rs reduce(my_ushort4_1) accumulator(my_ushort4_1_accum) combiner(combiner)
+static void my_ushort4_1_accum(int *accum, ushort4 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_2) accumulator(my_ushort4_2_accum) combiner(combiner)
+static void my_ushort4_2_accum(int *accum, ushort4 in, uint x) { }
+
+#pragma rs reduce(my_ushort4_3) accumulator(my_ushort4_3_accum) combiner(combiner)
+static void my_ushort4_3_accum(int *accum, ushort4 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_ushort4_4) accumulator(my_ushort4_4_accum) combiner(combiner)
+static void my_ushort4_4_accum(int *accum, ushort4 in, uint y) { }
+
+#pragma rs reduce(my_ushort4_5) accumulator(my_ushort4_5_accum) combiner(combiner)
+static void my_ushort4_5_accum(int *accum, ushort4 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_ushort4_6) accumulator(my_ushort4_6_accum) combiner(combiner)
+static void my_ushort4_6_accum(int *accum, ushort4 in, uint x, uint y) { }
+
+#pragma rs reduce(my_ushort4_7) accumulator(my_ushort4_7_accum) combiner(combiner)
+static void my_ushort4_7_accum(int *accum, ushort4 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_ushort4_8) accumulator(my_ushort4_8_accum) combiner(combiner)
+static void my_ushort4_8_accum(int *accum, ushort4 in, uint z) { }
+
+#pragma rs reduce(my_ushort4_9) accumulator(my_ushort4_9_accum) combiner(combiner)
+static void my_ushort4_9_accum(int *accum, ushort4 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_ushort4_10) accumulator(my_ushort4_10_accum) combiner(combiner)
+static void my_ushort4_10_accum(int *accum, ushort4 in, uint x, uint z) { }
+
+#pragma rs reduce(my_ushort4_11) accumulator(my_ushort4_11_accum) combiner(combiner)
+static void my_ushort4_11_accum(int *accum, ushort4 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_ushort4_12) accumulator(my_ushort4_12_accum) combiner(combiner)
+static void my_ushort4_12_accum(int *accum, ushort4 in, uint y, uint z) { }
+
+#pragma rs reduce(my_ushort4_13) accumulator(my_ushort4_13_accum) combiner(combiner)
+static void my_ushort4_13_accum(int *accum, ushort4 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_ushort4_14) accumulator(my_ushort4_14_accum) combiner(combiner)
+static void my_ushort4_14_accum(int *accum, ushort4 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_ushort4_15) accumulator(my_ushort4_15_accum) combiner(combiner)
+static void my_ushort4_15_accum(int *accum, ushort4 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_uint_0) accumulator(my_uint_0_accum) combiner(combiner)
+static void my_uint_0_accum(int *accum, uint in) { }
+
+#pragma rs reduce(my_uint_1) accumulator(my_uint_1_accum) combiner(combiner)
+static void my_uint_1_accum(int *accum, uint in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uint_2) accumulator(my_uint_2_accum) combiner(combiner)
+static void my_uint_2_accum(int *accum, uint in, uint x) { }
+
+#pragma rs reduce(my_uint_3) accumulator(my_uint_3_accum) combiner(combiner)
+static void my_uint_3_accum(int *accum, uint in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_uint_4) accumulator(my_uint_4_accum) combiner(combiner)
+static void my_uint_4_accum(int *accum, uint in, uint y) { }
+
+#pragma rs reduce(my_uint_5) accumulator(my_uint_5_accum) combiner(combiner)
+static void my_uint_5_accum(int *accum, uint in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_uint_6) accumulator(my_uint_6_accum) combiner(combiner)
+static void my_uint_6_accum(int *accum, uint in, uint x, uint y) { }
+
+#pragma rs reduce(my_uint_7) accumulator(my_uint_7_accum) combiner(combiner)
+static void my_uint_7_accum(int *accum, uint in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_uint_8) accumulator(my_uint_8_accum) combiner(combiner)
+static void my_uint_8_accum(int *accum, uint in, uint z) { }
+
+#pragma rs reduce(my_uint_9) accumulator(my_uint_9_accum) combiner(combiner)
+static void my_uint_9_accum(int *accum, uint in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_uint_10) accumulator(my_uint_10_accum) combiner(combiner)
+static void my_uint_10_accum(int *accum, uint in, uint x, uint z) { }
+
+#pragma rs reduce(my_uint_11) accumulator(my_uint_11_accum) combiner(combiner)
+static void my_uint_11_accum(int *accum, uint in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_uint_12) accumulator(my_uint_12_accum) combiner(combiner)
+static void my_uint_12_accum(int *accum, uint in, uint y, uint z) { }
+
+#pragma rs reduce(my_uint_13) accumulator(my_uint_13_accum) combiner(combiner)
+static void my_uint_13_accum(int *accum, uint in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_uint_14) accumulator(my_uint_14_accum) combiner(combiner)
+static void my_uint_14_accum(int *accum, uint in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_uint_15) accumulator(my_uint_15_accum) combiner(combiner)
+static void my_uint_15_accum(int *accum, uint in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_uint2_0) accumulator(my_uint2_0_accum) combiner(combiner)
+static void my_uint2_0_accum(int *accum, uint2 in) { }
+
+#pragma rs reduce(my_uint2_1) accumulator(my_uint2_1_accum) combiner(combiner)
+static void my_uint2_1_accum(int *accum, uint2 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uint2_2) accumulator(my_uint2_2_accum) combiner(combiner)
+static void my_uint2_2_accum(int *accum, uint2 in, uint x) { }
+
+#pragma rs reduce(my_uint2_3) accumulator(my_uint2_3_accum) combiner(combiner)
+static void my_uint2_3_accum(int *accum, uint2 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_uint2_4) accumulator(my_uint2_4_accum) combiner(combiner)
+static void my_uint2_4_accum(int *accum, uint2 in, uint y) { }
+
+#pragma rs reduce(my_uint2_5) accumulator(my_uint2_5_accum) combiner(combiner)
+static void my_uint2_5_accum(int *accum, uint2 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_uint2_6) accumulator(my_uint2_6_accum) combiner(combiner)
+static void my_uint2_6_accum(int *accum, uint2 in, uint x, uint y) { }
+
+#pragma rs reduce(my_uint2_7) accumulator(my_uint2_7_accum) combiner(combiner)
+static void my_uint2_7_accum(int *accum, uint2 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_uint2_8) accumulator(my_uint2_8_accum) combiner(combiner)
+static void my_uint2_8_accum(int *accum, uint2 in, uint z) { }
+
+#pragma rs reduce(my_uint2_9) accumulator(my_uint2_9_accum) combiner(combiner)
+static void my_uint2_9_accum(int *accum, uint2 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_uint2_10) accumulator(my_uint2_10_accum) combiner(combiner)
+static void my_uint2_10_accum(int *accum, uint2 in, uint x, uint z) { }
+
+#pragma rs reduce(my_uint2_11) accumulator(my_uint2_11_accum) combiner(combiner)
+static void my_uint2_11_accum(int *accum, uint2 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_uint2_12) accumulator(my_uint2_12_accum) combiner(combiner)
+static void my_uint2_12_accum(int *accum, uint2 in, uint y, uint z) { }
+
+#pragma rs reduce(my_uint2_13) accumulator(my_uint2_13_accum) combiner(combiner)
+static void my_uint2_13_accum(int *accum, uint2 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_uint2_14) accumulator(my_uint2_14_accum) combiner(combiner)
+static void my_uint2_14_accum(int *accum, uint2 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_uint2_15) accumulator(my_uint2_15_accum) combiner(combiner)
+static void my_uint2_15_accum(int *accum, uint2 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_uint4_0) accumulator(my_uint4_0_accum) combiner(combiner)
+static void my_uint4_0_accum(int *accum, uint4 in) { }
+
+#pragma rs reduce(my_uint4_1) accumulator(my_uint4_1_accum) combiner(combiner)
+static void my_uint4_1_accum(int *accum, uint4 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uint4_2) accumulator(my_uint4_2_accum) combiner(combiner)
+static void my_uint4_2_accum(int *accum, uint4 in, uint x) { }
+
+#pragma rs reduce(my_uint4_3) accumulator(my_uint4_3_accum) combiner(combiner)
+static void my_uint4_3_accum(int *accum, uint4 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_uint4_4) accumulator(my_uint4_4_accum) combiner(combiner)
+static void my_uint4_4_accum(int *accum, uint4 in, uint y) { }
+
+#pragma rs reduce(my_uint4_5) accumulator(my_uint4_5_accum) combiner(combiner)
+static void my_uint4_5_accum(int *accum, uint4 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_uint4_6) accumulator(my_uint4_6_accum) combiner(combiner)
+static void my_uint4_6_accum(int *accum, uint4 in, uint x, uint y) { }
+
+#pragma rs reduce(my_uint4_7) accumulator(my_uint4_7_accum) combiner(combiner)
+static void my_uint4_7_accum(int *accum, uint4 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_uint4_8) accumulator(my_uint4_8_accum) combiner(combiner)
+static void my_uint4_8_accum(int *accum, uint4 in, uint z) { }
+
+#pragma rs reduce(my_uint4_9) accumulator(my_uint4_9_accum) combiner(combiner)
+static void my_uint4_9_accum(int *accum, uint4 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_uint4_10) accumulator(my_uint4_10_accum) combiner(combiner)
+static void my_uint4_10_accum(int *accum, uint4 in, uint x, uint z) { }
+
+#pragma rs reduce(my_uint4_11) accumulator(my_uint4_11_accum) combiner(combiner)
+static void my_uint4_11_accum(int *accum, uint4 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_uint4_12) accumulator(my_uint4_12_accum) combiner(combiner)
+static void my_uint4_12_accum(int *accum, uint4 in, uint y, uint z) { }
+
+#pragma rs reduce(my_uint4_13) accumulator(my_uint4_13_accum) combiner(combiner)
+static void my_uint4_13_accum(int *accum, uint4 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_uint4_14) accumulator(my_uint4_14_accum) combiner(combiner)
+static void my_uint4_14_accum(int *accum, uint4 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_uint4_15) accumulator(my_uint4_15_accum) combiner(combiner)
+static void my_uint4_15_accum(int *accum, uint4 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_ulong_0) accumulator(my_ulong_0_accum) combiner(combiner)
+static void my_ulong_0_accum(int *accum, ulong in) { }
+
+#pragma rs reduce(my_ulong_1) accumulator(my_ulong_1_accum) combiner(combiner)
+static void my_ulong_1_accum(int *accum, ulong in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ulong_2) accumulator(my_ulong_2_accum) combiner(combiner)
+static void my_ulong_2_accum(int *accum, ulong in, uint x) { }
+
+#pragma rs reduce(my_ulong_3) accumulator(my_ulong_3_accum) combiner(combiner)
+static void my_ulong_3_accum(int *accum, ulong in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_ulong_4) accumulator(my_ulong_4_accum) combiner(combiner)
+static void my_ulong_4_accum(int *accum, ulong in, uint y) { }
+
+#pragma rs reduce(my_ulong_5) accumulator(my_ulong_5_accum) combiner(combiner)
+static void my_ulong_5_accum(int *accum, ulong in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_ulong_6) accumulator(my_ulong_6_accum) combiner(combiner)
+static void my_ulong_6_accum(int *accum, ulong in, uint x, uint y) { }
+
+#pragma rs reduce(my_ulong_7) accumulator(my_ulong_7_accum) combiner(combiner)
+static void my_ulong_7_accum(int *accum, ulong in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_ulong_8) accumulator(my_ulong_8_accum) combiner(combiner)
+static void my_ulong_8_accum(int *accum, ulong in, uint z) { }
+
+#pragma rs reduce(my_ulong_9) accumulator(my_ulong_9_accum) combiner(combiner)
+static void my_ulong_9_accum(int *accum, ulong in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_ulong_10) accumulator(my_ulong_10_accum) combiner(combiner)
+static void my_ulong_10_accum(int *accum, ulong in, uint x, uint z) { }
+
+#pragma rs reduce(my_ulong_11) accumulator(my_ulong_11_accum) combiner(combiner)
+static void my_ulong_11_accum(int *accum, ulong in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_ulong_12) accumulator(my_ulong_12_accum) combiner(combiner)
+static void my_ulong_12_accum(int *accum, ulong in, uint y, uint z) { }
+
+#pragma rs reduce(my_ulong_13) accumulator(my_ulong_13_accum) combiner(combiner)
+static void my_ulong_13_accum(int *accum, ulong in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_ulong_14) accumulator(my_ulong_14_accum) combiner(combiner)
+static void my_ulong_14_accum(int *accum, ulong in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_ulong_15) accumulator(my_ulong_15_accum) combiner(combiner)
+static void my_ulong_15_accum(int *accum, ulong in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_ulong2_0) accumulator(my_ulong2_0_accum) combiner(combiner)
+static void my_ulong2_0_accum(int *accum, ulong2 in) { }
+
+#pragma rs reduce(my_ulong2_1) accumulator(my_ulong2_1_accum) combiner(combiner)
+static void my_ulong2_1_accum(int *accum, ulong2 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ulong2_2) accumulator(my_ulong2_2_accum) combiner(combiner)
+static void my_ulong2_2_accum(int *accum, ulong2 in, uint x) { }
+
+#pragma rs reduce(my_ulong2_3) accumulator(my_ulong2_3_accum) combiner(combiner)
+static void my_ulong2_3_accum(int *accum, ulong2 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_ulong2_4) accumulator(my_ulong2_4_accum) combiner(combiner)
+static void my_ulong2_4_accum(int *accum, ulong2 in, uint y) { }
+
+#pragma rs reduce(my_ulong2_5) accumulator(my_ulong2_5_accum) combiner(combiner)
+static void my_ulong2_5_accum(int *accum, ulong2 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_ulong2_6) accumulator(my_ulong2_6_accum) combiner(combiner)
+static void my_ulong2_6_accum(int *accum, ulong2 in, uint x, uint y) { }
+
+#pragma rs reduce(my_ulong2_7) accumulator(my_ulong2_7_accum) combiner(combiner)
+static void my_ulong2_7_accum(int *accum, ulong2 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_ulong2_8) accumulator(my_ulong2_8_accum) combiner(combiner)
+static void my_ulong2_8_accum(int *accum, ulong2 in, uint z) { }
+
+#pragma rs reduce(my_ulong2_9) accumulator(my_ulong2_9_accum) combiner(combiner)
+static void my_ulong2_9_accum(int *accum, ulong2 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_ulong2_10) accumulator(my_ulong2_10_accum) combiner(combiner)
+static void my_ulong2_10_accum(int *accum, ulong2 in, uint x, uint z) { }
+
+#pragma rs reduce(my_ulong2_11) accumulator(my_ulong2_11_accum) combiner(combiner)
+static void my_ulong2_11_accum(int *accum, ulong2 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_ulong2_12) accumulator(my_ulong2_12_accum) combiner(combiner)
+static void my_ulong2_12_accum(int *accum, ulong2 in, uint y, uint z) { }
+
+#pragma rs reduce(my_ulong2_13) accumulator(my_ulong2_13_accum) combiner(combiner)
+static void my_ulong2_13_accum(int *accum, ulong2 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_ulong2_14) accumulator(my_ulong2_14_accum) combiner(combiner)
+static void my_ulong2_14_accum(int *accum, ulong2 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_ulong2_15) accumulator(my_ulong2_15_accum) combiner(combiner)
+static void my_ulong2_15_accum(int *accum, ulong2 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_ulong4_0) accumulator(my_ulong4_0_accum) combiner(combiner)
+static void my_ulong4_0_accum(int *accum, ulong4 in) { }
+
+#pragma rs reduce(my_ulong4_1) accumulator(my_ulong4_1_accum) combiner(combiner)
+static void my_ulong4_1_accum(int *accum, ulong4 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ulong4_2) accumulator(my_ulong4_2_accum) combiner(combiner)
+static void my_ulong4_2_accum(int *accum, ulong4 in, uint x) { }
+
+#pragma rs reduce(my_ulong4_3) accumulator(my_ulong4_3_accum) combiner(combiner)
+static void my_ulong4_3_accum(int *accum, ulong4 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_ulong4_4) accumulator(my_ulong4_4_accum) combiner(combiner)
+static void my_ulong4_4_accum(int *accum, ulong4 in, uint y) { }
+
+#pragma rs reduce(my_ulong4_5) accumulator(my_ulong4_5_accum) combiner(combiner)
+static void my_ulong4_5_accum(int *accum, ulong4 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_ulong4_6) accumulator(my_ulong4_6_accum) combiner(combiner)
+static void my_ulong4_6_accum(int *accum, ulong4 in, uint x, uint y) { }
+
+#pragma rs reduce(my_ulong4_7) accumulator(my_ulong4_7_accum) combiner(combiner)
+static void my_ulong4_7_accum(int *accum, ulong4 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_ulong4_8) accumulator(my_ulong4_8_accum) combiner(combiner)
+static void my_ulong4_8_accum(int *accum, ulong4 in, uint z) { }
+
+#pragma rs reduce(my_ulong4_9) accumulator(my_ulong4_9_accum) combiner(combiner)
+static void my_ulong4_9_accum(int *accum, ulong4 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_ulong4_10) accumulator(my_ulong4_10_accum) combiner(combiner)
+static void my_ulong4_10_accum(int *accum, ulong4 in, uint x, uint z) { }
+
+#pragma rs reduce(my_ulong4_11) accumulator(my_ulong4_11_accum) combiner(combiner)
+static void my_ulong4_11_accum(int *accum, ulong4 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_ulong4_12) accumulator(my_ulong4_12_accum) combiner(combiner)
+static void my_ulong4_12_accum(int *accum, ulong4 in, uint y, uint z) { }
+
+#pragma rs reduce(my_ulong4_13) accumulator(my_ulong4_13_accum) combiner(combiner)
+static void my_ulong4_13_accum(int *accum, ulong4 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_ulong4_14) accumulator(my_ulong4_14_accum) combiner(combiner)
+static void my_ulong4_14_accum(int *accum, ulong4 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_ulong4_15) accumulator(my_ulong4_15_accum) combiner(combiner)
+static void my_ulong4_15_accum(int *accum, ulong4 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_bool_0) accumulator(my_bool_0_accum) combiner(combiner)
+static void my_bool_0_accum(int *accum, bool in) { }
+
+#pragma rs reduce(my_bool_1) accumulator(my_bool_1_accum) combiner(combiner)
+static void my_bool_1_accum(int *accum, bool in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_2) accumulator(my_bool_2_accum) combiner(combiner)
+static void my_bool_2_accum(int *accum, bool in, uint x) { }
+
+#pragma rs reduce(my_bool_3) accumulator(my_bool_3_accum) combiner(combiner)
+static void my_bool_3_accum(int *accum, bool in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_bool_4) accumulator(my_bool_4_accum) combiner(combiner)
+static void my_bool_4_accum(int *accum, bool in, uint y) { }
+
+#pragma rs reduce(my_bool_5) accumulator(my_bool_5_accum) combiner(combiner)
+static void my_bool_5_accum(int *accum, bool in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_bool_6) accumulator(my_bool_6_accum) combiner(combiner)
+static void my_bool_6_accum(int *accum, bool in, uint x, uint y) { }
+
+#pragma rs reduce(my_bool_7) accumulator(my_bool_7_accum) combiner(combiner)
+static void my_bool_7_accum(int *accum, bool in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_bool_8) accumulator(my_bool_8_accum) combiner(combiner)
+static void my_bool_8_accum(int *accum, bool in, uint z) { }
+
+#pragma rs reduce(my_bool_9) accumulator(my_bool_9_accum) combiner(combiner)
+static void my_bool_9_accum(int *accum, bool in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_bool_10) accumulator(my_bool_10_accum) combiner(combiner)
+static void my_bool_10_accum(int *accum, bool in, uint x, uint z) { }
+
+#pragma rs reduce(my_bool_11) accumulator(my_bool_11_accum) combiner(combiner)
+static void my_bool_11_accum(int *accum, bool in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_bool_12) accumulator(my_bool_12_accum) combiner(combiner)
+static void my_bool_12_accum(int *accum, bool in, uint y, uint z) { }
+
+#pragma rs reduce(my_bool_13) accumulator(my_bool_13_accum) combiner(combiner)
+static void my_bool_13_accum(int *accum, bool in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_bool_14) accumulator(my_bool_14_accum) combiner(combiner)
+static void my_bool_14_accum(int *accum, bool in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_bool_15) accumulator(my_bool_15_accum) combiner(combiner)
+static void my_bool_15_accum(int *accum, bool in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_rs_matrix2x2_0) accumulator(my_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_0_accum(int *accum, rs_matrix2x2 in) { }
+
+#pragma rs reduce(my_rs_matrix2x2_1) accumulator(my_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_1_accum(int *accum, rs_matrix2x2 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_2) accumulator(my_rs_matrix2x2_2_accum) combiner(combiner)
+static void my_rs_matrix2x2_2_accum(int *accum, rs_matrix2x2 in, uint x) { }
+
+#pragma rs reduce(my_rs_matrix2x2_3) accumulator(my_rs_matrix2x2_3_accum) combiner(combiner)
+static void my_rs_matrix2x2_3_accum(int *accum, rs_matrix2x2 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_rs_matrix2x2_4) accumulator(my_rs_matrix2x2_4_accum) combiner(combiner)
+static void my_rs_matrix2x2_4_accum(int *accum, rs_matrix2x2 in, uint y) { }
+
+#pragma rs reduce(my_rs_matrix2x2_5) accumulator(my_rs_matrix2x2_5_accum) combiner(combiner)
+static void my_rs_matrix2x2_5_accum(int *accum, rs_matrix2x2 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_rs_matrix2x2_6) accumulator(my_rs_matrix2x2_6_accum) combiner(combiner)
+static void my_rs_matrix2x2_6_accum(int *accum, rs_matrix2x2 in, uint x, uint y) { }
+
+#pragma rs reduce(my_rs_matrix2x2_7) accumulator(my_rs_matrix2x2_7_accum) combiner(combiner)
+static void my_rs_matrix2x2_7_accum(int *accum, rs_matrix2x2 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_rs_matrix2x2_8) accumulator(my_rs_matrix2x2_8_accum) combiner(combiner)
+static void my_rs_matrix2x2_8_accum(int *accum, rs_matrix2x2 in, uint z) { }
+
+#pragma rs reduce(my_rs_matrix2x2_9) accumulator(my_rs_matrix2x2_9_accum) combiner(combiner)
+static void my_rs_matrix2x2_9_accum(int *accum, rs_matrix2x2 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_rs_matrix2x2_10) accumulator(my_rs_matrix2x2_10_accum) combiner(combiner)
+static void my_rs_matrix2x2_10_accum(int *accum, rs_matrix2x2 in, uint x, uint z) { }
+
+#pragma rs reduce(my_rs_matrix2x2_11) accumulator(my_rs_matrix2x2_11_accum) combiner(combiner)
+static void my_rs_matrix2x2_11_accum(int *accum, rs_matrix2x2 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_rs_matrix2x2_12) accumulator(my_rs_matrix2x2_12_accum) combiner(combiner)
+static void my_rs_matrix2x2_12_accum(int *accum, rs_matrix2x2 in, uint y, uint z) { }
+
+#pragma rs reduce(my_rs_matrix2x2_13) accumulator(my_rs_matrix2x2_13_accum) combiner(combiner)
+static void my_rs_matrix2x2_13_accum(int *accum, rs_matrix2x2 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_rs_matrix2x2_14) accumulator(my_rs_matrix2x2_14_accum) combiner(combiner)
+static void my_rs_matrix2x2_14_accum(int *accum, rs_matrix2x2 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_rs_matrix2x2_15) accumulator(my_rs_matrix2x2_15_accum) combiner(combiner)
+static void my_rs_matrix2x2_15_accum(int *accum, rs_matrix2x2 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_rs_matrix3x3_0) accumulator(my_rs_matrix3x3_0_accum) combiner(combiner)
+static void my_rs_matrix3x3_0_accum(int *accum, rs_matrix3x3 in) { }
+
+#pragma rs reduce(my_rs_matrix3x3_1) accumulator(my_rs_matrix3x3_1_accum) combiner(combiner)
+static void my_rs_matrix3x3_1_accum(int *accum, rs_matrix3x3 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix3x3_2) accumulator(my_rs_matrix3x3_2_accum) combiner(combiner)
+static void my_rs_matrix3x3_2_accum(int *accum, rs_matrix3x3 in, uint x) { }
+
+#pragma rs reduce(my_rs_matrix3x3_3) accumulator(my_rs_matrix3x3_3_accum) combiner(combiner)
+static void my_rs_matrix3x3_3_accum(int *accum, rs_matrix3x3 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_rs_matrix3x3_4) accumulator(my_rs_matrix3x3_4_accum) combiner(combiner)
+static void my_rs_matrix3x3_4_accum(int *accum, rs_matrix3x3 in, uint y) { }
+
+#pragma rs reduce(my_rs_matrix3x3_5) accumulator(my_rs_matrix3x3_5_accum) combiner(combiner)
+static void my_rs_matrix3x3_5_accum(int *accum, rs_matrix3x3 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_rs_matrix3x3_6) accumulator(my_rs_matrix3x3_6_accum) combiner(combiner)
+static void my_rs_matrix3x3_6_accum(int *accum, rs_matrix3x3 in, uint x, uint y) { }
+
+#pragma rs reduce(my_rs_matrix3x3_7) accumulator(my_rs_matrix3x3_7_accum) combiner(combiner)
+static void my_rs_matrix3x3_7_accum(int *accum, rs_matrix3x3 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_rs_matrix3x3_8) accumulator(my_rs_matrix3x3_8_accum) combiner(combiner)
+static void my_rs_matrix3x3_8_accum(int *accum, rs_matrix3x3 in, uint z) { }
+
+#pragma rs reduce(my_rs_matrix3x3_9) accumulator(my_rs_matrix3x3_9_accum) combiner(combiner)
+static void my_rs_matrix3x3_9_accum(int *accum, rs_matrix3x3 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_rs_matrix3x3_10) accumulator(my_rs_matrix3x3_10_accum) combiner(combiner)
+static void my_rs_matrix3x3_10_accum(int *accum, rs_matrix3x3 in, uint x, uint z) { }
+
+#pragma rs reduce(my_rs_matrix3x3_11) accumulator(my_rs_matrix3x3_11_accum) combiner(combiner)
+static void my_rs_matrix3x3_11_accum(int *accum, rs_matrix3x3 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_rs_matrix3x3_12) accumulator(my_rs_matrix3x3_12_accum) combiner(combiner)
+static void my_rs_matrix3x3_12_accum(int *accum, rs_matrix3x3 in, uint y, uint z) { }
+
+#pragma rs reduce(my_rs_matrix3x3_13) accumulator(my_rs_matrix3x3_13_accum) combiner(combiner)
+static void my_rs_matrix3x3_13_accum(int *accum, rs_matrix3x3 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_rs_matrix3x3_14) accumulator(my_rs_matrix3x3_14_accum) combiner(combiner)
+static void my_rs_matrix3x3_14_accum(int *accum, rs_matrix3x3 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_rs_matrix3x3_15) accumulator(my_rs_matrix3x3_15_accum) combiner(combiner)
+static void my_rs_matrix3x3_15_accum(int *accum, rs_matrix3x3 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_rs_matrix4x4_0) accumulator(my_rs_matrix4x4_0_accum) combiner(combiner)
+static void my_rs_matrix4x4_0_accum(int *accum, rs_matrix4x4 in) { }
+
+#pragma rs reduce(my_rs_matrix4x4_1) accumulator(my_rs_matrix4x4_1_accum) combiner(combiner)
+static void my_rs_matrix4x4_1_accum(int *accum, rs_matrix4x4 in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix4x4_2) accumulator(my_rs_matrix4x4_2_accum) combiner(combiner)
+static void my_rs_matrix4x4_2_accum(int *accum, rs_matrix4x4 in, uint x) { }
+
+#pragma rs reduce(my_rs_matrix4x4_3) accumulator(my_rs_matrix4x4_3_accum) combiner(combiner)
+static void my_rs_matrix4x4_3_accum(int *accum, rs_matrix4x4 in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_rs_matrix4x4_4) accumulator(my_rs_matrix4x4_4_accum) combiner(combiner)
+static void my_rs_matrix4x4_4_accum(int *accum, rs_matrix4x4 in, uint y) { }
+
+#pragma rs reduce(my_rs_matrix4x4_5) accumulator(my_rs_matrix4x4_5_accum) combiner(combiner)
+static void my_rs_matrix4x4_5_accum(int *accum, rs_matrix4x4 in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_rs_matrix4x4_6) accumulator(my_rs_matrix4x4_6_accum) combiner(combiner)
+static void my_rs_matrix4x4_6_accum(int *accum, rs_matrix4x4 in, uint x, uint y) { }
+
+#pragma rs reduce(my_rs_matrix4x4_7) accumulator(my_rs_matrix4x4_7_accum) combiner(combiner)
+static void my_rs_matrix4x4_7_accum(int *accum, rs_matrix4x4 in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_rs_matrix4x4_8) accumulator(my_rs_matrix4x4_8_accum) combiner(combiner)
+static void my_rs_matrix4x4_8_accum(int *accum, rs_matrix4x4 in, uint z) { }
+
+#pragma rs reduce(my_rs_matrix4x4_9) accumulator(my_rs_matrix4x4_9_accum) combiner(combiner)
+static void my_rs_matrix4x4_9_accum(int *accum, rs_matrix4x4 in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_rs_matrix4x4_10) accumulator(my_rs_matrix4x4_10_accum) combiner(combiner)
+static void my_rs_matrix4x4_10_accum(int *accum, rs_matrix4x4 in, uint x, uint z) { }
+
+#pragma rs reduce(my_rs_matrix4x4_11) accumulator(my_rs_matrix4x4_11_accum) combiner(combiner)
+static void my_rs_matrix4x4_11_accum(int *accum, rs_matrix4x4 in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_rs_matrix4x4_12) accumulator(my_rs_matrix4x4_12_accum) combiner(combiner)
+static void my_rs_matrix4x4_12_accum(int *accum, rs_matrix4x4 in, uint y, uint z) { }
+
+#pragma rs reduce(my_rs_matrix4x4_13) accumulator(my_rs_matrix4x4_13_accum) combiner(combiner)
+static void my_rs_matrix4x4_13_accum(int *accum, rs_matrix4x4 in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_rs_matrix4x4_14) accumulator(my_rs_matrix4x4_14_accum) combiner(combiner)
+static void my_rs_matrix4x4_14_accum(int *accum, rs_matrix4x4 in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_rs_matrix4x4_15) accumulator(my_rs_matrix4x4_15_accum) combiner(combiner)
+static void my_rs_matrix4x4_15_accum(int *accum, rs_matrix4x4 in, rs_kernel_context context, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_MyStruct_0) accumulator(my_MyStruct_0_accum) combiner(combiner)
+static void my_MyStruct_0_accum(int *accum, MyStruct in) { }
+
+#pragma rs reduce(my_MyStruct_1) accumulator(my_MyStruct_1_accum) combiner(combiner)
+static void my_MyStruct_1_accum(int *accum, MyStruct in, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_2) accumulator(my_MyStruct_2_accum) combiner(combiner)
+static void my_MyStruct_2_accum(int *accum, MyStruct in, uint x) { }
+
+#pragma rs reduce(my_MyStruct_3) accumulator(my_MyStruct_3_accum) combiner(combiner)
+static void my_MyStruct_3_accum(int *accum, MyStruct in, rs_kernel_context context, uint x) { }
+
+#pragma rs reduce(my_MyStruct_4) accumulator(my_MyStruct_4_accum) combiner(combiner)
+static void my_MyStruct_4_accum(int *accum, MyStruct in, uint y) { }
+
+#pragma rs reduce(my_MyStruct_5) accumulator(my_MyStruct_5_accum) combiner(combiner)
+static void my_MyStruct_5_accum(int *accum, MyStruct in, rs_kernel_context context, uint y) { }
+
+#pragma rs reduce(my_MyStruct_6) accumulator(my_MyStruct_6_accum) combiner(combiner)
+static void my_MyStruct_6_accum(int *accum, MyStruct in, uint x, uint y) { }
+
+#pragma rs reduce(my_MyStruct_7) accumulator(my_MyStruct_7_accum) combiner(combiner)
+static void my_MyStruct_7_accum(int *accum, MyStruct in, rs_kernel_context context, uint x, uint y) { }
+
+#pragma rs reduce(my_MyStruct_8) accumulator(my_MyStruct_8_accum) combiner(combiner)
+static void my_MyStruct_8_accum(int *accum, MyStruct in, uint z) { }
+
+#pragma rs reduce(my_MyStruct_9) accumulator(my_MyStruct_9_accum) combiner(combiner)
+static void my_MyStruct_9_accum(int *accum, MyStruct in, rs_kernel_context context, uint z) { }
+
+#pragma rs reduce(my_MyStruct_10) accumulator(my_MyStruct_10_accum) combiner(combiner)
+static void my_MyStruct_10_accum(int *accum, MyStruct in, uint x, uint z) { }
+
+#pragma rs reduce(my_MyStruct_11) accumulator(my_MyStruct_11_accum) combiner(combiner)
+static void my_MyStruct_11_accum(int *accum, MyStruct in, rs_kernel_context context, uint x, uint z) { }
+
+#pragma rs reduce(my_MyStruct_12) accumulator(my_MyStruct_12_accum) combiner(combiner)
+static void my_MyStruct_12_accum(int *accum, MyStruct in, uint y, uint z) { }
+
+#pragma rs reduce(my_MyStruct_13) accumulator(my_MyStruct_13_accum) combiner(combiner)
+static void my_MyStruct_13_accum(int *accum, MyStruct in, rs_kernel_context context, uint y, uint z) { }
+
+#pragma rs reduce(my_MyStruct_14) accumulator(my_MyStruct_14_accum) combiner(combiner)
+static void my_MyStruct_14_accum(int *accum, MyStruct in, uint x, uint y, uint z) { }
+
+#pragma rs reduce(my_MyStruct_15) accumulator(my_MyStruct_15_accum) combiner(combiner)
+static void my_MyStruct_15_accum(int *accum, MyStruct in, rs_kernel_context context, uint x, uint y, uint z) { }
diff --git a/tests/P_reduce_general/stderr.txt.expect b/tests/P_reduce_general_input/stderr.txt.expect
similarity index 100%
rename from tests/P_reduce_general/stderr.txt.expect
rename to tests/P_reduce_general_input/stderr.txt.expect
diff --git a/tests/P_reduce_general/stdout.txt.expect b/tests/P_reduce_general_input/stdout.txt.expect
similarity index 100%
rename from tests/P_reduce_general/stdout.txt.expect
rename to tests/P_reduce_general_input/stdout.txt.expect
diff --git a/tests/P_reduce_general_inputs/gen-inputs.pl b/tests/P_reduce_general_inputs/gen-inputs.pl
new file mode 100755
index 0000000..3146d5c
--- /dev/null
+++ b/tests/P_reduce_general_inputs/gen-inputs.pl
@@ -0,0 +1,71 @@
+#!/usr/bin/perl -w
+
+# Generate trivial test cases to exercise input types.
+
+use strict;
+
+# deliberately non-exhaustive
+my @basicTypes = ("half", "float", # "double",
+                  "char", "short", # "int", "long",
+                  "uchar", "ushort", # "uint", "ulong",
+                  "bool",
+                  "rs_matrix2x2", # "rs_matrix3x3", "rs_matrix4x4",
+                  "MyStruct");
+
+# 1 signifies non-vector
+# 3 is not supported for exported types
+my @vecLengths = (1, 2, 4);
+
+sub isVectorEligible {
+  my ($type) = @_;
+
+  # There are no bool vectors or struct vectors
+  return 0 if ($type eq "bool") || ($type eq "MyStruct");
+
+  # There are no matrix or object vectors
+  return 0 if (substr($type, 0, 3) eq "rs_");
+
+  # Else ok
+  return 1;
+}
+
+print "// -target-api 0 -Wall -Werror\n";
+print "#pragma version(1)\n";
+print "#pragma rs java_package_name(inputs)\n\n";
+print "// This test case was created by $0.\n";
+print "// It exercises various legal combinations of inputs and special parameters,\n";
+print "// so that we can ensure\n";
+print "// (a) We do not choke when compiling them\n";
+print "// (b) We reflect them correctly\n\n";
+print "// One example struct type\n";
+print "typedef struct MyStruct { float f; double d; } MyStruct;\n\n";
+print "// Trivial combiner shared by all test cases\n";
+print "static void combiner(int *accum, const int *other) { }\n";
+
+foreach my $basicTypeA (@basicTypes) {
+  foreach my $vecLenA (@vecLengths) {
+    next if ($vecLenA > 1) && !isVectorEligible($basicTypeA);
+
+    my $eltNameA = $basicTypeA;
+    $eltNameA .= $vecLenA if ($vecLenA > 1);
+
+    foreach my $basicTypeB (@basicTypes) {
+      foreach my $vecLenB (@vecLengths) {
+        next if ($vecLenB > 1) && !isVectorEligible($basicTypeB);
+
+        my $eltNameB = $basicTypeB;
+        $eltNameB .= $vecLenB if ($vecLenB > 1);
+
+        for (my $hasSpecial = 0; $hasSpecial <= 1; ++$hasSpecial) {
+          my $reduceName = "my_${eltNameA}_${eltNameB}_${hasSpecial}";
+          my $accumName = "${reduceName}_accum";
+          print "\n";
+          print "#pragma rs reduce(${reduceName}) accumulator(${accumName}) combiner(combiner)\n";
+          print "static void ${accumName}(int *accum, ${eltNameA} a, ${eltNameB} b";
+          print ", rs_kernel_context context" if ($hasSpecial);
+          print ") { }\n";
+        }
+      }
+    }
+  }
+}
diff --git a/tests/P_reduce_general_inputs/reduce_general_inputs.rs b/tests/P_reduce_general_inputs/reduce_general_inputs.rs
new file mode 100644
index 0000000..079bacb
--- /dev/null
+++ b/tests/P_reduce_general_inputs/reduce_general_inputs.rs
@@ -0,0 +1,2661 @@
+// -target-api 0 -Wall -Werror
+#pragma version(1)
+#pragma rs java_package_name(inputs)
+
+// This test case was created by ./gen-inputs.pl.
+// It exercises various legal combinations of inputs and special parameters,
+// so that we can ensure
+// (a) We do not choke when compiling them
+// (b) We reflect them correctly
+
+// One example struct type
+typedef struct MyStruct { float f; double d; } MyStruct;
+
+// Trivial combiner shared by all test cases
+static void combiner(int *accum, const int *other) { }
+
+#pragma rs reduce(my_half_half_0) accumulator(my_half_half_0_accum) combiner(combiner)
+static void my_half_half_0_accum(int *accum, half a, half b) { }
+
+#pragma rs reduce(my_half_half_1) accumulator(my_half_half_1_accum) combiner(combiner)
+static void my_half_half_1_accum(int *accum, half a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_half2_0) accumulator(my_half_half2_0_accum) combiner(combiner)
+static void my_half_half2_0_accum(int *accum, half a, half2 b) { }
+
+#pragma rs reduce(my_half_half2_1) accumulator(my_half_half2_1_accum) combiner(combiner)
+static void my_half_half2_1_accum(int *accum, half a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_half4_0) accumulator(my_half_half4_0_accum) combiner(combiner)
+static void my_half_half4_0_accum(int *accum, half a, half4 b) { }
+
+#pragma rs reduce(my_half_half4_1) accumulator(my_half_half4_1_accum) combiner(combiner)
+static void my_half_half4_1_accum(int *accum, half a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_float_0) accumulator(my_half_float_0_accum) combiner(combiner)
+static void my_half_float_0_accum(int *accum, half a, float b) { }
+
+#pragma rs reduce(my_half_float_1) accumulator(my_half_float_1_accum) combiner(combiner)
+static void my_half_float_1_accum(int *accum, half a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_float2_0) accumulator(my_half_float2_0_accum) combiner(combiner)
+static void my_half_float2_0_accum(int *accum, half a, float2 b) { }
+
+#pragma rs reduce(my_half_float2_1) accumulator(my_half_float2_1_accum) combiner(combiner)
+static void my_half_float2_1_accum(int *accum, half a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_float4_0) accumulator(my_half_float4_0_accum) combiner(combiner)
+static void my_half_float4_0_accum(int *accum, half a, float4 b) { }
+
+#pragma rs reduce(my_half_float4_1) accumulator(my_half_float4_1_accum) combiner(combiner)
+static void my_half_float4_1_accum(int *accum, half a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_char_0) accumulator(my_half_char_0_accum) combiner(combiner)
+static void my_half_char_0_accum(int *accum, half a, char b) { }
+
+#pragma rs reduce(my_half_char_1) accumulator(my_half_char_1_accum) combiner(combiner)
+static void my_half_char_1_accum(int *accum, half a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_char2_0) accumulator(my_half_char2_0_accum) combiner(combiner)
+static void my_half_char2_0_accum(int *accum, half a, char2 b) { }
+
+#pragma rs reduce(my_half_char2_1) accumulator(my_half_char2_1_accum) combiner(combiner)
+static void my_half_char2_1_accum(int *accum, half a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_char4_0) accumulator(my_half_char4_0_accum) combiner(combiner)
+static void my_half_char4_0_accum(int *accum, half a, char4 b) { }
+
+#pragma rs reduce(my_half_char4_1) accumulator(my_half_char4_1_accum) combiner(combiner)
+static void my_half_char4_1_accum(int *accum, half a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_short_0) accumulator(my_half_short_0_accum) combiner(combiner)
+static void my_half_short_0_accum(int *accum, half a, short b) { }
+
+#pragma rs reduce(my_half_short_1) accumulator(my_half_short_1_accum) combiner(combiner)
+static void my_half_short_1_accum(int *accum, half a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_short2_0) accumulator(my_half_short2_0_accum) combiner(combiner)
+static void my_half_short2_0_accum(int *accum, half a, short2 b) { }
+
+#pragma rs reduce(my_half_short2_1) accumulator(my_half_short2_1_accum) combiner(combiner)
+static void my_half_short2_1_accum(int *accum, half a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_short4_0) accumulator(my_half_short4_0_accum) combiner(combiner)
+static void my_half_short4_0_accum(int *accum, half a, short4 b) { }
+
+#pragma rs reduce(my_half_short4_1) accumulator(my_half_short4_1_accum) combiner(combiner)
+static void my_half_short4_1_accum(int *accum, half a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_uchar_0) accumulator(my_half_uchar_0_accum) combiner(combiner)
+static void my_half_uchar_0_accum(int *accum, half a, uchar b) { }
+
+#pragma rs reduce(my_half_uchar_1) accumulator(my_half_uchar_1_accum) combiner(combiner)
+static void my_half_uchar_1_accum(int *accum, half a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_uchar2_0) accumulator(my_half_uchar2_0_accum) combiner(combiner)
+static void my_half_uchar2_0_accum(int *accum, half a, uchar2 b) { }
+
+#pragma rs reduce(my_half_uchar2_1) accumulator(my_half_uchar2_1_accum) combiner(combiner)
+static void my_half_uchar2_1_accum(int *accum, half a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_uchar4_0) accumulator(my_half_uchar4_0_accum) combiner(combiner)
+static void my_half_uchar4_0_accum(int *accum, half a, uchar4 b) { }
+
+#pragma rs reduce(my_half_uchar4_1) accumulator(my_half_uchar4_1_accum) combiner(combiner)
+static void my_half_uchar4_1_accum(int *accum, half a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_ushort_0) accumulator(my_half_ushort_0_accum) combiner(combiner)
+static void my_half_ushort_0_accum(int *accum, half a, ushort b) { }
+
+#pragma rs reduce(my_half_ushort_1) accumulator(my_half_ushort_1_accum) combiner(combiner)
+static void my_half_ushort_1_accum(int *accum, half a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_ushort2_0) accumulator(my_half_ushort2_0_accum) combiner(combiner)
+static void my_half_ushort2_0_accum(int *accum, half a, ushort2 b) { }
+
+#pragma rs reduce(my_half_ushort2_1) accumulator(my_half_ushort2_1_accum) combiner(combiner)
+static void my_half_ushort2_1_accum(int *accum, half a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_ushort4_0) accumulator(my_half_ushort4_0_accum) combiner(combiner)
+static void my_half_ushort4_0_accum(int *accum, half a, ushort4 b) { }
+
+#pragma rs reduce(my_half_ushort4_1) accumulator(my_half_ushort4_1_accum) combiner(combiner)
+static void my_half_ushort4_1_accum(int *accum, half a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_bool_0) accumulator(my_half_bool_0_accum) combiner(combiner)
+static void my_half_bool_0_accum(int *accum, half a, bool b) { }
+
+#pragma rs reduce(my_half_bool_1) accumulator(my_half_bool_1_accum) combiner(combiner)
+static void my_half_bool_1_accum(int *accum, half a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_rs_matrix2x2_0) accumulator(my_half_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_half_rs_matrix2x2_0_accum(int *accum, half a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_half_rs_matrix2x2_1) accumulator(my_half_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_half_rs_matrix2x2_1_accum(int *accum, half a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half_MyStruct_0) accumulator(my_half_MyStruct_0_accum) combiner(combiner)
+static void my_half_MyStruct_0_accum(int *accum, half a, MyStruct b) { }
+
+#pragma rs reduce(my_half_MyStruct_1) accumulator(my_half_MyStruct_1_accum) combiner(combiner)
+static void my_half_MyStruct_1_accum(int *accum, half a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_half_0) accumulator(my_half2_half_0_accum) combiner(combiner)
+static void my_half2_half_0_accum(int *accum, half2 a, half b) { }
+
+#pragma rs reduce(my_half2_half_1) accumulator(my_half2_half_1_accum) combiner(combiner)
+static void my_half2_half_1_accum(int *accum, half2 a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_half2_0) accumulator(my_half2_half2_0_accum) combiner(combiner)
+static void my_half2_half2_0_accum(int *accum, half2 a, half2 b) { }
+
+#pragma rs reduce(my_half2_half2_1) accumulator(my_half2_half2_1_accum) combiner(combiner)
+static void my_half2_half2_1_accum(int *accum, half2 a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_half4_0) accumulator(my_half2_half4_0_accum) combiner(combiner)
+static void my_half2_half4_0_accum(int *accum, half2 a, half4 b) { }
+
+#pragma rs reduce(my_half2_half4_1) accumulator(my_half2_half4_1_accum) combiner(combiner)
+static void my_half2_half4_1_accum(int *accum, half2 a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_float_0) accumulator(my_half2_float_0_accum) combiner(combiner)
+static void my_half2_float_0_accum(int *accum, half2 a, float b) { }
+
+#pragma rs reduce(my_half2_float_1) accumulator(my_half2_float_1_accum) combiner(combiner)
+static void my_half2_float_1_accum(int *accum, half2 a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_float2_0) accumulator(my_half2_float2_0_accum) combiner(combiner)
+static void my_half2_float2_0_accum(int *accum, half2 a, float2 b) { }
+
+#pragma rs reduce(my_half2_float2_1) accumulator(my_half2_float2_1_accum) combiner(combiner)
+static void my_half2_float2_1_accum(int *accum, half2 a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_float4_0) accumulator(my_half2_float4_0_accum) combiner(combiner)
+static void my_half2_float4_0_accum(int *accum, half2 a, float4 b) { }
+
+#pragma rs reduce(my_half2_float4_1) accumulator(my_half2_float4_1_accum) combiner(combiner)
+static void my_half2_float4_1_accum(int *accum, half2 a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_char_0) accumulator(my_half2_char_0_accum) combiner(combiner)
+static void my_half2_char_0_accum(int *accum, half2 a, char b) { }
+
+#pragma rs reduce(my_half2_char_1) accumulator(my_half2_char_1_accum) combiner(combiner)
+static void my_half2_char_1_accum(int *accum, half2 a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_char2_0) accumulator(my_half2_char2_0_accum) combiner(combiner)
+static void my_half2_char2_0_accum(int *accum, half2 a, char2 b) { }
+
+#pragma rs reduce(my_half2_char2_1) accumulator(my_half2_char2_1_accum) combiner(combiner)
+static void my_half2_char2_1_accum(int *accum, half2 a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_char4_0) accumulator(my_half2_char4_0_accum) combiner(combiner)
+static void my_half2_char4_0_accum(int *accum, half2 a, char4 b) { }
+
+#pragma rs reduce(my_half2_char4_1) accumulator(my_half2_char4_1_accum) combiner(combiner)
+static void my_half2_char4_1_accum(int *accum, half2 a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_short_0) accumulator(my_half2_short_0_accum) combiner(combiner)
+static void my_half2_short_0_accum(int *accum, half2 a, short b) { }
+
+#pragma rs reduce(my_half2_short_1) accumulator(my_half2_short_1_accum) combiner(combiner)
+static void my_half2_short_1_accum(int *accum, half2 a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_short2_0) accumulator(my_half2_short2_0_accum) combiner(combiner)
+static void my_half2_short2_0_accum(int *accum, half2 a, short2 b) { }
+
+#pragma rs reduce(my_half2_short2_1) accumulator(my_half2_short2_1_accum) combiner(combiner)
+static void my_half2_short2_1_accum(int *accum, half2 a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_short4_0) accumulator(my_half2_short4_0_accum) combiner(combiner)
+static void my_half2_short4_0_accum(int *accum, half2 a, short4 b) { }
+
+#pragma rs reduce(my_half2_short4_1) accumulator(my_half2_short4_1_accum) combiner(combiner)
+static void my_half2_short4_1_accum(int *accum, half2 a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_uchar_0) accumulator(my_half2_uchar_0_accum) combiner(combiner)
+static void my_half2_uchar_0_accum(int *accum, half2 a, uchar b) { }
+
+#pragma rs reduce(my_half2_uchar_1) accumulator(my_half2_uchar_1_accum) combiner(combiner)
+static void my_half2_uchar_1_accum(int *accum, half2 a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_uchar2_0) accumulator(my_half2_uchar2_0_accum) combiner(combiner)
+static void my_half2_uchar2_0_accum(int *accum, half2 a, uchar2 b) { }
+
+#pragma rs reduce(my_half2_uchar2_1) accumulator(my_half2_uchar2_1_accum) combiner(combiner)
+static void my_half2_uchar2_1_accum(int *accum, half2 a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_uchar4_0) accumulator(my_half2_uchar4_0_accum) combiner(combiner)
+static void my_half2_uchar4_0_accum(int *accum, half2 a, uchar4 b) { }
+
+#pragma rs reduce(my_half2_uchar4_1) accumulator(my_half2_uchar4_1_accum) combiner(combiner)
+static void my_half2_uchar4_1_accum(int *accum, half2 a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_ushort_0) accumulator(my_half2_ushort_0_accum) combiner(combiner)
+static void my_half2_ushort_0_accum(int *accum, half2 a, ushort b) { }
+
+#pragma rs reduce(my_half2_ushort_1) accumulator(my_half2_ushort_1_accum) combiner(combiner)
+static void my_half2_ushort_1_accum(int *accum, half2 a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_ushort2_0) accumulator(my_half2_ushort2_0_accum) combiner(combiner)
+static void my_half2_ushort2_0_accum(int *accum, half2 a, ushort2 b) { }
+
+#pragma rs reduce(my_half2_ushort2_1) accumulator(my_half2_ushort2_1_accum) combiner(combiner)
+static void my_half2_ushort2_1_accum(int *accum, half2 a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_ushort4_0) accumulator(my_half2_ushort4_0_accum) combiner(combiner)
+static void my_half2_ushort4_0_accum(int *accum, half2 a, ushort4 b) { }
+
+#pragma rs reduce(my_half2_ushort4_1) accumulator(my_half2_ushort4_1_accum) combiner(combiner)
+static void my_half2_ushort4_1_accum(int *accum, half2 a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_bool_0) accumulator(my_half2_bool_0_accum) combiner(combiner)
+static void my_half2_bool_0_accum(int *accum, half2 a, bool b) { }
+
+#pragma rs reduce(my_half2_bool_1) accumulator(my_half2_bool_1_accum) combiner(combiner)
+static void my_half2_bool_1_accum(int *accum, half2 a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_rs_matrix2x2_0) accumulator(my_half2_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_half2_rs_matrix2x2_0_accum(int *accum, half2 a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_half2_rs_matrix2x2_1) accumulator(my_half2_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_half2_rs_matrix2x2_1_accum(int *accum, half2 a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half2_MyStruct_0) accumulator(my_half2_MyStruct_0_accum) combiner(combiner)
+static void my_half2_MyStruct_0_accum(int *accum, half2 a, MyStruct b) { }
+
+#pragma rs reduce(my_half2_MyStruct_1) accumulator(my_half2_MyStruct_1_accum) combiner(combiner)
+static void my_half2_MyStruct_1_accum(int *accum, half2 a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_half_0) accumulator(my_half4_half_0_accum) combiner(combiner)
+static void my_half4_half_0_accum(int *accum, half4 a, half b) { }
+
+#pragma rs reduce(my_half4_half_1) accumulator(my_half4_half_1_accum) combiner(combiner)
+static void my_half4_half_1_accum(int *accum, half4 a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_half2_0) accumulator(my_half4_half2_0_accum) combiner(combiner)
+static void my_half4_half2_0_accum(int *accum, half4 a, half2 b) { }
+
+#pragma rs reduce(my_half4_half2_1) accumulator(my_half4_half2_1_accum) combiner(combiner)
+static void my_half4_half2_1_accum(int *accum, half4 a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_half4_0) accumulator(my_half4_half4_0_accum) combiner(combiner)
+static void my_half4_half4_0_accum(int *accum, half4 a, half4 b) { }
+
+#pragma rs reduce(my_half4_half4_1) accumulator(my_half4_half4_1_accum) combiner(combiner)
+static void my_half4_half4_1_accum(int *accum, half4 a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_float_0) accumulator(my_half4_float_0_accum) combiner(combiner)
+static void my_half4_float_0_accum(int *accum, half4 a, float b) { }
+
+#pragma rs reduce(my_half4_float_1) accumulator(my_half4_float_1_accum) combiner(combiner)
+static void my_half4_float_1_accum(int *accum, half4 a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_float2_0) accumulator(my_half4_float2_0_accum) combiner(combiner)
+static void my_half4_float2_0_accum(int *accum, half4 a, float2 b) { }
+
+#pragma rs reduce(my_half4_float2_1) accumulator(my_half4_float2_1_accum) combiner(combiner)
+static void my_half4_float2_1_accum(int *accum, half4 a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_float4_0) accumulator(my_half4_float4_0_accum) combiner(combiner)
+static void my_half4_float4_0_accum(int *accum, half4 a, float4 b) { }
+
+#pragma rs reduce(my_half4_float4_1) accumulator(my_half4_float4_1_accum) combiner(combiner)
+static void my_half4_float4_1_accum(int *accum, half4 a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_char_0) accumulator(my_half4_char_0_accum) combiner(combiner)
+static void my_half4_char_0_accum(int *accum, half4 a, char b) { }
+
+#pragma rs reduce(my_half4_char_1) accumulator(my_half4_char_1_accum) combiner(combiner)
+static void my_half4_char_1_accum(int *accum, half4 a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_char2_0) accumulator(my_half4_char2_0_accum) combiner(combiner)
+static void my_half4_char2_0_accum(int *accum, half4 a, char2 b) { }
+
+#pragma rs reduce(my_half4_char2_1) accumulator(my_half4_char2_1_accum) combiner(combiner)
+static void my_half4_char2_1_accum(int *accum, half4 a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_char4_0) accumulator(my_half4_char4_0_accum) combiner(combiner)
+static void my_half4_char4_0_accum(int *accum, half4 a, char4 b) { }
+
+#pragma rs reduce(my_half4_char4_1) accumulator(my_half4_char4_1_accum) combiner(combiner)
+static void my_half4_char4_1_accum(int *accum, half4 a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_short_0) accumulator(my_half4_short_0_accum) combiner(combiner)
+static void my_half4_short_0_accum(int *accum, half4 a, short b) { }
+
+#pragma rs reduce(my_half4_short_1) accumulator(my_half4_short_1_accum) combiner(combiner)
+static void my_half4_short_1_accum(int *accum, half4 a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_short2_0) accumulator(my_half4_short2_0_accum) combiner(combiner)
+static void my_half4_short2_0_accum(int *accum, half4 a, short2 b) { }
+
+#pragma rs reduce(my_half4_short2_1) accumulator(my_half4_short2_1_accum) combiner(combiner)
+static void my_half4_short2_1_accum(int *accum, half4 a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_short4_0) accumulator(my_half4_short4_0_accum) combiner(combiner)
+static void my_half4_short4_0_accum(int *accum, half4 a, short4 b) { }
+
+#pragma rs reduce(my_half4_short4_1) accumulator(my_half4_short4_1_accum) combiner(combiner)
+static void my_half4_short4_1_accum(int *accum, half4 a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_uchar_0) accumulator(my_half4_uchar_0_accum) combiner(combiner)
+static void my_half4_uchar_0_accum(int *accum, half4 a, uchar b) { }
+
+#pragma rs reduce(my_half4_uchar_1) accumulator(my_half4_uchar_1_accum) combiner(combiner)
+static void my_half4_uchar_1_accum(int *accum, half4 a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_uchar2_0) accumulator(my_half4_uchar2_0_accum) combiner(combiner)
+static void my_half4_uchar2_0_accum(int *accum, half4 a, uchar2 b) { }
+
+#pragma rs reduce(my_half4_uchar2_1) accumulator(my_half4_uchar2_1_accum) combiner(combiner)
+static void my_half4_uchar2_1_accum(int *accum, half4 a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_uchar4_0) accumulator(my_half4_uchar4_0_accum) combiner(combiner)
+static void my_half4_uchar4_0_accum(int *accum, half4 a, uchar4 b) { }
+
+#pragma rs reduce(my_half4_uchar4_1) accumulator(my_half4_uchar4_1_accum) combiner(combiner)
+static void my_half4_uchar4_1_accum(int *accum, half4 a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_ushort_0) accumulator(my_half4_ushort_0_accum) combiner(combiner)
+static void my_half4_ushort_0_accum(int *accum, half4 a, ushort b) { }
+
+#pragma rs reduce(my_half4_ushort_1) accumulator(my_half4_ushort_1_accum) combiner(combiner)
+static void my_half4_ushort_1_accum(int *accum, half4 a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_ushort2_0) accumulator(my_half4_ushort2_0_accum) combiner(combiner)
+static void my_half4_ushort2_0_accum(int *accum, half4 a, ushort2 b) { }
+
+#pragma rs reduce(my_half4_ushort2_1) accumulator(my_half4_ushort2_1_accum) combiner(combiner)
+static void my_half4_ushort2_1_accum(int *accum, half4 a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_ushort4_0) accumulator(my_half4_ushort4_0_accum) combiner(combiner)
+static void my_half4_ushort4_0_accum(int *accum, half4 a, ushort4 b) { }
+
+#pragma rs reduce(my_half4_ushort4_1) accumulator(my_half4_ushort4_1_accum) combiner(combiner)
+static void my_half4_ushort4_1_accum(int *accum, half4 a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_bool_0) accumulator(my_half4_bool_0_accum) combiner(combiner)
+static void my_half4_bool_0_accum(int *accum, half4 a, bool b) { }
+
+#pragma rs reduce(my_half4_bool_1) accumulator(my_half4_bool_1_accum) combiner(combiner)
+static void my_half4_bool_1_accum(int *accum, half4 a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_rs_matrix2x2_0) accumulator(my_half4_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_half4_rs_matrix2x2_0_accum(int *accum, half4 a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_half4_rs_matrix2x2_1) accumulator(my_half4_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_half4_rs_matrix2x2_1_accum(int *accum, half4 a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_half4_MyStruct_0) accumulator(my_half4_MyStruct_0_accum) combiner(combiner)
+static void my_half4_MyStruct_0_accum(int *accum, half4 a, MyStruct b) { }
+
+#pragma rs reduce(my_half4_MyStruct_1) accumulator(my_half4_MyStruct_1_accum) combiner(combiner)
+static void my_half4_MyStruct_1_accum(int *accum, half4 a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_half_0) accumulator(my_float_half_0_accum) combiner(combiner)
+static void my_float_half_0_accum(int *accum, float a, half b) { }
+
+#pragma rs reduce(my_float_half_1) accumulator(my_float_half_1_accum) combiner(combiner)
+static void my_float_half_1_accum(int *accum, float a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_half2_0) accumulator(my_float_half2_0_accum) combiner(combiner)
+static void my_float_half2_0_accum(int *accum, float a, half2 b) { }
+
+#pragma rs reduce(my_float_half2_1) accumulator(my_float_half2_1_accum) combiner(combiner)
+static void my_float_half2_1_accum(int *accum, float a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_half4_0) accumulator(my_float_half4_0_accum) combiner(combiner)
+static void my_float_half4_0_accum(int *accum, float a, half4 b) { }
+
+#pragma rs reduce(my_float_half4_1) accumulator(my_float_half4_1_accum) combiner(combiner)
+static void my_float_half4_1_accum(int *accum, float a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_float_0) accumulator(my_float_float_0_accum) combiner(combiner)
+static void my_float_float_0_accum(int *accum, float a, float b) { }
+
+#pragma rs reduce(my_float_float_1) accumulator(my_float_float_1_accum) combiner(combiner)
+static void my_float_float_1_accum(int *accum, float a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_float2_0) accumulator(my_float_float2_0_accum) combiner(combiner)
+static void my_float_float2_0_accum(int *accum, float a, float2 b) { }
+
+#pragma rs reduce(my_float_float2_1) accumulator(my_float_float2_1_accum) combiner(combiner)
+static void my_float_float2_1_accum(int *accum, float a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_float4_0) accumulator(my_float_float4_0_accum) combiner(combiner)
+static void my_float_float4_0_accum(int *accum, float a, float4 b) { }
+
+#pragma rs reduce(my_float_float4_1) accumulator(my_float_float4_1_accum) combiner(combiner)
+static void my_float_float4_1_accum(int *accum, float a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_char_0) accumulator(my_float_char_0_accum) combiner(combiner)
+static void my_float_char_0_accum(int *accum, float a, char b) { }
+
+#pragma rs reduce(my_float_char_1) accumulator(my_float_char_1_accum) combiner(combiner)
+static void my_float_char_1_accum(int *accum, float a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_char2_0) accumulator(my_float_char2_0_accum) combiner(combiner)
+static void my_float_char2_0_accum(int *accum, float a, char2 b) { }
+
+#pragma rs reduce(my_float_char2_1) accumulator(my_float_char2_1_accum) combiner(combiner)
+static void my_float_char2_1_accum(int *accum, float a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_char4_0) accumulator(my_float_char4_0_accum) combiner(combiner)
+static void my_float_char4_0_accum(int *accum, float a, char4 b) { }
+
+#pragma rs reduce(my_float_char4_1) accumulator(my_float_char4_1_accum) combiner(combiner)
+static void my_float_char4_1_accum(int *accum, float a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_short_0) accumulator(my_float_short_0_accum) combiner(combiner)
+static void my_float_short_0_accum(int *accum, float a, short b) { }
+
+#pragma rs reduce(my_float_short_1) accumulator(my_float_short_1_accum) combiner(combiner)
+static void my_float_short_1_accum(int *accum, float a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_short2_0) accumulator(my_float_short2_0_accum) combiner(combiner)
+static void my_float_short2_0_accum(int *accum, float a, short2 b) { }
+
+#pragma rs reduce(my_float_short2_1) accumulator(my_float_short2_1_accum) combiner(combiner)
+static void my_float_short2_1_accum(int *accum, float a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_short4_0) accumulator(my_float_short4_0_accum) combiner(combiner)
+static void my_float_short4_0_accum(int *accum, float a, short4 b) { }
+
+#pragma rs reduce(my_float_short4_1) accumulator(my_float_short4_1_accum) combiner(combiner)
+static void my_float_short4_1_accum(int *accum, float a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_uchar_0) accumulator(my_float_uchar_0_accum) combiner(combiner)
+static void my_float_uchar_0_accum(int *accum, float a, uchar b) { }
+
+#pragma rs reduce(my_float_uchar_1) accumulator(my_float_uchar_1_accum) combiner(combiner)
+static void my_float_uchar_1_accum(int *accum, float a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_uchar2_0) accumulator(my_float_uchar2_0_accum) combiner(combiner)
+static void my_float_uchar2_0_accum(int *accum, float a, uchar2 b) { }
+
+#pragma rs reduce(my_float_uchar2_1) accumulator(my_float_uchar2_1_accum) combiner(combiner)
+static void my_float_uchar2_1_accum(int *accum, float a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_uchar4_0) accumulator(my_float_uchar4_0_accum) combiner(combiner)
+static void my_float_uchar4_0_accum(int *accum, float a, uchar4 b) { }
+
+#pragma rs reduce(my_float_uchar4_1) accumulator(my_float_uchar4_1_accum) combiner(combiner)
+static void my_float_uchar4_1_accum(int *accum, float a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_ushort_0) accumulator(my_float_ushort_0_accum) combiner(combiner)
+static void my_float_ushort_0_accum(int *accum, float a, ushort b) { }
+
+#pragma rs reduce(my_float_ushort_1) accumulator(my_float_ushort_1_accum) combiner(combiner)
+static void my_float_ushort_1_accum(int *accum, float a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_ushort2_0) accumulator(my_float_ushort2_0_accum) combiner(combiner)
+static void my_float_ushort2_0_accum(int *accum, float a, ushort2 b) { }
+
+#pragma rs reduce(my_float_ushort2_1) accumulator(my_float_ushort2_1_accum) combiner(combiner)
+static void my_float_ushort2_1_accum(int *accum, float a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_ushort4_0) accumulator(my_float_ushort4_0_accum) combiner(combiner)
+static void my_float_ushort4_0_accum(int *accum, float a, ushort4 b) { }
+
+#pragma rs reduce(my_float_ushort4_1) accumulator(my_float_ushort4_1_accum) combiner(combiner)
+static void my_float_ushort4_1_accum(int *accum, float a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_bool_0) accumulator(my_float_bool_0_accum) combiner(combiner)
+static void my_float_bool_0_accum(int *accum, float a, bool b) { }
+
+#pragma rs reduce(my_float_bool_1) accumulator(my_float_bool_1_accum) combiner(combiner)
+static void my_float_bool_1_accum(int *accum, float a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_rs_matrix2x2_0) accumulator(my_float_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_float_rs_matrix2x2_0_accum(int *accum, float a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_float_rs_matrix2x2_1) accumulator(my_float_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_float_rs_matrix2x2_1_accum(int *accum, float a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float_MyStruct_0) accumulator(my_float_MyStruct_0_accum) combiner(combiner)
+static void my_float_MyStruct_0_accum(int *accum, float a, MyStruct b) { }
+
+#pragma rs reduce(my_float_MyStruct_1) accumulator(my_float_MyStruct_1_accum) combiner(combiner)
+static void my_float_MyStruct_1_accum(int *accum, float a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_half_0) accumulator(my_float2_half_0_accum) combiner(combiner)
+static void my_float2_half_0_accum(int *accum, float2 a, half b) { }
+
+#pragma rs reduce(my_float2_half_1) accumulator(my_float2_half_1_accum) combiner(combiner)
+static void my_float2_half_1_accum(int *accum, float2 a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_half2_0) accumulator(my_float2_half2_0_accum) combiner(combiner)
+static void my_float2_half2_0_accum(int *accum, float2 a, half2 b) { }
+
+#pragma rs reduce(my_float2_half2_1) accumulator(my_float2_half2_1_accum) combiner(combiner)
+static void my_float2_half2_1_accum(int *accum, float2 a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_half4_0) accumulator(my_float2_half4_0_accum) combiner(combiner)
+static void my_float2_half4_0_accum(int *accum, float2 a, half4 b) { }
+
+#pragma rs reduce(my_float2_half4_1) accumulator(my_float2_half4_1_accum) combiner(combiner)
+static void my_float2_half4_1_accum(int *accum, float2 a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_float_0) accumulator(my_float2_float_0_accum) combiner(combiner)
+static void my_float2_float_0_accum(int *accum, float2 a, float b) { }
+
+#pragma rs reduce(my_float2_float_1) accumulator(my_float2_float_1_accum) combiner(combiner)
+static void my_float2_float_1_accum(int *accum, float2 a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_float2_0) accumulator(my_float2_float2_0_accum) combiner(combiner)
+static void my_float2_float2_0_accum(int *accum, float2 a, float2 b) { }
+
+#pragma rs reduce(my_float2_float2_1) accumulator(my_float2_float2_1_accum) combiner(combiner)
+static void my_float2_float2_1_accum(int *accum, float2 a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_float4_0) accumulator(my_float2_float4_0_accum) combiner(combiner)
+static void my_float2_float4_0_accum(int *accum, float2 a, float4 b) { }
+
+#pragma rs reduce(my_float2_float4_1) accumulator(my_float2_float4_1_accum) combiner(combiner)
+static void my_float2_float4_1_accum(int *accum, float2 a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_char_0) accumulator(my_float2_char_0_accum) combiner(combiner)
+static void my_float2_char_0_accum(int *accum, float2 a, char b) { }
+
+#pragma rs reduce(my_float2_char_1) accumulator(my_float2_char_1_accum) combiner(combiner)
+static void my_float2_char_1_accum(int *accum, float2 a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_char2_0) accumulator(my_float2_char2_0_accum) combiner(combiner)
+static void my_float2_char2_0_accum(int *accum, float2 a, char2 b) { }
+
+#pragma rs reduce(my_float2_char2_1) accumulator(my_float2_char2_1_accum) combiner(combiner)
+static void my_float2_char2_1_accum(int *accum, float2 a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_char4_0) accumulator(my_float2_char4_0_accum) combiner(combiner)
+static void my_float2_char4_0_accum(int *accum, float2 a, char4 b) { }
+
+#pragma rs reduce(my_float2_char4_1) accumulator(my_float2_char4_1_accum) combiner(combiner)
+static void my_float2_char4_1_accum(int *accum, float2 a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_short_0) accumulator(my_float2_short_0_accum) combiner(combiner)
+static void my_float2_short_0_accum(int *accum, float2 a, short b) { }
+
+#pragma rs reduce(my_float2_short_1) accumulator(my_float2_short_1_accum) combiner(combiner)
+static void my_float2_short_1_accum(int *accum, float2 a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_short2_0) accumulator(my_float2_short2_0_accum) combiner(combiner)
+static void my_float2_short2_0_accum(int *accum, float2 a, short2 b) { }
+
+#pragma rs reduce(my_float2_short2_1) accumulator(my_float2_short2_1_accum) combiner(combiner)
+static void my_float2_short2_1_accum(int *accum, float2 a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_short4_0) accumulator(my_float2_short4_0_accum) combiner(combiner)
+static void my_float2_short4_0_accum(int *accum, float2 a, short4 b) { }
+
+#pragma rs reduce(my_float2_short4_1) accumulator(my_float2_short4_1_accum) combiner(combiner)
+static void my_float2_short4_1_accum(int *accum, float2 a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_uchar_0) accumulator(my_float2_uchar_0_accum) combiner(combiner)
+static void my_float2_uchar_0_accum(int *accum, float2 a, uchar b) { }
+
+#pragma rs reduce(my_float2_uchar_1) accumulator(my_float2_uchar_1_accum) combiner(combiner)
+static void my_float2_uchar_1_accum(int *accum, float2 a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_uchar2_0) accumulator(my_float2_uchar2_0_accum) combiner(combiner)
+static void my_float2_uchar2_0_accum(int *accum, float2 a, uchar2 b) { }
+
+#pragma rs reduce(my_float2_uchar2_1) accumulator(my_float2_uchar2_1_accum) combiner(combiner)
+static void my_float2_uchar2_1_accum(int *accum, float2 a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_uchar4_0) accumulator(my_float2_uchar4_0_accum) combiner(combiner)
+static void my_float2_uchar4_0_accum(int *accum, float2 a, uchar4 b) { }
+
+#pragma rs reduce(my_float2_uchar4_1) accumulator(my_float2_uchar4_1_accum) combiner(combiner)
+static void my_float2_uchar4_1_accum(int *accum, float2 a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_ushort_0) accumulator(my_float2_ushort_0_accum) combiner(combiner)
+static void my_float2_ushort_0_accum(int *accum, float2 a, ushort b) { }
+
+#pragma rs reduce(my_float2_ushort_1) accumulator(my_float2_ushort_1_accum) combiner(combiner)
+static void my_float2_ushort_1_accum(int *accum, float2 a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_ushort2_0) accumulator(my_float2_ushort2_0_accum) combiner(combiner)
+static void my_float2_ushort2_0_accum(int *accum, float2 a, ushort2 b) { }
+
+#pragma rs reduce(my_float2_ushort2_1) accumulator(my_float2_ushort2_1_accum) combiner(combiner)
+static void my_float2_ushort2_1_accum(int *accum, float2 a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_ushort4_0) accumulator(my_float2_ushort4_0_accum) combiner(combiner)
+static void my_float2_ushort4_0_accum(int *accum, float2 a, ushort4 b) { }
+
+#pragma rs reduce(my_float2_ushort4_1) accumulator(my_float2_ushort4_1_accum) combiner(combiner)
+static void my_float2_ushort4_1_accum(int *accum, float2 a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_bool_0) accumulator(my_float2_bool_0_accum) combiner(combiner)
+static void my_float2_bool_0_accum(int *accum, float2 a, bool b) { }
+
+#pragma rs reduce(my_float2_bool_1) accumulator(my_float2_bool_1_accum) combiner(combiner)
+static void my_float2_bool_1_accum(int *accum, float2 a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_rs_matrix2x2_0) accumulator(my_float2_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_float2_rs_matrix2x2_0_accum(int *accum, float2 a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_float2_rs_matrix2x2_1) accumulator(my_float2_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_float2_rs_matrix2x2_1_accum(int *accum, float2 a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float2_MyStruct_0) accumulator(my_float2_MyStruct_0_accum) combiner(combiner)
+static void my_float2_MyStruct_0_accum(int *accum, float2 a, MyStruct b) { }
+
+#pragma rs reduce(my_float2_MyStruct_1) accumulator(my_float2_MyStruct_1_accum) combiner(combiner)
+static void my_float2_MyStruct_1_accum(int *accum, float2 a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_half_0) accumulator(my_float4_half_0_accum) combiner(combiner)
+static void my_float4_half_0_accum(int *accum, float4 a, half b) { }
+
+#pragma rs reduce(my_float4_half_1) accumulator(my_float4_half_1_accum) combiner(combiner)
+static void my_float4_half_1_accum(int *accum, float4 a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_half2_0) accumulator(my_float4_half2_0_accum) combiner(combiner)
+static void my_float4_half2_0_accum(int *accum, float4 a, half2 b) { }
+
+#pragma rs reduce(my_float4_half2_1) accumulator(my_float4_half2_1_accum) combiner(combiner)
+static void my_float4_half2_1_accum(int *accum, float4 a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_half4_0) accumulator(my_float4_half4_0_accum) combiner(combiner)
+static void my_float4_half4_0_accum(int *accum, float4 a, half4 b) { }
+
+#pragma rs reduce(my_float4_half4_1) accumulator(my_float4_half4_1_accum) combiner(combiner)
+static void my_float4_half4_1_accum(int *accum, float4 a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_float_0) accumulator(my_float4_float_0_accum) combiner(combiner)
+static void my_float4_float_0_accum(int *accum, float4 a, float b) { }
+
+#pragma rs reduce(my_float4_float_1) accumulator(my_float4_float_1_accum) combiner(combiner)
+static void my_float4_float_1_accum(int *accum, float4 a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_float2_0) accumulator(my_float4_float2_0_accum) combiner(combiner)
+static void my_float4_float2_0_accum(int *accum, float4 a, float2 b) { }
+
+#pragma rs reduce(my_float4_float2_1) accumulator(my_float4_float2_1_accum) combiner(combiner)
+static void my_float4_float2_1_accum(int *accum, float4 a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_float4_0) accumulator(my_float4_float4_0_accum) combiner(combiner)
+static void my_float4_float4_0_accum(int *accum, float4 a, float4 b) { }
+
+#pragma rs reduce(my_float4_float4_1) accumulator(my_float4_float4_1_accum) combiner(combiner)
+static void my_float4_float4_1_accum(int *accum, float4 a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_char_0) accumulator(my_float4_char_0_accum) combiner(combiner)
+static void my_float4_char_0_accum(int *accum, float4 a, char b) { }
+
+#pragma rs reduce(my_float4_char_1) accumulator(my_float4_char_1_accum) combiner(combiner)
+static void my_float4_char_1_accum(int *accum, float4 a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_char2_0) accumulator(my_float4_char2_0_accum) combiner(combiner)
+static void my_float4_char2_0_accum(int *accum, float4 a, char2 b) { }
+
+#pragma rs reduce(my_float4_char2_1) accumulator(my_float4_char2_1_accum) combiner(combiner)
+static void my_float4_char2_1_accum(int *accum, float4 a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_char4_0) accumulator(my_float4_char4_0_accum) combiner(combiner)
+static void my_float4_char4_0_accum(int *accum, float4 a, char4 b) { }
+
+#pragma rs reduce(my_float4_char4_1) accumulator(my_float4_char4_1_accum) combiner(combiner)
+static void my_float4_char4_1_accum(int *accum, float4 a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_short_0) accumulator(my_float4_short_0_accum) combiner(combiner)
+static void my_float4_short_0_accum(int *accum, float4 a, short b) { }
+
+#pragma rs reduce(my_float4_short_1) accumulator(my_float4_short_1_accum) combiner(combiner)
+static void my_float4_short_1_accum(int *accum, float4 a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_short2_0) accumulator(my_float4_short2_0_accum) combiner(combiner)
+static void my_float4_short2_0_accum(int *accum, float4 a, short2 b) { }
+
+#pragma rs reduce(my_float4_short2_1) accumulator(my_float4_short2_1_accum) combiner(combiner)
+static void my_float4_short2_1_accum(int *accum, float4 a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_short4_0) accumulator(my_float4_short4_0_accum) combiner(combiner)
+static void my_float4_short4_0_accum(int *accum, float4 a, short4 b) { }
+
+#pragma rs reduce(my_float4_short4_1) accumulator(my_float4_short4_1_accum) combiner(combiner)
+static void my_float4_short4_1_accum(int *accum, float4 a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_uchar_0) accumulator(my_float4_uchar_0_accum) combiner(combiner)
+static void my_float4_uchar_0_accum(int *accum, float4 a, uchar b) { }
+
+#pragma rs reduce(my_float4_uchar_1) accumulator(my_float4_uchar_1_accum) combiner(combiner)
+static void my_float4_uchar_1_accum(int *accum, float4 a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_uchar2_0) accumulator(my_float4_uchar2_0_accum) combiner(combiner)
+static void my_float4_uchar2_0_accum(int *accum, float4 a, uchar2 b) { }
+
+#pragma rs reduce(my_float4_uchar2_1) accumulator(my_float4_uchar2_1_accum) combiner(combiner)
+static void my_float4_uchar2_1_accum(int *accum, float4 a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_uchar4_0) accumulator(my_float4_uchar4_0_accum) combiner(combiner)
+static void my_float4_uchar4_0_accum(int *accum, float4 a, uchar4 b) { }
+
+#pragma rs reduce(my_float4_uchar4_1) accumulator(my_float4_uchar4_1_accum) combiner(combiner)
+static void my_float4_uchar4_1_accum(int *accum, float4 a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_ushort_0) accumulator(my_float4_ushort_0_accum) combiner(combiner)
+static void my_float4_ushort_0_accum(int *accum, float4 a, ushort b) { }
+
+#pragma rs reduce(my_float4_ushort_1) accumulator(my_float4_ushort_1_accum) combiner(combiner)
+static void my_float4_ushort_1_accum(int *accum, float4 a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_ushort2_0) accumulator(my_float4_ushort2_0_accum) combiner(combiner)
+static void my_float4_ushort2_0_accum(int *accum, float4 a, ushort2 b) { }
+
+#pragma rs reduce(my_float4_ushort2_1) accumulator(my_float4_ushort2_1_accum) combiner(combiner)
+static void my_float4_ushort2_1_accum(int *accum, float4 a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_ushort4_0) accumulator(my_float4_ushort4_0_accum) combiner(combiner)
+static void my_float4_ushort4_0_accum(int *accum, float4 a, ushort4 b) { }
+
+#pragma rs reduce(my_float4_ushort4_1) accumulator(my_float4_ushort4_1_accum) combiner(combiner)
+static void my_float4_ushort4_1_accum(int *accum, float4 a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_bool_0) accumulator(my_float4_bool_0_accum) combiner(combiner)
+static void my_float4_bool_0_accum(int *accum, float4 a, bool b) { }
+
+#pragma rs reduce(my_float4_bool_1) accumulator(my_float4_bool_1_accum) combiner(combiner)
+static void my_float4_bool_1_accum(int *accum, float4 a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_rs_matrix2x2_0) accumulator(my_float4_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_float4_rs_matrix2x2_0_accum(int *accum, float4 a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_float4_rs_matrix2x2_1) accumulator(my_float4_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_float4_rs_matrix2x2_1_accum(int *accum, float4 a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_float4_MyStruct_0) accumulator(my_float4_MyStruct_0_accum) combiner(combiner)
+static void my_float4_MyStruct_0_accum(int *accum, float4 a, MyStruct b) { }
+
+#pragma rs reduce(my_float4_MyStruct_1) accumulator(my_float4_MyStruct_1_accum) combiner(combiner)
+static void my_float4_MyStruct_1_accum(int *accum, float4 a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_half_0) accumulator(my_char_half_0_accum) combiner(combiner)
+static void my_char_half_0_accum(int *accum, char a, half b) { }
+
+#pragma rs reduce(my_char_half_1) accumulator(my_char_half_1_accum) combiner(combiner)
+static void my_char_half_1_accum(int *accum, char a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_half2_0) accumulator(my_char_half2_0_accum) combiner(combiner)
+static void my_char_half2_0_accum(int *accum, char a, half2 b) { }
+
+#pragma rs reduce(my_char_half2_1) accumulator(my_char_half2_1_accum) combiner(combiner)
+static void my_char_half2_1_accum(int *accum, char a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_half4_0) accumulator(my_char_half4_0_accum) combiner(combiner)
+static void my_char_half4_0_accum(int *accum, char a, half4 b) { }
+
+#pragma rs reduce(my_char_half4_1) accumulator(my_char_half4_1_accum) combiner(combiner)
+static void my_char_half4_1_accum(int *accum, char a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_float_0) accumulator(my_char_float_0_accum) combiner(combiner)
+static void my_char_float_0_accum(int *accum, char a, float b) { }
+
+#pragma rs reduce(my_char_float_1) accumulator(my_char_float_1_accum) combiner(combiner)
+static void my_char_float_1_accum(int *accum, char a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_float2_0) accumulator(my_char_float2_0_accum) combiner(combiner)
+static void my_char_float2_0_accum(int *accum, char a, float2 b) { }
+
+#pragma rs reduce(my_char_float2_1) accumulator(my_char_float2_1_accum) combiner(combiner)
+static void my_char_float2_1_accum(int *accum, char a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_float4_0) accumulator(my_char_float4_0_accum) combiner(combiner)
+static void my_char_float4_0_accum(int *accum, char a, float4 b) { }
+
+#pragma rs reduce(my_char_float4_1) accumulator(my_char_float4_1_accum) combiner(combiner)
+static void my_char_float4_1_accum(int *accum, char a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_char_0) accumulator(my_char_char_0_accum) combiner(combiner)
+static void my_char_char_0_accum(int *accum, char a, char b) { }
+
+#pragma rs reduce(my_char_char_1) accumulator(my_char_char_1_accum) combiner(combiner)
+static void my_char_char_1_accum(int *accum, char a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_char2_0) accumulator(my_char_char2_0_accum) combiner(combiner)
+static void my_char_char2_0_accum(int *accum, char a, char2 b) { }
+
+#pragma rs reduce(my_char_char2_1) accumulator(my_char_char2_1_accum) combiner(combiner)
+static void my_char_char2_1_accum(int *accum, char a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_char4_0) accumulator(my_char_char4_0_accum) combiner(combiner)
+static void my_char_char4_0_accum(int *accum, char a, char4 b) { }
+
+#pragma rs reduce(my_char_char4_1) accumulator(my_char_char4_1_accum) combiner(combiner)
+static void my_char_char4_1_accum(int *accum, char a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_short_0) accumulator(my_char_short_0_accum) combiner(combiner)
+static void my_char_short_0_accum(int *accum, char a, short b) { }
+
+#pragma rs reduce(my_char_short_1) accumulator(my_char_short_1_accum) combiner(combiner)
+static void my_char_short_1_accum(int *accum, char a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_short2_0) accumulator(my_char_short2_0_accum) combiner(combiner)
+static void my_char_short2_0_accum(int *accum, char a, short2 b) { }
+
+#pragma rs reduce(my_char_short2_1) accumulator(my_char_short2_1_accum) combiner(combiner)
+static void my_char_short2_1_accum(int *accum, char a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_short4_0) accumulator(my_char_short4_0_accum) combiner(combiner)
+static void my_char_short4_0_accum(int *accum, char a, short4 b) { }
+
+#pragma rs reduce(my_char_short4_1) accumulator(my_char_short4_1_accum) combiner(combiner)
+static void my_char_short4_1_accum(int *accum, char a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_uchar_0) accumulator(my_char_uchar_0_accum) combiner(combiner)
+static void my_char_uchar_0_accum(int *accum, char a, uchar b) { }
+
+#pragma rs reduce(my_char_uchar_1) accumulator(my_char_uchar_1_accum) combiner(combiner)
+static void my_char_uchar_1_accum(int *accum, char a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_uchar2_0) accumulator(my_char_uchar2_0_accum) combiner(combiner)
+static void my_char_uchar2_0_accum(int *accum, char a, uchar2 b) { }
+
+#pragma rs reduce(my_char_uchar2_1) accumulator(my_char_uchar2_1_accum) combiner(combiner)
+static void my_char_uchar2_1_accum(int *accum, char a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_uchar4_0) accumulator(my_char_uchar4_0_accum) combiner(combiner)
+static void my_char_uchar4_0_accum(int *accum, char a, uchar4 b) { }
+
+#pragma rs reduce(my_char_uchar4_1) accumulator(my_char_uchar4_1_accum) combiner(combiner)
+static void my_char_uchar4_1_accum(int *accum, char a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_ushort_0) accumulator(my_char_ushort_0_accum) combiner(combiner)
+static void my_char_ushort_0_accum(int *accum, char a, ushort b) { }
+
+#pragma rs reduce(my_char_ushort_1) accumulator(my_char_ushort_1_accum) combiner(combiner)
+static void my_char_ushort_1_accum(int *accum, char a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_ushort2_0) accumulator(my_char_ushort2_0_accum) combiner(combiner)
+static void my_char_ushort2_0_accum(int *accum, char a, ushort2 b) { }
+
+#pragma rs reduce(my_char_ushort2_1) accumulator(my_char_ushort2_1_accum) combiner(combiner)
+static void my_char_ushort2_1_accum(int *accum, char a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_ushort4_0) accumulator(my_char_ushort4_0_accum) combiner(combiner)
+static void my_char_ushort4_0_accum(int *accum, char a, ushort4 b) { }
+
+#pragma rs reduce(my_char_ushort4_1) accumulator(my_char_ushort4_1_accum) combiner(combiner)
+static void my_char_ushort4_1_accum(int *accum, char a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_bool_0) accumulator(my_char_bool_0_accum) combiner(combiner)
+static void my_char_bool_0_accum(int *accum, char a, bool b) { }
+
+#pragma rs reduce(my_char_bool_1) accumulator(my_char_bool_1_accum) combiner(combiner)
+static void my_char_bool_1_accum(int *accum, char a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_rs_matrix2x2_0) accumulator(my_char_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_char_rs_matrix2x2_0_accum(int *accum, char a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_char_rs_matrix2x2_1) accumulator(my_char_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_char_rs_matrix2x2_1_accum(int *accum, char a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char_MyStruct_0) accumulator(my_char_MyStruct_0_accum) combiner(combiner)
+static void my_char_MyStruct_0_accum(int *accum, char a, MyStruct b) { }
+
+#pragma rs reduce(my_char_MyStruct_1) accumulator(my_char_MyStruct_1_accum) combiner(combiner)
+static void my_char_MyStruct_1_accum(int *accum, char a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_half_0) accumulator(my_char2_half_0_accum) combiner(combiner)
+static void my_char2_half_0_accum(int *accum, char2 a, half b) { }
+
+#pragma rs reduce(my_char2_half_1) accumulator(my_char2_half_1_accum) combiner(combiner)
+static void my_char2_half_1_accum(int *accum, char2 a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_half2_0) accumulator(my_char2_half2_0_accum) combiner(combiner)
+static void my_char2_half2_0_accum(int *accum, char2 a, half2 b) { }
+
+#pragma rs reduce(my_char2_half2_1) accumulator(my_char2_half2_1_accum) combiner(combiner)
+static void my_char2_half2_1_accum(int *accum, char2 a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_half4_0) accumulator(my_char2_half4_0_accum) combiner(combiner)
+static void my_char2_half4_0_accum(int *accum, char2 a, half4 b) { }
+
+#pragma rs reduce(my_char2_half4_1) accumulator(my_char2_half4_1_accum) combiner(combiner)
+static void my_char2_half4_1_accum(int *accum, char2 a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_float_0) accumulator(my_char2_float_0_accum) combiner(combiner)
+static void my_char2_float_0_accum(int *accum, char2 a, float b) { }
+
+#pragma rs reduce(my_char2_float_1) accumulator(my_char2_float_1_accum) combiner(combiner)
+static void my_char2_float_1_accum(int *accum, char2 a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_float2_0) accumulator(my_char2_float2_0_accum) combiner(combiner)
+static void my_char2_float2_0_accum(int *accum, char2 a, float2 b) { }
+
+#pragma rs reduce(my_char2_float2_1) accumulator(my_char2_float2_1_accum) combiner(combiner)
+static void my_char2_float2_1_accum(int *accum, char2 a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_float4_0) accumulator(my_char2_float4_0_accum) combiner(combiner)
+static void my_char2_float4_0_accum(int *accum, char2 a, float4 b) { }
+
+#pragma rs reduce(my_char2_float4_1) accumulator(my_char2_float4_1_accum) combiner(combiner)
+static void my_char2_float4_1_accum(int *accum, char2 a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_char_0) accumulator(my_char2_char_0_accum) combiner(combiner)
+static void my_char2_char_0_accum(int *accum, char2 a, char b) { }
+
+#pragma rs reduce(my_char2_char_1) accumulator(my_char2_char_1_accum) combiner(combiner)
+static void my_char2_char_1_accum(int *accum, char2 a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_char2_0) accumulator(my_char2_char2_0_accum) combiner(combiner)
+static void my_char2_char2_0_accum(int *accum, char2 a, char2 b) { }
+
+#pragma rs reduce(my_char2_char2_1) accumulator(my_char2_char2_1_accum) combiner(combiner)
+static void my_char2_char2_1_accum(int *accum, char2 a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_char4_0) accumulator(my_char2_char4_0_accum) combiner(combiner)
+static void my_char2_char4_0_accum(int *accum, char2 a, char4 b) { }
+
+#pragma rs reduce(my_char2_char4_1) accumulator(my_char2_char4_1_accum) combiner(combiner)
+static void my_char2_char4_1_accum(int *accum, char2 a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_short_0) accumulator(my_char2_short_0_accum) combiner(combiner)
+static void my_char2_short_0_accum(int *accum, char2 a, short b) { }
+
+#pragma rs reduce(my_char2_short_1) accumulator(my_char2_short_1_accum) combiner(combiner)
+static void my_char2_short_1_accum(int *accum, char2 a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_short2_0) accumulator(my_char2_short2_0_accum) combiner(combiner)
+static void my_char2_short2_0_accum(int *accum, char2 a, short2 b) { }
+
+#pragma rs reduce(my_char2_short2_1) accumulator(my_char2_short2_1_accum) combiner(combiner)
+static void my_char2_short2_1_accum(int *accum, char2 a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_short4_0) accumulator(my_char2_short4_0_accum) combiner(combiner)
+static void my_char2_short4_0_accum(int *accum, char2 a, short4 b) { }
+
+#pragma rs reduce(my_char2_short4_1) accumulator(my_char2_short4_1_accum) combiner(combiner)
+static void my_char2_short4_1_accum(int *accum, char2 a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_uchar_0) accumulator(my_char2_uchar_0_accum) combiner(combiner)
+static void my_char2_uchar_0_accum(int *accum, char2 a, uchar b) { }
+
+#pragma rs reduce(my_char2_uchar_1) accumulator(my_char2_uchar_1_accum) combiner(combiner)
+static void my_char2_uchar_1_accum(int *accum, char2 a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_uchar2_0) accumulator(my_char2_uchar2_0_accum) combiner(combiner)
+static void my_char2_uchar2_0_accum(int *accum, char2 a, uchar2 b) { }
+
+#pragma rs reduce(my_char2_uchar2_1) accumulator(my_char2_uchar2_1_accum) combiner(combiner)
+static void my_char2_uchar2_1_accum(int *accum, char2 a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_uchar4_0) accumulator(my_char2_uchar4_0_accum) combiner(combiner)
+static void my_char2_uchar4_0_accum(int *accum, char2 a, uchar4 b) { }
+
+#pragma rs reduce(my_char2_uchar4_1) accumulator(my_char2_uchar4_1_accum) combiner(combiner)
+static void my_char2_uchar4_1_accum(int *accum, char2 a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_ushort_0) accumulator(my_char2_ushort_0_accum) combiner(combiner)
+static void my_char2_ushort_0_accum(int *accum, char2 a, ushort b) { }
+
+#pragma rs reduce(my_char2_ushort_1) accumulator(my_char2_ushort_1_accum) combiner(combiner)
+static void my_char2_ushort_1_accum(int *accum, char2 a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_ushort2_0) accumulator(my_char2_ushort2_0_accum) combiner(combiner)
+static void my_char2_ushort2_0_accum(int *accum, char2 a, ushort2 b) { }
+
+#pragma rs reduce(my_char2_ushort2_1) accumulator(my_char2_ushort2_1_accum) combiner(combiner)
+static void my_char2_ushort2_1_accum(int *accum, char2 a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_ushort4_0) accumulator(my_char2_ushort4_0_accum) combiner(combiner)
+static void my_char2_ushort4_0_accum(int *accum, char2 a, ushort4 b) { }
+
+#pragma rs reduce(my_char2_ushort4_1) accumulator(my_char2_ushort4_1_accum) combiner(combiner)
+static void my_char2_ushort4_1_accum(int *accum, char2 a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_bool_0) accumulator(my_char2_bool_0_accum) combiner(combiner)
+static void my_char2_bool_0_accum(int *accum, char2 a, bool b) { }
+
+#pragma rs reduce(my_char2_bool_1) accumulator(my_char2_bool_1_accum) combiner(combiner)
+static void my_char2_bool_1_accum(int *accum, char2 a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_rs_matrix2x2_0) accumulator(my_char2_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_char2_rs_matrix2x2_0_accum(int *accum, char2 a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_char2_rs_matrix2x2_1) accumulator(my_char2_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_char2_rs_matrix2x2_1_accum(int *accum, char2 a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char2_MyStruct_0) accumulator(my_char2_MyStruct_0_accum) combiner(combiner)
+static void my_char2_MyStruct_0_accum(int *accum, char2 a, MyStruct b) { }
+
+#pragma rs reduce(my_char2_MyStruct_1) accumulator(my_char2_MyStruct_1_accum) combiner(combiner)
+static void my_char2_MyStruct_1_accum(int *accum, char2 a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_half_0) accumulator(my_char4_half_0_accum) combiner(combiner)
+static void my_char4_half_0_accum(int *accum, char4 a, half b) { }
+
+#pragma rs reduce(my_char4_half_1) accumulator(my_char4_half_1_accum) combiner(combiner)
+static void my_char4_half_1_accum(int *accum, char4 a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_half2_0) accumulator(my_char4_half2_0_accum) combiner(combiner)
+static void my_char4_half2_0_accum(int *accum, char4 a, half2 b) { }
+
+#pragma rs reduce(my_char4_half2_1) accumulator(my_char4_half2_1_accum) combiner(combiner)
+static void my_char4_half2_1_accum(int *accum, char4 a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_half4_0) accumulator(my_char4_half4_0_accum) combiner(combiner)
+static void my_char4_half4_0_accum(int *accum, char4 a, half4 b) { }
+
+#pragma rs reduce(my_char4_half4_1) accumulator(my_char4_half4_1_accum) combiner(combiner)
+static void my_char4_half4_1_accum(int *accum, char4 a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_float_0) accumulator(my_char4_float_0_accum) combiner(combiner)
+static void my_char4_float_0_accum(int *accum, char4 a, float b) { }
+
+#pragma rs reduce(my_char4_float_1) accumulator(my_char4_float_1_accum) combiner(combiner)
+static void my_char4_float_1_accum(int *accum, char4 a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_float2_0) accumulator(my_char4_float2_0_accum) combiner(combiner)
+static void my_char4_float2_0_accum(int *accum, char4 a, float2 b) { }
+
+#pragma rs reduce(my_char4_float2_1) accumulator(my_char4_float2_1_accum) combiner(combiner)
+static void my_char4_float2_1_accum(int *accum, char4 a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_float4_0) accumulator(my_char4_float4_0_accum) combiner(combiner)
+static void my_char4_float4_0_accum(int *accum, char4 a, float4 b) { }
+
+#pragma rs reduce(my_char4_float4_1) accumulator(my_char4_float4_1_accum) combiner(combiner)
+static void my_char4_float4_1_accum(int *accum, char4 a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_char_0) accumulator(my_char4_char_0_accum) combiner(combiner)
+static void my_char4_char_0_accum(int *accum, char4 a, char b) { }
+
+#pragma rs reduce(my_char4_char_1) accumulator(my_char4_char_1_accum) combiner(combiner)
+static void my_char4_char_1_accum(int *accum, char4 a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_char2_0) accumulator(my_char4_char2_0_accum) combiner(combiner)
+static void my_char4_char2_0_accum(int *accum, char4 a, char2 b) { }
+
+#pragma rs reduce(my_char4_char2_1) accumulator(my_char4_char2_1_accum) combiner(combiner)
+static void my_char4_char2_1_accum(int *accum, char4 a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_char4_0) accumulator(my_char4_char4_0_accum) combiner(combiner)
+static void my_char4_char4_0_accum(int *accum, char4 a, char4 b) { }
+
+#pragma rs reduce(my_char4_char4_1) accumulator(my_char4_char4_1_accum) combiner(combiner)
+static void my_char4_char4_1_accum(int *accum, char4 a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_short_0) accumulator(my_char4_short_0_accum) combiner(combiner)
+static void my_char4_short_0_accum(int *accum, char4 a, short b) { }
+
+#pragma rs reduce(my_char4_short_1) accumulator(my_char4_short_1_accum) combiner(combiner)
+static void my_char4_short_1_accum(int *accum, char4 a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_short2_0) accumulator(my_char4_short2_0_accum) combiner(combiner)
+static void my_char4_short2_0_accum(int *accum, char4 a, short2 b) { }
+
+#pragma rs reduce(my_char4_short2_1) accumulator(my_char4_short2_1_accum) combiner(combiner)
+static void my_char4_short2_1_accum(int *accum, char4 a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_short4_0) accumulator(my_char4_short4_0_accum) combiner(combiner)
+static void my_char4_short4_0_accum(int *accum, char4 a, short4 b) { }
+
+#pragma rs reduce(my_char4_short4_1) accumulator(my_char4_short4_1_accum) combiner(combiner)
+static void my_char4_short4_1_accum(int *accum, char4 a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_uchar_0) accumulator(my_char4_uchar_0_accum) combiner(combiner)
+static void my_char4_uchar_0_accum(int *accum, char4 a, uchar b) { }
+
+#pragma rs reduce(my_char4_uchar_1) accumulator(my_char4_uchar_1_accum) combiner(combiner)
+static void my_char4_uchar_1_accum(int *accum, char4 a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_uchar2_0) accumulator(my_char4_uchar2_0_accum) combiner(combiner)
+static void my_char4_uchar2_0_accum(int *accum, char4 a, uchar2 b) { }
+
+#pragma rs reduce(my_char4_uchar2_1) accumulator(my_char4_uchar2_1_accum) combiner(combiner)
+static void my_char4_uchar2_1_accum(int *accum, char4 a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_uchar4_0) accumulator(my_char4_uchar4_0_accum) combiner(combiner)
+static void my_char4_uchar4_0_accum(int *accum, char4 a, uchar4 b) { }
+
+#pragma rs reduce(my_char4_uchar4_1) accumulator(my_char4_uchar4_1_accum) combiner(combiner)
+static void my_char4_uchar4_1_accum(int *accum, char4 a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_ushort_0) accumulator(my_char4_ushort_0_accum) combiner(combiner)
+static void my_char4_ushort_0_accum(int *accum, char4 a, ushort b) { }
+
+#pragma rs reduce(my_char4_ushort_1) accumulator(my_char4_ushort_1_accum) combiner(combiner)
+static void my_char4_ushort_1_accum(int *accum, char4 a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_ushort2_0) accumulator(my_char4_ushort2_0_accum) combiner(combiner)
+static void my_char4_ushort2_0_accum(int *accum, char4 a, ushort2 b) { }
+
+#pragma rs reduce(my_char4_ushort2_1) accumulator(my_char4_ushort2_1_accum) combiner(combiner)
+static void my_char4_ushort2_1_accum(int *accum, char4 a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_ushort4_0) accumulator(my_char4_ushort4_0_accum) combiner(combiner)
+static void my_char4_ushort4_0_accum(int *accum, char4 a, ushort4 b) { }
+
+#pragma rs reduce(my_char4_ushort4_1) accumulator(my_char4_ushort4_1_accum) combiner(combiner)
+static void my_char4_ushort4_1_accum(int *accum, char4 a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_bool_0) accumulator(my_char4_bool_0_accum) combiner(combiner)
+static void my_char4_bool_0_accum(int *accum, char4 a, bool b) { }
+
+#pragma rs reduce(my_char4_bool_1) accumulator(my_char4_bool_1_accum) combiner(combiner)
+static void my_char4_bool_1_accum(int *accum, char4 a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_rs_matrix2x2_0) accumulator(my_char4_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_char4_rs_matrix2x2_0_accum(int *accum, char4 a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_char4_rs_matrix2x2_1) accumulator(my_char4_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_char4_rs_matrix2x2_1_accum(int *accum, char4 a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_char4_MyStruct_0) accumulator(my_char4_MyStruct_0_accum) combiner(combiner)
+static void my_char4_MyStruct_0_accum(int *accum, char4 a, MyStruct b) { }
+
+#pragma rs reduce(my_char4_MyStruct_1) accumulator(my_char4_MyStruct_1_accum) combiner(combiner)
+static void my_char4_MyStruct_1_accum(int *accum, char4 a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_half_0) accumulator(my_short_half_0_accum) combiner(combiner)
+static void my_short_half_0_accum(int *accum, short a, half b) { }
+
+#pragma rs reduce(my_short_half_1) accumulator(my_short_half_1_accum) combiner(combiner)
+static void my_short_half_1_accum(int *accum, short a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_half2_0) accumulator(my_short_half2_0_accum) combiner(combiner)
+static void my_short_half2_0_accum(int *accum, short a, half2 b) { }
+
+#pragma rs reduce(my_short_half2_1) accumulator(my_short_half2_1_accum) combiner(combiner)
+static void my_short_half2_1_accum(int *accum, short a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_half4_0) accumulator(my_short_half4_0_accum) combiner(combiner)
+static void my_short_half4_0_accum(int *accum, short a, half4 b) { }
+
+#pragma rs reduce(my_short_half4_1) accumulator(my_short_half4_1_accum) combiner(combiner)
+static void my_short_half4_1_accum(int *accum, short a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_float_0) accumulator(my_short_float_0_accum) combiner(combiner)
+static void my_short_float_0_accum(int *accum, short a, float b) { }
+
+#pragma rs reduce(my_short_float_1) accumulator(my_short_float_1_accum) combiner(combiner)
+static void my_short_float_1_accum(int *accum, short a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_float2_0) accumulator(my_short_float2_0_accum) combiner(combiner)
+static void my_short_float2_0_accum(int *accum, short a, float2 b) { }
+
+#pragma rs reduce(my_short_float2_1) accumulator(my_short_float2_1_accum) combiner(combiner)
+static void my_short_float2_1_accum(int *accum, short a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_float4_0) accumulator(my_short_float4_0_accum) combiner(combiner)
+static void my_short_float4_0_accum(int *accum, short a, float4 b) { }
+
+#pragma rs reduce(my_short_float4_1) accumulator(my_short_float4_1_accum) combiner(combiner)
+static void my_short_float4_1_accum(int *accum, short a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_char_0) accumulator(my_short_char_0_accum) combiner(combiner)
+static void my_short_char_0_accum(int *accum, short a, char b) { }
+
+#pragma rs reduce(my_short_char_1) accumulator(my_short_char_1_accum) combiner(combiner)
+static void my_short_char_1_accum(int *accum, short a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_char2_0) accumulator(my_short_char2_0_accum) combiner(combiner)
+static void my_short_char2_0_accum(int *accum, short a, char2 b) { }
+
+#pragma rs reduce(my_short_char2_1) accumulator(my_short_char2_1_accum) combiner(combiner)
+static void my_short_char2_1_accum(int *accum, short a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_char4_0) accumulator(my_short_char4_0_accum) combiner(combiner)
+static void my_short_char4_0_accum(int *accum, short a, char4 b) { }
+
+#pragma rs reduce(my_short_char4_1) accumulator(my_short_char4_1_accum) combiner(combiner)
+static void my_short_char4_1_accum(int *accum, short a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_short_0) accumulator(my_short_short_0_accum) combiner(combiner)
+static void my_short_short_0_accum(int *accum, short a, short b) { }
+
+#pragma rs reduce(my_short_short_1) accumulator(my_short_short_1_accum) combiner(combiner)
+static void my_short_short_1_accum(int *accum, short a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_short2_0) accumulator(my_short_short2_0_accum) combiner(combiner)
+static void my_short_short2_0_accum(int *accum, short a, short2 b) { }
+
+#pragma rs reduce(my_short_short2_1) accumulator(my_short_short2_1_accum) combiner(combiner)
+static void my_short_short2_1_accum(int *accum, short a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_short4_0) accumulator(my_short_short4_0_accum) combiner(combiner)
+static void my_short_short4_0_accum(int *accum, short a, short4 b) { }
+
+#pragma rs reduce(my_short_short4_1) accumulator(my_short_short4_1_accum) combiner(combiner)
+static void my_short_short4_1_accum(int *accum, short a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_uchar_0) accumulator(my_short_uchar_0_accum) combiner(combiner)
+static void my_short_uchar_0_accum(int *accum, short a, uchar b) { }
+
+#pragma rs reduce(my_short_uchar_1) accumulator(my_short_uchar_1_accum) combiner(combiner)
+static void my_short_uchar_1_accum(int *accum, short a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_uchar2_0) accumulator(my_short_uchar2_0_accum) combiner(combiner)
+static void my_short_uchar2_0_accum(int *accum, short a, uchar2 b) { }
+
+#pragma rs reduce(my_short_uchar2_1) accumulator(my_short_uchar2_1_accum) combiner(combiner)
+static void my_short_uchar2_1_accum(int *accum, short a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_uchar4_0) accumulator(my_short_uchar4_0_accum) combiner(combiner)
+static void my_short_uchar4_0_accum(int *accum, short a, uchar4 b) { }
+
+#pragma rs reduce(my_short_uchar4_1) accumulator(my_short_uchar4_1_accum) combiner(combiner)
+static void my_short_uchar4_1_accum(int *accum, short a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_ushort_0) accumulator(my_short_ushort_0_accum) combiner(combiner)
+static void my_short_ushort_0_accum(int *accum, short a, ushort b) { }
+
+#pragma rs reduce(my_short_ushort_1) accumulator(my_short_ushort_1_accum) combiner(combiner)
+static void my_short_ushort_1_accum(int *accum, short a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_ushort2_0) accumulator(my_short_ushort2_0_accum) combiner(combiner)
+static void my_short_ushort2_0_accum(int *accum, short a, ushort2 b) { }
+
+#pragma rs reduce(my_short_ushort2_1) accumulator(my_short_ushort2_1_accum) combiner(combiner)
+static void my_short_ushort2_1_accum(int *accum, short a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_ushort4_0) accumulator(my_short_ushort4_0_accum) combiner(combiner)
+static void my_short_ushort4_0_accum(int *accum, short a, ushort4 b) { }
+
+#pragma rs reduce(my_short_ushort4_1) accumulator(my_short_ushort4_1_accum) combiner(combiner)
+static void my_short_ushort4_1_accum(int *accum, short a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_bool_0) accumulator(my_short_bool_0_accum) combiner(combiner)
+static void my_short_bool_0_accum(int *accum, short a, bool b) { }
+
+#pragma rs reduce(my_short_bool_1) accumulator(my_short_bool_1_accum) combiner(combiner)
+static void my_short_bool_1_accum(int *accum, short a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_rs_matrix2x2_0) accumulator(my_short_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_short_rs_matrix2x2_0_accum(int *accum, short a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_short_rs_matrix2x2_1) accumulator(my_short_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_short_rs_matrix2x2_1_accum(int *accum, short a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short_MyStruct_0) accumulator(my_short_MyStruct_0_accum) combiner(combiner)
+static void my_short_MyStruct_0_accum(int *accum, short a, MyStruct b) { }
+
+#pragma rs reduce(my_short_MyStruct_1) accumulator(my_short_MyStruct_1_accum) combiner(combiner)
+static void my_short_MyStruct_1_accum(int *accum, short a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_half_0) accumulator(my_short2_half_0_accum) combiner(combiner)
+static void my_short2_half_0_accum(int *accum, short2 a, half b) { }
+
+#pragma rs reduce(my_short2_half_1) accumulator(my_short2_half_1_accum) combiner(combiner)
+static void my_short2_half_1_accum(int *accum, short2 a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_half2_0) accumulator(my_short2_half2_0_accum) combiner(combiner)
+static void my_short2_half2_0_accum(int *accum, short2 a, half2 b) { }
+
+#pragma rs reduce(my_short2_half2_1) accumulator(my_short2_half2_1_accum) combiner(combiner)
+static void my_short2_half2_1_accum(int *accum, short2 a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_half4_0) accumulator(my_short2_half4_0_accum) combiner(combiner)
+static void my_short2_half4_0_accum(int *accum, short2 a, half4 b) { }
+
+#pragma rs reduce(my_short2_half4_1) accumulator(my_short2_half4_1_accum) combiner(combiner)
+static void my_short2_half4_1_accum(int *accum, short2 a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_float_0) accumulator(my_short2_float_0_accum) combiner(combiner)
+static void my_short2_float_0_accum(int *accum, short2 a, float b) { }
+
+#pragma rs reduce(my_short2_float_1) accumulator(my_short2_float_1_accum) combiner(combiner)
+static void my_short2_float_1_accum(int *accum, short2 a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_float2_0) accumulator(my_short2_float2_0_accum) combiner(combiner)
+static void my_short2_float2_0_accum(int *accum, short2 a, float2 b) { }
+
+#pragma rs reduce(my_short2_float2_1) accumulator(my_short2_float2_1_accum) combiner(combiner)
+static void my_short2_float2_1_accum(int *accum, short2 a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_float4_0) accumulator(my_short2_float4_0_accum) combiner(combiner)
+static void my_short2_float4_0_accum(int *accum, short2 a, float4 b) { }
+
+#pragma rs reduce(my_short2_float4_1) accumulator(my_short2_float4_1_accum) combiner(combiner)
+static void my_short2_float4_1_accum(int *accum, short2 a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_char_0) accumulator(my_short2_char_0_accum) combiner(combiner)
+static void my_short2_char_0_accum(int *accum, short2 a, char b) { }
+
+#pragma rs reduce(my_short2_char_1) accumulator(my_short2_char_1_accum) combiner(combiner)
+static void my_short2_char_1_accum(int *accum, short2 a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_char2_0) accumulator(my_short2_char2_0_accum) combiner(combiner)
+static void my_short2_char2_0_accum(int *accum, short2 a, char2 b) { }
+
+#pragma rs reduce(my_short2_char2_1) accumulator(my_short2_char2_1_accum) combiner(combiner)
+static void my_short2_char2_1_accum(int *accum, short2 a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_char4_0) accumulator(my_short2_char4_0_accum) combiner(combiner)
+static void my_short2_char4_0_accum(int *accum, short2 a, char4 b) { }
+
+#pragma rs reduce(my_short2_char4_1) accumulator(my_short2_char4_1_accum) combiner(combiner)
+static void my_short2_char4_1_accum(int *accum, short2 a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_short_0) accumulator(my_short2_short_0_accum) combiner(combiner)
+static void my_short2_short_0_accum(int *accum, short2 a, short b) { }
+
+#pragma rs reduce(my_short2_short_1) accumulator(my_short2_short_1_accum) combiner(combiner)
+static void my_short2_short_1_accum(int *accum, short2 a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_short2_0) accumulator(my_short2_short2_0_accum) combiner(combiner)
+static void my_short2_short2_0_accum(int *accum, short2 a, short2 b) { }
+
+#pragma rs reduce(my_short2_short2_1) accumulator(my_short2_short2_1_accum) combiner(combiner)
+static void my_short2_short2_1_accum(int *accum, short2 a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_short4_0) accumulator(my_short2_short4_0_accum) combiner(combiner)
+static void my_short2_short4_0_accum(int *accum, short2 a, short4 b) { }
+
+#pragma rs reduce(my_short2_short4_1) accumulator(my_short2_short4_1_accum) combiner(combiner)
+static void my_short2_short4_1_accum(int *accum, short2 a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_uchar_0) accumulator(my_short2_uchar_0_accum) combiner(combiner)
+static void my_short2_uchar_0_accum(int *accum, short2 a, uchar b) { }
+
+#pragma rs reduce(my_short2_uchar_1) accumulator(my_short2_uchar_1_accum) combiner(combiner)
+static void my_short2_uchar_1_accum(int *accum, short2 a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_uchar2_0) accumulator(my_short2_uchar2_0_accum) combiner(combiner)
+static void my_short2_uchar2_0_accum(int *accum, short2 a, uchar2 b) { }
+
+#pragma rs reduce(my_short2_uchar2_1) accumulator(my_short2_uchar2_1_accum) combiner(combiner)
+static void my_short2_uchar2_1_accum(int *accum, short2 a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_uchar4_0) accumulator(my_short2_uchar4_0_accum) combiner(combiner)
+static void my_short2_uchar4_0_accum(int *accum, short2 a, uchar4 b) { }
+
+#pragma rs reduce(my_short2_uchar4_1) accumulator(my_short2_uchar4_1_accum) combiner(combiner)
+static void my_short2_uchar4_1_accum(int *accum, short2 a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_ushort_0) accumulator(my_short2_ushort_0_accum) combiner(combiner)
+static void my_short2_ushort_0_accum(int *accum, short2 a, ushort b) { }
+
+#pragma rs reduce(my_short2_ushort_1) accumulator(my_short2_ushort_1_accum) combiner(combiner)
+static void my_short2_ushort_1_accum(int *accum, short2 a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_ushort2_0) accumulator(my_short2_ushort2_0_accum) combiner(combiner)
+static void my_short2_ushort2_0_accum(int *accum, short2 a, ushort2 b) { }
+
+#pragma rs reduce(my_short2_ushort2_1) accumulator(my_short2_ushort2_1_accum) combiner(combiner)
+static void my_short2_ushort2_1_accum(int *accum, short2 a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_ushort4_0) accumulator(my_short2_ushort4_0_accum) combiner(combiner)
+static void my_short2_ushort4_0_accum(int *accum, short2 a, ushort4 b) { }
+
+#pragma rs reduce(my_short2_ushort4_1) accumulator(my_short2_ushort4_1_accum) combiner(combiner)
+static void my_short2_ushort4_1_accum(int *accum, short2 a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_bool_0) accumulator(my_short2_bool_0_accum) combiner(combiner)
+static void my_short2_bool_0_accum(int *accum, short2 a, bool b) { }
+
+#pragma rs reduce(my_short2_bool_1) accumulator(my_short2_bool_1_accum) combiner(combiner)
+static void my_short2_bool_1_accum(int *accum, short2 a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_rs_matrix2x2_0) accumulator(my_short2_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_short2_rs_matrix2x2_0_accum(int *accum, short2 a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_short2_rs_matrix2x2_1) accumulator(my_short2_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_short2_rs_matrix2x2_1_accum(int *accum, short2 a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short2_MyStruct_0) accumulator(my_short2_MyStruct_0_accum) combiner(combiner)
+static void my_short2_MyStruct_0_accum(int *accum, short2 a, MyStruct b) { }
+
+#pragma rs reduce(my_short2_MyStruct_1) accumulator(my_short2_MyStruct_1_accum) combiner(combiner)
+static void my_short2_MyStruct_1_accum(int *accum, short2 a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_half_0) accumulator(my_short4_half_0_accum) combiner(combiner)
+static void my_short4_half_0_accum(int *accum, short4 a, half b) { }
+
+#pragma rs reduce(my_short4_half_1) accumulator(my_short4_half_1_accum) combiner(combiner)
+static void my_short4_half_1_accum(int *accum, short4 a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_half2_0) accumulator(my_short4_half2_0_accum) combiner(combiner)
+static void my_short4_half2_0_accum(int *accum, short4 a, half2 b) { }
+
+#pragma rs reduce(my_short4_half2_1) accumulator(my_short4_half2_1_accum) combiner(combiner)
+static void my_short4_half2_1_accum(int *accum, short4 a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_half4_0) accumulator(my_short4_half4_0_accum) combiner(combiner)
+static void my_short4_half4_0_accum(int *accum, short4 a, half4 b) { }
+
+#pragma rs reduce(my_short4_half4_1) accumulator(my_short4_half4_1_accum) combiner(combiner)
+static void my_short4_half4_1_accum(int *accum, short4 a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_float_0) accumulator(my_short4_float_0_accum) combiner(combiner)
+static void my_short4_float_0_accum(int *accum, short4 a, float b) { }
+
+#pragma rs reduce(my_short4_float_1) accumulator(my_short4_float_1_accum) combiner(combiner)
+static void my_short4_float_1_accum(int *accum, short4 a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_float2_0) accumulator(my_short4_float2_0_accum) combiner(combiner)
+static void my_short4_float2_0_accum(int *accum, short4 a, float2 b) { }
+
+#pragma rs reduce(my_short4_float2_1) accumulator(my_short4_float2_1_accum) combiner(combiner)
+static void my_short4_float2_1_accum(int *accum, short4 a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_float4_0) accumulator(my_short4_float4_0_accum) combiner(combiner)
+static void my_short4_float4_0_accum(int *accum, short4 a, float4 b) { }
+
+#pragma rs reduce(my_short4_float4_1) accumulator(my_short4_float4_1_accum) combiner(combiner)
+static void my_short4_float4_1_accum(int *accum, short4 a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_char_0) accumulator(my_short4_char_0_accum) combiner(combiner)
+static void my_short4_char_0_accum(int *accum, short4 a, char b) { }
+
+#pragma rs reduce(my_short4_char_1) accumulator(my_short4_char_1_accum) combiner(combiner)
+static void my_short4_char_1_accum(int *accum, short4 a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_char2_0) accumulator(my_short4_char2_0_accum) combiner(combiner)
+static void my_short4_char2_0_accum(int *accum, short4 a, char2 b) { }
+
+#pragma rs reduce(my_short4_char2_1) accumulator(my_short4_char2_1_accum) combiner(combiner)
+static void my_short4_char2_1_accum(int *accum, short4 a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_char4_0) accumulator(my_short4_char4_0_accum) combiner(combiner)
+static void my_short4_char4_0_accum(int *accum, short4 a, char4 b) { }
+
+#pragma rs reduce(my_short4_char4_1) accumulator(my_short4_char4_1_accum) combiner(combiner)
+static void my_short4_char4_1_accum(int *accum, short4 a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_short_0) accumulator(my_short4_short_0_accum) combiner(combiner)
+static void my_short4_short_0_accum(int *accum, short4 a, short b) { }
+
+#pragma rs reduce(my_short4_short_1) accumulator(my_short4_short_1_accum) combiner(combiner)
+static void my_short4_short_1_accum(int *accum, short4 a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_short2_0) accumulator(my_short4_short2_0_accum) combiner(combiner)
+static void my_short4_short2_0_accum(int *accum, short4 a, short2 b) { }
+
+#pragma rs reduce(my_short4_short2_1) accumulator(my_short4_short2_1_accum) combiner(combiner)
+static void my_short4_short2_1_accum(int *accum, short4 a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_short4_0) accumulator(my_short4_short4_0_accum) combiner(combiner)
+static void my_short4_short4_0_accum(int *accum, short4 a, short4 b) { }
+
+#pragma rs reduce(my_short4_short4_1) accumulator(my_short4_short4_1_accum) combiner(combiner)
+static void my_short4_short4_1_accum(int *accum, short4 a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_uchar_0) accumulator(my_short4_uchar_0_accum) combiner(combiner)
+static void my_short4_uchar_0_accum(int *accum, short4 a, uchar b) { }
+
+#pragma rs reduce(my_short4_uchar_1) accumulator(my_short4_uchar_1_accum) combiner(combiner)
+static void my_short4_uchar_1_accum(int *accum, short4 a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_uchar2_0) accumulator(my_short4_uchar2_0_accum) combiner(combiner)
+static void my_short4_uchar2_0_accum(int *accum, short4 a, uchar2 b) { }
+
+#pragma rs reduce(my_short4_uchar2_1) accumulator(my_short4_uchar2_1_accum) combiner(combiner)
+static void my_short4_uchar2_1_accum(int *accum, short4 a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_uchar4_0) accumulator(my_short4_uchar4_0_accum) combiner(combiner)
+static void my_short4_uchar4_0_accum(int *accum, short4 a, uchar4 b) { }
+
+#pragma rs reduce(my_short4_uchar4_1) accumulator(my_short4_uchar4_1_accum) combiner(combiner)
+static void my_short4_uchar4_1_accum(int *accum, short4 a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_ushort_0) accumulator(my_short4_ushort_0_accum) combiner(combiner)
+static void my_short4_ushort_0_accum(int *accum, short4 a, ushort b) { }
+
+#pragma rs reduce(my_short4_ushort_1) accumulator(my_short4_ushort_1_accum) combiner(combiner)
+static void my_short4_ushort_1_accum(int *accum, short4 a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_ushort2_0) accumulator(my_short4_ushort2_0_accum) combiner(combiner)
+static void my_short4_ushort2_0_accum(int *accum, short4 a, ushort2 b) { }
+
+#pragma rs reduce(my_short4_ushort2_1) accumulator(my_short4_ushort2_1_accum) combiner(combiner)
+static void my_short4_ushort2_1_accum(int *accum, short4 a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_ushort4_0) accumulator(my_short4_ushort4_0_accum) combiner(combiner)
+static void my_short4_ushort4_0_accum(int *accum, short4 a, ushort4 b) { }
+
+#pragma rs reduce(my_short4_ushort4_1) accumulator(my_short4_ushort4_1_accum) combiner(combiner)
+static void my_short4_ushort4_1_accum(int *accum, short4 a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_bool_0) accumulator(my_short4_bool_0_accum) combiner(combiner)
+static void my_short4_bool_0_accum(int *accum, short4 a, bool b) { }
+
+#pragma rs reduce(my_short4_bool_1) accumulator(my_short4_bool_1_accum) combiner(combiner)
+static void my_short4_bool_1_accum(int *accum, short4 a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_rs_matrix2x2_0) accumulator(my_short4_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_short4_rs_matrix2x2_0_accum(int *accum, short4 a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_short4_rs_matrix2x2_1) accumulator(my_short4_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_short4_rs_matrix2x2_1_accum(int *accum, short4 a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_short4_MyStruct_0) accumulator(my_short4_MyStruct_0_accum) combiner(combiner)
+static void my_short4_MyStruct_0_accum(int *accum, short4 a, MyStruct b) { }
+
+#pragma rs reduce(my_short4_MyStruct_1) accumulator(my_short4_MyStruct_1_accum) combiner(combiner)
+static void my_short4_MyStruct_1_accum(int *accum, short4 a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_half_0) accumulator(my_uchar_half_0_accum) combiner(combiner)
+static void my_uchar_half_0_accum(int *accum, uchar a, half b) { }
+
+#pragma rs reduce(my_uchar_half_1) accumulator(my_uchar_half_1_accum) combiner(combiner)
+static void my_uchar_half_1_accum(int *accum, uchar a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_half2_0) accumulator(my_uchar_half2_0_accum) combiner(combiner)
+static void my_uchar_half2_0_accum(int *accum, uchar a, half2 b) { }
+
+#pragma rs reduce(my_uchar_half2_1) accumulator(my_uchar_half2_1_accum) combiner(combiner)
+static void my_uchar_half2_1_accum(int *accum, uchar a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_half4_0) accumulator(my_uchar_half4_0_accum) combiner(combiner)
+static void my_uchar_half4_0_accum(int *accum, uchar a, half4 b) { }
+
+#pragma rs reduce(my_uchar_half4_1) accumulator(my_uchar_half4_1_accum) combiner(combiner)
+static void my_uchar_half4_1_accum(int *accum, uchar a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_float_0) accumulator(my_uchar_float_0_accum) combiner(combiner)
+static void my_uchar_float_0_accum(int *accum, uchar a, float b) { }
+
+#pragma rs reduce(my_uchar_float_1) accumulator(my_uchar_float_1_accum) combiner(combiner)
+static void my_uchar_float_1_accum(int *accum, uchar a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_float2_0) accumulator(my_uchar_float2_0_accum) combiner(combiner)
+static void my_uchar_float2_0_accum(int *accum, uchar a, float2 b) { }
+
+#pragma rs reduce(my_uchar_float2_1) accumulator(my_uchar_float2_1_accum) combiner(combiner)
+static void my_uchar_float2_1_accum(int *accum, uchar a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_float4_0) accumulator(my_uchar_float4_0_accum) combiner(combiner)
+static void my_uchar_float4_0_accum(int *accum, uchar a, float4 b) { }
+
+#pragma rs reduce(my_uchar_float4_1) accumulator(my_uchar_float4_1_accum) combiner(combiner)
+static void my_uchar_float4_1_accum(int *accum, uchar a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_char_0) accumulator(my_uchar_char_0_accum) combiner(combiner)
+static void my_uchar_char_0_accum(int *accum, uchar a, char b) { }
+
+#pragma rs reduce(my_uchar_char_1) accumulator(my_uchar_char_1_accum) combiner(combiner)
+static void my_uchar_char_1_accum(int *accum, uchar a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_char2_0) accumulator(my_uchar_char2_0_accum) combiner(combiner)
+static void my_uchar_char2_0_accum(int *accum, uchar a, char2 b) { }
+
+#pragma rs reduce(my_uchar_char2_1) accumulator(my_uchar_char2_1_accum) combiner(combiner)
+static void my_uchar_char2_1_accum(int *accum, uchar a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_char4_0) accumulator(my_uchar_char4_0_accum) combiner(combiner)
+static void my_uchar_char4_0_accum(int *accum, uchar a, char4 b) { }
+
+#pragma rs reduce(my_uchar_char4_1) accumulator(my_uchar_char4_1_accum) combiner(combiner)
+static void my_uchar_char4_1_accum(int *accum, uchar a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_short_0) accumulator(my_uchar_short_0_accum) combiner(combiner)
+static void my_uchar_short_0_accum(int *accum, uchar a, short b) { }
+
+#pragma rs reduce(my_uchar_short_1) accumulator(my_uchar_short_1_accum) combiner(combiner)
+static void my_uchar_short_1_accum(int *accum, uchar a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_short2_0) accumulator(my_uchar_short2_0_accum) combiner(combiner)
+static void my_uchar_short2_0_accum(int *accum, uchar a, short2 b) { }
+
+#pragma rs reduce(my_uchar_short2_1) accumulator(my_uchar_short2_1_accum) combiner(combiner)
+static void my_uchar_short2_1_accum(int *accum, uchar a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_short4_0) accumulator(my_uchar_short4_0_accum) combiner(combiner)
+static void my_uchar_short4_0_accum(int *accum, uchar a, short4 b) { }
+
+#pragma rs reduce(my_uchar_short4_1) accumulator(my_uchar_short4_1_accum) combiner(combiner)
+static void my_uchar_short4_1_accum(int *accum, uchar a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_uchar_0) accumulator(my_uchar_uchar_0_accum) combiner(combiner)
+static void my_uchar_uchar_0_accum(int *accum, uchar a, uchar b) { }
+
+#pragma rs reduce(my_uchar_uchar_1) accumulator(my_uchar_uchar_1_accum) combiner(combiner)
+static void my_uchar_uchar_1_accum(int *accum, uchar a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_uchar2_0) accumulator(my_uchar_uchar2_0_accum) combiner(combiner)
+static void my_uchar_uchar2_0_accum(int *accum, uchar a, uchar2 b) { }
+
+#pragma rs reduce(my_uchar_uchar2_1) accumulator(my_uchar_uchar2_1_accum) combiner(combiner)
+static void my_uchar_uchar2_1_accum(int *accum, uchar a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_uchar4_0) accumulator(my_uchar_uchar4_0_accum) combiner(combiner)
+static void my_uchar_uchar4_0_accum(int *accum, uchar a, uchar4 b) { }
+
+#pragma rs reduce(my_uchar_uchar4_1) accumulator(my_uchar_uchar4_1_accum) combiner(combiner)
+static void my_uchar_uchar4_1_accum(int *accum, uchar a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_ushort_0) accumulator(my_uchar_ushort_0_accum) combiner(combiner)
+static void my_uchar_ushort_0_accum(int *accum, uchar a, ushort b) { }
+
+#pragma rs reduce(my_uchar_ushort_1) accumulator(my_uchar_ushort_1_accum) combiner(combiner)
+static void my_uchar_ushort_1_accum(int *accum, uchar a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_ushort2_0) accumulator(my_uchar_ushort2_0_accum) combiner(combiner)
+static void my_uchar_ushort2_0_accum(int *accum, uchar a, ushort2 b) { }
+
+#pragma rs reduce(my_uchar_ushort2_1) accumulator(my_uchar_ushort2_1_accum) combiner(combiner)
+static void my_uchar_ushort2_1_accum(int *accum, uchar a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_ushort4_0) accumulator(my_uchar_ushort4_0_accum) combiner(combiner)
+static void my_uchar_ushort4_0_accum(int *accum, uchar a, ushort4 b) { }
+
+#pragma rs reduce(my_uchar_ushort4_1) accumulator(my_uchar_ushort4_1_accum) combiner(combiner)
+static void my_uchar_ushort4_1_accum(int *accum, uchar a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_bool_0) accumulator(my_uchar_bool_0_accum) combiner(combiner)
+static void my_uchar_bool_0_accum(int *accum, uchar a, bool b) { }
+
+#pragma rs reduce(my_uchar_bool_1) accumulator(my_uchar_bool_1_accum) combiner(combiner)
+static void my_uchar_bool_1_accum(int *accum, uchar a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_rs_matrix2x2_0) accumulator(my_uchar_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_uchar_rs_matrix2x2_0_accum(int *accum, uchar a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_uchar_rs_matrix2x2_1) accumulator(my_uchar_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_uchar_rs_matrix2x2_1_accum(int *accum, uchar a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar_MyStruct_0) accumulator(my_uchar_MyStruct_0_accum) combiner(combiner)
+static void my_uchar_MyStruct_0_accum(int *accum, uchar a, MyStruct b) { }
+
+#pragma rs reduce(my_uchar_MyStruct_1) accumulator(my_uchar_MyStruct_1_accum) combiner(combiner)
+static void my_uchar_MyStruct_1_accum(int *accum, uchar a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_half_0) accumulator(my_uchar2_half_0_accum) combiner(combiner)
+static void my_uchar2_half_0_accum(int *accum, uchar2 a, half b) { }
+
+#pragma rs reduce(my_uchar2_half_1) accumulator(my_uchar2_half_1_accum) combiner(combiner)
+static void my_uchar2_half_1_accum(int *accum, uchar2 a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_half2_0) accumulator(my_uchar2_half2_0_accum) combiner(combiner)
+static void my_uchar2_half2_0_accum(int *accum, uchar2 a, half2 b) { }
+
+#pragma rs reduce(my_uchar2_half2_1) accumulator(my_uchar2_half2_1_accum) combiner(combiner)
+static void my_uchar2_half2_1_accum(int *accum, uchar2 a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_half4_0) accumulator(my_uchar2_half4_0_accum) combiner(combiner)
+static void my_uchar2_half4_0_accum(int *accum, uchar2 a, half4 b) { }
+
+#pragma rs reduce(my_uchar2_half4_1) accumulator(my_uchar2_half4_1_accum) combiner(combiner)
+static void my_uchar2_half4_1_accum(int *accum, uchar2 a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_float_0) accumulator(my_uchar2_float_0_accum) combiner(combiner)
+static void my_uchar2_float_0_accum(int *accum, uchar2 a, float b) { }
+
+#pragma rs reduce(my_uchar2_float_1) accumulator(my_uchar2_float_1_accum) combiner(combiner)
+static void my_uchar2_float_1_accum(int *accum, uchar2 a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_float2_0) accumulator(my_uchar2_float2_0_accum) combiner(combiner)
+static void my_uchar2_float2_0_accum(int *accum, uchar2 a, float2 b) { }
+
+#pragma rs reduce(my_uchar2_float2_1) accumulator(my_uchar2_float2_1_accum) combiner(combiner)
+static void my_uchar2_float2_1_accum(int *accum, uchar2 a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_float4_0) accumulator(my_uchar2_float4_0_accum) combiner(combiner)
+static void my_uchar2_float4_0_accum(int *accum, uchar2 a, float4 b) { }
+
+#pragma rs reduce(my_uchar2_float4_1) accumulator(my_uchar2_float4_1_accum) combiner(combiner)
+static void my_uchar2_float4_1_accum(int *accum, uchar2 a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_char_0) accumulator(my_uchar2_char_0_accum) combiner(combiner)
+static void my_uchar2_char_0_accum(int *accum, uchar2 a, char b) { }
+
+#pragma rs reduce(my_uchar2_char_1) accumulator(my_uchar2_char_1_accum) combiner(combiner)
+static void my_uchar2_char_1_accum(int *accum, uchar2 a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_char2_0) accumulator(my_uchar2_char2_0_accum) combiner(combiner)
+static void my_uchar2_char2_0_accum(int *accum, uchar2 a, char2 b) { }
+
+#pragma rs reduce(my_uchar2_char2_1) accumulator(my_uchar2_char2_1_accum) combiner(combiner)
+static void my_uchar2_char2_1_accum(int *accum, uchar2 a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_char4_0) accumulator(my_uchar2_char4_0_accum) combiner(combiner)
+static void my_uchar2_char4_0_accum(int *accum, uchar2 a, char4 b) { }
+
+#pragma rs reduce(my_uchar2_char4_1) accumulator(my_uchar2_char4_1_accum) combiner(combiner)
+static void my_uchar2_char4_1_accum(int *accum, uchar2 a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_short_0) accumulator(my_uchar2_short_0_accum) combiner(combiner)
+static void my_uchar2_short_0_accum(int *accum, uchar2 a, short b) { }
+
+#pragma rs reduce(my_uchar2_short_1) accumulator(my_uchar2_short_1_accum) combiner(combiner)
+static void my_uchar2_short_1_accum(int *accum, uchar2 a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_short2_0) accumulator(my_uchar2_short2_0_accum) combiner(combiner)
+static void my_uchar2_short2_0_accum(int *accum, uchar2 a, short2 b) { }
+
+#pragma rs reduce(my_uchar2_short2_1) accumulator(my_uchar2_short2_1_accum) combiner(combiner)
+static void my_uchar2_short2_1_accum(int *accum, uchar2 a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_short4_0) accumulator(my_uchar2_short4_0_accum) combiner(combiner)
+static void my_uchar2_short4_0_accum(int *accum, uchar2 a, short4 b) { }
+
+#pragma rs reduce(my_uchar2_short4_1) accumulator(my_uchar2_short4_1_accum) combiner(combiner)
+static void my_uchar2_short4_1_accum(int *accum, uchar2 a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_uchar_0) accumulator(my_uchar2_uchar_0_accum) combiner(combiner)
+static void my_uchar2_uchar_0_accum(int *accum, uchar2 a, uchar b) { }
+
+#pragma rs reduce(my_uchar2_uchar_1) accumulator(my_uchar2_uchar_1_accum) combiner(combiner)
+static void my_uchar2_uchar_1_accum(int *accum, uchar2 a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_uchar2_0) accumulator(my_uchar2_uchar2_0_accum) combiner(combiner)
+static void my_uchar2_uchar2_0_accum(int *accum, uchar2 a, uchar2 b) { }
+
+#pragma rs reduce(my_uchar2_uchar2_1) accumulator(my_uchar2_uchar2_1_accum) combiner(combiner)
+static void my_uchar2_uchar2_1_accum(int *accum, uchar2 a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_uchar4_0) accumulator(my_uchar2_uchar4_0_accum) combiner(combiner)
+static void my_uchar2_uchar4_0_accum(int *accum, uchar2 a, uchar4 b) { }
+
+#pragma rs reduce(my_uchar2_uchar4_1) accumulator(my_uchar2_uchar4_1_accum) combiner(combiner)
+static void my_uchar2_uchar4_1_accum(int *accum, uchar2 a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_ushort_0) accumulator(my_uchar2_ushort_0_accum) combiner(combiner)
+static void my_uchar2_ushort_0_accum(int *accum, uchar2 a, ushort b) { }
+
+#pragma rs reduce(my_uchar2_ushort_1) accumulator(my_uchar2_ushort_1_accum) combiner(combiner)
+static void my_uchar2_ushort_1_accum(int *accum, uchar2 a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_ushort2_0) accumulator(my_uchar2_ushort2_0_accum) combiner(combiner)
+static void my_uchar2_ushort2_0_accum(int *accum, uchar2 a, ushort2 b) { }
+
+#pragma rs reduce(my_uchar2_ushort2_1) accumulator(my_uchar2_ushort2_1_accum) combiner(combiner)
+static void my_uchar2_ushort2_1_accum(int *accum, uchar2 a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_ushort4_0) accumulator(my_uchar2_ushort4_0_accum) combiner(combiner)
+static void my_uchar2_ushort4_0_accum(int *accum, uchar2 a, ushort4 b) { }
+
+#pragma rs reduce(my_uchar2_ushort4_1) accumulator(my_uchar2_ushort4_1_accum) combiner(combiner)
+static void my_uchar2_ushort4_1_accum(int *accum, uchar2 a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_bool_0) accumulator(my_uchar2_bool_0_accum) combiner(combiner)
+static void my_uchar2_bool_0_accum(int *accum, uchar2 a, bool b) { }
+
+#pragma rs reduce(my_uchar2_bool_1) accumulator(my_uchar2_bool_1_accum) combiner(combiner)
+static void my_uchar2_bool_1_accum(int *accum, uchar2 a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_rs_matrix2x2_0) accumulator(my_uchar2_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_uchar2_rs_matrix2x2_0_accum(int *accum, uchar2 a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_uchar2_rs_matrix2x2_1) accumulator(my_uchar2_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_uchar2_rs_matrix2x2_1_accum(int *accum, uchar2 a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar2_MyStruct_0) accumulator(my_uchar2_MyStruct_0_accum) combiner(combiner)
+static void my_uchar2_MyStruct_0_accum(int *accum, uchar2 a, MyStruct b) { }
+
+#pragma rs reduce(my_uchar2_MyStruct_1) accumulator(my_uchar2_MyStruct_1_accum) combiner(combiner)
+static void my_uchar2_MyStruct_1_accum(int *accum, uchar2 a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_half_0) accumulator(my_uchar4_half_0_accum) combiner(combiner)
+static void my_uchar4_half_0_accum(int *accum, uchar4 a, half b) { }
+
+#pragma rs reduce(my_uchar4_half_1) accumulator(my_uchar4_half_1_accum) combiner(combiner)
+static void my_uchar4_half_1_accum(int *accum, uchar4 a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_half2_0) accumulator(my_uchar4_half2_0_accum) combiner(combiner)
+static void my_uchar4_half2_0_accum(int *accum, uchar4 a, half2 b) { }
+
+#pragma rs reduce(my_uchar4_half2_1) accumulator(my_uchar4_half2_1_accum) combiner(combiner)
+static void my_uchar4_half2_1_accum(int *accum, uchar4 a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_half4_0) accumulator(my_uchar4_half4_0_accum) combiner(combiner)
+static void my_uchar4_half4_0_accum(int *accum, uchar4 a, half4 b) { }
+
+#pragma rs reduce(my_uchar4_half4_1) accumulator(my_uchar4_half4_1_accum) combiner(combiner)
+static void my_uchar4_half4_1_accum(int *accum, uchar4 a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_float_0) accumulator(my_uchar4_float_0_accum) combiner(combiner)
+static void my_uchar4_float_0_accum(int *accum, uchar4 a, float b) { }
+
+#pragma rs reduce(my_uchar4_float_1) accumulator(my_uchar4_float_1_accum) combiner(combiner)
+static void my_uchar4_float_1_accum(int *accum, uchar4 a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_float2_0) accumulator(my_uchar4_float2_0_accum) combiner(combiner)
+static void my_uchar4_float2_0_accum(int *accum, uchar4 a, float2 b) { }
+
+#pragma rs reduce(my_uchar4_float2_1) accumulator(my_uchar4_float2_1_accum) combiner(combiner)
+static void my_uchar4_float2_1_accum(int *accum, uchar4 a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_float4_0) accumulator(my_uchar4_float4_0_accum) combiner(combiner)
+static void my_uchar4_float4_0_accum(int *accum, uchar4 a, float4 b) { }
+
+#pragma rs reduce(my_uchar4_float4_1) accumulator(my_uchar4_float4_1_accum) combiner(combiner)
+static void my_uchar4_float4_1_accum(int *accum, uchar4 a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_char_0) accumulator(my_uchar4_char_0_accum) combiner(combiner)
+static void my_uchar4_char_0_accum(int *accum, uchar4 a, char b) { }
+
+#pragma rs reduce(my_uchar4_char_1) accumulator(my_uchar4_char_1_accum) combiner(combiner)
+static void my_uchar4_char_1_accum(int *accum, uchar4 a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_char2_0) accumulator(my_uchar4_char2_0_accum) combiner(combiner)
+static void my_uchar4_char2_0_accum(int *accum, uchar4 a, char2 b) { }
+
+#pragma rs reduce(my_uchar4_char2_1) accumulator(my_uchar4_char2_1_accum) combiner(combiner)
+static void my_uchar4_char2_1_accum(int *accum, uchar4 a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_char4_0) accumulator(my_uchar4_char4_0_accum) combiner(combiner)
+static void my_uchar4_char4_0_accum(int *accum, uchar4 a, char4 b) { }
+
+#pragma rs reduce(my_uchar4_char4_1) accumulator(my_uchar4_char4_1_accum) combiner(combiner)
+static void my_uchar4_char4_1_accum(int *accum, uchar4 a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_short_0) accumulator(my_uchar4_short_0_accum) combiner(combiner)
+static void my_uchar4_short_0_accum(int *accum, uchar4 a, short b) { }
+
+#pragma rs reduce(my_uchar4_short_1) accumulator(my_uchar4_short_1_accum) combiner(combiner)
+static void my_uchar4_short_1_accum(int *accum, uchar4 a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_short2_0) accumulator(my_uchar4_short2_0_accum) combiner(combiner)
+static void my_uchar4_short2_0_accum(int *accum, uchar4 a, short2 b) { }
+
+#pragma rs reduce(my_uchar4_short2_1) accumulator(my_uchar4_short2_1_accum) combiner(combiner)
+static void my_uchar4_short2_1_accum(int *accum, uchar4 a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_short4_0) accumulator(my_uchar4_short4_0_accum) combiner(combiner)
+static void my_uchar4_short4_0_accum(int *accum, uchar4 a, short4 b) { }
+
+#pragma rs reduce(my_uchar4_short4_1) accumulator(my_uchar4_short4_1_accum) combiner(combiner)
+static void my_uchar4_short4_1_accum(int *accum, uchar4 a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_uchar_0) accumulator(my_uchar4_uchar_0_accum) combiner(combiner)
+static void my_uchar4_uchar_0_accum(int *accum, uchar4 a, uchar b) { }
+
+#pragma rs reduce(my_uchar4_uchar_1) accumulator(my_uchar4_uchar_1_accum) combiner(combiner)
+static void my_uchar4_uchar_1_accum(int *accum, uchar4 a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_uchar2_0) accumulator(my_uchar4_uchar2_0_accum) combiner(combiner)
+static void my_uchar4_uchar2_0_accum(int *accum, uchar4 a, uchar2 b) { }
+
+#pragma rs reduce(my_uchar4_uchar2_1) accumulator(my_uchar4_uchar2_1_accum) combiner(combiner)
+static void my_uchar4_uchar2_1_accum(int *accum, uchar4 a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_uchar4_0) accumulator(my_uchar4_uchar4_0_accum) combiner(combiner)
+static void my_uchar4_uchar4_0_accum(int *accum, uchar4 a, uchar4 b) { }
+
+#pragma rs reduce(my_uchar4_uchar4_1) accumulator(my_uchar4_uchar4_1_accum) combiner(combiner)
+static void my_uchar4_uchar4_1_accum(int *accum, uchar4 a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_ushort_0) accumulator(my_uchar4_ushort_0_accum) combiner(combiner)
+static void my_uchar4_ushort_0_accum(int *accum, uchar4 a, ushort b) { }
+
+#pragma rs reduce(my_uchar4_ushort_1) accumulator(my_uchar4_ushort_1_accum) combiner(combiner)
+static void my_uchar4_ushort_1_accum(int *accum, uchar4 a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_ushort2_0) accumulator(my_uchar4_ushort2_0_accum) combiner(combiner)
+static void my_uchar4_ushort2_0_accum(int *accum, uchar4 a, ushort2 b) { }
+
+#pragma rs reduce(my_uchar4_ushort2_1) accumulator(my_uchar4_ushort2_1_accum) combiner(combiner)
+static void my_uchar4_ushort2_1_accum(int *accum, uchar4 a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_ushort4_0) accumulator(my_uchar4_ushort4_0_accum) combiner(combiner)
+static void my_uchar4_ushort4_0_accum(int *accum, uchar4 a, ushort4 b) { }
+
+#pragma rs reduce(my_uchar4_ushort4_1) accumulator(my_uchar4_ushort4_1_accum) combiner(combiner)
+static void my_uchar4_ushort4_1_accum(int *accum, uchar4 a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_bool_0) accumulator(my_uchar4_bool_0_accum) combiner(combiner)
+static void my_uchar4_bool_0_accum(int *accum, uchar4 a, bool b) { }
+
+#pragma rs reduce(my_uchar4_bool_1) accumulator(my_uchar4_bool_1_accum) combiner(combiner)
+static void my_uchar4_bool_1_accum(int *accum, uchar4 a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_rs_matrix2x2_0) accumulator(my_uchar4_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_uchar4_rs_matrix2x2_0_accum(int *accum, uchar4 a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_uchar4_rs_matrix2x2_1) accumulator(my_uchar4_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_uchar4_rs_matrix2x2_1_accum(int *accum, uchar4 a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_uchar4_MyStruct_0) accumulator(my_uchar4_MyStruct_0_accum) combiner(combiner)
+static void my_uchar4_MyStruct_0_accum(int *accum, uchar4 a, MyStruct b) { }
+
+#pragma rs reduce(my_uchar4_MyStruct_1) accumulator(my_uchar4_MyStruct_1_accum) combiner(combiner)
+static void my_uchar4_MyStruct_1_accum(int *accum, uchar4 a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_half_0) accumulator(my_ushort_half_0_accum) combiner(combiner)
+static void my_ushort_half_0_accum(int *accum, ushort a, half b) { }
+
+#pragma rs reduce(my_ushort_half_1) accumulator(my_ushort_half_1_accum) combiner(combiner)
+static void my_ushort_half_1_accum(int *accum, ushort a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_half2_0) accumulator(my_ushort_half2_0_accum) combiner(combiner)
+static void my_ushort_half2_0_accum(int *accum, ushort a, half2 b) { }
+
+#pragma rs reduce(my_ushort_half2_1) accumulator(my_ushort_half2_1_accum) combiner(combiner)
+static void my_ushort_half2_1_accum(int *accum, ushort a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_half4_0) accumulator(my_ushort_half4_0_accum) combiner(combiner)
+static void my_ushort_half4_0_accum(int *accum, ushort a, half4 b) { }
+
+#pragma rs reduce(my_ushort_half4_1) accumulator(my_ushort_half4_1_accum) combiner(combiner)
+static void my_ushort_half4_1_accum(int *accum, ushort a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_float_0) accumulator(my_ushort_float_0_accum) combiner(combiner)
+static void my_ushort_float_0_accum(int *accum, ushort a, float b) { }
+
+#pragma rs reduce(my_ushort_float_1) accumulator(my_ushort_float_1_accum) combiner(combiner)
+static void my_ushort_float_1_accum(int *accum, ushort a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_float2_0) accumulator(my_ushort_float2_0_accum) combiner(combiner)
+static void my_ushort_float2_0_accum(int *accum, ushort a, float2 b) { }
+
+#pragma rs reduce(my_ushort_float2_1) accumulator(my_ushort_float2_1_accum) combiner(combiner)
+static void my_ushort_float2_1_accum(int *accum, ushort a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_float4_0) accumulator(my_ushort_float4_0_accum) combiner(combiner)
+static void my_ushort_float4_0_accum(int *accum, ushort a, float4 b) { }
+
+#pragma rs reduce(my_ushort_float4_1) accumulator(my_ushort_float4_1_accum) combiner(combiner)
+static void my_ushort_float4_1_accum(int *accum, ushort a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_char_0) accumulator(my_ushort_char_0_accum) combiner(combiner)
+static void my_ushort_char_0_accum(int *accum, ushort a, char b) { }
+
+#pragma rs reduce(my_ushort_char_1) accumulator(my_ushort_char_1_accum) combiner(combiner)
+static void my_ushort_char_1_accum(int *accum, ushort a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_char2_0) accumulator(my_ushort_char2_0_accum) combiner(combiner)
+static void my_ushort_char2_0_accum(int *accum, ushort a, char2 b) { }
+
+#pragma rs reduce(my_ushort_char2_1) accumulator(my_ushort_char2_1_accum) combiner(combiner)
+static void my_ushort_char2_1_accum(int *accum, ushort a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_char4_0) accumulator(my_ushort_char4_0_accum) combiner(combiner)
+static void my_ushort_char4_0_accum(int *accum, ushort a, char4 b) { }
+
+#pragma rs reduce(my_ushort_char4_1) accumulator(my_ushort_char4_1_accum) combiner(combiner)
+static void my_ushort_char4_1_accum(int *accum, ushort a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_short_0) accumulator(my_ushort_short_0_accum) combiner(combiner)
+static void my_ushort_short_0_accum(int *accum, ushort a, short b) { }
+
+#pragma rs reduce(my_ushort_short_1) accumulator(my_ushort_short_1_accum) combiner(combiner)
+static void my_ushort_short_1_accum(int *accum, ushort a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_short2_0) accumulator(my_ushort_short2_0_accum) combiner(combiner)
+static void my_ushort_short2_0_accum(int *accum, ushort a, short2 b) { }
+
+#pragma rs reduce(my_ushort_short2_1) accumulator(my_ushort_short2_1_accum) combiner(combiner)
+static void my_ushort_short2_1_accum(int *accum, ushort a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_short4_0) accumulator(my_ushort_short4_0_accum) combiner(combiner)
+static void my_ushort_short4_0_accum(int *accum, ushort a, short4 b) { }
+
+#pragma rs reduce(my_ushort_short4_1) accumulator(my_ushort_short4_1_accum) combiner(combiner)
+static void my_ushort_short4_1_accum(int *accum, ushort a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_uchar_0) accumulator(my_ushort_uchar_0_accum) combiner(combiner)
+static void my_ushort_uchar_0_accum(int *accum, ushort a, uchar b) { }
+
+#pragma rs reduce(my_ushort_uchar_1) accumulator(my_ushort_uchar_1_accum) combiner(combiner)
+static void my_ushort_uchar_1_accum(int *accum, ushort a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_uchar2_0) accumulator(my_ushort_uchar2_0_accum) combiner(combiner)
+static void my_ushort_uchar2_0_accum(int *accum, ushort a, uchar2 b) { }
+
+#pragma rs reduce(my_ushort_uchar2_1) accumulator(my_ushort_uchar2_1_accum) combiner(combiner)
+static void my_ushort_uchar2_1_accum(int *accum, ushort a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_uchar4_0) accumulator(my_ushort_uchar4_0_accum) combiner(combiner)
+static void my_ushort_uchar4_0_accum(int *accum, ushort a, uchar4 b) { }
+
+#pragma rs reduce(my_ushort_uchar4_1) accumulator(my_ushort_uchar4_1_accum) combiner(combiner)
+static void my_ushort_uchar4_1_accum(int *accum, ushort a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_ushort_0) accumulator(my_ushort_ushort_0_accum) combiner(combiner)
+static void my_ushort_ushort_0_accum(int *accum, ushort a, ushort b) { }
+
+#pragma rs reduce(my_ushort_ushort_1) accumulator(my_ushort_ushort_1_accum) combiner(combiner)
+static void my_ushort_ushort_1_accum(int *accum, ushort a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_ushort2_0) accumulator(my_ushort_ushort2_0_accum) combiner(combiner)
+static void my_ushort_ushort2_0_accum(int *accum, ushort a, ushort2 b) { }
+
+#pragma rs reduce(my_ushort_ushort2_1) accumulator(my_ushort_ushort2_1_accum) combiner(combiner)
+static void my_ushort_ushort2_1_accum(int *accum, ushort a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_ushort4_0) accumulator(my_ushort_ushort4_0_accum) combiner(combiner)
+static void my_ushort_ushort4_0_accum(int *accum, ushort a, ushort4 b) { }
+
+#pragma rs reduce(my_ushort_ushort4_1) accumulator(my_ushort_ushort4_1_accum) combiner(combiner)
+static void my_ushort_ushort4_1_accum(int *accum, ushort a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_bool_0) accumulator(my_ushort_bool_0_accum) combiner(combiner)
+static void my_ushort_bool_0_accum(int *accum, ushort a, bool b) { }
+
+#pragma rs reduce(my_ushort_bool_1) accumulator(my_ushort_bool_1_accum) combiner(combiner)
+static void my_ushort_bool_1_accum(int *accum, ushort a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_rs_matrix2x2_0) accumulator(my_ushort_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_ushort_rs_matrix2x2_0_accum(int *accum, ushort a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_ushort_rs_matrix2x2_1) accumulator(my_ushort_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_ushort_rs_matrix2x2_1_accum(int *accum, ushort a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort_MyStruct_0) accumulator(my_ushort_MyStruct_0_accum) combiner(combiner)
+static void my_ushort_MyStruct_0_accum(int *accum, ushort a, MyStruct b) { }
+
+#pragma rs reduce(my_ushort_MyStruct_1) accumulator(my_ushort_MyStruct_1_accum) combiner(combiner)
+static void my_ushort_MyStruct_1_accum(int *accum, ushort a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_half_0) accumulator(my_ushort2_half_0_accum) combiner(combiner)
+static void my_ushort2_half_0_accum(int *accum, ushort2 a, half b) { }
+
+#pragma rs reduce(my_ushort2_half_1) accumulator(my_ushort2_half_1_accum) combiner(combiner)
+static void my_ushort2_half_1_accum(int *accum, ushort2 a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_half2_0) accumulator(my_ushort2_half2_0_accum) combiner(combiner)
+static void my_ushort2_half2_0_accum(int *accum, ushort2 a, half2 b) { }
+
+#pragma rs reduce(my_ushort2_half2_1) accumulator(my_ushort2_half2_1_accum) combiner(combiner)
+static void my_ushort2_half2_1_accum(int *accum, ushort2 a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_half4_0) accumulator(my_ushort2_half4_0_accum) combiner(combiner)
+static void my_ushort2_half4_0_accum(int *accum, ushort2 a, half4 b) { }
+
+#pragma rs reduce(my_ushort2_half4_1) accumulator(my_ushort2_half4_1_accum) combiner(combiner)
+static void my_ushort2_half4_1_accum(int *accum, ushort2 a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_float_0) accumulator(my_ushort2_float_0_accum) combiner(combiner)
+static void my_ushort2_float_0_accum(int *accum, ushort2 a, float b) { }
+
+#pragma rs reduce(my_ushort2_float_1) accumulator(my_ushort2_float_1_accum) combiner(combiner)
+static void my_ushort2_float_1_accum(int *accum, ushort2 a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_float2_0) accumulator(my_ushort2_float2_0_accum) combiner(combiner)
+static void my_ushort2_float2_0_accum(int *accum, ushort2 a, float2 b) { }
+
+#pragma rs reduce(my_ushort2_float2_1) accumulator(my_ushort2_float2_1_accum) combiner(combiner)
+static void my_ushort2_float2_1_accum(int *accum, ushort2 a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_float4_0) accumulator(my_ushort2_float4_0_accum) combiner(combiner)
+static void my_ushort2_float4_0_accum(int *accum, ushort2 a, float4 b) { }
+
+#pragma rs reduce(my_ushort2_float4_1) accumulator(my_ushort2_float4_1_accum) combiner(combiner)
+static void my_ushort2_float4_1_accum(int *accum, ushort2 a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_char_0) accumulator(my_ushort2_char_0_accum) combiner(combiner)
+static void my_ushort2_char_0_accum(int *accum, ushort2 a, char b) { }
+
+#pragma rs reduce(my_ushort2_char_1) accumulator(my_ushort2_char_1_accum) combiner(combiner)
+static void my_ushort2_char_1_accum(int *accum, ushort2 a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_char2_0) accumulator(my_ushort2_char2_0_accum) combiner(combiner)
+static void my_ushort2_char2_0_accum(int *accum, ushort2 a, char2 b) { }
+
+#pragma rs reduce(my_ushort2_char2_1) accumulator(my_ushort2_char2_1_accum) combiner(combiner)
+static void my_ushort2_char2_1_accum(int *accum, ushort2 a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_char4_0) accumulator(my_ushort2_char4_0_accum) combiner(combiner)
+static void my_ushort2_char4_0_accum(int *accum, ushort2 a, char4 b) { }
+
+#pragma rs reduce(my_ushort2_char4_1) accumulator(my_ushort2_char4_1_accum) combiner(combiner)
+static void my_ushort2_char4_1_accum(int *accum, ushort2 a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_short_0) accumulator(my_ushort2_short_0_accum) combiner(combiner)
+static void my_ushort2_short_0_accum(int *accum, ushort2 a, short b) { }
+
+#pragma rs reduce(my_ushort2_short_1) accumulator(my_ushort2_short_1_accum) combiner(combiner)
+static void my_ushort2_short_1_accum(int *accum, ushort2 a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_short2_0) accumulator(my_ushort2_short2_0_accum) combiner(combiner)
+static void my_ushort2_short2_0_accum(int *accum, ushort2 a, short2 b) { }
+
+#pragma rs reduce(my_ushort2_short2_1) accumulator(my_ushort2_short2_1_accum) combiner(combiner)
+static void my_ushort2_short2_1_accum(int *accum, ushort2 a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_short4_0) accumulator(my_ushort2_short4_0_accum) combiner(combiner)
+static void my_ushort2_short4_0_accum(int *accum, ushort2 a, short4 b) { }
+
+#pragma rs reduce(my_ushort2_short4_1) accumulator(my_ushort2_short4_1_accum) combiner(combiner)
+static void my_ushort2_short4_1_accum(int *accum, ushort2 a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_uchar_0) accumulator(my_ushort2_uchar_0_accum) combiner(combiner)
+static void my_ushort2_uchar_0_accum(int *accum, ushort2 a, uchar b) { }
+
+#pragma rs reduce(my_ushort2_uchar_1) accumulator(my_ushort2_uchar_1_accum) combiner(combiner)
+static void my_ushort2_uchar_1_accum(int *accum, ushort2 a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_uchar2_0) accumulator(my_ushort2_uchar2_0_accum) combiner(combiner)
+static void my_ushort2_uchar2_0_accum(int *accum, ushort2 a, uchar2 b) { }
+
+#pragma rs reduce(my_ushort2_uchar2_1) accumulator(my_ushort2_uchar2_1_accum) combiner(combiner)
+static void my_ushort2_uchar2_1_accum(int *accum, ushort2 a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_uchar4_0) accumulator(my_ushort2_uchar4_0_accum) combiner(combiner)
+static void my_ushort2_uchar4_0_accum(int *accum, ushort2 a, uchar4 b) { }
+
+#pragma rs reduce(my_ushort2_uchar4_1) accumulator(my_ushort2_uchar4_1_accum) combiner(combiner)
+static void my_ushort2_uchar4_1_accum(int *accum, ushort2 a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_ushort_0) accumulator(my_ushort2_ushort_0_accum) combiner(combiner)
+static void my_ushort2_ushort_0_accum(int *accum, ushort2 a, ushort b) { }
+
+#pragma rs reduce(my_ushort2_ushort_1) accumulator(my_ushort2_ushort_1_accum) combiner(combiner)
+static void my_ushort2_ushort_1_accum(int *accum, ushort2 a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_ushort2_0) accumulator(my_ushort2_ushort2_0_accum) combiner(combiner)
+static void my_ushort2_ushort2_0_accum(int *accum, ushort2 a, ushort2 b) { }
+
+#pragma rs reduce(my_ushort2_ushort2_1) accumulator(my_ushort2_ushort2_1_accum) combiner(combiner)
+static void my_ushort2_ushort2_1_accum(int *accum, ushort2 a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_ushort4_0) accumulator(my_ushort2_ushort4_0_accum) combiner(combiner)
+static void my_ushort2_ushort4_0_accum(int *accum, ushort2 a, ushort4 b) { }
+
+#pragma rs reduce(my_ushort2_ushort4_1) accumulator(my_ushort2_ushort4_1_accum) combiner(combiner)
+static void my_ushort2_ushort4_1_accum(int *accum, ushort2 a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_bool_0) accumulator(my_ushort2_bool_0_accum) combiner(combiner)
+static void my_ushort2_bool_0_accum(int *accum, ushort2 a, bool b) { }
+
+#pragma rs reduce(my_ushort2_bool_1) accumulator(my_ushort2_bool_1_accum) combiner(combiner)
+static void my_ushort2_bool_1_accum(int *accum, ushort2 a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_rs_matrix2x2_0) accumulator(my_ushort2_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_ushort2_rs_matrix2x2_0_accum(int *accum, ushort2 a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_ushort2_rs_matrix2x2_1) accumulator(my_ushort2_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_ushort2_rs_matrix2x2_1_accum(int *accum, ushort2 a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort2_MyStruct_0) accumulator(my_ushort2_MyStruct_0_accum) combiner(combiner)
+static void my_ushort2_MyStruct_0_accum(int *accum, ushort2 a, MyStruct b) { }
+
+#pragma rs reduce(my_ushort2_MyStruct_1) accumulator(my_ushort2_MyStruct_1_accum) combiner(combiner)
+static void my_ushort2_MyStruct_1_accum(int *accum, ushort2 a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_half_0) accumulator(my_ushort4_half_0_accum) combiner(combiner)
+static void my_ushort4_half_0_accum(int *accum, ushort4 a, half b) { }
+
+#pragma rs reduce(my_ushort4_half_1) accumulator(my_ushort4_half_1_accum) combiner(combiner)
+static void my_ushort4_half_1_accum(int *accum, ushort4 a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_half2_0) accumulator(my_ushort4_half2_0_accum) combiner(combiner)
+static void my_ushort4_half2_0_accum(int *accum, ushort4 a, half2 b) { }
+
+#pragma rs reduce(my_ushort4_half2_1) accumulator(my_ushort4_half2_1_accum) combiner(combiner)
+static void my_ushort4_half2_1_accum(int *accum, ushort4 a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_half4_0) accumulator(my_ushort4_half4_0_accum) combiner(combiner)
+static void my_ushort4_half4_0_accum(int *accum, ushort4 a, half4 b) { }
+
+#pragma rs reduce(my_ushort4_half4_1) accumulator(my_ushort4_half4_1_accum) combiner(combiner)
+static void my_ushort4_half4_1_accum(int *accum, ushort4 a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_float_0) accumulator(my_ushort4_float_0_accum) combiner(combiner)
+static void my_ushort4_float_0_accum(int *accum, ushort4 a, float b) { }
+
+#pragma rs reduce(my_ushort4_float_1) accumulator(my_ushort4_float_1_accum) combiner(combiner)
+static void my_ushort4_float_1_accum(int *accum, ushort4 a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_float2_0) accumulator(my_ushort4_float2_0_accum) combiner(combiner)
+static void my_ushort4_float2_0_accum(int *accum, ushort4 a, float2 b) { }
+
+#pragma rs reduce(my_ushort4_float2_1) accumulator(my_ushort4_float2_1_accum) combiner(combiner)
+static void my_ushort4_float2_1_accum(int *accum, ushort4 a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_float4_0) accumulator(my_ushort4_float4_0_accum) combiner(combiner)
+static void my_ushort4_float4_0_accum(int *accum, ushort4 a, float4 b) { }
+
+#pragma rs reduce(my_ushort4_float4_1) accumulator(my_ushort4_float4_1_accum) combiner(combiner)
+static void my_ushort4_float4_1_accum(int *accum, ushort4 a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_char_0) accumulator(my_ushort4_char_0_accum) combiner(combiner)
+static void my_ushort4_char_0_accum(int *accum, ushort4 a, char b) { }
+
+#pragma rs reduce(my_ushort4_char_1) accumulator(my_ushort4_char_1_accum) combiner(combiner)
+static void my_ushort4_char_1_accum(int *accum, ushort4 a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_char2_0) accumulator(my_ushort4_char2_0_accum) combiner(combiner)
+static void my_ushort4_char2_0_accum(int *accum, ushort4 a, char2 b) { }
+
+#pragma rs reduce(my_ushort4_char2_1) accumulator(my_ushort4_char2_1_accum) combiner(combiner)
+static void my_ushort4_char2_1_accum(int *accum, ushort4 a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_char4_0) accumulator(my_ushort4_char4_0_accum) combiner(combiner)
+static void my_ushort4_char4_0_accum(int *accum, ushort4 a, char4 b) { }
+
+#pragma rs reduce(my_ushort4_char4_1) accumulator(my_ushort4_char4_1_accum) combiner(combiner)
+static void my_ushort4_char4_1_accum(int *accum, ushort4 a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_short_0) accumulator(my_ushort4_short_0_accum) combiner(combiner)
+static void my_ushort4_short_0_accum(int *accum, ushort4 a, short b) { }
+
+#pragma rs reduce(my_ushort4_short_1) accumulator(my_ushort4_short_1_accum) combiner(combiner)
+static void my_ushort4_short_1_accum(int *accum, ushort4 a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_short2_0) accumulator(my_ushort4_short2_0_accum) combiner(combiner)
+static void my_ushort4_short2_0_accum(int *accum, ushort4 a, short2 b) { }
+
+#pragma rs reduce(my_ushort4_short2_1) accumulator(my_ushort4_short2_1_accum) combiner(combiner)
+static void my_ushort4_short2_1_accum(int *accum, ushort4 a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_short4_0) accumulator(my_ushort4_short4_0_accum) combiner(combiner)
+static void my_ushort4_short4_0_accum(int *accum, ushort4 a, short4 b) { }
+
+#pragma rs reduce(my_ushort4_short4_1) accumulator(my_ushort4_short4_1_accum) combiner(combiner)
+static void my_ushort4_short4_1_accum(int *accum, ushort4 a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_uchar_0) accumulator(my_ushort4_uchar_0_accum) combiner(combiner)
+static void my_ushort4_uchar_0_accum(int *accum, ushort4 a, uchar b) { }
+
+#pragma rs reduce(my_ushort4_uchar_1) accumulator(my_ushort4_uchar_1_accum) combiner(combiner)
+static void my_ushort4_uchar_1_accum(int *accum, ushort4 a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_uchar2_0) accumulator(my_ushort4_uchar2_0_accum) combiner(combiner)
+static void my_ushort4_uchar2_0_accum(int *accum, ushort4 a, uchar2 b) { }
+
+#pragma rs reduce(my_ushort4_uchar2_1) accumulator(my_ushort4_uchar2_1_accum) combiner(combiner)
+static void my_ushort4_uchar2_1_accum(int *accum, ushort4 a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_uchar4_0) accumulator(my_ushort4_uchar4_0_accum) combiner(combiner)
+static void my_ushort4_uchar4_0_accum(int *accum, ushort4 a, uchar4 b) { }
+
+#pragma rs reduce(my_ushort4_uchar4_1) accumulator(my_ushort4_uchar4_1_accum) combiner(combiner)
+static void my_ushort4_uchar4_1_accum(int *accum, ushort4 a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_ushort_0) accumulator(my_ushort4_ushort_0_accum) combiner(combiner)
+static void my_ushort4_ushort_0_accum(int *accum, ushort4 a, ushort b) { }
+
+#pragma rs reduce(my_ushort4_ushort_1) accumulator(my_ushort4_ushort_1_accum) combiner(combiner)
+static void my_ushort4_ushort_1_accum(int *accum, ushort4 a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_ushort2_0) accumulator(my_ushort4_ushort2_0_accum) combiner(combiner)
+static void my_ushort4_ushort2_0_accum(int *accum, ushort4 a, ushort2 b) { }
+
+#pragma rs reduce(my_ushort4_ushort2_1) accumulator(my_ushort4_ushort2_1_accum) combiner(combiner)
+static void my_ushort4_ushort2_1_accum(int *accum, ushort4 a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_ushort4_0) accumulator(my_ushort4_ushort4_0_accum) combiner(combiner)
+static void my_ushort4_ushort4_0_accum(int *accum, ushort4 a, ushort4 b) { }
+
+#pragma rs reduce(my_ushort4_ushort4_1) accumulator(my_ushort4_ushort4_1_accum) combiner(combiner)
+static void my_ushort4_ushort4_1_accum(int *accum, ushort4 a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_bool_0) accumulator(my_ushort4_bool_0_accum) combiner(combiner)
+static void my_ushort4_bool_0_accum(int *accum, ushort4 a, bool b) { }
+
+#pragma rs reduce(my_ushort4_bool_1) accumulator(my_ushort4_bool_1_accum) combiner(combiner)
+static void my_ushort4_bool_1_accum(int *accum, ushort4 a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_rs_matrix2x2_0) accumulator(my_ushort4_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_ushort4_rs_matrix2x2_0_accum(int *accum, ushort4 a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_ushort4_rs_matrix2x2_1) accumulator(my_ushort4_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_ushort4_rs_matrix2x2_1_accum(int *accum, ushort4 a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_ushort4_MyStruct_0) accumulator(my_ushort4_MyStruct_0_accum) combiner(combiner)
+static void my_ushort4_MyStruct_0_accum(int *accum, ushort4 a, MyStruct b) { }
+
+#pragma rs reduce(my_ushort4_MyStruct_1) accumulator(my_ushort4_MyStruct_1_accum) combiner(combiner)
+static void my_ushort4_MyStruct_1_accum(int *accum, ushort4 a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_half_0) accumulator(my_bool_half_0_accum) combiner(combiner)
+static void my_bool_half_0_accum(int *accum, bool a, half b) { }
+
+#pragma rs reduce(my_bool_half_1) accumulator(my_bool_half_1_accum) combiner(combiner)
+static void my_bool_half_1_accum(int *accum, bool a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_half2_0) accumulator(my_bool_half2_0_accum) combiner(combiner)
+static void my_bool_half2_0_accum(int *accum, bool a, half2 b) { }
+
+#pragma rs reduce(my_bool_half2_1) accumulator(my_bool_half2_1_accum) combiner(combiner)
+static void my_bool_half2_1_accum(int *accum, bool a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_half4_0) accumulator(my_bool_half4_0_accum) combiner(combiner)
+static void my_bool_half4_0_accum(int *accum, bool a, half4 b) { }
+
+#pragma rs reduce(my_bool_half4_1) accumulator(my_bool_half4_1_accum) combiner(combiner)
+static void my_bool_half4_1_accum(int *accum, bool a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_float_0) accumulator(my_bool_float_0_accum) combiner(combiner)
+static void my_bool_float_0_accum(int *accum, bool a, float b) { }
+
+#pragma rs reduce(my_bool_float_1) accumulator(my_bool_float_1_accum) combiner(combiner)
+static void my_bool_float_1_accum(int *accum, bool a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_float2_0) accumulator(my_bool_float2_0_accum) combiner(combiner)
+static void my_bool_float2_0_accum(int *accum, bool a, float2 b) { }
+
+#pragma rs reduce(my_bool_float2_1) accumulator(my_bool_float2_1_accum) combiner(combiner)
+static void my_bool_float2_1_accum(int *accum, bool a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_float4_0) accumulator(my_bool_float4_0_accum) combiner(combiner)
+static void my_bool_float4_0_accum(int *accum, bool a, float4 b) { }
+
+#pragma rs reduce(my_bool_float4_1) accumulator(my_bool_float4_1_accum) combiner(combiner)
+static void my_bool_float4_1_accum(int *accum, bool a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_char_0) accumulator(my_bool_char_0_accum) combiner(combiner)
+static void my_bool_char_0_accum(int *accum, bool a, char b) { }
+
+#pragma rs reduce(my_bool_char_1) accumulator(my_bool_char_1_accum) combiner(combiner)
+static void my_bool_char_1_accum(int *accum, bool a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_char2_0) accumulator(my_bool_char2_0_accum) combiner(combiner)
+static void my_bool_char2_0_accum(int *accum, bool a, char2 b) { }
+
+#pragma rs reduce(my_bool_char2_1) accumulator(my_bool_char2_1_accum) combiner(combiner)
+static void my_bool_char2_1_accum(int *accum, bool a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_char4_0) accumulator(my_bool_char4_0_accum) combiner(combiner)
+static void my_bool_char4_0_accum(int *accum, bool a, char4 b) { }
+
+#pragma rs reduce(my_bool_char4_1) accumulator(my_bool_char4_1_accum) combiner(combiner)
+static void my_bool_char4_1_accum(int *accum, bool a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_short_0) accumulator(my_bool_short_0_accum) combiner(combiner)
+static void my_bool_short_0_accum(int *accum, bool a, short b) { }
+
+#pragma rs reduce(my_bool_short_1) accumulator(my_bool_short_1_accum) combiner(combiner)
+static void my_bool_short_1_accum(int *accum, bool a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_short2_0) accumulator(my_bool_short2_0_accum) combiner(combiner)
+static void my_bool_short2_0_accum(int *accum, bool a, short2 b) { }
+
+#pragma rs reduce(my_bool_short2_1) accumulator(my_bool_short2_1_accum) combiner(combiner)
+static void my_bool_short2_1_accum(int *accum, bool a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_short4_0) accumulator(my_bool_short4_0_accum) combiner(combiner)
+static void my_bool_short4_0_accum(int *accum, bool a, short4 b) { }
+
+#pragma rs reduce(my_bool_short4_1) accumulator(my_bool_short4_1_accum) combiner(combiner)
+static void my_bool_short4_1_accum(int *accum, bool a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_uchar_0) accumulator(my_bool_uchar_0_accum) combiner(combiner)
+static void my_bool_uchar_0_accum(int *accum, bool a, uchar b) { }
+
+#pragma rs reduce(my_bool_uchar_1) accumulator(my_bool_uchar_1_accum) combiner(combiner)
+static void my_bool_uchar_1_accum(int *accum, bool a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_uchar2_0) accumulator(my_bool_uchar2_0_accum) combiner(combiner)
+static void my_bool_uchar2_0_accum(int *accum, bool a, uchar2 b) { }
+
+#pragma rs reduce(my_bool_uchar2_1) accumulator(my_bool_uchar2_1_accum) combiner(combiner)
+static void my_bool_uchar2_1_accum(int *accum, bool a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_uchar4_0) accumulator(my_bool_uchar4_0_accum) combiner(combiner)
+static void my_bool_uchar4_0_accum(int *accum, bool a, uchar4 b) { }
+
+#pragma rs reduce(my_bool_uchar4_1) accumulator(my_bool_uchar4_1_accum) combiner(combiner)
+static void my_bool_uchar4_1_accum(int *accum, bool a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_ushort_0) accumulator(my_bool_ushort_0_accum) combiner(combiner)
+static void my_bool_ushort_0_accum(int *accum, bool a, ushort b) { }
+
+#pragma rs reduce(my_bool_ushort_1) accumulator(my_bool_ushort_1_accum) combiner(combiner)
+static void my_bool_ushort_1_accum(int *accum, bool a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_ushort2_0) accumulator(my_bool_ushort2_0_accum) combiner(combiner)
+static void my_bool_ushort2_0_accum(int *accum, bool a, ushort2 b) { }
+
+#pragma rs reduce(my_bool_ushort2_1) accumulator(my_bool_ushort2_1_accum) combiner(combiner)
+static void my_bool_ushort2_1_accum(int *accum, bool a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_ushort4_0) accumulator(my_bool_ushort4_0_accum) combiner(combiner)
+static void my_bool_ushort4_0_accum(int *accum, bool a, ushort4 b) { }
+
+#pragma rs reduce(my_bool_ushort4_1) accumulator(my_bool_ushort4_1_accum) combiner(combiner)
+static void my_bool_ushort4_1_accum(int *accum, bool a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_bool_0) accumulator(my_bool_bool_0_accum) combiner(combiner)
+static void my_bool_bool_0_accum(int *accum, bool a, bool b) { }
+
+#pragma rs reduce(my_bool_bool_1) accumulator(my_bool_bool_1_accum) combiner(combiner)
+static void my_bool_bool_1_accum(int *accum, bool a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_rs_matrix2x2_0) accumulator(my_bool_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_bool_rs_matrix2x2_0_accum(int *accum, bool a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_bool_rs_matrix2x2_1) accumulator(my_bool_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_bool_rs_matrix2x2_1_accum(int *accum, bool a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_bool_MyStruct_0) accumulator(my_bool_MyStruct_0_accum) combiner(combiner)
+static void my_bool_MyStruct_0_accum(int *accum, bool a, MyStruct b) { }
+
+#pragma rs reduce(my_bool_MyStruct_1) accumulator(my_bool_MyStruct_1_accum) combiner(combiner)
+static void my_bool_MyStruct_1_accum(int *accum, bool a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_half_0) accumulator(my_rs_matrix2x2_half_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_half_0_accum(int *accum, rs_matrix2x2 a, half b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_half_1) accumulator(my_rs_matrix2x2_half_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_half_1_accum(int *accum, rs_matrix2x2 a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_half2_0) accumulator(my_rs_matrix2x2_half2_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_half2_0_accum(int *accum, rs_matrix2x2 a, half2 b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_half2_1) accumulator(my_rs_matrix2x2_half2_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_half2_1_accum(int *accum, rs_matrix2x2 a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_half4_0) accumulator(my_rs_matrix2x2_half4_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_half4_0_accum(int *accum, rs_matrix2x2 a, half4 b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_half4_1) accumulator(my_rs_matrix2x2_half4_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_half4_1_accum(int *accum, rs_matrix2x2 a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_float_0) accumulator(my_rs_matrix2x2_float_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_float_0_accum(int *accum, rs_matrix2x2 a, float b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_float_1) accumulator(my_rs_matrix2x2_float_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_float_1_accum(int *accum, rs_matrix2x2 a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_float2_0) accumulator(my_rs_matrix2x2_float2_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_float2_0_accum(int *accum, rs_matrix2x2 a, float2 b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_float2_1) accumulator(my_rs_matrix2x2_float2_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_float2_1_accum(int *accum, rs_matrix2x2 a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_float4_0) accumulator(my_rs_matrix2x2_float4_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_float4_0_accum(int *accum, rs_matrix2x2 a, float4 b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_float4_1) accumulator(my_rs_matrix2x2_float4_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_float4_1_accum(int *accum, rs_matrix2x2 a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_char_0) accumulator(my_rs_matrix2x2_char_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_char_0_accum(int *accum, rs_matrix2x2 a, char b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_char_1) accumulator(my_rs_matrix2x2_char_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_char_1_accum(int *accum, rs_matrix2x2 a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_char2_0) accumulator(my_rs_matrix2x2_char2_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_char2_0_accum(int *accum, rs_matrix2x2 a, char2 b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_char2_1) accumulator(my_rs_matrix2x2_char2_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_char2_1_accum(int *accum, rs_matrix2x2 a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_char4_0) accumulator(my_rs_matrix2x2_char4_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_char4_0_accum(int *accum, rs_matrix2x2 a, char4 b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_char4_1) accumulator(my_rs_matrix2x2_char4_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_char4_1_accum(int *accum, rs_matrix2x2 a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_short_0) accumulator(my_rs_matrix2x2_short_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_short_0_accum(int *accum, rs_matrix2x2 a, short b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_short_1) accumulator(my_rs_matrix2x2_short_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_short_1_accum(int *accum, rs_matrix2x2 a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_short2_0) accumulator(my_rs_matrix2x2_short2_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_short2_0_accum(int *accum, rs_matrix2x2 a, short2 b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_short2_1) accumulator(my_rs_matrix2x2_short2_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_short2_1_accum(int *accum, rs_matrix2x2 a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_short4_0) accumulator(my_rs_matrix2x2_short4_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_short4_0_accum(int *accum, rs_matrix2x2 a, short4 b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_short4_1) accumulator(my_rs_matrix2x2_short4_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_short4_1_accum(int *accum, rs_matrix2x2 a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_uchar_0) accumulator(my_rs_matrix2x2_uchar_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_uchar_0_accum(int *accum, rs_matrix2x2 a, uchar b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_uchar_1) accumulator(my_rs_matrix2x2_uchar_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_uchar_1_accum(int *accum, rs_matrix2x2 a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_uchar2_0) accumulator(my_rs_matrix2x2_uchar2_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_uchar2_0_accum(int *accum, rs_matrix2x2 a, uchar2 b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_uchar2_1) accumulator(my_rs_matrix2x2_uchar2_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_uchar2_1_accum(int *accum, rs_matrix2x2 a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_uchar4_0) accumulator(my_rs_matrix2x2_uchar4_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_uchar4_0_accum(int *accum, rs_matrix2x2 a, uchar4 b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_uchar4_1) accumulator(my_rs_matrix2x2_uchar4_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_uchar4_1_accum(int *accum, rs_matrix2x2 a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_ushort_0) accumulator(my_rs_matrix2x2_ushort_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_ushort_0_accum(int *accum, rs_matrix2x2 a, ushort b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_ushort_1) accumulator(my_rs_matrix2x2_ushort_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_ushort_1_accum(int *accum, rs_matrix2x2 a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_ushort2_0) accumulator(my_rs_matrix2x2_ushort2_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_ushort2_0_accum(int *accum, rs_matrix2x2 a, ushort2 b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_ushort2_1) accumulator(my_rs_matrix2x2_ushort2_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_ushort2_1_accum(int *accum, rs_matrix2x2 a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_ushort4_0) accumulator(my_rs_matrix2x2_ushort4_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_ushort4_0_accum(int *accum, rs_matrix2x2 a, ushort4 b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_ushort4_1) accumulator(my_rs_matrix2x2_ushort4_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_ushort4_1_accum(int *accum, rs_matrix2x2 a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_bool_0) accumulator(my_rs_matrix2x2_bool_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_bool_0_accum(int *accum, rs_matrix2x2 a, bool b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_bool_1) accumulator(my_rs_matrix2x2_bool_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_bool_1_accum(int *accum, rs_matrix2x2 a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_rs_matrix2x2_0) accumulator(my_rs_matrix2x2_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_rs_matrix2x2_0_accum(int *accum, rs_matrix2x2 a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_rs_matrix2x2_1) accumulator(my_rs_matrix2x2_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_rs_matrix2x2_1_accum(int *accum, rs_matrix2x2 a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_rs_matrix2x2_MyStruct_0) accumulator(my_rs_matrix2x2_MyStruct_0_accum) combiner(combiner)
+static void my_rs_matrix2x2_MyStruct_0_accum(int *accum, rs_matrix2x2 a, MyStruct b) { }
+
+#pragma rs reduce(my_rs_matrix2x2_MyStruct_1) accumulator(my_rs_matrix2x2_MyStruct_1_accum) combiner(combiner)
+static void my_rs_matrix2x2_MyStruct_1_accum(int *accum, rs_matrix2x2 a, MyStruct b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_half_0) accumulator(my_MyStruct_half_0_accum) combiner(combiner)
+static void my_MyStruct_half_0_accum(int *accum, MyStruct a, half b) { }
+
+#pragma rs reduce(my_MyStruct_half_1) accumulator(my_MyStruct_half_1_accum) combiner(combiner)
+static void my_MyStruct_half_1_accum(int *accum, MyStruct a, half b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_half2_0) accumulator(my_MyStruct_half2_0_accum) combiner(combiner)
+static void my_MyStruct_half2_0_accum(int *accum, MyStruct a, half2 b) { }
+
+#pragma rs reduce(my_MyStruct_half2_1) accumulator(my_MyStruct_half2_1_accum) combiner(combiner)
+static void my_MyStruct_half2_1_accum(int *accum, MyStruct a, half2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_half4_0) accumulator(my_MyStruct_half4_0_accum) combiner(combiner)
+static void my_MyStruct_half4_0_accum(int *accum, MyStruct a, half4 b) { }
+
+#pragma rs reduce(my_MyStruct_half4_1) accumulator(my_MyStruct_half4_1_accum) combiner(combiner)
+static void my_MyStruct_half4_1_accum(int *accum, MyStruct a, half4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_float_0) accumulator(my_MyStruct_float_0_accum) combiner(combiner)
+static void my_MyStruct_float_0_accum(int *accum, MyStruct a, float b) { }
+
+#pragma rs reduce(my_MyStruct_float_1) accumulator(my_MyStruct_float_1_accum) combiner(combiner)
+static void my_MyStruct_float_1_accum(int *accum, MyStruct a, float b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_float2_0) accumulator(my_MyStruct_float2_0_accum) combiner(combiner)
+static void my_MyStruct_float2_0_accum(int *accum, MyStruct a, float2 b) { }
+
+#pragma rs reduce(my_MyStruct_float2_1) accumulator(my_MyStruct_float2_1_accum) combiner(combiner)
+static void my_MyStruct_float2_1_accum(int *accum, MyStruct a, float2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_float4_0) accumulator(my_MyStruct_float4_0_accum) combiner(combiner)
+static void my_MyStruct_float4_0_accum(int *accum, MyStruct a, float4 b) { }
+
+#pragma rs reduce(my_MyStruct_float4_1) accumulator(my_MyStruct_float4_1_accum) combiner(combiner)
+static void my_MyStruct_float4_1_accum(int *accum, MyStruct a, float4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_char_0) accumulator(my_MyStruct_char_0_accum) combiner(combiner)
+static void my_MyStruct_char_0_accum(int *accum, MyStruct a, char b) { }
+
+#pragma rs reduce(my_MyStruct_char_1) accumulator(my_MyStruct_char_1_accum) combiner(combiner)
+static void my_MyStruct_char_1_accum(int *accum, MyStruct a, char b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_char2_0) accumulator(my_MyStruct_char2_0_accum) combiner(combiner)
+static void my_MyStruct_char2_0_accum(int *accum, MyStruct a, char2 b) { }
+
+#pragma rs reduce(my_MyStruct_char2_1) accumulator(my_MyStruct_char2_1_accum) combiner(combiner)
+static void my_MyStruct_char2_1_accum(int *accum, MyStruct a, char2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_char4_0) accumulator(my_MyStruct_char4_0_accum) combiner(combiner)
+static void my_MyStruct_char4_0_accum(int *accum, MyStruct a, char4 b) { }
+
+#pragma rs reduce(my_MyStruct_char4_1) accumulator(my_MyStruct_char4_1_accum) combiner(combiner)
+static void my_MyStruct_char4_1_accum(int *accum, MyStruct a, char4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_short_0) accumulator(my_MyStruct_short_0_accum) combiner(combiner)
+static void my_MyStruct_short_0_accum(int *accum, MyStruct a, short b) { }
+
+#pragma rs reduce(my_MyStruct_short_1) accumulator(my_MyStruct_short_1_accum) combiner(combiner)
+static void my_MyStruct_short_1_accum(int *accum, MyStruct a, short b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_short2_0) accumulator(my_MyStruct_short2_0_accum) combiner(combiner)
+static void my_MyStruct_short2_0_accum(int *accum, MyStruct a, short2 b) { }
+
+#pragma rs reduce(my_MyStruct_short2_1) accumulator(my_MyStruct_short2_1_accum) combiner(combiner)
+static void my_MyStruct_short2_1_accum(int *accum, MyStruct a, short2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_short4_0) accumulator(my_MyStruct_short4_0_accum) combiner(combiner)
+static void my_MyStruct_short4_0_accum(int *accum, MyStruct a, short4 b) { }
+
+#pragma rs reduce(my_MyStruct_short4_1) accumulator(my_MyStruct_short4_1_accum) combiner(combiner)
+static void my_MyStruct_short4_1_accum(int *accum, MyStruct a, short4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_uchar_0) accumulator(my_MyStruct_uchar_0_accum) combiner(combiner)
+static void my_MyStruct_uchar_0_accum(int *accum, MyStruct a, uchar b) { }
+
+#pragma rs reduce(my_MyStruct_uchar_1) accumulator(my_MyStruct_uchar_1_accum) combiner(combiner)
+static void my_MyStruct_uchar_1_accum(int *accum, MyStruct a, uchar b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_uchar2_0) accumulator(my_MyStruct_uchar2_0_accum) combiner(combiner)
+static void my_MyStruct_uchar2_0_accum(int *accum, MyStruct a, uchar2 b) { }
+
+#pragma rs reduce(my_MyStruct_uchar2_1) accumulator(my_MyStruct_uchar2_1_accum) combiner(combiner)
+static void my_MyStruct_uchar2_1_accum(int *accum, MyStruct a, uchar2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_uchar4_0) accumulator(my_MyStruct_uchar4_0_accum) combiner(combiner)
+static void my_MyStruct_uchar4_0_accum(int *accum, MyStruct a, uchar4 b) { }
+
+#pragma rs reduce(my_MyStruct_uchar4_1) accumulator(my_MyStruct_uchar4_1_accum) combiner(combiner)
+static void my_MyStruct_uchar4_1_accum(int *accum, MyStruct a, uchar4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_ushort_0) accumulator(my_MyStruct_ushort_0_accum) combiner(combiner)
+static void my_MyStruct_ushort_0_accum(int *accum, MyStruct a, ushort b) { }
+
+#pragma rs reduce(my_MyStruct_ushort_1) accumulator(my_MyStruct_ushort_1_accum) combiner(combiner)
+static void my_MyStruct_ushort_1_accum(int *accum, MyStruct a, ushort b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_ushort2_0) accumulator(my_MyStruct_ushort2_0_accum) combiner(combiner)
+static void my_MyStruct_ushort2_0_accum(int *accum, MyStruct a, ushort2 b) { }
+
+#pragma rs reduce(my_MyStruct_ushort2_1) accumulator(my_MyStruct_ushort2_1_accum) combiner(combiner)
+static void my_MyStruct_ushort2_1_accum(int *accum, MyStruct a, ushort2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_ushort4_0) accumulator(my_MyStruct_ushort4_0_accum) combiner(combiner)
+static void my_MyStruct_ushort4_0_accum(int *accum, MyStruct a, ushort4 b) { }
+
+#pragma rs reduce(my_MyStruct_ushort4_1) accumulator(my_MyStruct_ushort4_1_accum) combiner(combiner)
+static void my_MyStruct_ushort4_1_accum(int *accum, MyStruct a, ushort4 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_bool_0) accumulator(my_MyStruct_bool_0_accum) combiner(combiner)
+static void my_MyStruct_bool_0_accum(int *accum, MyStruct a, bool b) { }
+
+#pragma rs reduce(my_MyStruct_bool_1) accumulator(my_MyStruct_bool_1_accum) combiner(combiner)
+static void my_MyStruct_bool_1_accum(int *accum, MyStruct a, bool b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_rs_matrix2x2_0) accumulator(my_MyStruct_rs_matrix2x2_0_accum) combiner(combiner)
+static void my_MyStruct_rs_matrix2x2_0_accum(int *accum, MyStruct a, rs_matrix2x2 b) { }
+
+#pragma rs reduce(my_MyStruct_rs_matrix2x2_1) accumulator(my_MyStruct_rs_matrix2x2_1_accum) combiner(combiner)
+static void my_MyStruct_rs_matrix2x2_1_accum(int *accum, MyStruct a, rs_matrix2x2 b, rs_kernel_context context) { }
+
+#pragma rs reduce(my_MyStruct_MyStruct_0) accumulator(my_MyStruct_MyStruct_0_accum) combiner(combiner)
+static void my_MyStruct_MyStruct_0_accum(int *accum, MyStruct a, MyStruct b) { }
+
+#pragma rs reduce(my_MyStruct_MyStruct_1) accumulator(my_MyStruct_MyStruct_1_accum) combiner(combiner)
+static void my_MyStruct_MyStruct_1_accum(int *accum, MyStruct a, MyStruct b, rs_kernel_context context) { }
diff --git a/tests/P_reduce_general/stderr.txt.expect b/tests/P_reduce_general_inputs/stderr.txt.expect
similarity index 100%
copy from tests/P_reduce_general/stderr.txt.expect
copy to tests/P_reduce_general_inputs/stderr.txt.expect
diff --git a/tests/P_reduce_general/stdout.txt.expect b/tests/P_reduce_general_inputs/stdout.txt.expect
similarity index 100%
copy from tests/P_reduce_general/stdout.txt.expect
copy to tests/P_reduce_general_inputs/stdout.txt.expect
diff --git a/tests/P_reduce_general_result/gen-result.pl b/tests/P_reduce_general_result/gen-result.pl
new file mode 100755
index 0000000..417b6b8
--- /dev/null
+++ b/tests/P_reduce_general_result/gen-result.pl
@@ -0,0 +1,50 @@
+#!/usr/bin/perl -w
+
+# Generate trivial test cases to exercise result types.
+
+use strict;
+
+my @basicTypes = ("half", "float", "double",
+                  "char", "short", "int", "long",
+                  "uchar", "ushort", "uint", "ulong",
+                  "bool",
+                  "MyStruct");
+
+# 1 signifies non-vector
+# 3 is not supported for exported types
+my @vecLengths = (1, 2, 4);
+
+print "// -target-api 0 -Wall -Werror\n";
+print "#pragma version(1)\n";
+print "#pragma rs java_package_name(result)\n\n";
+print "// This test case was created by $0.\n";
+print "// It exercises all legal Java-reflectable result types, so that we can ensure\n";
+print "// (a) We do not choke when compiling them\n";
+print "// (b) We reflect them correctly\n\n";
+print "// One example struct type\n";
+print "typedef struct MyStruct { float f; double d; } MyStruct;\n";
+
+foreach my $basicType (@basicTypes) {
+  for (my $isArray = 0; $isArray <= 1; ++$isArray) {
+    foreach my $vecLen (@vecLengths) {
+
+      # There are no bool vectors or struct vectors
+      next if ($vecLen > 1) && (($basicType eq "bool") || ($basicType eq "MyStruct"));
+
+      # We do not support half vectors as reduction results
+      next if ($vecLen > 1) && ($basicType eq "half");
+
+      my $eltName = $basicType;
+      $eltName .= $vecLen if ($vecLen > 1);
+      my $resultName = ($isArray ? "array_${eltName}" : $eltName);
+      my $reduceName = "my_${resultName}";
+      my $accumName = "${reduceName}_accum";
+      my $combName = "${reduceName}_comb";
+      print "\n";
+      print "#pragma rs reduce(${reduceName}) accumulator(${accumName}) combiner(${combName})\n";
+      print "typedef ${eltName} ${resultName}[7];\n" if ($isArray);
+      print "static void ${accumName}(${resultName} *accum, ${eltName} val) { }\n";
+      print "static void ${combName}(${resultName} *accum, const ${resultName} *other) { }\n";
+    }
+  }
+}
diff --git a/tests/P_reduce_general_result/reduce_general_result.rs b/tests/P_reduce_general_result/reduce_general_result.rs
new file mode 100644
index 0000000..8f2c59a
--- /dev/null
+++ b/tests/P_reduce_general_result/reduce_general_result.rs
@@ -0,0 +1,308 @@
+// -target-api 0 -Wall -Werror
+#pragma version(1)
+#pragma rs java_package_name(result)
+
+// This test case was created by ./gen-result.pl.
+// It exercises all legal Java-reflectable result types, so that we can ensure
+// (a) We do not choke when compiling them
+// (b) We reflect them correctly
+
+// One example struct type
+typedef struct MyStruct { float f; double d; } MyStruct;
+
+#pragma rs reduce(my_half) accumulator(my_half_accum) combiner(my_half_comb)
+static void my_half_accum(half *accum, half val) { }
+static void my_half_comb(half *accum, const half *other) { }
+
+#pragma rs reduce(my_array_half) accumulator(my_array_half_accum) combiner(my_array_half_comb)
+typedef half array_half[7];
+static void my_array_half_accum(array_half *accum, half val) { }
+static void my_array_half_comb(array_half *accum, const array_half *other) { }
+
+#pragma rs reduce(my_float) accumulator(my_float_accum) combiner(my_float_comb)
+static void my_float_accum(float *accum, float val) { }
+static void my_float_comb(float *accum, const float *other) { }
+
+#pragma rs reduce(my_float2) accumulator(my_float2_accum) combiner(my_float2_comb)
+static void my_float2_accum(float2 *accum, float2 val) { }
+static void my_float2_comb(float2 *accum, const float2 *other) { }
+
+#pragma rs reduce(my_float4) accumulator(my_float4_accum) combiner(my_float4_comb)
+static void my_float4_accum(float4 *accum, float4 val) { }
+static void my_float4_comb(float4 *accum, const float4 *other) { }
+
+#pragma rs reduce(my_array_float) accumulator(my_array_float_accum) combiner(my_array_float_comb)
+typedef float array_float[7];
+static void my_array_float_accum(array_float *accum, float val) { }
+static void my_array_float_comb(array_float *accum, const array_float *other) { }
+
+#pragma rs reduce(my_array_float2) accumulator(my_array_float2_accum) combiner(my_array_float2_comb)
+typedef float2 array_float2[7];
+static void my_array_float2_accum(array_float2 *accum, float2 val) { }
+static void my_array_float2_comb(array_float2 *accum, const array_float2 *other) { }
+
+#pragma rs reduce(my_array_float4) accumulator(my_array_float4_accum) combiner(my_array_float4_comb)
+typedef float4 array_float4[7];
+static void my_array_float4_accum(array_float4 *accum, float4 val) { }
+static void my_array_float4_comb(array_float4 *accum, const array_float4 *other) { }
+
+#pragma rs reduce(my_double) accumulator(my_double_accum) combiner(my_double_comb)
+static void my_double_accum(double *accum, double val) { }
+static void my_double_comb(double *accum, const double *other) { }
+
+#pragma rs reduce(my_double2) accumulator(my_double2_accum) combiner(my_double2_comb)
+static void my_double2_accum(double2 *accum, double2 val) { }
+static void my_double2_comb(double2 *accum, const double2 *other) { }
+
+#pragma rs reduce(my_double4) accumulator(my_double4_accum) combiner(my_double4_comb)
+static void my_double4_accum(double4 *accum, double4 val) { }
+static void my_double4_comb(double4 *accum, const double4 *other) { }
+
+#pragma rs reduce(my_array_double) accumulator(my_array_double_accum) combiner(my_array_double_comb)
+typedef double array_double[7];
+static void my_array_double_accum(array_double *accum, double val) { }
+static void my_array_double_comb(array_double *accum, const array_double *other) { }
+
+#pragma rs reduce(my_array_double2) accumulator(my_array_double2_accum) combiner(my_array_double2_comb)
+typedef double2 array_double2[7];
+static void my_array_double2_accum(array_double2 *accum, double2 val) { }
+static void my_array_double2_comb(array_double2 *accum, const array_double2 *other) { }
+
+#pragma rs reduce(my_array_double4) accumulator(my_array_double4_accum) combiner(my_array_double4_comb)
+typedef double4 array_double4[7];
+static void my_array_double4_accum(array_double4 *accum, double4 val) { }
+static void my_array_double4_comb(array_double4 *accum, const array_double4 *other) { }
+
+#pragma rs reduce(my_char) accumulator(my_char_accum) combiner(my_char_comb)
+static void my_char_accum(char *accum, char val) { }
+static void my_char_comb(char *accum, const char *other) { }
+
+#pragma rs reduce(my_char2) accumulator(my_char2_accum) combiner(my_char2_comb)
+static void my_char2_accum(char2 *accum, char2 val) { }
+static void my_char2_comb(char2 *accum, const char2 *other) { }
+
+#pragma rs reduce(my_char4) accumulator(my_char4_accum) combiner(my_char4_comb)
+static void my_char4_accum(char4 *accum, char4 val) { }
+static void my_char4_comb(char4 *accum, const char4 *other) { }
+
+#pragma rs reduce(my_array_char) accumulator(my_array_char_accum) combiner(my_array_char_comb)
+typedef char array_char[7];
+static void my_array_char_accum(array_char *accum, char val) { }
+static void my_array_char_comb(array_char *accum, const array_char *other) { }
+
+#pragma rs reduce(my_array_char2) accumulator(my_array_char2_accum) combiner(my_array_char2_comb)
+typedef char2 array_char2[7];
+static void my_array_char2_accum(array_char2 *accum, char2 val) { }
+static void my_array_char2_comb(array_char2 *accum, const array_char2 *other) { }
+
+#pragma rs reduce(my_array_char4) accumulator(my_array_char4_accum) combiner(my_array_char4_comb)
+typedef char4 array_char4[7];
+static void my_array_char4_accum(array_char4 *accum, char4 val) { }
+static void my_array_char4_comb(array_char4 *accum, const array_char4 *other) { }
+
+#pragma rs reduce(my_short) accumulator(my_short_accum) combiner(my_short_comb)
+static void my_short_accum(short *accum, short val) { }
+static void my_short_comb(short *accum, const short *other) { }
+
+#pragma rs reduce(my_short2) accumulator(my_short2_accum) combiner(my_short2_comb)
+static void my_short2_accum(short2 *accum, short2 val) { }
+static void my_short2_comb(short2 *accum, const short2 *other) { }
+
+#pragma rs reduce(my_short4) accumulator(my_short4_accum) combiner(my_short4_comb)
+static void my_short4_accum(short4 *accum, short4 val) { }
+static void my_short4_comb(short4 *accum, const short4 *other) { }
+
+#pragma rs reduce(my_array_short) accumulator(my_array_short_accum) combiner(my_array_short_comb)
+typedef short array_short[7];
+static void my_array_short_accum(array_short *accum, short val) { }
+static void my_array_short_comb(array_short *accum, const array_short *other) { }
+
+#pragma rs reduce(my_array_short2) accumulator(my_array_short2_accum) combiner(my_array_short2_comb)
+typedef short2 array_short2[7];
+static void my_array_short2_accum(array_short2 *accum, short2 val) { }
+static void my_array_short2_comb(array_short2 *accum, const array_short2 *other) { }
+
+#pragma rs reduce(my_array_short4) accumulator(my_array_short4_accum) combiner(my_array_short4_comb)
+typedef short4 array_short4[7];
+static void my_array_short4_accum(array_short4 *accum, short4 val) { }
+static void my_array_short4_comb(array_short4 *accum, const array_short4 *other) { }
+
+#pragma rs reduce(my_int) accumulator(my_int_accum) combiner(my_int_comb)
+static void my_int_accum(int *accum, int val) { }
+static void my_int_comb(int *accum, const int *other) { }
+
+#pragma rs reduce(my_int2) accumulator(my_int2_accum) combiner(my_int2_comb)
+static void my_int2_accum(int2 *accum, int2 val) { }
+static void my_int2_comb(int2 *accum, const int2 *other) { }
+
+#pragma rs reduce(my_int4) accumulator(my_int4_accum) combiner(my_int4_comb)
+static void my_int4_accum(int4 *accum, int4 val) { }
+static void my_int4_comb(int4 *accum, const int4 *other) { }
+
+#pragma rs reduce(my_array_int) accumulator(my_array_int_accum) combiner(my_array_int_comb)
+typedef int array_int[7];
+static void my_array_int_accum(array_int *accum, int val) { }
+static void my_array_int_comb(array_int *accum, const array_int *other) { }
+
+#pragma rs reduce(my_array_int2) accumulator(my_array_int2_accum) combiner(my_array_int2_comb)
+typedef int2 array_int2[7];
+static void my_array_int2_accum(array_int2 *accum, int2 val) { }
+static void my_array_int2_comb(array_int2 *accum, const array_int2 *other) { }
+
+#pragma rs reduce(my_array_int4) accumulator(my_array_int4_accum) combiner(my_array_int4_comb)
+typedef int4 array_int4[7];
+static void my_array_int4_accum(array_int4 *accum, int4 val) { }
+static void my_array_int4_comb(array_int4 *accum, const array_int4 *other) { }
+
+#pragma rs reduce(my_long) accumulator(my_long_accum) combiner(my_long_comb)
+static void my_long_accum(long *accum, long val) { }
+static void my_long_comb(long *accum, const long *other) { }
+
+#pragma rs reduce(my_long2) accumulator(my_long2_accum) combiner(my_long2_comb)
+static void my_long2_accum(long2 *accum, long2 val) { }
+static void my_long2_comb(long2 *accum, const long2 *other) { }
+
+#pragma rs reduce(my_long4) accumulator(my_long4_accum) combiner(my_long4_comb)
+static void my_long4_accum(long4 *accum, long4 val) { }
+static void my_long4_comb(long4 *accum, const long4 *other) { }
+
+#pragma rs reduce(my_array_long) accumulator(my_array_long_accum) combiner(my_array_long_comb)
+typedef long array_long[7];
+static void my_array_long_accum(array_long *accum, long val) { }
+static void my_array_long_comb(array_long *accum, const array_long *other) { }
+
+#pragma rs reduce(my_array_long2) accumulator(my_array_long2_accum) combiner(my_array_long2_comb)
+typedef long2 array_long2[7];
+static void my_array_long2_accum(array_long2 *accum, long2 val) { }
+static void my_array_long2_comb(array_long2 *accum, const array_long2 *other) { }
+
+#pragma rs reduce(my_array_long4) accumulator(my_array_long4_accum) combiner(my_array_long4_comb)
+typedef long4 array_long4[7];
+static void my_array_long4_accum(array_long4 *accum, long4 val) { }
+static void my_array_long4_comb(array_long4 *accum, const array_long4 *other) { }
+
+#pragma rs reduce(my_uchar) accumulator(my_uchar_accum) combiner(my_uchar_comb)
+static void my_uchar_accum(uchar *accum, uchar val) { }
+static void my_uchar_comb(uchar *accum, const uchar *other) { }
+
+#pragma rs reduce(my_uchar2) accumulator(my_uchar2_accum) combiner(my_uchar2_comb)
+static void my_uchar2_accum(uchar2 *accum, uchar2 val) { }
+static void my_uchar2_comb(uchar2 *accum, const uchar2 *other) { }
+
+#pragma rs reduce(my_uchar4) accumulator(my_uchar4_accum) combiner(my_uchar4_comb)
+static void my_uchar4_accum(uchar4 *accum, uchar4 val) { }
+static void my_uchar4_comb(uchar4 *accum, const uchar4 *other) { }
+
+#pragma rs reduce(my_array_uchar) accumulator(my_array_uchar_accum) combiner(my_array_uchar_comb)
+typedef uchar array_uchar[7];
+static void my_array_uchar_accum(array_uchar *accum, uchar val) { }
+static void my_array_uchar_comb(array_uchar *accum, const array_uchar *other) { }
+
+#pragma rs reduce(my_array_uchar2) accumulator(my_array_uchar2_accum) combiner(my_array_uchar2_comb)
+typedef uchar2 array_uchar2[7];
+static void my_array_uchar2_accum(array_uchar2 *accum, uchar2 val) { }
+static void my_array_uchar2_comb(array_uchar2 *accum, const array_uchar2 *other) { }
+
+#pragma rs reduce(my_array_uchar4) accumulator(my_array_uchar4_accum) combiner(my_array_uchar4_comb)
+typedef uchar4 array_uchar4[7];
+static void my_array_uchar4_accum(array_uchar4 *accum, uchar4 val) { }
+static void my_array_uchar4_comb(array_uchar4 *accum, const array_uchar4 *other) { }
+
+#pragma rs reduce(my_ushort) accumulator(my_ushort_accum) combiner(my_ushort_comb)
+static void my_ushort_accum(ushort *accum, ushort val) { }
+static void my_ushort_comb(ushort *accum, const ushort *other) { }
+
+#pragma rs reduce(my_ushort2) accumulator(my_ushort2_accum) combiner(my_ushort2_comb)
+static void my_ushort2_accum(ushort2 *accum, ushort2 val) { }
+static void my_ushort2_comb(ushort2 *accum, const ushort2 *other) { }
+
+#pragma rs reduce(my_ushort4) accumulator(my_ushort4_accum) combiner(my_ushort4_comb)
+static void my_ushort4_accum(ushort4 *accum, ushort4 val) { }
+static void my_ushort4_comb(ushort4 *accum, const ushort4 *other) { }
+
+#pragma rs reduce(my_array_ushort) accumulator(my_array_ushort_accum) combiner(my_array_ushort_comb)
+typedef ushort array_ushort[7];
+static void my_array_ushort_accum(array_ushort *accum, ushort val) { }
+static void my_array_ushort_comb(array_ushort *accum, const array_ushort *other) { }
+
+#pragma rs reduce(my_array_ushort2) accumulator(my_array_ushort2_accum) combiner(my_array_ushort2_comb)
+typedef ushort2 array_ushort2[7];
+static void my_array_ushort2_accum(array_ushort2 *accum, ushort2 val) { }
+static void my_array_ushort2_comb(array_ushort2 *accum, const array_ushort2 *other) { }
+
+#pragma rs reduce(my_array_ushort4) accumulator(my_array_ushort4_accum) combiner(my_array_ushort4_comb)
+typedef ushort4 array_ushort4[7];
+static void my_array_ushort4_accum(array_ushort4 *accum, ushort4 val) { }
+static void my_array_ushort4_comb(array_ushort4 *accum, const array_ushort4 *other) { }
+
+#pragma rs reduce(my_uint) accumulator(my_uint_accum) combiner(my_uint_comb)
+static void my_uint_accum(uint *accum, uint val) { }
+static void my_uint_comb(uint *accum, const uint *other) { }
+
+#pragma rs reduce(my_uint2) accumulator(my_uint2_accum) combiner(my_uint2_comb)
+static void my_uint2_accum(uint2 *accum, uint2 val) { }
+static void my_uint2_comb(uint2 *accum, const uint2 *other) { }
+
+#pragma rs reduce(my_uint4) accumulator(my_uint4_accum) combiner(my_uint4_comb)
+static void my_uint4_accum(uint4 *accum, uint4 val) { }
+static void my_uint4_comb(uint4 *accum, const uint4 *other) { }
+
+#pragma rs reduce(my_array_uint) accumulator(my_array_uint_accum) combiner(my_array_uint_comb)
+typedef uint array_uint[7];
+static void my_array_uint_accum(array_uint *accum, uint val) { }
+static void my_array_uint_comb(array_uint *accum, const array_uint *other) { }
+
+#pragma rs reduce(my_array_uint2) accumulator(my_array_uint2_accum) combiner(my_array_uint2_comb)
+typedef uint2 array_uint2[7];
+static void my_array_uint2_accum(array_uint2 *accum, uint2 val) { }
+static void my_array_uint2_comb(array_uint2 *accum, const array_uint2 *other) { }
+
+#pragma rs reduce(my_array_uint4) accumulator(my_array_uint4_accum) combiner(my_array_uint4_comb)
+typedef uint4 array_uint4[7];
+static void my_array_uint4_accum(array_uint4 *accum, uint4 val) { }
+static void my_array_uint4_comb(array_uint4 *accum, const array_uint4 *other) { }
+
+#pragma rs reduce(my_ulong) accumulator(my_ulong_accum) combiner(my_ulong_comb)
+static void my_ulong_accum(ulong *accum, ulong val) { }
+static void my_ulong_comb(ulong *accum, const ulong *other) { }
+
+#pragma rs reduce(my_ulong2) accumulator(my_ulong2_accum) combiner(my_ulong2_comb)
+static void my_ulong2_accum(ulong2 *accum, ulong2 val) { }
+static void my_ulong2_comb(ulong2 *accum, const ulong2 *other) { }
+
+#pragma rs reduce(my_ulong4) accumulator(my_ulong4_accum) combiner(my_ulong4_comb)
+static void my_ulong4_accum(ulong4 *accum, ulong4 val) { }
+static void my_ulong4_comb(ulong4 *accum, const ulong4 *other) { }
+
+#pragma rs reduce(my_array_ulong) accumulator(my_array_ulong_accum) combiner(my_array_ulong_comb)
+typedef ulong array_ulong[7];
+static void my_array_ulong_accum(array_ulong *accum, ulong val) { }
+static void my_array_ulong_comb(array_ulong *accum, const array_ulong *other) { }
+
+#pragma rs reduce(my_array_ulong2) accumulator(my_array_ulong2_accum) combiner(my_array_ulong2_comb)
+typedef ulong2 array_ulong2[7];
+static void my_array_ulong2_accum(array_ulong2 *accum, ulong2 val) { }
+static void my_array_ulong2_comb(array_ulong2 *accum, const array_ulong2 *other) { }
+
+#pragma rs reduce(my_array_ulong4) accumulator(my_array_ulong4_accum) combiner(my_array_ulong4_comb)
+typedef ulong4 array_ulong4[7];
+static void my_array_ulong4_accum(array_ulong4 *accum, ulong4 val) { }
+static void my_array_ulong4_comb(array_ulong4 *accum, const array_ulong4 *other) { }
+
+#pragma rs reduce(my_bool) accumulator(my_bool_accum) combiner(my_bool_comb)
+static void my_bool_accum(bool *accum, bool val) { }
+static void my_bool_comb(bool *accum, const bool *other) { }
+
+#pragma rs reduce(my_array_bool) accumulator(my_array_bool_accum) combiner(my_array_bool_comb)
+typedef bool array_bool[7];
+static void my_array_bool_accum(array_bool *accum, bool val) { }
+static void my_array_bool_comb(array_bool *accum, const array_bool *other) { }
+
+#pragma rs reduce(my_MyStruct) accumulator(my_MyStruct_accum) combiner(my_MyStruct_comb)
+static void my_MyStruct_accum(MyStruct *accum, MyStruct val) { }
+static void my_MyStruct_comb(MyStruct *accum, const MyStruct *other) { }
+
+#pragma rs reduce(my_array_MyStruct) accumulator(my_array_MyStruct_accum) combiner(my_array_MyStruct_comb)
+typedef MyStruct array_MyStruct[7];
+static void my_array_MyStruct_accum(array_MyStruct *accum, MyStruct val) { }
+static void my_array_MyStruct_comb(array_MyStruct *accum, const array_MyStruct *other) { }
diff --git a/tests/P_reduce_general/stderr.txt.expect b/tests/P_reduce_general_result/stderr.txt.expect
similarity index 100%
copy from tests/P_reduce_general/stderr.txt.expect
copy to tests/P_reduce_general_result/stderr.txt.expect
diff --git a/tests/P_reduce_general/stdout.txt.expect b/tests/P_reduce_general_result/stdout.txt.expect
similarity index 100%
copy from tests/P_reduce_general/stdout.txt.expect
copy to tests/P_reduce_general_result/stdout.txt.expect