Add semantic analysis of "#pragma rs reduce" script functions.
Also:
- Make initializer() optional.
- Swap initializer and accumulator in metadata.
- Expose new slang::HasRSObjectType() interface from reference counting engine.
Bug: 23535724
Change-Id: If042e227a1af87c231c867ef20ed4c2082bb1871
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
