3d segmantation

sparseconvnet/SCN/generic/Geometry/FullConvolutionRules.h

+// Copyright 2016-present, Facebook, Inc.
+// All rights reserved.
+//
+// This source code is licensed under the license found in the
+// LICENSE file in the root directory of this source tree.
+
+#ifndef FULLDECONVOLUTIONRULES_H
+#define FULLDECONVOLUTIONRULES_H
+#include "RectangularRegions.h"
+
+template <uInt dimension>
+void FullConvolution_InputSgToRulesAndOutputSg(
+    SparseGrid<dimension> &inputGrid, SparseGrid<dimension> &outputGrid,
+    RuleBook &rules, long *size, long *stride, long *inputSpatialSize,
+    long *outputSpatialSize) {
+  rules.resize(volume<dimension>(size));
+
+  // Swap Input.. and OutputRegionCalculator v.s. a normal Convolution
+  for (auto const &inIter : inputGrid.mp) {
+    auto outRegion =
+        InputRegionCalculator<dimension>(inIter.first, size, stride);
+    for (auto j : outRegion) {
+      auto inRegion =
+          OutputRegionCalculator<dimension>(j, size, stride, outputSpatialSize);
+      uInt rulesOffset = outRegion.offset(j);
+      auto outIter = outputGrid.mp.find(j);
+      if (outIter == outputGrid.mp.end()) {
+        outIter =
+            outputGrid.mp.insert(std::make_pair(j, outputGrid.ctr++)).first;
+      }
+      rules[rulesOffset].push_back(inIter.second + inputGrid.ctr);
+      rules[rulesOffset].push_back(outIter->second);
+    }
+  }
+}
+
+template <uInt dimension>
+uInt FullConvolution_InputSgsToRulesAndOutputSgs(
+    SparseGrids<dimension> &input_SGs, SparseGrids<dimension> &output_SGs,
+    RuleBook &rules, long *filterSize, long *filterStride,
+    long *input_spatialSize, long *output_spatialSize) {
+  rules.clear();
+  output_SGs.clear();
+  uInt batchSize = input_SGs.size();
+  output_SGs.resize(batchSize);
+  uInt output_nActive = 0;
+  for (uInt i = 0; i < batchSize; i++) {
+    auto &iSG = input_SGs[i];
+    auto &oSG = output_SGs[i];
+    oSG.ctr = output_nActive;
+    FullConvolution_InputSgToRulesAndOutputSg<dimension>(
+        iSG, oSG, rules, filterSize, filterStride, input_spatialSize,
+        output_spatialSize);
+    output_nActive = oSG.ctr;
+    oSG.ctr = 0;
+  }
+  return output_nActive;
+}
+
+template <uInt dimension>
+uInt FullConvolution_InputSgsToRulesAndOutputSgs_OMP(
+    SparseGrids<dimension> &input_SGs, SparseGrids<dimension> &output_SGs,
+    RuleBook &rules, long *filterSize, long *filterStride,
+    long *input_spatialSize, long *output_spatialSize) {
+  rules.clear();
+  rules.resize(volume<dimension>(filterSize));
+  output_SGs.clear();
+  uInt batchSize = input_SGs.size();
+  output_SGs.resize(batchSize);
+  std::vector<RuleBook> rbs(batchSize);
+  {
+    uInt i;
+#pragma omp parallel for private(i)
+    for (i = 0; i < batchSize; i++)
+      FullConvolution_InputSgToRulesAndOutputSg<dimension>(
+          input_SGs[i], output_SGs[i], rbs[i], filterSize, filterStride,
+          input_spatialSize, output_spatialSize);
+  }
+  uInt output_nActive = 0;
+  for (uInt i = 0; i < batchSize; i++) {
+    // Parallel assignment:
+    // output_nActive     <-  output_nActive+output_SGs[i].ctr
+    // output_SGs[i].ctr  <-  output_nActive
+    uInt tmp = output_nActive;
+    output_nActive += output_SGs[i].ctr;
+    output_SGs[i].ctr = tmp;
+  }
+  {
+    uInt i;
+#pragma omp parallel for private(i)
+    for (i = 0; i < rules.size(); i++) {
+      auto &R = rules[i];
+      for (uInt j = 0; j < batchSize; j++) {
+        auto &r = rbs[j][i];
+        auto offset = output_SGs[j].ctr;
+        for (uInt k = 0; k < r.size();) {
+          R.push_back(r[k++]);
+          R.push_back(r[k++] + offset);
+        }
+      }
+    }
+  }
+  return output_nActive;
+}
+#endif /* FULLDECONVOLUTIONRULES_H */

PyTorch/sparseconvnet/SCN/generic/Geometry/InputLayerRules.h → sparseconvnet/SCN/generic/Geometry/IOLayersRules.h

@@ -8,7 +8,14 @@
 #define INPUTLAYER_H
 #include "../SparseConvNet.h"
 
-// mode 1==overwrite, 2=keep, 3=sum, 4=mean
+// Rulebook Format
+// rules[0][0] == mode
+// rules[0][1] == maxActive per spatial location (==1 for modes 0,1,2)
+// rules[0][2] == nInputRows
+// rules[0][3] == nOutputRows
+// rules[1]   nOutputRows x (1+maxActive)
+
+// mode 0==guaranteed unique 1==overwrite, 2=keep, 3=sum, 4=mean
 template <uInt dimension>
 void inputLayerRules(SparseGrids<dimension> &SGs, RuleBook &rules, long *coords,
                      uInt nInputRows, uInt nInputColumns, uInt batchSize,
@@ -18,6 +25,39 @@ void inputLayerRules(SparseGrids<dimension> &SGs, RuleBook &rules, long *coords,
   assert(SGs.size() == 0);
   SGs.resize(batchSize); // Set a minimum batch size if necessary
   Point<dimension> p;
+
+  if (mode == 0) {
+    nActive = nInputRows;
+    rules.resize(1);
+    rules[0].push_back(mode);
+    rules[0].push_back(1);
+    rules[0].push_back(nInputRows);
+    rules[0].push_back(nInputRows);
+
+    if (nInputColumns == dimension) {
+      SGs.resize(1);
+      auto &sg = SGs[0];
+      for (int i = 0; i < nInputRows; ++i) {
+        for (int j = 0; j < dimension; j++)
+          p[j] = coords[j];
+        coords += dimension;
+        sg.mp[p] = i;
+      }
+    } else { // nInputColumns == dimension + 1
+      uInt idx;
+      for (int i = 0; i < nInputRows; ++i) {
+        for (int j = 0; j < dimension; j++)
+          p[j] = coords[j];
+        idx = coords[dimension];
+        coords += dimension + 1;
+        if (idx + 1 >= SGs.size())
+          SGs.resize(idx + 1);
+        SGs[idx].mp[p] = i;
+      }
+    }
+    return;
+  }
+
   // Compile list of how input rows correspond to output rows
   std::vector<std::vector<uInt>> outputRows;
   if (nInputColumns == dimension) {
@@ -85,6 +125,16 @@ void inputLayerRules(SparseGrids<dimension> &SGs, RuleBook &rules, long *coords,
   }
 }
 
+
+
+// Rulebook Format
+// rules[0][0] == mode
+// rules[0][1] == maxActive per spatial location (==1 for modes 0,1,2)
+// rules[0][2] == batchSize
+// rules[0][3] == length
+// rules[0][4] == nOutputRows
+// rules[1]   nOutputRows x (1+maxActive)
+
 // bl is a batchSize x length x dimension long array of coordinates
 // mode 0==guaranteed unique and all present; 1==overwrite, 2=keep, 3=sum,
 // 4=mean

PyTorch/sparseconvnet/SCN/generic/Geometry/Metadata.cpp → sparseconvnet/SCN/generic/Geometry/Metadata.cpp

@@ -166,6 +166,16 @@ extern "C" void
   }
 }
 
+extern "C" void scn_D_(sparsifyMetadata)(void **mIn, void **mOut,
+                                         THLongTensor *spatialSize,
+                                         THByteTensor *filter,
+                                         THLongTensor *cuSum) {
+  SCN_INITIALIZE_AND_REFERENCE(Metadata<Dimension>, mIn)
+  SCN_INITIALIZE_AND_REFERENCE(Metadata<Dimension>, mOut)
+  _mOut.clear();
+  getSparsifiedMetadata(_mIn, _mOut, spatialSize, filter, cuSum);
+}
+
 // tensor is size[0] x .. x size[Dimension-1] x size[Dimension]
 // size[0] x .. x size[Dimension-1] == spatial volume
 // size[Dimension] == #feature planes

PyTorch/sparseconvnet/SCN/generic/Geometry/Metadata.h → sparseconvnet/SCN/generic/Geometry/Metadata.h

@@ -10,7 +10,9 @@
 #include "../SparseConvNet.h"
 #include "ActivePoolingRules.h"
 #include "ConvolutionRules.h"
-#include "InputLayerRules.h"
+#include "IOLayersRules.h"
+#include "FullConvolutionRules.h"
+#include "RandomizedStrideRules.h"
 #include "SubmanifoldConvolutionRules.h"
 #include <tuple>
 #include <unordered_map>
@@ -36,6 +38,9 @@ public:
   std::unordered_map<Point<3 * dimension>, RuleBook,
                      IntArrayHash<3 * dimension>> ruleBooks;
 
+  std::unordered_map<Point<3 * dimension>, RuleBook,
+                     IntArrayHash<3 * dimension>> fullConvolutionRuleBooks;
+
   std::unordered_map<Point<dimension>, RuleBook, IntArrayHash<dimension>>
       sparseToDenseRuleBooks;
 
@@ -43,14 +48,18 @@ public:
   SparseGrids<dimension> *inputSGs;
   SparseGrid<dimension> *inputSG;
   uInt *inputNActive;
+  std::default_random_engine re;
 
-  Metadata() {}
+  Metadata() :
+  re(std::chrono::system_clock::now().time_since_epoch().count()) {}
   void clear() {
     nActive.clear();
     grids.clear();
     activePoolingRuleBooks.clear();
+    inputLayerRuleBook.clear();
     validRuleBooks.clear();
     ruleBooks.clear();
+    fullConvolutionRuleBooks.clear();
     sparseToDenseRuleBooks.clear();
     inputSGs = nullptr;
     inputSG = nullptr;
@@ -153,6 +162,91 @@ public:
     }
     return rb;
   }
+  RuleBook &getFullConvolutionRuleBook(THLongTensor *inputSpatialSize,
+                                       THLongTensor *outputSpatialSize,
+                                       THLongTensor *size, THLongTensor *stride,
+                                       Metadata<dimension> &newM) {
+    auto p = ThreeLongTensorsToPoint<dimension>(inputSpatialSize, size, stride);
+    auto &rb = fullConvolutionRuleBooks[p];
+    if (rb.empty()) {
+      newM.clear();
+      auto iS = LongTensorToPoint<dimension>(inputSpatialSize);
+      auto oS = LongTensorToPoint<dimension>(outputSpatialSize);
+      newM.grids[iS] = grids[iS]; // copy
+      newM.nActive[iS] = nActive[iS];
+      auto &iSGs = newM.grids[iS];
+      auto &oSGs = newM.grids[oS];
+      newM.nActive[oS] = FullConvolution_InputSgsToRulesAndOutputSgs_OMP(
+          iSGs, oSGs, rb, THLongTensor_data(size), THLongTensor_data(stride),
+          THLongTensor_data(inputSpatialSize),
+          THLongTensor_data(outputSpatialSize));
+    }
+    return rb;
+  }
+
+  RuleBook &getRandomizedStrideRuleBook(THLongTensor *inputSpatialSize,
+                                        THLongTensor *outputSpatialSize,
+                                        THLongTensor *size, THLongTensor *stride, bool openMP) {
+    auto p = ThreeLongTensorsToPoint<dimension>(inputSpatialSize, size, stride);
+    auto &rb = ruleBooks[p];
+    if (rb.empty()) {
+      auto iS = LongTensorToPoint<dimension>(inputSpatialSize);
+      auto oS = LongTensorToPoint<dimension>(outputSpatialSize);
+      auto &iSGs = grids[iS];
+      auto &oSGs = grids[oS];
+      nActive[oS] =
+#if defined(ENABLE_OPENMP)
+          openMP ? //Convolution_InputSgsToRulesAndOutputSgs_OMP
+          RSR_InputSgsToRulesAndOutputSgs_OMP
+          (
+                       iSGs, oSGs, rb,
+                        THLongTensor_data(size),
+                        THLongTensor_data(stride),
+                        THLongTensor_data(inputSpatialSize),
+                        THLongTensor_data(outputSpatialSize), re
+                     )
+                 :
+#endif
+                 RSR_InputSgsToRulesAndOutputSgs(
+                     iSGs, oSGs, rb,
+                     THLongTensor_data(size),
+                     THLongTensor_data(stride),
+                     THLongTensor_data(inputSpatialSize),
+                     THLongTensor_data(outputSpatialSize),
+                     re);
+    }
+    return rb;
+  }
 };
 
+template <uInt dimension>
+void getSparsifiedMetadata(Metadata<dimension> &mIn, Metadata<dimension> &mOut,
+                           THLongTensor *spatialSize, THByteTensor *filter,
+                           THLongTensor *cuSum) {
+  // Create a new SparseGrids with fewer entries.
+  auto p = LongTensorToPoint<dimension>(spatialSize);
+  auto &sgsIn = mIn.grids[p];
+  auto &sgsOut = mOut.grids[p];
+  sgsOut.resize(sgsIn.size());
+  if (filter->nDimension == 1) {
+    auto f = THByteTensor_data(filter);
+    auto cs = THLongTensor_data(cuSum);
+    auto nActive = cs[THLongTensor_nElement(cuSum) - 1];
+    mOut.nActive[p] = nActive;
+    uInt sample;
+#pragma omp parallel for private(sample)
+    for (sample = 0; sample < sgsIn.size(); ++sample) {
+      auto &sgIn = sgsIn[sample];
+      auto &sgOut = sgsOut[sample];
+      for (auto const &iter : sgIn.mp) {
+        auto n = iter.second + sgIn.ctr;
+        if (f[n])
+          sgOut.mp[iter.first] = cs[n] - 1;
+      }
+    }
+  } else {
+    mOut.nActive[p] = 0;
+  }
+}
+
 #endif

sparseconvnet/SCN/generic/Geometry/RandomizedStrideRules.h

+// Copyright 2016-present, Facebook, Inc.
+// All rights reserved.
+//
+// This source code is licensed under the license found in the
+// LICENSE file in the root directory of this source tree.
+
+#ifndef RSRRULES_H
+#define RSRRULES_H
+#include "RectangularRegions.h"
+#include <cstring>
+
+class RSRTicks {
+public:
+  std::vector<uInt> inputL;
+  std::vector<uInt> inputR;
+  std::vector<uInt> outputL;
+  std::vector<uInt> outputR;
+  RSRTicks(uInt input_spatialSize, uInt output_spatialSize, uInt size, uInt stride, std::default_random_engine re) {
+    std::vector<uInt> steps;
+    //steps.resize(output_spatialSize/3,stride-1);
+    //steps.resize(output_spatialSize/3*2,stride+1);
+    steps.resize(output_spatialSize-1,stride);
+    std::shuffle(steps.begin(), steps.end(), re);
+    inputL.push_back(0);
+    inputR.push_back(size-1);
+    for (auto step : steps) {
+      inputL.push_back(inputL.back()+step);
+      inputR.push_back(inputR.back()+step);
+    }
+    assert(inputR.back() == input_spatialSize - 1);
+    outputL.resize(input_spatialSize, output_spatialSize);
+    outputR.resize(input_spatialSize, 0);
+    for (uInt i = 0; i < output_spatialSize; i++) {
+      for (uInt j = inputL[i]; j <= inputR[i]; j++) {
+        outputL[j] = std::min(outputL[j], i);
+        outputR[j] = std::max(outputR[j], i);
+      }
+    }
+  }
+};
+
+typedef std::vector<RSRTicks> RSRTicksV;
+
+RSRTicksV RSRRegions(long *input_spatialSize, long *output_spatialSize,
+                       uInt dimension, long *size, long *stride, std::default_random_engine re) {
+  RSRTicksV t;
+  for (uInt i = 0; i < dimension; i++)
+    t.emplace_back(RSRTicks(input_spatialSize[i], output_spatialSize[i],
+                              size[i], stride[i], re));
+  return t;
+}
+
+template <uInt dimension>
+RectangularRegion<dimension>
+RSRInputRegionCalculator(const Point<dimension> &output, RSRTicksV &t) {
+  Point<dimension> lb, ub;
+  for (uInt i = 0; i < dimension; i++) {
+    lb[i] = t[i].inputL[output[i]];
+    ub[i] = t[i].inputR[output[i]];
+  }
+  return RectangularRegion<dimension>(lb, ub);
+}
+template <uInt dimension>
+RectangularRegion<dimension>
+RSROutputRegionCalculator(const Point<dimension> &input, RSRTicksV &t) {
+  Point<dimension> lb, ub;
+  for (uInt i = 0; i < dimension; i++) {
+    lb[i] = t[i].outputL[input[i]];
+    ub[i] = t[i].outputR[input[i]];
+  }
+  return RectangularRegion<dimension>(lb, ub);
+}
+
+template <uInt dimension>
+void RSR_InputSgToRulesAndOutputSg(SparseGrid<dimension> &inputGrid,
+                                   SparseGrid<dimension> &outputGrid,
+                                   RuleBook &rules, RSRTicksV &t, long *size, long *stride) {
+  rules.resize(volume<dimension>(size));
+
+  for (auto const &inIter : inputGrid.mp) {
+    for (auto j : RSROutputRegionCalculator<dimension>(inIter.first, t)) {
+      auto inRegion = RSRInputRegionCalculator<dimension>(j, t);
+      uInt rulesOffset = inRegion.offset(inIter.first);
+      auto outIter = outputGrid.mp.find(j);
+      if (outIter == outputGrid.mp.end()) {
+        outIter =
+            outputGrid.mp.insert(std::make_pair(j, outputGrid.ctr++)).first;
+      }
+      assert(inIter.second<1e6);
+      assert(outIter->second<1e6);
+      rules[rulesOffset].push_back(inIter.second + inputGrid.ctr);
+      rules[rulesOffset].push_back(outIter->second);
+    }
+  }
+}
+
+template <uInt dimension>
+uInt RSR_InputSgsToRulesAndOutputSgs(SparseGrids<dimension> &input_SGs,
+                                     SparseGrids<dimension> &output_SGs,
+                                     RuleBook &rules, long *size,long *stride,
+                                     long *input_spatialSize,
+                                     long *output_spatialSize,
+                                     std::default_random_engine re) {
+  auto t = RSRRegions(input_spatialSize, output_spatialSize, dimension,
+                        size, stride, re);
+
+  rules.clear();
+  output_SGs.clear();
+  uInt batchSize = input_SGs.size();
+  output_SGs.resize(batchSize);
+  uInt output_nActive = 0;
+  for (uInt i = 0; i < batchSize; i++) {
+    auto &iSG = input_SGs[i];
+    auto &oSG = output_SGs[i];
+    oSG.ctr = output_nActive;
+    RSR_InputSgToRulesAndOutputSg<dimension>(iSG, oSG, rules, t, size, stride);
+    output_nActive = oSG.ctr;
+    oSG.ctr = 0;
+  }
+  return output_nActive;
+}
+
+template <uInt dimension>
+uInt RSR_InputSgsToRulesAndOutputSgs_OMP(SparseGrids<dimension> &input_SGs,
+                                         SparseGrids<dimension> &output_SGs,
+                                         RuleBook &rules,
+                                         long *size, long *stride,
+                                         long *input_spatialSize,
+                                         long *output_spatialSize,
+                                         std::default_random_engine re) {
+  auto t = RSRRegions(input_spatialSize, output_spatialSize, dimension,
+                        size, stride, re);
+  rules.clear();
+  rules.resize(volume<dimension>(size));
+  output_SGs.clear();
+  uInt batchSize = input_SGs.size();
+  output_SGs.resize(batchSize);
+  std::vector<RuleBook> rbs(batchSize);
+  {
+    uInt i;
+#pragma omp parallel for private(i)
+    for (i = 0; i < batchSize; i++)
+      RSR_InputSgToRulesAndOutputSg<dimension>(input_SGs[i], output_SGs[i],
+                                               rbs[i], t, size, stride);
+  }
+  uInt output_nActive = 0;
+  for (uInt i = 0; i < batchSize; i++) {
+    // Parallel assignment:
+    // output_nActive     <-  output_nActive+output_SGs[i].ctr
+    // output_SGs[i].ctr  <-  output_nActive
+    uInt tmp = output_nActive;
+    output_nActive += output_SGs[i].ctr;
+    output_SGs[i].ctr = tmp;
+  }
+  {
+    uInt i;
+#pragma omp parallel for private(i)
+    for (i = 0; i < rules.size(); i++) {
+      auto &R = rules[i];
+      for (uInt j = 0; j < batchSize; j++) {
+        auto &r = rbs[j][i];
+        auto offset = output_SGs[j].ctr;
+        for (uInt k = 0; k < r.size();) {
+          R.push_back(r[k++]);
+          R.push_back(r[k++] + offset);
+        }
+      }
+    }
+  }
+  return output_nActive;
+}
+#endif /* RSRRULES_H */

PyTorch/sparseconvnet/SCN/generic/SparseConvNet.h → sparseconvnet/SCN/generic/SparseConvNet.h

@@ -16,6 +16,8 @@
 #include <string>
 #include <tuple>
 #include <vector>
+#include <random>
+#include <chrono>
 #define ENABLE_OPENMP YES
 #if defined(ENABLE_OPENMP)
 #include <omp.h>

PyTorch/sparseconvnet/SCN/header_cpu.c → sparseconvnet/SCN/header_cpu.c

@@ -168,6 +168,26 @@ void scn_9_getSpatialLocations(void **m, THLongTensor *spatialSize,
   THLongTensor *locations){}
 void scn_10_getSpatialLocations(void **m, THLongTensor *spatialSize,
   THLongTensor *locations){}
+void scn_1_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum){}
+void scn_2_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum){}
+void scn_3_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum){}
+void scn_4_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum){}
+void scn_5_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum){}
+void scn_6_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum){}
+void scn_7_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum){}
+void scn_8_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum){}
+void scn_9_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum){}
+void scn_10_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum){}
 void scn_cpu_float_AffineReluTrivialConvolution_updateOutput(
   THFloatTensor *input_features, THFloatTensor *output_features,
   THFloatTensor *affineWeight, THFloatTensor *affineBias, THFloatTensor *convWeight){}
@@ -264,1721 +284,2441 @@ void scn_cpu_double_NetworkInNetwork_accGradParameters(
   THDoubleTensor *d_weight, THDoubleTensor *d_bias){}
 void scn_cpu_float1ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THFloatTensor *output_features, _Bool average){}
 void scn_cpu_double1ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average){}
 void scn_cpu_float2ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THFloatTensor *output_features, _Bool average){}
 void scn_cpu_double2ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average){}
 void scn_cpu_float3ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THFloatTensor *output_features, _Bool average){}
 void scn_cpu_double3ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average){}
 void scn_cpu_float4ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THFloatTensor *output_features, _Bool average){}
 void scn_cpu_double4ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average){}
 void scn_cpu_float5ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THFloatTensor *output_features, _Bool average){}
 void scn_cpu_double5ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average){}
 void scn_cpu_float6ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THFloatTensor *output_features, _Bool average){}
 void scn_cpu_double6ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average){}
 void scn_cpu_float7ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THFloatTensor *output_features, _Bool average){}
 void scn_cpu_double7ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average){}
 void scn_cpu_float8ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THFloatTensor *output_features, _Bool average){}
 void scn_cpu_double8ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average){}
 void scn_cpu_float9ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THFloatTensor *output_features, _Bool average){}
 void scn_cpu_double9ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average){}
 void scn_cpu_float10ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THFloatTensor *output_features, _Bool average){}
 void scn_cpu_double10ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}void scn_cpu_float1ActivePooling_updateGradInput(
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average){}void scn_cpu_float1ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_cpu_double1ActivePooling_updateGradInput(
+  _Bool average){}void scn_cpu_double1ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_cpu_float2ActivePooling_updateGradInput(
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average){}void scn_cpu_float2ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_cpu_double2ActivePooling_updateGradInput(
+  _Bool average){}void scn_cpu_double2ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_cpu_float3ActivePooling_updateGradInput(
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average){}void scn_cpu_float3ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_cpu_double3ActivePooling_updateGradInput(
+  _Bool average){}void scn_cpu_double3ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_cpu_float4ActivePooling_updateGradInput(
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average){}void scn_cpu_float4ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_cpu_double4ActivePooling_updateGradInput(
+  _Bool average){}void scn_cpu_double4ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_cpu_float5ActivePooling_updateGradInput(
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average){}void scn_cpu_float5ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_cpu_double5ActivePooling_updateGradInput(
+  _Bool average){}void scn_cpu_double5ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_cpu_float6ActivePooling_updateGradInput(
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average){}void scn_cpu_float6ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_cpu_double6ActivePooling_updateGradInput(
+  _Bool average){}void scn_cpu_double6ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_cpu_float7ActivePooling_updateGradInput(
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average){}void scn_cpu_float7ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_cpu_double7ActivePooling_updateGradInput(
+  _Bool average){}void scn_cpu_double7ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_cpu_float8ActivePooling_updateGradInput(
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average){}void scn_cpu_float8ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_cpu_double8ActivePooling_updateGradInput(
+  _Bool average){}void scn_cpu_double8ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_cpu_float9ActivePooling_updateGradInput(
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average){}void scn_cpu_float9ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_cpu_double9ActivePooling_updateGradInput(
+  _Bool average){}void scn_cpu_double9ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_cpu_float10ActivePooling_updateGradInput(
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average){}void scn_cpu_float10ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_cpu_double10ActivePooling_updateGradInput(
+  _Bool average){}void scn_cpu_double10ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average){}
 void scn_cpu_float1AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double1AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float2AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double2AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float3AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double3AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float4AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double4AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float5AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double5AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float6AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double6AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float7AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double7AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float8AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double8AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float9AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double9AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float10AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double10AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float1AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *d_output_features, long nFeaturesToDrop){}
 void scn_cpu_double1AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *d_output_features, long nFeaturesToDrop){}
 void scn_cpu_float2AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *d_output_features, long nFeaturesToDrop){}
 void scn_cpu_double2AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *d_output_features, long nFeaturesToDrop){}
 void scn_cpu_float3AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *d_output_features, long nFeaturesToDrop){}
 void scn_cpu_double3AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *d_output_features, long nFeaturesToDrop){}
 void scn_cpu_float4AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *d_output_features, long nFeaturesToDrop){}
 void scn_cpu_double4AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *d_output_features, long nFeaturesToDrop){}
 void scn_cpu_float5AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *d_output_features, long nFeaturesToDrop){}
 void scn_cpu_double5AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *d_output_features, long nFeaturesToDrop){}
 void scn_cpu_float6AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *d_output_features, long nFeaturesToDrop){}
 void scn_cpu_double6AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *d_output_features, long nFeaturesToDrop){}
 void scn_cpu_float7AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *d_output_features, long nFeaturesToDrop){}
 void scn_cpu_double7AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *d_output_features, long nFeaturesToDrop){}
 void scn_cpu_float8AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *d_output_features, long nFeaturesToDrop){}
 void scn_cpu_double8AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *d_output_features, long nFeaturesToDrop){}
 void scn_cpu_float9AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *d_output_features, long nFeaturesToDrop){}
 void scn_cpu_double9AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *d_output_features, long nFeaturesToDrop){}
 void scn_cpu_float10AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *d_output_features, long nFeaturesToDrop){}
 void scn_cpu_double10AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *d_output_features, long nFeaturesToDrop){}
 double scn_cpu_float1Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double1Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float2Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double2Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float3Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double3Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float4Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double4Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float5Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double5Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float6Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double6Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float7Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double7Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float8Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double8Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float9Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double9Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float10Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double10Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 void scn_cpu_float1Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double1Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float2Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double2Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float3Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double3Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float4Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double4Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float5Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double5Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float6Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double6Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float7Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double7Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float8Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double8Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float9Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double9Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float10Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double10Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
+double scn_cpu_float1RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double1RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume){}
+double scn_cpu_float2RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double2RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume){}
+double scn_cpu_float3RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double3RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume){}
+double scn_cpu_float4RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double4RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume){}
+double scn_cpu_float5RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double5RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume){}
+double scn_cpu_float6RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double6RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume){}
+double scn_cpu_float7RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double7RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume){}
+double scn_cpu_float8RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double8RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume){}
+double scn_cpu_float9RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double9RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume){}
+double scn_cpu_float10RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double10RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume){}
+void scn_cpu_float1RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double1RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume){}
+void scn_cpu_float2RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double2RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume){}
+void scn_cpu_float3RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double3RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume){}
+void scn_cpu_float4RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double4RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume){}
+void scn_cpu_float5RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double5RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume){}
+void scn_cpu_float6RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double6RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume){}
+void scn_cpu_float7RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double7RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume){}
+void scn_cpu_float8RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double8RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume){}
+void scn_cpu_float9RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double9RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume){}
+void scn_cpu_float10RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double10RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume){}
 double scn_cpu_float1Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double1Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float2Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double2Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float3Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double3Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float4Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double4Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float5Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double5Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float6Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double6Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float7Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double7Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float8Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double8Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float9Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double9Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float10Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double10Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 void scn_cpu_float1Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double1Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float2Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double2Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float3Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double3Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float4Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double4Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float5Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double5Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float6Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double6Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float7Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double7Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float8Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double8Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float9Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double9Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float10Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double10Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
+double scn_cpu_float1FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double1FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume){}
+double scn_cpu_float2FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double2FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume){}
+double scn_cpu_float3FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double3FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume){}
+double scn_cpu_float4FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double4FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume){}
+double scn_cpu_float5FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double5FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume){}
+double scn_cpu_float6FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double6FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume){}
+double scn_cpu_float7FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double7FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume){}
+double scn_cpu_float8FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double8FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume){}
+double scn_cpu_float9FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double9FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume){}
+double scn_cpu_float10FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume){}
+double scn_cpu_double10FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume){}
+void scn_cpu_float1FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double1FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume){}
+void scn_cpu_float2FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double2FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume){}
+void scn_cpu_float3FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double3FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume){}
+void scn_cpu_float4FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double4FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume){}
+void scn_cpu_float5FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double5FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume){}
+void scn_cpu_float6FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double6FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume){}
+void scn_cpu_float7FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double7FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume){}
+void scn_cpu_float8FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double8FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume){}
+void scn_cpu_float9FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double9FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume){}
+void scn_cpu_float10FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume){}
+void scn_cpu_double10FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float1MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double1MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float2MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double2MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float3MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double3MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float4MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double4MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float5MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double5MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float6MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double6MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float7MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double7MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float8MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double8MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float9MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double9MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float10MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_double10MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
 void scn_cpu_float1MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_cpu_double1MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_cpu_float2MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_cpu_double2MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_cpu_float3MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_cpu_double3MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_cpu_float4MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_cpu_double4MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_cpu_float5MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_cpu_double5MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_cpu_float6MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_cpu_double6MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_cpu_float7MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_cpu_double7MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_cpu_float8MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_cpu_double8MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_cpu_float9MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_cpu_double9MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_cpu_float10MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_cpu_double10MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer){}
+  long nFeaturesToDrop){}
+void scn_cpu_float1RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double1RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float2RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double2RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float3RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double3RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float4RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double4RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float5RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double5RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float6RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double6RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float7RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double7RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float8RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double8RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float9RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double9RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float10RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double10RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float1RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_cpu_double1RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_cpu_float2RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_cpu_double2RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_cpu_float3RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_cpu_double3RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_cpu_float4RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_cpu_double4RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_cpu_float5RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_cpu_double5RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_cpu_float6RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_cpu_double6RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_cpu_float7RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_cpu_double7RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_cpu_float8RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_cpu_double8RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_cpu_float9RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_cpu_double9RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_cpu_float10RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_cpu_double10RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop){}
 void scn_cpu_float1SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THFloatTensor *output_features, long nPlanes){}
 void scn_cpu_double1SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THDoubleTensor *output_features, long nPlanes){}
 void scn_cpu_float2SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THFloatTensor *output_features, long nPlanes){}
 void scn_cpu_double2SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THDoubleTensor *output_features, long nPlanes){}
 void scn_cpu_float3SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THFloatTensor *output_features, long nPlanes){}
 void scn_cpu_double3SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THDoubleTensor *output_features, long nPlanes){}
 void scn_cpu_float4SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THFloatTensor *output_features, long nPlanes){}
 void scn_cpu_double4SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THDoubleTensor *output_features, long nPlanes){}
 void scn_cpu_float5SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THFloatTensor *output_features, long nPlanes){}
 void scn_cpu_double5SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THDoubleTensor *output_features, long nPlanes){}
 void scn_cpu_float6SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THFloatTensor *output_features, long nPlanes){}
 void scn_cpu_double6SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THDoubleTensor *output_features, long nPlanes){}
 void scn_cpu_float7SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THFloatTensor *output_features, long nPlanes){}
 void scn_cpu_double7SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THDoubleTensor *output_features, long nPlanes){}
 void scn_cpu_float8SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THFloatTensor *output_features, long nPlanes){}
 void scn_cpu_double8SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THDoubleTensor *output_features, long nPlanes){}
 void scn_cpu_float9SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THFloatTensor *output_features, long nPlanes){}
 void scn_cpu_double9SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THDoubleTensor *output_features, long nPlanes){}
 void scn_cpu_float10SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THFloatTensor *output_features, long nPlanes){}
 void scn_cpu_double10SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes){}
+  THDoubleTensor *output_features, long nPlanes){}
 void scn_cpu_float1SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double1SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer){}
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float2SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double2SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer){}
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float3SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double3SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer){}
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float4SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double4SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer){}
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float5SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double5SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer){}
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float6SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double6SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer){}
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float7SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double7SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer){}
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float8SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double8SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer){}
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float9SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double9SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer){}
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float10SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double10SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer){}
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 double scn_cpu_float1SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double1SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float2SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double2SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float3SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double3SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float4SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double4SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float5SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double5SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float6SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double6SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float7SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double7SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float8SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double8SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float9SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double9SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 double scn_cpu_float10SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *bias, long filterVolume){}
 double scn_cpu_double10SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *bias, long filterVolume){}
 void scn_cpu_float1SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double1SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float2SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double2SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float3SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double3SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float4SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double4SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float5SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double5SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float6SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double6SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float7SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double7SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float8SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double8SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float9SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double9SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float10SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THFloatTensor *d_bias, long filterVolume){}
 void scn_cpu_double10SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer){}
+  THDoubleTensor *d_bias, long filterVolume){}
 void scn_cpu_float1InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  long mode){}
 void scn_cpu_double1InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode){}
 void scn_cpu_float2InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  long mode){}
 void scn_cpu_double2InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode){}
 void scn_cpu_float3InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  long mode){}
 void scn_cpu_double3InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode){}
 void scn_cpu_float4InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  long mode){}
 void scn_cpu_double4InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode){}
 void scn_cpu_float5InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  long mode){}
 void scn_cpu_double5InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode){}
 void scn_cpu_float6InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  long mode){}
 void scn_cpu_double6InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode){}
 void scn_cpu_float7InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  long mode){}
 void scn_cpu_double7InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode){}
 void scn_cpu_float8InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  long mode){}
 void scn_cpu_double8InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode){}
 void scn_cpu_float9InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  long mode){}
 void scn_cpu_double9InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode){}
 void scn_cpu_float10InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  long mode){}
 void scn_cpu_double10InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode){}
 void scn_cpu_float1InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double1InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float2InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double2InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float3InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double3InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float4InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double4InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float5InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double5InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float6InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double6InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float7InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double7InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float8InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double8InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float9InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double9InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float10InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double10InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
+void scn_cpu_float1OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
+void scn_cpu_double1OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
+void scn_cpu_float2OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
+void scn_cpu_double2OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
+void scn_cpu_float3OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
+void scn_cpu_double3OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
+void scn_cpu_float4OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
+void scn_cpu_double4OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
+void scn_cpu_float5OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
+void scn_cpu_double5OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
+void scn_cpu_float6OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
+void scn_cpu_double6OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
+void scn_cpu_float7OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
+void scn_cpu_double7OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
+void scn_cpu_float8OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
+void scn_cpu_double8OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
+void scn_cpu_float9OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
+void scn_cpu_double9OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
+void scn_cpu_float10OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
+void scn_cpu_double10OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
+void scn_cpu_float1OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
+void scn_cpu_double1OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
+void scn_cpu_float2OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
+void scn_cpu_double2OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
+void scn_cpu_float3OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
+void scn_cpu_double3OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
+void scn_cpu_float4OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
+void scn_cpu_double4OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
+void scn_cpu_float5OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
+void scn_cpu_double5OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
+void scn_cpu_float6OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
+void scn_cpu_double6OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
+void scn_cpu_float7OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
+void scn_cpu_double7OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
+void scn_cpu_float8OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
+void scn_cpu_double8OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
+void scn_cpu_float9OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
+void scn_cpu_double9OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
+void scn_cpu_float10OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
+void scn_cpu_double10OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float1BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode){}
 void scn_cpu_double1BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode){}
 void scn_cpu_float2BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode){}
 void scn_cpu_double2BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode){}
 void scn_cpu_float3BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode){}
 void scn_cpu_double3BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode){}
 void scn_cpu_float4BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode){}
 void scn_cpu_double4BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode){}
 void scn_cpu_float5BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode){}
 void scn_cpu_double5BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode){}
 void scn_cpu_float6BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode){}
 void scn_cpu_double6BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode){}
 void scn_cpu_float7BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode){}
 void scn_cpu_double7BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode){}
 void scn_cpu_float8BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode){}
 void scn_cpu_double8BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode){}
 void scn_cpu_float9BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode){}
 void scn_cpu_double9BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode){}
 void scn_cpu_float10BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode){}
 void scn_cpu_double10BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode){}
 void scn_cpu_float1BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features){}
 void scn_cpu_double1BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features){}
 void scn_cpu_float2BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features){}
 void scn_cpu_double2BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features){}
 void scn_cpu_float3BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features){}
 void scn_cpu_double3BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features){}
 void scn_cpu_float4BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features){}
 void scn_cpu_double4BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features){}
 void scn_cpu_float5BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features){}
 void scn_cpu_double5BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features){}
 void scn_cpu_float6BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features){}
 void scn_cpu_double6BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features){}
 void scn_cpu_float7BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features){}
 void scn_cpu_double7BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features){}
 void scn_cpu_float8BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features){}
 void scn_cpu_double8BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features){}
 void scn_cpu_float9BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features){}
 void scn_cpu_double9BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features){}
 void scn_cpu_float10BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features){}
 void scn_cpu_double10BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features){}
 void scn_cpu_float1BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
 void scn_cpu_double1BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
 void scn_cpu_float2BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
 void scn_cpu_double2BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
 void scn_cpu_float3BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
 void scn_cpu_double3BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
 void scn_cpu_float4BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
 void scn_cpu_double4BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
 void scn_cpu_float5BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
 void scn_cpu_double5BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
 void scn_cpu_float6BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
 void scn_cpu_double6BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
 void scn_cpu_float7BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
 void scn_cpu_double7BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
 void scn_cpu_float8BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
 void scn_cpu_double8BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
 void scn_cpu_float9BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
 void scn_cpu_double9BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
 void scn_cpu_float10BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features){}
 void scn_cpu_double10BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features){}
 void scn_cpu_float1BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double1BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float2BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double2BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float3BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double3BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float4BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double4BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float5BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double5BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float6BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double6BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float7BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double7BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float8BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double8BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float9BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double9BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
 void scn_cpu_float10BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features){}
 void scn_cpu_double10BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
\ No newline at end of file
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features){}
+void scn_cpu_float1UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double1UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float2UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double2UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float3UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double3UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float4UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double4UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float5UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double5UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float6UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double6UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float7UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double7UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float8UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double8UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float9UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double9UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float10UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_double10UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop){}
+void scn_cpu_float1UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_cpu_double1UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_cpu_float2UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_cpu_double2UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_cpu_float3UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_cpu_double3UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_cpu_float4UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_cpu_double4UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_cpu_float5UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_cpu_double5UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_cpu_float6UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_cpu_double6UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_cpu_float7UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_cpu_double7UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_cpu_float8UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_cpu_double8UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_cpu_float9UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_cpu_double9UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_cpu_float10UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_cpu_double10UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop){}
\ No newline at end of file

PyTorch/sparseconvnet/SCN/header_cpu.h → sparseconvnet/SCN/header_cpu.h

@@ -168,6 +168,26 @@ void scn_9_getSpatialLocations(void **m, THLongTensor *spatialSize,
   THLongTensor *locations);
 void scn_10_getSpatialLocations(void **m, THLongTensor *spatialSize,
   THLongTensor *locations);
+void scn_1_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum);
+void scn_2_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum);
+void scn_3_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum);
+void scn_4_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum);
+void scn_5_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum);
+void scn_6_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum);
+void scn_7_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum);
+void scn_8_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum);
+void scn_9_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum);
+void scn_10_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum);
 void scn_cpu_float_AffineReluTrivialConvolution_updateOutput(
   THFloatTensor *input_features, THFloatTensor *output_features,
   THFloatTensor *affineWeight, THFloatTensor *affineBias, THFloatTensor *convWeight);
@@ -264,1721 +284,2441 @@ void scn_cpu_double_NetworkInNetwork_accGradParameters(
   THDoubleTensor *d_weight, THDoubleTensor *d_bias);
 void scn_cpu_float1ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THFloatTensor *output_features, _Bool average);
 void scn_cpu_double1ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average);
 void scn_cpu_float2ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THFloatTensor *output_features, _Bool average);
 void scn_cpu_double2ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average);
 void scn_cpu_float3ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THFloatTensor *output_features, _Bool average);
 void scn_cpu_double3ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average);
 void scn_cpu_float4ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THFloatTensor *output_features, _Bool average);
 void scn_cpu_double4ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average);
 void scn_cpu_float5ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THFloatTensor *output_features, _Bool average);
 void scn_cpu_double5ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average);
 void scn_cpu_float6ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THFloatTensor *output_features, _Bool average);
 void scn_cpu_double6ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average);
 void scn_cpu_float7ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THFloatTensor *output_features, _Bool average);
 void scn_cpu_double7ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average);
 void scn_cpu_float8ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THFloatTensor *output_features, _Bool average);
 void scn_cpu_double8ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average);
 void scn_cpu_float9ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THFloatTensor *output_features, _Bool average);
 void scn_cpu_double9ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average);
 void scn_cpu_float10ActivePooling_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THFloatTensor *output_features, _Bool average);
 void scn_cpu_double10ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;void scn_cpu_float1ActivePooling_updateGradInput(
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, _Bool average);void scn_cpu_float1ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_cpu_double1ActivePooling_updateGradInput(
+  _Bool average);void scn_cpu_double1ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_cpu_float2ActivePooling_updateGradInput(
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average);void scn_cpu_float2ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_cpu_double2ActivePooling_updateGradInput(
+  _Bool average);void scn_cpu_double2ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_cpu_float3ActivePooling_updateGradInput(
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average);void scn_cpu_float3ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_cpu_double3ActivePooling_updateGradInput(
+  _Bool average);void scn_cpu_double3ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_cpu_float4ActivePooling_updateGradInput(
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average);void scn_cpu_float4ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_cpu_double4ActivePooling_updateGradInput(
+  _Bool average);void scn_cpu_double4ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_cpu_float5ActivePooling_updateGradInput(
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average);void scn_cpu_float5ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_cpu_double5ActivePooling_updateGradInput(
+  _Bool average);void scn_cpu_double5ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_cpu_float6ActivePooling_updateGradInput(
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average);void scn_cpu_float6ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_cpu_double6ActivePooling_updateGradInput(
+  _Bool average);void scn_cpu_double6ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_cpu_float7ActivePooling_updateGradInput(
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average);void scn_cpu_float7ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_cpu_double7ActivePooling_updateGradInput(
+  _Bool average);void scn_cpu_double7ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_cpu_float8ActivePooling_updateGradInput(
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average);void scn_cpu_float8ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_cpu_double8ActivePooling_updateGradInput(
+  _Bool average);void scn_cpu_double8ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_cpu_float9ActivePooling_updateGradInput(
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average);void scn_cpu_float9ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_cpu_double9ActivePooling_updateGradInput(
+  _Bool average);void scn_cpu_double9ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_cpu_float10ActivePooling_updateGradInput(
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average);void scn_cpu_float10ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
   THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_cpu_double10ActivePooling_updateGradInput(
+  _Bool average);void scn_cpu_double10ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  _Bool average);
 void scn_cpu_float1AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double1AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float2AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double2AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float3AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double3AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float4AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double4AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float5AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double5AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float6AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double6AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float7AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double7AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float8AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double8AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float9AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double9AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float10AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double10AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float1AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *d_output_features, long nFeaturesToDrop);
 void scn_cpu_double1AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *d_output_features, long nFeaturesToDrop);
 void scn_cpu_float2AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *d_output_features, long nFeaturesToDrop);
 void scn_cpu_double2AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *d_output_features, long nFeaturesToDrop);
 void scn_cpu_float3AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *d_output_features, long nFeaturesToDrop);
 void scn_cpu_double3AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *d_output_features, long nFeaturesToDrop);
 void scn_cpu_float4AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *d_output_features, long nFeaturesToDrop);
 void scn_cpu_double4AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *d_output_features, long nFeaturesToDrop);
 void scn_cpu_float5AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *d_output_features, long nFeaturesToDrop);
 void scn_cpu_double5AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *d_output_features, long nFeaturesToDrop);
 void scn_cpu_float6AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *d_output_features, long nFeaturesToDrop);
 void scn_cpu_double6AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *d_output_features, long nFeaturesToDrop);
 void scn_cpu_float7AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *d_output_features, long nFeaturesToDrop);
 void scn_cpu_double7AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *d_output_features, long nFeaturesToDrop);
 void scn_cpu_float8AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *d_output_features, long nFeaturesToDrop);
 void scn_cpu_double8AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *d_output_features, long nFeaturesToDrop);
 void scn_cpu_float9AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *d_output_features, long nFeaturesToDrop);
 void scn_cpu_double9AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *d_output_features, long nFeaturesToDrop);
 void scn_cpu_float10AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
-  THFloatTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *d_output_features, long nFeaturesToDrop);
 void scn_cpu_double10AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-  THDoubleTensor *d_output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *d_output_features, long nFeaturesToDrop);
 double scn_cpu_float1Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double1Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float2Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double2Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float3Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double3Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float4Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double4Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float5Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double5Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float6Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double6Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float7Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double7Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float8Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double8Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float9Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double9Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float10Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double10Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 void scn_cpu_float1Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double1Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float2Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double2Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float3Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double3Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float4Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double4Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float5Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double5Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float6Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double6Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float7Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double7Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float8Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double8Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float9Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double9Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float10Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double10Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
+double scn_cpu_float1RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume);
+double scn_cpu_double1RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume);
+double scn_cpu_float2RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume);
+double scn_cpu_double2RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume);
+double scn_cpu_float3RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume);
+double scn_cpu_double3RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume);
+double scn_cpu_float4RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume);
+double scn_cpu_double4RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume);
+double scn_cpu_float5RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume);
+double scn_cpu_double5RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume);
+double scn_cpu_float6RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume);
+double scn_cpu_double6RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume);
+double scn_cpu_float7RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume);
+double scn_cpu_double7RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume);
+double scn_cpu_float8RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume);
+double scn_cpu_double8RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume);
+double scn_cpu_float9RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume);
+double scn_cpu_double9RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume);
+double scn_cpu_float10RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume);
+double scn_cpu_double10RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume);
+void scn_cpu_float1RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double1RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume);
+void scn_cpu_float2RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double2RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume);
+void scn_cpu_float3RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double3RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume);
+void scn_cpu_float4RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double4RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume);
+void scn_cpu_float5RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double5RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume);
+void scn_cpu_float6RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double6RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume);
+void scn_cpu_float7RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double7RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume);
+void scn_cpu_float8RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double8RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume);
+void scn_cpu_float9RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double9RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume);
+void scn_cpu_float10RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+  THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double10RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+  THDoubleTensor *d_bias, long filterVolume);
 double scn_cpu_float1Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double1Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float2Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double2Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float3Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double3Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float4Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double4Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float5Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double5Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float6Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double6Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float7Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double7Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float8Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double8Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float9Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double9Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float10Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double10Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 void scn_cpu_float1Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double1Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float2Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double2Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float3Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double3Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float4Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double4Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float5Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double5Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float6Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double6Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float7Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double7Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float8Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double8Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float9Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double9Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float10Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double10Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
+double scn_cpu_float1FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume);
+double scn_cpu_double1FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume);
+double scn_cpu_float2FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume);
+double scn_cpu_double2FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume);
+double scn_cpu_float3FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume);
+double scn_cpu_double3FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume);
+double scn_cpu_float4FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume);
+double scn_cpu_double4FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume);
+double scn_cpu_float5FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume);
+double scn_cpu_double5FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume);
+double scn_cpu_float6FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume);
+double scn_cpu_double6FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume);
+double scn_cpu_float7FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume);
+double scn_cpu_double7FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume);
+double scn_cpu_float8FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume);
+double scn_cpu_double8FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume);
+double scn_cpu_float9FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume);
+double scn_cpu_double9FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume);
+double scn_cpu_float10FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+    THFloatTensor *bias, long filterVolume);
+double scn_cpu_double10FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+    THDoubleTensor *bias, long filterVolume);
+void scn_cpu_float1FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double1FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume);
+void scn_cpu_float2FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double2FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume);
+void scn_cpu_float3FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double3FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume);
+void scn_cpu_float4FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double4FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume);
+void scn_cpu_float5FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double5FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume);
+void scn_cpu_float6FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double6FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume);
+void scn_cpu_float7FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double7FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume);
+void scn_cpu_float8FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double8FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume);
+void scn_cpu_float9FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double9FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume);
+void scn_cpu_float10FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THFloatTensor *input_features, THFloatTensor *d_input_features,
+    THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
+    THFloatTensor *d_bias, long filterVolume);
+void scn_cpu_double10FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+    THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
+    THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float1MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double1MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float2MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double2MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float3MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double3MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float4MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double4MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float5MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double5MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float6MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double6MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float7MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double7MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float8MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double8MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float9MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double9MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float10MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_double10MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
 void scn_cpu_float1MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_cpu_double1MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_cpu_float2MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_cpu_double2MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_cpu_float3MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_cpu_double3MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_cpu_float4MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_cpu_double4MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_cpu_float5MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_cpu_double5MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_cpu_float6MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_cpu_double6MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_cpu_float7MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_cpu_double7MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_cpu_float8MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_cpu_double8MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_cpu_float9MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_cpu_double9MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_cpu_float10MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *output_features, THFloatTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_cpu_double10MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-  long nFeaturesToDrop, void *rulesBuffer);
+  long nFeaturesToDrop);
+void scn_cpu_float1RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double1RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float2RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double2RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float3RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double3RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float4RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double4RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float5RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double5RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float6RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double6RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float7RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double7RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float8RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double8RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float9RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double9RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float10RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double10RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float1RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_cpu_double1RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_cpu_float2RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_cpu_double2RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_cpu_float3RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_cpu_double3RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_cpu_float4RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_cpu_double4RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_cpu_float5RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_cpu_double5RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_cpu_float6RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_cpu_double6RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_cpu_float7RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_cpu_double7RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_cpu_float8RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_cpu_double8RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_cpu_float9RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_cpu_double9RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_cpu_float10RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_cpu_double10RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features,
+  long nFeaturesToDrop);
 void scn_cpu_float1SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes);
+  THFloatTensor *output_features, long nPlanes);
 void scn_cpu_double1SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes);
+  THDoubleTensor *output_features, long nPlanes);
 void scn_cpu_float2SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes);
+  THFloatTensor *output_features, long nPlanes);
 void scn_cpu_double2SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes);
+  THDoubleTensor *output_features, long nPlanes);
 void scn_cpu_float3SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes);
+  THFloatTensor *output_features, long nPlanes);
 void scn_cpu_double3SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes);
+  THDoubleTensor *output_features, long nPlanes);
 void scn_cpu_float4SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes);
+  THFloatTensor *output_features, long nPlanes);
 void scn_cpu_double4SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes);
+  THDoubleTensor *output_features, long nPlanes);
 void scn_cpu_float5SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes);
+  THFloatTensor *output_features, long nPlanes);
 void scn_cpu_double5SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes);
+  THDoubleTensor *output_features, long nPlanes);
 void scn_cpu_float6SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes);
+  THFloatTensor *output_features, long nPlanes);
 void scn_cpu_double6SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes);
+  THDoubleTensor *output_features, long nPlanes);
 void scn_cpu_float7SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes);
+  THFloatTensor *output_features, long nPlanes);
 void scn_cpu_double7SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes);
+  THDoubleTensor *output_features, long nPlanes);
 void scn_cpu_float8SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes);
+  THFloatTensor *output_features, long nPlanes);
 void scn_cpu_double8SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes);
+  THDoubleTensor *output_features, long nPlanes);
 void scn_cpu_float9SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes);
+  THFloatTensor *output_features, long nPlanes);
 void scn_cpu_double9SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes);
+  THDoubleTensor *output_features, long nPlanes);
 void scn_cpu_float10SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, long nPlanes);
+  THFloatTensor *output_features, long nPlanes);
 void scn_cpu_double10SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *output_features, void *rulesBuffer, long nPlanes);
+  THDoubleTensor *output_features, long nPlanes);
 void scn_cpu_float1SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double1SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer);
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float2SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double2SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer);
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float3SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double3SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer);
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float4SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double4SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer);
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float5SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double5SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer);
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float6SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double6SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer);
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float7SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double7SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer);
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float8SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double8SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer);
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float9SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double9SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer);
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float10SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double10SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-  void *rulesBuffer);
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 double scn_cpu_float1SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double1SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float2SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double2SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float3SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double3SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float4SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double4SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float5SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double5SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float6SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double6SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float7SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double7SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float8SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double8SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float9SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double9SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 double scn_cpu_float10SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
-  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *bias, long filterVolume);
 double scn_cpu_double10SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
-  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *bias, long filterVolume);
 void scn_cpu_float1SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double1SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float2SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double2SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float3SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double3SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float4SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double4SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float5SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double5SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float6SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double6SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float7SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double7SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float8SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double8SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float9SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double9SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float10SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THFloatTensor *input_features, THFloatTensor *d_input_features,
   THFloatTensor *d_output_features, THFloatTensor *weight, THFloatTensor *d_weight,
-  THFloatTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THFloatTensor *d_bias, long filterVolume);
 void scn_cpu_double10SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THDoubleTensor *input_features, THDoubleTensor *d_input_features,
   THDoubleTensor *d_output_features, THDoubleTensor *weight, THDoubleTensor *d_weight,
-  THDoubleTensor *d_bias, long filterVolume, void *rulesBuffer);
+  THDoubleTensor *d_bias, long filterVolume);
 void scn_cpu_float1InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  long mode);
 void scn_cpu_double1InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode);
 void scn_cpu_float2InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  long mode);
 void scn_cpu_double2InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode);
 void scn_cpu_float3InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  long mode);
 void scn_cpu_double3InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode);
 void scn_cpu_float4InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  long mode);
 void scn_cpu_double4InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode);
 void scn_cpu_float5InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  long mode);
 void scn_cpu_double5InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode);
 void scn_cpu_float6InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  long mode);
 void scn_cpu_double6InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode);
 void scn_cpu_float7InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  long mode);
 void scn_cpu_double7InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode);
 void scn_cpu_float8InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  long mode);
 void scn_cpu_double8InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode);
 void scn_cpu_float9InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  long mode);
 void scn_cpu_double9InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode);
 void scn_cpu_float10InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
   THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  long mode);
 void scn_cpu_double10InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long batchSize,
+  long mode);
 void scn_cpu_float1InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double1InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float2InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double2InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float3InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double3InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float4InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double4InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float5InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double5InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float6InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double6InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float7InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double7InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float8InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double8InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float9InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double9InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float10InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double10InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
+void scn_cpu_float1OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
+void scn_cpu_double1OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
+void scn_cpu_float2OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
+void scn_cpu_double2OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
+void scn_cpu_float3OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
+void scn_cpu_double3OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
+void scn_cpu_float4OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
+void scn_cpu_double4OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
+void scn_cpu_float5OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
+void scn_cpu_double5OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
+void scn_cpu_float6OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
+void scn_cpu_double6OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
+void scn_cpu_float7OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
+void scn_cpu_double7OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
+void scn_cpu_float8OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
+void scn_cpu_double8OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
+void scn_cpu_float9OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
+void scn_cpu_double9OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
+void scn_cpu_float10OutputLayer_updateOutput(
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
+void scn_cpu_double10OutputLayer_updateOutput(
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
+void scn_cpu_float1OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
+void scn_cpu_double1OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
+void scn_cpu_float2OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
+void scn_cpu_double2OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
+void scn_cpu_float3OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
+void scn_cpu_double3OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
+void scn_cpu_float4OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
+void scn_cpu_double4OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
+void scn_cpu_float5OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
+void scn_cpu_double5OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
+void scn_cpu_float6OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
+void scn_cpu_double6OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
+void scn_cpu_float7OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
+void scn_cpu_double7OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
+void scn_cpu_float8OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
+void scn_cpu_double8OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
+void scn_cpu_float9OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
+void scn_cpu_double9OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
+void scn_cpu_float10OutputLayer_updateGradInput(
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
+void scn_cpu_double10OutputLayer_updateGradInput(
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float1BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode);
 void scn_cpu_double1BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode);
 void scn_cpu_float2BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode);
 void scn_cpu_double2BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode);
 void scn_cpu_float3BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode);
 void scn_cpu_double3BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode);
 void scn_cpu_float4BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode);
 void scn_cpu_double4BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode);
 void scn_cpu_float5BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode);
 void scn_cpu_double5BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode);
 void scn_cpu_float6BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode);
 void scn_cpu_double6BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode);
 void scn_cpu_float7BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode);
 void scn_cpu_double7BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode);
 void scn_cpu_float8BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode);
 void scn_cpu_double8BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode);
 void scn_cpu_float9BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode);
 void scn_cpu_double9BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode);
 void scn_cpu_float10BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THFloatTensor *input_features, THFloatTensor *output_features, long mode);
 void scn_cpu_double10BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long mode);
 void scn_cpu_float1BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features);
 void scn_cpu_double1BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features);
 void scn_cpu_float2BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features);
 void scn_cpu_double2BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features);
 void scn_cpu_float3BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features);
 void scn_cpu_double3BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features);
 void scn_cpu_float4BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features);
 void scn_cpu_double4BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features);
 void scn_cpu_float5BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features);
 void scn_cpu_double5BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features);
 void scn_cpu_float6BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features);
 void scn_cpu_double6BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features);
 void scn_cpu_float7BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features);
 void scn_cpu_double7BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features);
 void scn_cpu_float8BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features);
 void scn_cpu_double8BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features);
 void scn_cpu_float9BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features);
 void scn_cpu_double9BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features);
 void scn_cpu_float10BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features);
 void scn_cpu_double10BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features,THDoubleTensor *d_output_features);
 void scn_cpu_float1BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
 void scn_cpu_double1BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
 void scn_cpu_float2BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
 void scn_cpu_double2BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
 void scn_cpu_float3BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
 void scn_cpu_double3BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
 void scn_cpu_float4BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
 void scn_cpu_double4BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
 void scn_cpu_float5BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
 void scn_cpu_double5BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
 void scn_cpu_float6BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
 void scn_cpu_double6BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
 void scn_cpu_float7BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
 void scn_cpu_double7BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
 void scn_cpu_float8BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
 void scn_cpu_double8BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
 void scn_cpu_float9BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
 void scn_cpu_double9BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
 void scn_cpu_float10BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *input_features, THFloatTensor *output_features);
 void scn_cpu_double10BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *input_features, THDoubleTensor *output_features);
 void scn_cpu_float1BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double1BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float2BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double2BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float3BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double3BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float4BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double4BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float5BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double5BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float6BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double6BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float7BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double7BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float8BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double8BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float9BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double9BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
 void scn_cpu_float10BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features);
 void scn_cpu_double10BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
\ No newline at end of file
+  void **m, THDoubleTensor *d_input_features, THDoubleTensor *d_output_features);
+void scn_cpu_float1UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double1UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float2UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double2UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float3UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double3UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float4UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double4UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float5UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double5UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float6UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double6UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float7UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double7UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float8UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double8UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float9UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double9UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float10UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_double10UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *output_features, long nFeaturesToDrop);
+void scn_cpu_float1UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_cpu_double1UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_cpu_float2UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_cpu_double2UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_cpu_float3UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_cpu_double3UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_cpu_float4UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_cpu_double4UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_cpu_float5UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_cpu_double5UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_cpu_float6UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_cpu_double6UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_cpu_float7UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_cpu_double7UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_cpu_float8UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_cpu_double8UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_cpu_float9UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_cpu_double9UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_cpu_float10UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THFloatTensor *input_features,
+    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_cpu_double10UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THDoubleTensor *input_features,
+    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+    long nFeaturesToDrop);
\ No newline at end of file

PyTorch/sparseconvnet/SCN/header_gpu.c → sparseconvnet/SCN/header_gpu.c

@@ -52,862 +52,1222 @@ void scn_gpu_float_NetworkInNetwork_accGradParameters(
   THCudaTensor *input_features, THCudaTensor *d_output_features,
   THCudaTensor *d_weight, THCudaTensor *d_bias){}
 void scn_gpu_float1ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average){}
 void scn_gpu_float2ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average){}
 void scn_gpu_float3ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average){}
 void scn_gpu_float4ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average){}
 void scn_gpu_float5ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average){}
 void scn_gpu_float6ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average){}
 void scn_gpu_float7ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average){}
 void scn_gpu_float8ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average){}
 void scn_gpu_float9ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average){}
 void scn_gpu_float10ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);{}void scn_gpu_float1ActivePooling_updateGradInput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average){}void scn_gpu_float1ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_gpu_float2ActivePooling_updateGradInput(
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average){}void scn_gpu_float2ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_gpu_float3ActivePooling_updateGradInput(
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average){}void scn_gpu_float3ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_gpu_float4ActivePooling_updateGradInput(
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average){}void scn_gpu_float4ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_gpu_float5ActivePooling_updateGradInput(
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average){}void scn_gpu_float5ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_gpu_float6ActivePooling_updateGradInput(
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average){}void scn_gpu_float6ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_gpu_float7ActivePooling_updateGradInput(
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average){}void scn_gpu_float7ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_gpu_float8ActivePooling_updateGradInput(
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average){}void scn_gpu_float8ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_gpu_float9ActivePooling_updateGradInput(
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average){}void scn_gpu_float9ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}void scn_gpu_float10ActivePooling_updateGradInput(
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average){}void scn_gpu_float10ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);{}
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average){}
 void scn_gpu_float1AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float2AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float3AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float4AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float5AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float6AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float7AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float8AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float9AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float10AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float1AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_output_features, long nFeaturesToDrop){}
 void scn_gpu_float2AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_output_features, long nFeaturesToDrop){}
 void scn_gpu_float3AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_output_features, long nFeaturesToDrop){}
 void scn_gpu_float4AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_output_features, long nFeaturesToDrop){}
 void scn_gpu_float5AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_output_features, long nFeaturesToDrop){}
 void scn_gpu_float6AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_output_features, long nFeaturesToDrop){}
 void scn_gpu_float7AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_output_features, long nFeaturesToDrop){}
 void scn_gpu_float8AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_output_features, long nFeaturesToDrop){}
 void scn_gpu_float9AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_output_features, long nFeaturesToDrop){}
 void scn_gpu_float10AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_output_features, long nFeaturesToDrop){}
 double scn_gpu_float1Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float2Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float3Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float4Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float5Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float6Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float7Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float8Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float9Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float10Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 void scn_gpu_float1Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float2Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float3Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float4Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float5Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float6Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float7Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float8Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float9Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float10Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
+double scn_gpu_float1RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume){}
+double scn_gpu_float2RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume){}
+double scn_gpu_float3RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume){}
+double scn_gpu_float4RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume){}
+double scn_gpu_float5RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume){}
+double scn_gpu_float6RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume){}
+double scn_gpu_float7RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume){}
+double scn_gpu_float8RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume){}
+double scn_gpu_float9RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume){}
+double scn_gpu_float10RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume){}
+void scn_gpu_float1RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume){}
+void scn_gpu_float2RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume){}
+void scn_gpu_float3RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume){}
+void scn_gpu_float4RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume){}
+void scn_gpu_float5RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume){}
+void scn_gpu_float6RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume){}
+void scn_gpu_float7RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume){}
+void scn_gpu_float8RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume){}
+void scn_gpu_float9RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume){}
+void scn_gpu_float10RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume){}
 double scn_gpu_float1Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float2Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float3Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float4Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float5Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float6Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float7Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float8Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float9Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float10Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 void scn_gpu_float1Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float2Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float3Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float4Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float5Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float6Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float7Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float8Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float9Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float10Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
+double scn_gpu_float1FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume){}
+double scn_gpu_float2FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume){}
+double scn_gpu_float3FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume){}
+double scn_gpu_float4FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume){}
+double scn_gpu_float5FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume){}
+double scn_gpu_float6FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume){}
+double scn_gpu_float7FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume){}
+double scn_gpu_float8FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume){}
+double scn_gpu_float9FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume){}
+double scn_gpu_float10FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume){}
+void scn_gpu_float1FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume){}
+void scn_gpu_float2FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume){}
+void scn_gpu_float3FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume){}
+void scn_gpu_float4FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume){}
+void scn_gpu_float5FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume){}
+void scn_gpu_float6FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume){}
+void scn_gpu_float7FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume){}
+void scn_gpu_float8FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume){}
+void scn_gpu_float9FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume){}
+void scn_gpu_float10FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float1MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float2MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float3MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float4MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float5MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float6MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float7MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float8MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float9MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float10MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
 void scn_gpu_float1MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_gpu_float2MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_gpu_float3MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_gpu_float4MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_gpu_float5MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_gpu_float6MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_gpu_float7MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_gpu_float8MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_gpu_float9MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer){}
+  long nFeaturesToDrop){}
 void scn_gpu_float10MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer){}
+  long nFeaturesToDrop){}
+void scn_gpu_float1RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float2RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float3RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float4RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float5RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float6RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float7RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float8RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float9RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float10RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float1RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_gpu_float2RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_gpu_float3RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_gpu_float4RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_gpu_float5RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_gpu_float6RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_gpu_float7RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_gpu_float8RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_gpu_float9RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop){}
+void scn_gpu_float10RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop){}
 void scn_gpu_float1SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes){}
+  THCudaTensor *output_features, long nPlanes){}
 void scn_gpu_float2SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes){}
+  THCudaTensor *output_features, long nPlanes){}
 void scn_gpu_float3SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes){}
+  THCudaTensor *output_features, long nPlanes){}
 void scn_gpu_float4SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes){}
+  THCudaTensor *output_features, long nPlanes){}
 void scn_gpu_float5SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes){}
+  THCudaTensor *output_features, long nPlanes){}
 void scn_gpu_float6SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes){}
+  THCudaTensor *output_features, long nPlanes){}
 void scn_gpu_float7SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes){}
+  THCudaTensor *output_features, long nPlanes){}
 void scn_gpu_float8SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes){}
+  THCudaTensor *output_features, long nPlanes){}
 void scn_gpu_float9SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes){}
+  THCudaTensor *output_features, long nPlanes){}
 void scn_gpu_float10SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes){}
+  THCudaTensor *output_features, long nPlanes){}
 void scn_gpu_float1SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float2SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float3SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float4SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float5SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float6SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float7SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float8SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float9SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float10SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 double scn_gpu_float1SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float2SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float3SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float4SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float5SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float6SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float7SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float8SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float9SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 double scn_gpu_float10SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *bias, long filterVolume){}
 void scn_gpu_float1SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float2SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float3SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float4SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float5SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float6SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float7SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float8SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float9SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float10SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer){}
+  THCudaTensor *d_bias, long filterVolume){}
 void scn_gpu_float1InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode){}
 void scn_gpu_float2InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode){}
 void scn_gpu_float3InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode){}
 void scn_gpu_float4InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode){}
 void scn_gpu_float5InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode){}
 void scn_gpu_float6InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode){}
 void scn_gpu_float7InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode){}
 void scn_gpu_float8InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode){}
 void scn_gpu_float9InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode){}
 void scn_gpu_float10InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode){}
 void scn_gpu_float1InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float2InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float3InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float4InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float5InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float6InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float7InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float8InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float9InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float10InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
+void scn_gpu_float1OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
+void scn_gpu_float2OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
+void scn_gpu_float3OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
+void scn_gpu_float4OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
+void scn_gpu_float5OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
+void scn_gpu_float6OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
+void scn_gpu_float7OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
+void scn_gpu_float8OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
+void scn_gpu_float9OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
+void scn_gpu_float10OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
+void scn_gpu_float1OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
+void scn_gpu_float2OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
+void scn_gpu_float3OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
+void scn_gpu_float4OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
+void scn_gpu_float5OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
+void scn_gpu_float6OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
+void scn_gpu_float7OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
+void scn_gpu_float8OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
+void scn_gpu_float9OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
+void scn_gpu_float10OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float1BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode){}
 void scn_gpu_float2BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode){}
 void scn_gpu_float3BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode){}
 void scn_gpu_float4BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode){}
 void scn_gpu_float5BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode){}
 void scn_gpu_float6BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode){}
 void scn_gpu_float7BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode){}
 void scn_gpu_float8BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode){}
 void scn_gpu_float9BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode){}
 void scn_gpu_float10BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer){}
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode){}
 void scn_gpu_float1BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features){}
 void scn_gpu_float2BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features){}
 void scn_gpu_float3BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features){}
 void scn_gpu_float4BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features){}
 void scn_gpu_float5BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features){}
 void scn_gpu_float6BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features){}
 void scn_gpu_float7BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features){}
 void scn_gpu_float8BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features){}
 void scn_gpu_float9BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features){}
 void scn_gpu_float10BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features){}
 void scn_gpu_float1BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
 void scn_gpu_float2BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
 void scn_gpu_float3BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
 void scn_gpu_float4BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
 void scn_gpu_float5BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
 void scn_gpu_float6BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
 void scn_gpu_float7BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
 void scn_gpu_float8BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
 void scn_gpu_float9BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
 void scn_gpu_float10BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features){}
 void scn_gpu_float1BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float2BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float3BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float4BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float5BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float6BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float7BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float8BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float9BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
 void scn_gpu_float10BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer){}
\ No newline at end of file
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features){}
+void scn_gpu_float1UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float2UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float3UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float4UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float5UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float6UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float7UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float8UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float9UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float10UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop){}
+void scn_gpu_float1UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_gpu_float2UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_gpu_float3UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_gpu_float4UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_gpu_float5UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_gpu_float6UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_gpu_float7UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_gpu_float8UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_gpu_float9UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop){}
+void scn_gpu_float10UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop){}
\ No newline at end of file

PyTorch/sparseconvnet/SCN/header_gpu.h → sparseconvnet/SCN/header_gpu.h

@@ -52,862 +52,1222 @@ void scn_gpu_float_NetworkInNetwork_accGradParameters(
   THCudaTensor *input_features, THCudaTensor *d_output_features,
   THCudaTensor *d_weight, THCudaTensor *d_bias);
 void scn_gpu_float1ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average);
 void scn_gpu_float2ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average);
 void scn_gpu_float3ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average);
 void scn_gpu_float4ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average);
 void scn_gpu_float5ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average);
 void scn_gpu_float6ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average);
 void scn_gpu_float7ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average);
 void scn_gpu_float8ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average);
 void scn_gpu_float9ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average);
 void scn_gpu_float10ActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);;void scn_gpu_float1ActivePooling_updateGradInput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, _Bool average);void scn_gpu_float1ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_gpu_float2ActivePooling_updateGradInput(
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average);void scn_gpu_float2ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_gpu_float3ActivePooling_updateGradInput(
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average);void scn_gpu_float3ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_gpu_float4ActivePooling_updateGradInput(
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average);void scn_gpu_float4ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_gpu_float5ActivePooling_updateGradInput(
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average);void scn_gpu_float5ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_gpu_float6ActivePooling_updateGradInput(
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average);void scn_gpu_float6ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_gpu_float7ActivePooling_updateGradInput(
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average);void scn_gpu_float7ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_gpu_float8ActivePooling_updateGradInput(
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average);void scn_gpu_float8ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_gpu_float9ActivePooling_updateGradInput(
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average);void scn_gpu_float9ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;void scn_gpu_float10ActivePooling_updateGradInput(
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average);void scn_gpu_float10ActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);;
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  _Bool average);
 void scn_gpu_float1AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float2AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float3AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float4AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float5AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float6AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float7AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float8AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float9AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float10AveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float1AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_output_features, long nFeaturesToDrop);
 void scn_gpu_float2AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_output_features, long nFeaturesToDrop);
 void scn_gpu_float3AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_output_features, long nFeaturesToDrop);
 void scn_gpu_float4AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_output_features, long nFeaturesToDrop);
 void scn_gpu_float5AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_output_features, long nFeaturesToDrop);
 void scn_gpu_float6AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_output_features, long nFeaturesToDrop);
 void scn_gpu_float7AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_output_features, long nFeaturesToDrop);
 void scn_gpu_float8AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_output_features, long nFeaturesToDrop);
 void scn_gpu_float9AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_output_features, long nFeaturesToDrop);
 void scn_gpu_float10AveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
-  THCudaTensor *d_output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_output_features, long nFeaturesToDrop);
 double scn_gpu_float1Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float2Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float3Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float4Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float5Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float6Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float7Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float8Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float9Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float10Convolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 void scn_gpu_float1Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float2Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float3Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float4Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float5Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float6Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float7Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float8Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float9Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float10Convolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
+double scn_gpu_float1RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume);
+double scn_gpu_float2RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume);
+double scn_gpu_float3RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume);
+double scn_gpu_float4RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume);
+double scn_gpu_float5RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume);
+double scn_gpu_float6RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume);
+double scn_gpu_float7RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume);
+double scn_gpu_float8RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume);
+double scn_gpu_float9RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume);
+double scn_gpu_float10RandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume);
+void scn_gpu_float1RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume);
+void scn_gpu_float2RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume);
+void scn_gpu_float3RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume);
+void scn_gpu_float4RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume);
+void scn_gpu_float5RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume);
+void scn_gpu_float6RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume);
+void scn_gpu_float7RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume);
+void scn_gpu_float8RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume);
+void scn_gpu_float9RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume);
+void scn_gpu_float10RandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+  THCudaTensor *d_bias, long filterVolume);
 double scn_gpu_float1Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float2Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float3Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float4Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float5Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float6Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float7Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float8Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float9Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float10Deconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 void scn_gpu_float1Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float2Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float3Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float4Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float5Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float6Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float7Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float8Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float9Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float10Deconvolution_backward(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
+double scn_gpu_float1FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume);
+double scn_gpu_float2FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume);
+double scn_gpu_float3FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume);
+double scn_gpu_float4FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume);
+double scn_gpu_float5FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume);
+double scn_gpu_float6FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume);
+double scn_gpu_float7FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume);
+double scn_gpu_float8FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume);
+double scn_gpu_float9FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume);
+double scn_gpu_float10FullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+    THCudaTensor *bias, long filterVolume);
+void scn_gpu_float1FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume);
+void scn_gpu_float2FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume);
+void scn_gpu_float3FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume);
+void scn_gpu_float4FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume);
+void scn_gpu_float5FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume);
+void scn_gpu_float6FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume);
+void scn_gpu_float7FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume);
+void scn_gpu_float8FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume);
+void scn_gpu_float9FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume);
+void scn_gpu_float10FullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THCudaTensor *input_features, THCudaTensor *d_input_features,
+    THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
+    THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float1MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float2MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float3MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float4MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float5MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float6MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float7MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float8MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float9MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float10MaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
 void scn_gpu_float1MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_gpu_float2MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_gpu_float3MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_gpu_float4MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_gpu_float5MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_gpu_float6MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_gpu_float7MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_gpu_float8MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_gpu_float9MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer);
+  long nFeaturesToDrop);
 void scn_gpu_float10MaxPooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *output_features, THCudaTensor *d_output_features,
-  long nFeaturesToDrop, THCudaIntTensor *rulesBuffer);
+  long nFeaturesToDrop);
+void scn_gpu_float1RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float2RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float3RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float4RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float5RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float6RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float7RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float8RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float9RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float10RandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float1RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_gpu_float2RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_gpu_float3RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_gpu_float4RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_gpu_float5RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_gpu_float6RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_gpu_float7RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_gpu_float8RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_gpu_float9RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop);
+void scn_gpu_float10RandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features,
+  long nFeaturesToDrop);
 void scn_gpu_float1SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes);
+  THCudaTensor *output_features, long nPlanes);
 void scn_gpu_float2SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes);
+  THCudaTensor *output_features, long nPlanes);
 void scn_gpu_float3SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes);
+  THCudaTensor *output_features, long nPlanes);
 void scn_gpu_float4SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes);
+  THCudaTensor *output_features, long nPlanes);
 void scn_gpu_float5SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes);
+  THCudaTensor *output_features, long nPlanes);
 void scn_gpu_float6SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes);
+  THCudaTensor *output_features, long nPlanes);
 void scn_gpu_float7SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes);
+  THCudaTensor *output_features, long nPlanes);
 void scn_gpu_float8SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes);
+  THCudaTensor *output_features, long nPlanes);
 void scn_gpu_float9SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes);
+  THCudaTensor *output_features, long nPlanes);
 void scn_gpu_float10SparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, long nPlanes);
+  THCudaTensor *output_features, long nPlanes);
 void scn_gpu_float1SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float2SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float3SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float4SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float5SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float6SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float7SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float8SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float9SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float10SparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-  THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 double scn_gpu_float1SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float2SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float3SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float4SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float5SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float6SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float7SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float8SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float9SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 double scn_gpu_float10SubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
-  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *bias, long filterVolume);
 void scn_gpu_float1SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float2SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float3SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float4SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float5SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float6SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float7SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float8SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float9SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float10SubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THCudaTensor *input_features, THCudaTensor *d_input_features,
   THCudaTensor *d_output_features, THCudaTensor *weight, THCudaTensor *d_weight,
-  THCudaTensor *d_bias, long filterVolume, THCudaIntTensor *rulesBuffer);
+  THCudaTensor *d_bias, long filterVolume);
 void scn_gpu_float1InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode);
 void scn_gpu_float2InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode);
 void scn_gpu_float3InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode);
 void scn_gpu_float4InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode);
 void scn_gpu_float5InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode);
 void scn_gpu_float6InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode);
 void scn_gpu_float7InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode);
 void scn_gpu_float8InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode);
 void scn_gpu_float9InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode);
 void scn_gpu_float10InputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long batchSize,
+  long mode);
 void scn_gpu_float1InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float2InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float3InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float4InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float5InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float6InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float7InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float8InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float9InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float10InputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
+void scn_gpu_float1OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
+void scn_gpu_float2OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
+void scn_gpu_float3OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
+void scn_gpu_float4OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
+void scn_gpu_float5OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
+void scn_gpu_float6OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
+void scn_gpu_float7OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
+void scn_gpu_float8OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
+void scn_gpu_float9OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
+void scn_gpu_float10OutputLayer_updateOutput(
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
+void scn_gpu_float1OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
+void scn_gpu_float2OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
+void scn_gpu_float3OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
+void scn_gpu_float4OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
+void scn_gpu_float5OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
+void scn_gpu_float6OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
+void scn_gpu_float7OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
+void scn_gpu_float8OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
+void scn_gpu_float9OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
+void scn_gpu_float10OutputLayer_updateGradInput(
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float1BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode);
 void scn_gpu_float2BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode);
 void scn_gpu_float3BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode);
 void scn_gpu_float4BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode);
 void scn_gpu_float5BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode);
 void scn_gpu_float6BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode);
 void scn_gpu_float7BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode);
 void scn_gpu_float8BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode);
 void scn_gpu_float9BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode);
 void scn_gpu_float10BLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer);
+  THCudaTensor *input_features, THCudaTensor *output_features, long mode);
 void scn_gpu_float1BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features);
 void scn_gpu_float2BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features);
 void scn_gpu_float3BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features);
 void scn_gpu_float4BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features);
 void scn_gpu_float5BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features);
 void scn_gpu_float6BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features);
 void scn_gpu_float7BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features);
 void scn_gpu_float8BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features);
 void scn_gpu_float9BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features);
 void scn_gpu_float10BLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features,THCudaTensor *d_output_features);
 void scn_gpu_float1BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
 void scn_gpu_float2BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
 void scn_gpu_float3BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
 void scn_gpu_float4BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
 void scn_gpu_float5BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
 void scn_gpu_float6BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
 void scn_gpu_float7BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
 void scn_gpu_float8BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
 void scn_gpu_float9BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
 void scn_gpu_float10BLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *input_features, THCudaTensor *output_features);
 void scn_gpu_float1BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float2BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float3BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float4BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float5BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float6BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float7BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float8BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float9BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
 void scn_gpu_float10BLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer);
\ No newline at end of file
+  void **m, THCudaTensor *d_input_features, THCudaTensor *d_output_features);
+void scn_gpu_float1UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float2UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float3UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float4UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float5UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float6UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float7UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float8UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float9UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float10UnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *output_features, long nFeaturesToDrop);
+void scn_gpu_float1UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_gpu_float2UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_gpu_float3UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_gpu_float4UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_gpu_float5UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_gpu_float6UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_gpu_float7UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_gpu_float8UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_gpu_float9UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop);
+void scn_gpu_float10UnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THCudaTensor *input_features,
+    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+    long nFeaturesToDrop);
\ No newline at end of file

PyTorch/sparseconvnet/SCN/init.cpp → sparseconvnet/SCN/init.cpp

@@ -36,7 +36,7 @@
 #include "generic/CPU/Deconvolution.cpp"
 #include "generic/CPU/THGenerateDimFloatTypes.h"
 
-#include "generic/CPU/InputLayer.cpp"
+#include "generic/CPU/IOLayers.cpp"
 #include "generic/CPU/THGenerateDimFloatTypes.h"
 
 #include "generic/CPU/LeakyReLU.cpp"
@@ -51,6 +51,9 @@
 #include "generic/CPU/SparseToDense.cpp"
 #include "generic/CPU/THGenerateDimFloatTypes.h"
 
+#include "generic/CPU/UnPooling.cpp"
+#include "generic/CPU/THGenerateDimFloatTypes.h"
+
 extern "C" long scn_readPtr(void **ptr) { return (long)(ptr[0]); }
 extern "C" void scn_writePtr(long p, void **ptr) { ptr[0] = (void *)p; }
 extern "C" double scn_ruleBookBits(void) { return 8 * sizeof(uInt); }

PyTorch/sparseconvnet/SCN/init.cu → sparseconvnet/SCN/init.cu

@@ -7,9 +7,6 @@
 #include "init.cpp"
 
 #include <THC/THC.h>
-// #include <THC/THCTensor.h>
-// #include <THC/THCNumerics.cuh>
-// #include <THC/THCAtomics.cuh>
 
 extern THCState *state;
 
@@ -37,7 +34,7 @@ extern THCState *state;
 #include "generic/GPU/Deconvolution.cu"
 #include "generic/GPU/THGenerateDimCudaFloatTypes.h"
 
-#include "generic/GPU/InputLayer.cu"
+#include "generic/GPU/IOLayers.cu"
 #include "generic/GPU/THGenerateDimCudaFloatTypes.h"
 
 #include "generic/GPU/LeakyReLU.cu"
@@ -52,5 +49,8 @@ extern THCState *state;
 #include "generic/GPU/SparseToDense.cu"
 #include "generic/GPU/THGenerateDimCudaFloatTypes.h"
 
+#include "generic/GPU/UnPooling.cu"
+#include "generic/GPU/THGenerateDimCudaFloatTypes.h"
+
 #undef scn_R_
 #undef scn_DR_

PyTorch/sparseconvnet/SCN/make_ffi_headers.py → sparseconvnet/SCN/make_ffi_headers.py

@@ -4,8 +4,6 @@
 # This source code is licensed under the license found in the
 # LICENSE file in the root directory of this source tree.
 
-n_bits = 32
-
 f_cpu = [open('header_cpu.c', 'w'), open('header_cpu.h', 'w')]
 f_gpu = [open('header_gpu.c', 'w'), open('header_gpu.h', 'w')]
 for f in f_cpu + f_gpu:
@@ -31,22 +29,18 @@ def dim_fn(st, f=f_cpu):
 def typed_fn(st):
     s = st
     s = s.replace('ARCH', 'cpu')
-    s = s.replace('THITensor', 'void')
     s = s.replace('REAL', 'float')
     s = s.replace('THTensor', 'THFloatTensor')
     fn(s, f_cpu)
 
     s = st
     s = s.replace('ARCH', 'cpu')
-    s = s.replace('THITensor', 'void')
     s = s.replace('REAL', 'double')
     s = s.replace('THTensor', 'THDoubleTensor')
     fn(s, f_cpu)
 
     s = st
     s = s.replace('ARCH', 'gpu')
-    s = s.replace('THITensor', 'THCudaIntTensor' if n_bits ==
-                  32 else 'THCudaLongTensor')
     s = s.replace('REAL', 'float')
     s = s.replace('THTensor', 'THCudaTensor')
     fn(s, f_gpu)
@@ -110,6 +104,9 @@ dim_fn("""
 void scn_DIMENSION_getSpatialLocations(void **m, THLongTensor *spatialSize,
   THLongTensor *locations)""")
 
+dim_fn("""
+void scn_DIMENSION_sparsifyMetadata(void **mIn, void **mOut,
+  THLongTensor *spatialSize, THByteTensor *filter, THLongTensor *cuSum)""")
 
 typed_fn("""
 void scn_ARCH_REAL_AffineReluTrivialConvolution_updateOutput(
@@ -184,35 +181,33 @@ void scn_ARCH_REAL_NetworkInNetwork_accGradParameters(
 
 dim_typed_fn("""
 void scn_ARCH_REAL_DIMENSIONActivePooling_updateOutput(
-  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-  THFloatTensor *output_features, void *rulesBuffer, _Bool average);""")
+  THLongTensor *inputSize, void **m, THTensor *input_features,
+  THTensor *output_features, _Bool average)""")
 
 dim_typed_fn("""void scn_ARCH_REAL_DIMENSIONActivePooling_updateGradInput(
   THLongTensor *inputSize, void **m,
-  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer, _Bool average);""")
+  THTensor *d_input_features, THTensor *d_output_features,
+  _Bool average)""")
 
 dim_typed_fn("""
 void scn_ARCH_REAL_DIMENSIONAveragePooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THTensor *input_features, THTensor *output_features, long nFeaturesToDrop,
-  THITensor *rulesBuffer)""")
+  THTensor *input_features, THTensor *output_features, long nFeaturesToDrop)""")
 
 dim_typed_fn("""
 void scn_ARCH_REAL_DIMENSIONAveragePooling_updateGradInput(
   THLongTensor * inputSize, THLongTensor * outputSize,
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THTensor *input_features, THTensor *d_input_features,
-  THTensor *d_output_features, long nFeaturesToDrop,
-  THITensor *rulesBuffer)""")
+  THTensor *d_output_features, long nFeaturesToDrop)""")
 
 dim_typed_fn("""
 double scn_ARCH_REAL_DIMENSIONConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THTensor *input_features, THTensor *output_features, THTensor *weight,
-  THTensor *bias, long filterVolume, THITensor *rulesBuffer)""")
+  THTensor *bias, long filterVolume)""")
 
 dim_typed_fn("""
 void scn_ARCH_REAL_DIMENSIONConvolution_backward(
@@ -220,14 +215,29 @@ void scn_ARCH_REAL_DIMENSIONConvolution_backward(
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THTensor *input_features, THTensor *d_input_features,
   THTensor *d_output_features, THTensor *weight, THTensor *d_weight,
-  THTensor *d_bias, long filterVolume, THITensor *rulesBuffer)""")
+  THTensor *d_bias, long filterVolume)""")
+
+dim_typed_fn("""
+double scn_ARCH_REAL_DIMENSIONRandomizedStrideConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THTensor *input_features, THTensor *output_features, THTensor *weight,
+  THTensor *bias, long filterVolume)""")
+
+dim_typed_fn("""
+void scn_ARCH_REAL_DIMENSIONRandomizedStrideConvolution_backward(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THTensor *input_features, THTensor *d_input_features,
+  THTensor *d_output_features, THTensor *weight, THTensor *d_weight,
+  THTensor *d_bias, long filterVolume)""")
 
 dim_typed_fn("""
 double scn_ARCH_REAL_DIMENSIONDeconvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THTensor *input_features, THTensor *output_features, THTensor *weight,
-  THTensor *bias, long filterVolume, THITensor *rulesBuffer)""")
+  THTensor *bias, long filterVolume)""")
 
 dim_typed_fn("""
 void scn_ARCH_REAL_DIMENSIONDeconvolution_backward(
@@ -235,14 +245,28 @@ void scn_ARCH_REAL_DIMENSIONDeconvolution_backward(
   THLongTensor *filterSize, THLongTensor *filterStride, void **m,
   THTensor *input_features, THTensor *d_input_features,
   THTensor *d_output_features, THTensor *weight, THTensor *d_weight,
-  THTensor *d_bias, long filterVolume, THITensor *rulesBuffer)""")
+  THTensor *d_bias, long filterVolume)""")
+
+dim_typed_fn("""
+double scn_ARCH_REAL_DIMENSIONFullConvolution_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THTensor *input_features, THTensor *output_features, THTensor *weight,
+    THTensor *bias, long filterVolume)""")
+
+dim_typed_fn("""
+void scn_ARCH_REAL_DIMENSIONFullConvolution_backward(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *filterSize,
+    THLongTensor *filterStride, void **mIn, void **mOut,
+    THTensor *input_features, THTensor *d_input_features,
+    THTensor *d_output_features, THTensor *weight, THTensor *d_weight,
+    THTensor *d_bias, long filterVolume)""")
 
 dim_typed_fn("""
 void scn_ARCH_REAL_DIMENSIONMaxPooling_updateOutput(
   THLongTensor *inputSize, THLongTensor *outputSize,
   THLongTensor *poolSize, THLongTensor *poolStride, void **m,
-  THTensor *input_features, THTensor *output_features, long nFeaturesToDrop,
-  THITensor *rulesBuffer)""")
+  THTensor *input_features, THTensor *output_features, long nFeaturesToDrop)""")
 
 dim_typed_fn("""
 void scn_ARCH_REAL_DIMENSIONMaxPooling_updateGradInput(
@@ -250,61 +274,91 @@ void scn_ARCH_REAL_DIMENSIONMaxPooling_updateGradInput(
   THLongTensor * poolSize, THLongTensor * poolStride, void **m,
   THTensor *input_features, THTensor *d_input_features,
   THTensor *output_features, THTensor *d_output_features,
-  long nFeaturesToDrop, THITensor *rulesBuffer)""")
+  long nFeaturesToDrop)""")
+
+
+dim_typed_fn("""
+void scn_ARCH_REAL_DIMENSIONRandomizedStrideMaxPooling_updateOutput(
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THTensor *input_features, THTensor *output_features, long nFeaturesToDrop)""")
+
+dim_typed_fn("""
+void scn_ARCH_REAL_DIMENSIONRandomizedStrideMaxPooling_updateGradInput(
+  THLongTensor * inputSize, THLongTensor * outputSize,
+  THLongTensor * poolSize, THLongTensor * poolStride, void **m,
+  THTensor *input_features, THTensor *d_input_features,
+  THTensor *output_features, THTensor *d_output_features,
+  long nFeaturesToDrop)""")
 
 dim_typed_fn("""
 void scn_ARCH_REAL_DIMENSIONSparseToDense_updateOutput(
   THLongTensor *inputSize, void **m, THTensor *input_features,
-  THTensor *output_features, THITensor *rulesBuffer, long nPlanes)""")
+  THTensor *output_features, long nPlanes)""")
 
 dim_typed_fn("""
 void scn_ARCH_REAL_DIMENSIONSparseToDense_updateGradInput(
   THLongTensor *inputSize, void **m, THTensor *input_features,
-  THTensor *d_input_features, THTensor *d_output_features,
-  THITensor *rulesBuffer)""")
+  THTensor *d_input_features, THTensor *d_output_features)""")
 
 dim_typed_fn("""
 double scn_ARCH_REAL_DIMENSIONSubmanifoldConvolution_updateOutput(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THTensor *input_features, THTensor *output_features, THTensor *weight,
-  THTensor *bias, long filterVolume, THITensor *rulesBuffer)""")
+  THTensor *bias, long filterVolume)""")
 
 dim_typed_fn("""
 void scn_ARCH_REAL_DIMENSIONSubmanifoldConvolution_backward(
   THLongTensor *inputSize, THLongTensor *filterSize, void **m,
   THTensor *input_features, THTensor *d_input_features,
   THTensor *d_output_features, THTensor *weight, THTensor *d_weight,
-  THTensor *d_bias, long filterVolume, THITensor *rulesBuffer)""")
+  THTensor *d_bias, long filterVolume)""")
 
 
 dim_typed_fn("""
 void scn_ARCH_REAL_DIMENSIONInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long batchSize,
-  long mode, void *rulesBuffer)""")
+  THTensor *input_features, THTensor *output_features, long batchSize,
+  long mode)""")
 
 dim_typed_fn("""
 void scn_ARCH_REAL_DIMENSIONInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer)""")
+  void **m, THTensor *d_input_features, THTensor *d_output_features)""")
+
+dim_typed_fn("""
+void scn_ARCH_REAL_DIMENSIONOutputLayer_updateOutput(
+  void **m, THTensor *input_features, THTensor *output_features)""")
+
+dim_typed_fn("""
+void scn_ARCH_REAL_DIMENSIONOutputLayer_updateGradInput(
+  void **m, THTensor *d_input_features, THTensor *d_output_features)""")
 
 dim_typed_fn("""
 void scn_ARCH_REAL_DIMENSIONBLInputLayer_updateOutput(
   void **m, THLongTensor *spatialSize, THLongTensor *input_coords,
-  THFloatTensor *input_features, THFloatTensor *output_features, long mode,
-  void *rulesBuffer)""")
+  THTensor *input_features, THTensor *output_features, long mode)""")
 
 dim_typed_fn("""
 void scn_ARCH_REAL_DIMENSIONBLInputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features,THFloatTensor *d_output_features,
-  void *rulesBuffer)""")
+  void **m, THTensor *d_input_features,THTensor *d_output_features)""")
 
 dim_typed_fn("""
 void scn_ARCH_REAL_DIMENSIONBLOutputLayer_updateOutput(
-  void **m, THFloatTensor *input_features, THFloatTensor *output_features,
-  void *rulesBuffer)""")
+  void **m, THTensor *input_features, THTensor *output_features)""")
 
 dim_typed_fn("""
 void scn_ARCH_REAL_DIMENSIONBLOutputLayer_updateGradInput(
-  void **m, THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-  void *rulesBuffer)""")
+  void **m, THTensor *d_input_features, THTensor *d_output_features)""")
+
+dim_typed_fn("""
+void scn_ARCH_REAL_DIMENSIONUnPooling_updateOutput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THTensor *input_features,
+    THTensor *output_features, long nFeaturesToDrop)""")
+
+dim_typed_fn("""
+void scn_ARCH_REAL_DIMENSIONUnPooling_updateGradInput(
+    THLongTensor *inputSize, THLongTensor *outputSize, THLongTensor *poolSize,
+    THLongTensor *poolStride, void **m, THTensor *input_features,
+    THTensor *d_input_features, THTensor *d_output_features,
+    long nFeaturesToDrop)""")

PyTorch/sparseconvnet/__init__.py → sparseconvnet/__init__.py

@@ -6,7 +6,7 @@
 
 forward_pass_multiplyAdd_count = 0
 forward_pass_hidden_states = 0
-from .activations import Tanh, Sigmoid, ReLU, ELU
+from .activations import Tanh, Sigmoid, ReLU, ELU, BatchNormELU
 from .averagePooling import AveragePooling
 from .batchNormalization import BatchNormalization, BatchNormReLU, BatchNormLeakyReLU
 from .classificationTrainValidate import ClassificationTrainValidate
@@ -14,18 +14,23 @@ from .convolution import Convolution
 from .deconvolution import Deconvolution
 from .denseToSparse import DenseToSparse
 from .dropout import Dropout, BatchwiseDropout
+from .fullConvolution import FullConvolution
 from .identity import Identity
 from .inputBatch import InputBatch
-from .inputLayer import InputLayer, BLInputLayer, BLOutputLayer
+from .ioLayers import InputLayer, OutputLayer, BLInputLayer, BLOutputLayer
 from .maxPooling import MaxPooling
 from .metadata import Metadata
 from .networkArchitectures import *
 from .networkInNetwork import NetworkInNetwork
+from .randomizedStrideConvolution import RandomizedStrideConvolution
+from .randomizedStrideMaxPooling import RandomizedStrideMaxPooling
 from .sequential import Sequential
 from .sparseConvNetTensor import SparseConvNetTensor
 from .sparseToDense import SparseToDense
+from .sparsify import Sparsify
 from .submanifoldConvolution import SubmanifoldConvolution, ValidConvolution
 from .tables import *
+from .unPooling import UnPooling
 
 
 def concatenate_feature_planes(input):

PyTorch/sparseconvnet/activations.py → sparseconvnet/activations.py

@@ -47,3 +47,6 @@ class ELU(Module):
         output.metadata = input.metadata
         output.spatial_size = input.spatial_size
         return output
+
+def BatchNormELU(nPlanes, eps=1e-4, momentum=0.9):
+    return sparseconvnet.Sequential().add(BatchNormalization(nPlanes,eps,momentum)).add(ELU())

PyTorch/sparseconvnet/averagePooling.py → sparseconvnet/averagePooling.py

@@ -89,8 +89,7 @@ class AveragePoolingFunction(Function):
             input_metadata.ffi,
             input_features,
             output_features,
-            nFeaturesToDrop,
-            torch.cuda.IntTensor() if input_features.is_cuda else nullptr)
+            nFeaturesToDrop)
         ctx.save_for_backward(input_features,
                               output_features,
                               input_spatial_size,
@@ -119,6 +118,5 @@ class AveragePoolingFunction(Function):
             input_features,
             grad_input,
             grad_output.contiguous(),
-            ctx.nFeaturesToDrop,
-            torch.cuda.IntTensor() if input_features.is_cuda else nullptr)
+            ctx.nFeaturesToDrop)
         return grad_input, None, None, None, None, None, None, None