add batch information to getSpatialLocations

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

@@ -63,9 +63,7 @@ extern "C" void scn_D_(setInputSpatialLocations)(void **m,
   assert((locations->size[1] == Dimension or
           locations->size[1] == 1 + Dimension) and
          "locations.size(0) must be either Dimension or Dimension+1");
-
   SCN_INITIALIZE_AND_REFERENCE(Metadata<Dimension>, m)
-
   Point<Dimension> p;
   auto &nActive = *_m.inputNActive;
   auto nPlanes = vecs->size[1];
@@ -73,7 +71,8 @@ extern "C" void scn_D_(setInputSpatialLocations)(void **m,
   auto v = THFloatTensor_data(vecs);
 
   if (locations->size[1] == Dimension) {
-    assert(_m.inputSG); // add points to current sample
+    // add points to current sample
+    assert(_m.inputSG);
     auto &mp = _m.inputSG->mp;
     for (uInt idx = 0; idx < locations->size[0]; ++idx) {
       for (int d = 0; d < Dimension; ++d)
@@ -101,9 +100,9 @@ extern "C" void scn_D_(setInputSpatialLocations)(void **m,
   }
 }
 
-extern "C" void scn_D_(getSpatialLocations)(void **m,
-                                            THLongTensor *spatialSize,
-                                            THLongTensor *locations) {
+extern "C" void scn_D_(getSpatialLocations)(void **m, THLongTensor *spatialSize,
+                                            THLongTensor *locations,
+                                            THLongTensor *batchIdxs) {
   SCN_INITIALIZE_AND_REFERENCE(Metadata<Dimension>, m)
   uInt nActive = _m.getNActive(spatialSize);
   auto &SGs = _m.getSparseGrid(spatialSize);
@@ -125,9 +124,9 @@ extern "C" void scn_D_(getSpatialLocations)(void **m,
   }
 }
 extern "C" void
-    scn_D_(createMetadataForDenseToSparse)(void **m, THLongTensor *spatialSize_,
-                                           THLongTensor *pad_,
-                                           THLongTensor *nz_, long batchSize) {
+scn_D_(createMetadataForDenseToSparse)(void **m, THLongTensor *spatialSize_,
+                                       THLongTensor *pad_, THLongTensor *nz_,
+                                       long batchSize) {
   SCN_INITIALIZE_AND_REFERENCE(Metadata<Dimension>, m)
   _m.setInputSpatialSize(spatialSize_);
   _m.inputSGs->resize(batchSize);

PyTorch/sparseconvnet/SCN/header_cpu.h

@@ -4,1872 +4,1829 @@
 // This source code is licensed under the license found in the
 // LICENSE file in the root directory of this source tree.
 
-void scn_2_drawCurve(void **m, THFloatTensor *features, THFloatTensor *stroke);
-
 long scn_readPtr(void **ptr);
 void scn_writePtr(long p, void **ptr);
 double scn_ruleBookBits(void);
-double scn_1_addSampleFromThresholdedTensor(void **m, THFloatTensor *features_,
-                                            THFloatTensor *tensor_,
-                                            THLongTensor *offset_,
-                                            THLongTensor *spatialSize_,
-                                            float threshold);
+void scn_2_drawCurve(void **m, THFloatTensor *features, THFloatTensor *stroke);
+  double scn_1_addSampleFromThresholdedTensor(
+  void **m, THFloatTensor *features_, THFloatTensor *tensor_,
+  THLongTensor *offset_, THLongTensor *spatialSize_, float threshold);
 void scn_1_batchAddSample(void **m);
-void scn_1_createMetadataForDenseToSparse(void **m, THLongTensor *spatialSize_,
-                                          THLongTensor *pad, THLongTensor *nz,
-                                          long batchSize);
+void scn_1_createMetadataForDenseToSparse(
+  void **m, THLongTensor *spatialSize_, THLongTensor *pad, THLongTensor *nz,
+  long batchSize);
 void scn_1_freeMetadata(void **metadata);
 void scn_1_generateRuleBooks3s2(void **m);
 void scn_1_generateRuleBooks2s2(void **m);
 void scn_1_setInputSpatialSize(void **m, THLongTensor *spatialSize);
 void scn_1_setInputSpatialLocation(void **m, THFloatTensor *features,
-                                   THLongTensor *location, THFloatTensor *vec,
-                                   _Bool overwrite);
+  THLongTensor *location, THFloatTensor *vec, _Bool overwrite);
 void scn_1_setInputSpatialLocations(void **m, THFloatTensor *features,
-                                   THLongTensor *locations, THFloatTensor *vecs,
-                                   _Bool overwrite);
-void scn_1_getSpatialLocations(void **m,
-                               THLongTensor *spatialSize,
-                               THLongTensor *locations);
-double scn_2_addSampleFromThresholdedTensor(void **m, THFloatTensor *features_,
-                                            THFloatTensor *tensor_,
-                                            THLongTensor *offset_,
-                                            THLongTensor *spatialSize_,
-                                            float threshold);
+  THLongTensor *locations, THFloatTensor *vecs, _Bool overwrite);
+void scn_1_getSpatialLocations(void **m, THLongTensor *spatialSize,
+  THLongTensor *locations);
+  double scn_2_addSampleFromThresholdedTensor(
+  void **m, THFloatTensor *features_, THFloatTensor *tensor_,
+  THLongTensor *offset_, THLongTensor *spatialSize_, float threshold);
 void scn_2_batchAddSample(void **m);
-void scn_2_createMetadataForDenseToSparse(void **m, THLongTensor *spatialSize_,
-                                          THLongTensor *pad, THLongTensor *nz,
-                                          long batchSize);
+void scn_2_createMetadataForDenseToSparse(
+  void **m, THLongTensor *spatialSize_, THLongTensor *pad, THLongTensor *nz,
+  long batchSize);
 void scn_2_freeMetadata(void **metadata);
 void scn_2_generateRuleBooks3s2(void **m);
 void scn_2_generateRuleBooks2s2(void **m);
 void scn_2_setInputSpatialSize(void **m, THLongTensor *spatialSize);
 void scn_2_setInputSpatialLocation(void **m, THFloatTensor *features,
-                                   THLongTensor* location, THFloatTensor *vec,
-                                   _Bool overwrite);
+  THLongTensor *location, THFloatTensor *vec, _Bool overwrite);
 void scn_2_setInputSpatialLocations(void **m, THFloatTensor *features,
-                                   THLongTensor *locations, THFloatTensor *vecs,
-                                   _Bool overwrite);
-void scn_2_getSpatialLocations(void **m,
-                               THLongTensor *spatialSize,
-                               THLongTensor *locations);
-double scn_3_addSampleFromThresholdedTensor(void **m, THFloatTensor *features_,
-                                            THFloatTensor *tensor_,
-                                            THLongTensor *offset_,
-                                            THLongTensor *spatialSize_,
-                                            float threshold);
+  THLongTensor *locations, THFloatTensor *vecs, _Bool overwrite);
+void scn_2_getSpatialLocations(void **m, THLongTensor *spatialSize,
+  THLongTensor *locations);
+  double scn_3_addSampleFromThresholdedTensor(
+  void **m, THFloatTensor *features_, THFloatTensor *tensor_,
+  THLongTensor *offset_, THLongTensor *spatialSize_, float threshold);
 void scn_3_batchAddSample(void **m);
-void scn_3_createMetadataForDenseToSparse(void **m, THLongTensor *spatialSize_,
-                                          THLongTensor *pad, THLongTensor *nz,
-                                          long batchSize);
+void scn_3_createMetadataForDenseToSparse(
+  void **m, THLongTensor *spatialSize_, THLongTensor *pad, THLongTensor *nz,
+  long batchSize);
 void scn_3_freeMetadata(void **metadata);
 void scn_3_generateRuleBooks3s2(void **m);
 void scn_3_generateRuleBooks2s2(void **m);
 void scn_3_setInputSpatialSize(void **m, THLongTensor *spatialSize);
 void scn_3_setInputSpatialLocation(void **m, THFloatTensor *features,
-                                   THLongTensor *location, THFloatTensor *vec,
-                                   _Bool overwrite);
+  THLongTensor *location, THFloatTensor *vec, _Bool overwrite);
 void scn_3_setInputSpatialLocations(void **m, THFloatTensor *features,
-                                   THLongTensor *locations, THFloatTensor *vecs,
-                                   _Bool overwrite);
-void scn_3_getSpatialLocations(void **m,
-                               THLongTensor *spatialSize,
-                               THLongTensor *locations);
-double scn_4_addSampleFromThresholdedTensor(void **m, THFloatTensor *features_,
-                                            THFloatTensor *tensor_,
-                                            THLongTensor *offset_,
-                                            THLongTensor *spatialSize_,
-                                            float threshold);
+  THLongTensor *locations, THFloatTensor *vecs, _Bool overwrite);
+void scn_3_getSpatialLocations(void **m, THLongTensor *spatialSize,
+  THLongTensor *locations);
+  double scn_4_addSampleFromThresholdedTensor(
+  void **m, THFloatTensor *features_, THFloatTensor *tensor_,
+  THLongTensor *offset_, THLongTensor *spatialSize_, float threshold);
 void scn_4_batchAddSample(void **m);
-void scn_4_createMetadataForDenseToSparse(void **m, THLongTensor *spatialSize_,
-                                          THLongTensor *pad, THLongTensor *nz,
-                                          long batchSize);
+void scn_4_createMetadataForDenseToSparse(
+  void **m, THLongTensor *spatialSize_, THLongTensor *pad, THLongTensor *nz,
+  long batchSize);
 void scn_4_freeMetadata(void **metadata);
 void scn_4_generateRuleBooks3s2(void **m);
 void scn_4_generateRuleBooks2s2(void **m);
 void scn_4_setInputSpatialSize(void **m, THLongTensor *spatialSize);
 void scn_4_setInputSpatialLocation(void **m, THFloatTensor *features,
-                                   THLongTensor *location, THFloatTensor *vec,
-                                   _Bool overwrite);
+  THLongTensor *location, THFloatTensor *vec, _Bool overwrite);
 void scn_4_setInputSpatialLocations(void **m, THFloatTensor *features,
-                                   THLongTensor *locations, THFloatTensor *vecs,
-                                   _Bool overwrite);
-void scn_4_getSpatialLocations(void **m,
-                               THLongTensor *spatialSize,
-                               THLongTensor *locations);
-double scn_5_addSampleFromThresholdedTensor(void **m, THFloatTensor *features_,
-                                            THFloatTensor *tensor_,
-                                            THLongTensor *offset_,
-                                            THLongTensor *spatialSize_,
-                                            float threshold);
+  THLongTensor *locations, THFloatTensor *vecs, _Bool overwrite);
+void scn_4_getSpatialLocations(void **m, THLongTensor *spatialSize,
+  THLongTensor *locations);
+  double scn_5_addSampleFromThresholdedTensor(
+  void **m, THFloatTensor *features_, THFloatTensor *tensor_,
+  THLongTensor *offset_, THLongTensor *spatialSize_, float threshold);
 void scn_5_batchAddSample(void **m);
-void scn_5_createMetadataForDenseToSparse(void **m, THLongTensor *spatialSize_,
-                                          THLongTensor *pad, THLongTensor *nz,
-                                          long batchSize);
+void scn_5_createMetadataForDenseToSparse(
+  void **m, THLongTensor *spatialSize_, THLongTensor *pad, THLongTensor *nz,
+  long batchSize);
 void scn_5_freeMetadata(void **metadata);
 void scn_5_generateRuleBooks3s2(void **m);
 void scn_5_generateRuleBooks2s2(void **m);
 void scn_5_setInputSpatialSize(void **m, THLongTensor *spatialSize);
 void scn_5_setInputSpatialLocation(void **m, THFloatTensor *features,
-                                   THLongTensor *location, THFloatTensor *vec,
-                                   _Bool overwrite);
+  THLongTensor *location, THFloatTensor *vec, _Bool overwrite);
 void scn_5_setInputSpatialLocations(void **m, THFloatTensor *features,
-                                   THLongTensor *locations, THFloatTensor *vecs,
-                                   _Bool overwrite);
-void scn_5_getSpatialLocations(void **m,
-                               THLongTensor *spatialSize,
-                               THLongTensor *locations);
-double scn_6_addSampleFromThresholdedTensor(void **m, THFloatTensor *features_,
-                                            THFloatTensor *tensor_,
-                                            THLongTensor *offset_,
-                                            THLongTensor *spatialSize_,
-                                            float threshold);
+  THLongTensor *locations, THFloatTensor *vecs, _Bool overwrite);
+void scn_5_getSpatialLocations(void **m, THLongTensor *spatialSize,
+  THLongTensor *locations);
+  double scn_6_addSampleFromThresholdedTensor(
+  void **m, THFloatTensor *features_, THFloatTensor *tensor_,
+  THLongTensor *offset_, THLongTensor *spatialSize_, float threshold);
 void scn_6_batchAddSample(void **m);
-void scn_6_createMetadataForDenseToSparse(void **m, THLongTensor *spatialSize_,
-                                          THLongTensor *pad, THLongTensor *nz,
-                                          long batchSize);
+void scn_6_createMetadataForDenseToSparse(
+  void **m, THLongTensor *spatialSize_, THLongTensor *pad, THLongTensor *nz,
+  long batchSize);
 void scn_6_freeMetadata(void **metadata);
 void scn_6_generateRuleBooks3s2(void **m);
 void scn_6_generateRuleBooks2s2(void **m);
 void scn_6_setInputSpatialSize(void **m, THLongTensor *spatialSize);
 void scn_6_setInputSpatialLocation(void **m, THFloatTensor *features,
-                                   THLongTensor *location, THFloatTensor *vec,
-                                   _Bool overwrite);
+  THLongTensor *location, THFloatTensor *vec, _Bool overwrite);
 void scn_6_setInputSpatialLocations(void **m, THFloatTensor *features,
-                                   THLongTensor *locations, THFloatTensor *vecs,
-                                   _Bool overwrite);
-void scn_6_getSpatialLocations(void **m,
-                               THLongTensor *spatialSize,
-                               THLongTensor *locations);
-double scn_7_addSampleFromThresholdedTensor(void **m, THFloatTensor *features_,
-                                            THFloatTensor *tensor_,
-                                            THLongTensor *offset_,
-                                            THLongTensor *spatialSize_,
-                                            float threshold);
+  THLongTensor *locations, THFloatTensor *vecs, _Bool overwrite);
+void scn_6_getSpatialLocations(void **m, THLongTensor *spatialSize,
+  THLongTensor *locations);
+  double scn_7_addSampleFromThresholdedTensor(
+  void **m, THFloatTensor *features_, THFloatTensor *tensor_,
+  THLongTensor *offset_, THLongTensor *spatialSize_, float threshold);
 void scn_7_batchAddSample(void **m);
-void scn_7_createMetadataForDenseToSparse(void **m, THLongTensor *spatialSize_,
-                                          THLongTensor *pad, THLongTensor *nz,
-                                          long batchSize);
+void scn_7_createMetadataForDenseToSparse(
+  void **m, THLongTensor *spatialSize_, THLongTensor *pad, THLongTensor *nz,
+  long batchSize);
 void scn_7_freeMetadata(void **metadata);
 void scn_7_generateRuleBooks3s2(void **m);
 void scn_7_generateRuleBooks2s2(void **m);
 void scn_7_setInputSpatialSize(void **m, THLongTensor *spatialSize);
 void scn_7_setInputSpatialLocation(void **m, THFloatTensor *features,
-                                   THLongTensor *location, THFloatTensor *vec,
-                                   _Bool overwrite);
+  THLongTensor *location, THFloatTensor *vec, _Bool overwrite);
 void scn_7_setInputSpatialLocations(void **m, THFloatTensor *features,
-                                   THLongTensor *locations, THFloatTensor *vecs,
-                                   _Bool overwrite);
-void scn_7_getSpatialLocations(void **m,
-                               THLongTensor *spatialSize,
-                               THLongTensor *locations);
-double scn_8_addSampleFromThresholdedTensor(void **m, THFloatTensor *features_,
-                                            THFloatTensor *tensor_,
-                                            THLongTensor *offset_,
-                                            THLongTensor *spatialSize_,
-                                            float threshold);
+  THLongTensor *locations, THFloatTensor *vecs, _Bool overwrite);
+void scn_7_getSpatialLocations(void **m, THLongTensor *spatialSize,
+  THLongTensor *locations);
+  double scn_8_addSampleFromThresholdedTensor(
+  void **m, THFloatTensor *features_, THFloatTensor *tensor_,
+  THLongTensor *offset_, THLongTensor *spatialSize_, float threshold);
 void scn_8_batchAddSample(void **m);
-void scn_8_createMetadataForDenseToSparse(void **m, THLongTensor *spatialSize_,
-                                          THLongTensor *pad, THLongTensor *nz,
-                                          long batchSize);
+void scn_8_createMetadataForDenseToSparse(
+  void **m, THLongTensor *spatialSize_, THLongTensor *pad, THLongTensor *nz,
+  long batchSize);
 void scn_8_freeMetadata(void **metadata);
 void scn_8_generateRuleBooks3s2(void **m);
 void scn_8_generateRuleBooks2s2(void **m);
 void scn_8_setInputSpatialSize(void **m, THLongTensor *spatialSize);
 void scn_8_setInputSpatialLocation(void **m, THFloatTensor *features,
-                                   THLongTensor *location, THFloatTensor *vec,
-                                  _Bool overwrite);
+  THLongTensor *location, THFloatTensor *vec, _Bool overwrite);
 void scn_8_setInputSpatialLocations(void **m, THFloatTensor *features,
-                                   THLongTensor *locations, THFloatTensor *vecs,
-                                   _Bool overwrite);
-void scn_8_getSpatialLocations(void **m,
-                               THLongTensor *spatialSize,
-                               THLongTensor *locations);
-double scn_9_addSampleFromThresholdedTensor(void **m, THFloatTensor *features_,
-                                            THFloatTensor *tensor_,
-                                            THLongTensor *offset_,
-                                            THLongTensor *spatialSize_,
-                                            float threshold);
+  THLongTensor *locations, THFloatTensor *vecs, _Bool overwrite);
+void scn_8_getSpatialLocations(void **m, THLongTensor *spatialSize,
+  THLongTensor *locations);
+  double scn_9_addSampleFromThresholdedTensor(
+  void **m, THFloatTensor *features_, THFloatTensor *tensor_,
+  THLongTensor *offset_, THLongTensor *spatialSize_, float threshold);
 void scn_9_batchAddSample(void **m);
-void scn_9_createMetadataForDenseToSparse(void **m, THLongTensor *spatialSize_,
-                                          THLongTensor *pad, THLongTensor *nz,
-                                          long batchSize);
+void scn_9_createMetadataForDenseToSparse(
+  void **m, THLongTensor *spatialSize_, THLongTensor *pad, THLongTensor *nz,
+  long batchSize);
 void scn_9_freeMetadata(void **metadata);
 void scn_9_generateRuleBooks3s2(void **m);
 void scn_9_generateRuleBooks2s2(void **m);
 void scn_9_setInputSpatialSize(void **m, THLongTensor *spatialSize);
 void scn_9_setInputSpatialLocation(void **m, THFloatTensor *features,
-                                   THLongTensor *location, THFloatTensor *vec,
-                                   _Bool overwrite);
+  THLongTensor *location, THFloatTensor *vec, _Bool overwrite);
 void scn_9_setInputSpatialLocations(void **m, THFloatTensor *features,
-                                   THLongTensor *locations, THFloatTensor *vecs,
-                                   _Bool overwrite);
-void scn_9_getSpatialLocations(void **m,
-                               THLongTensor *spatialSize,
-                               THLongTensor *locations);
-double scn_10_addSampleFromThresholdedTensor(void **m, THFloatTensor *features_,
-                                             THFloatTensor *tensor_,
-                                             THLongTensor *offset_,
-                                             THLongTensor *spatialSize_,
-                                             float threshold);
+  THLongTensor *locations, THFloatTensor *vecs, _Bool overwrite);
+void scn_9_getSpatialLocations(void **m, THLongTensor *spatialSize,
+  THLongTensor *locations);
+  double scn_10_addSampleFromThresholdedTensor(
+  void **m, THFloatTensor *features_, THFloatTensor *tensor_,
+  THLongTensor *offset_, THLongTensor *spatialSize_, float threshold);
 void scn_10_batchAddSample(void **m);
-void scn_10_createMetadataForDenseToSparse(void **m, THLongTensor *spatialSize_,
-                                           THLongTensor *pad, THLongTensor *nz,
-                                           long batchSize);
+void scn_10_createMetadataForDenseToSparse(
+  void **m, THLongTensor *spatialSize_, THLongTensor *pad, THLongTensor *nz,
+  long batchSize);
 void scn_10_freeMetadata(void **metadata);
 void scn_10_generateRuleBooks3s2(void **m);
 void scn_10_generateRuleBooks2s2(void **m);
 void scn_10_setInputSpatialSize(void **m, THLongTensor *spatialSize);
 void scn_10_setInputSpatialLocation(void **m, THFloatTensor *features,
-                                    THLongTensor *location, THFloatTensor *vec,
-                                    _Bool overwrite);
+  THLongTensor *location, THFloatTensor *vec, _Bool overwrite);
 void scn_10_setInputSpatialLocations(void **m, THFloatTensor *features,
-                                   THLongTensor *locations, THFloatTensor *vecs,
-                                   _Bool overwrite);
-void scn_10_getSpatialLocations(void **m,
-                                THLongTensor *spatialSize,
-                                THLongTensor *locations);
-void scn_cpu_float_AffineReluTrivialConvolution_updateOutput(
-    THFloatTensor *input_features, THFloatTensor *output_features,
-    THFloatTensor *affineWeight, THFloatTensor *affineBias,
-    THFloatTensor *convWeight);
+  THLongTensor *locations, THFloatTensor *vecs, _Bool overwrite);
+void scn_10_getSpatialLocations(void **m, THLongTensor *spatialSize,
+  THLongTensor *locations);
+  void scn_cpu_float_AffineReluTrivialConvolution_updateOutput(
+  THFloatTensor *input_features, THFloatTensor *output_features,
+  THFloatTensor *affineWeight, THFloatTensor *affineBias, THFloatTensor *convWeight);
 void scn_cpu_float_AffineReluTrivialConvolution_backward(
-    THFloatTensor *input_features, THFloatTensor *d_input_features,
-    THFloatTensor *d_output_features, THFloatTensor *affineWeight,
-    THFloatTensor *d_affineWeight, THFloatTensor *affineBias,
-    THFloatTensor *d_affineBias, THFloatTensor *convWeight,
-    THFloatTensor *d_convWeight, _Bool additiveGrad);
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *affineWeight,
+  THFloatTensor *d_affineWeight, THFloatTensor *affineBias, THFloatTensor *d_affineBias,
+  THFloatTensor *convWeight, THFloatTensor *d_convWeight, _Bool additiveGrad);
 
 // BatchwiseMultiplicativeDropout
 void scn_cpu_float_BatchwiseMultiplicativeDropout_updateOutput(
-    THFloatTensor *input_features, THFloatTensor *output_features,
-    THFloatTensor *noise, long nPlanes, long input_stride, long output_stride,
-    float alpha);
+  THFloatTensor *input_features, THFloatTensor *output_features,
+  THFloatTensor *noise, long nPlanes, long input_stride, long output_stride,
+  float alpha);
 void scn_cpu_float_BatchwiseMultiplicativeDropout_updateGradInput(
-    THFloatTensor *input_features, THFloatTensor *d_input_features,
-    THFloatTensor *d_output_features, THFloatTensor *noise, long nPlanes,
-    long input_stride, long output_stride, float alpha);
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, THFloatTensor *noise, long nPlanes,
+  long input_stride, long output_stride, float alpha);
 
 // BatchNormalization
 void scn_cpu_float_BatchNormalization_updateOutput(
-    THFloatTensor *input_features, THFloatTensor *output_features,
-    THFloatTensor *saveMean, THFloatTensor *saveInvStd,
-    THFloatTensor *runningMean, THFloatTensor *runningVar,
-    THFloatTensor *weight, THFloatTensor *bias, float eps, float momentum,
-    _Bool train, float leakiness);
+  THFloatTensor *input_features, THFloatTensor *output_features,
+  THFloatTensor *saveMean, THFloatTensor *saveInvStd, THFloatTensor *runningMean,
+  THFloatTensor *runningVar, THFloatTensor *weight, THFloatTensor *bias, float eps,
+  float momentum, _Bool train, float leakiness);
 void scn_cpu_float_BatchNormalization_backward(
-    THFloatTensor *input_features, THFloatTensor *d_input_features,
-    THFloatTensor *output_features, THFloatTensor *d_output_features,
-    THFloatTensor *saveMean, THFloatTensor *saveInvStd,
-    THFloatTensor *runningMean, THFloatTensor *runningVar,
-    THFloatTensor *weight, THFloatTensor *bias, THFloatTensor *d_weight,
-    THFloatTensor *d_bias, float leakiness);
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *output_features, THFloatTensor *d_output_features, THFloatTensor *saveMean,
+  THFloatTensor *saveInvStd, THFloatTensor *runningMean, THFloatTensor *runningVar,
+  THFloatTensor *weight, THFloatTensor *bias, THFloatTensor *d_weight, THFloatTensor *d_bias,
+  float leakiness);
 // BatchNormalizationInTensor
 void scn_cpu_float_BatchNormalizationInTensor_updateOutput(
-    THFloatTensor *input_features, THFloatTensor *output_features,
-    THFloatTensor *saveMean, THFloatTensor *saveInvStd,
-    THFloatTensor *runningMean, THFloatTensor *runningVar,
-    THFloatTensor *weight, THFloatTensor *bias, float eps, float momentum,
-    _Bool train, float leakiness);
+  THFloatTensor *input_features, THFloatTensor *output_features,
+  THFloatTensor *saveMean, THFloatTensor *saveInvStd, THFloatTensor *runningMean,
+  THFloatTensor *runningVar, THFloatTensor *weight, THFloatTensor *bias, float eps,
+  float momentum, _Bool train, float leakiness);
 
 // LeakyReLU
-void scn_cpu_float_LeakyReLU_updateOutput(THFloatTensor *input_features,
-                                          THFloatTensor *output_features,
-                                          long n, float alpha);
-void scn_cpu_float_LeakyReLU_updateGradInput(THFloatTensor *input_features,
-                                             THFloatTensor *d_input_features,
-                                             THFloatTensor *d_output_features,
-                                             long n, float alpha);
+void scn_cpu_float_LeakyReLU_updateOutput(
+  THFloatTensor *input_features, THFloatTensor *output_features, long n,
+  float alpha);
+void scn_cpu_float_LeakyReLU_updateGradInput(
+  THFloatTensor *input_features, THFloatTensor *d_input_features,
+  THFloatTensor *d_output_features, long n, float alpha);
 
 // NetworkInNetwork
 double scn_cpu_float_NetworkInNetwork_updateOutput(
-    THFloatTensor *input_features, THFloatTensor *output_features,
-    THFloatTensor *weight, THFloatTensor *bias);
+  THFloatTensor *input_features, THFloatTensor *output_features,
+  THFloatTensor *weight, THFloatTensor *bias);
 void scn_cpu_float_NetworkInNetwork_updateGradInput(
-    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-    THFloatTensor *weight);
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  THFloatTensor *weight);
 void scn_cpu_float_NetworkInNetwork_accGradParameters(
-    THFloatTensor *input_features, THFloatTensor *d_output_features,
-    THFloatTensor *d_weight, THFloatTensor *d_bias);
-void scn_cpu_double_AffineReluTrivialConvolution_updateOutput(
-    THDoubleTensor *input_features, THDoubleTensor *output_features,
-    THDoubleTensor *affineWeight, THDoubleTensor *affineBias,
-    THDoubleTensor *convWeight);
+  THFloatTensor *input_features, THFloatTensor *d_output_features,
+  THFloatTensor *d_weight, THFloatTensor *d_bias);
+  void scn_cpu_double_AffineReluTrivialConvolution_updateOutput(
+  THDoubleTensor *input_features, THDoubleTensor *output_features,
+  THDoubleTensor *affineWeight, THDoubleTensor *affineBias, THDoubleTensor *convWeight);
 void scn_cpu_double_AffineReluTrivialConvolution_backward(
-    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-    THDoubleTensor *d_output_features, THDoubleTensor *affineWeight,
-    THDoubleTensor *d_affineWeight, THDoubleTensor *affineBias,
-    THDoubleTensor *d_affineBias, THDoubleTensor *convWeight,
-    THDoubleTensor *d_convWeight, _Bool additiveGrad);
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *affineWeight,
+  THDoubleTensor *d_affineWeight, THDoubleTensor *affineBias, THDoubleTensor *d_affineBias,
+  THDoubleTensor *convWeight, THDoubleTensor *d_convWeight, _Bool additiveGrad);
 
 // BatchwiseMultiplicativeDropout
 void scn_cpu_double_BatchwiseMultiplicativeDropout_updateOutput(
-    THDoubleTensor *input_features, THDoubleTensor *output_features,
-    THDoubleTensor *noise, long nPlanes, long input_stride, long output_stride,
-    float alpha);
+  THDoubleTensor *input_features, THDoubleTensor *output_features,
+  THDoubleTensor *noise, long nPlanes, long input_stride, long output_stride,
+  float alpha);
 void scn_cpu_double_BatchwiseMultiplicativeDropout_updateGradInput(
-    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-    THDoubleTensor *d_output_features, THDoubleTensor *noise, long nPlanes,
-    long input_stride, long output_stride, float alpha);
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, THDoubleTensor *noise, long nPlanes,
+  long input_stride, long output_stride, float alpha);
 
 // BatchNormalization
 void scn_cpu_double_BatchNormalization_updateOutput(
-    THDoubleTensor *input_features, THDoubleTensor *output_features,
-    THDoubleTensor *saveMean, THDoubleTensor *saveInvStd,
-    THDoubleTensor *runningMean, THDoubleTensor *runningVar,
-    THDoubleTensor *weight, THDoubleTensor *bias, double eps, double momentum,
-    _Bool train, double leakiness);
+  THDoubleTensor *input_features, THDoubleTensor *output_features,
+  THDoubleTensor *saveMean, THDoubleTensor *saveInvStd, THDoubleTensor *runningMean,
+  THDoubleTensor *runningVar, THDoubleTensor *weight, THDoubleTensor *bias, double eps,
+  double momentum, _Bool train, double leakiness);
 void scn_cpu_double_BatchNormalization_backward(
-    THDoubleTensor *input_features, THDoubleTensor *d_input_features,
-    THDoubleTensor *output_features, THDoubleTensor *d_output_features,
-    THDoubleTensor *saveMean, THDoubleTensor *saveInvStd,
-    THDoubleTensor *runningMean, THDoubleTensor *runningVar,
-    THDoubleTensor *weight, THDoubleTensor *bias, THDoubleTensor *d_weight,
-    THDoubleTensor *d_bias, double leakiness);
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *output_features, THDoubleTensor *d_output_features, THDoubleTensor *saveMean,
+  THDoubleTensor *saveInvStd, THDoubleTensor *runningMean, THDoubleTensor *runningVar,
+  THDoubleTensor *weight, THDoubleTensor *bias, THDoubleTensor *d_weight, THDoubleTensor *d_bias,
+  double leakiness);
 // BatchNormalizationInTensor
 void scn_cpu_double_BatchNormalizationInTensor_updateOutput(
-    THDoubleTensor *input_features, THDoubleTensor *output_features,
-    THDoubleTensor *saveMean, THDoubleTensor *saveInvStd,
-    THDoubleTensor *runningMean, THDoubleTensor *runningVar,
-    THDoubleTensor *weight, THDoubleTensor *bias, double eps, double momentum,
-    _Bool train, double leakiness);
+  THDoubleTensor *input_features, THDoubleTensor *output_features,
+  THDoubleTensor *saveMean, THDoubleTensor *saveInvStd, THDoubleTensor *runningMean,
+  THDoubleTensor *runningVar, THDoubleTensor *weight, THDoubleTensor *bias, double eps,
+  double momentum, _Bool train, double leakiness);
 
 // LeakyReLU
-void scn_cpu_double_LeakyReLU_updateOutput(THDoubleTensor *input_features,
-                                           THDoubleTensor *output_features,
-                                           long n, float alpha);
-void scn_cpu_double_LeakyReLU_updateGradInput(THDoubleTensor *input_features,
-                                              THDoubleTensor *d_input_features,
-                                              THDoubleTensor *d_output_features,
-                                              long n, float alpha);
+void scn_cpu_double_LeakyReLU_updateOutput(
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long n,
+  float alpha);
+void scn_cpu_double_LeakyReLU_updateGradInput(
+  THDoubleTensor *input_features, THDoubleTensor *d_input_features,
+  THDoubleTensor *d_output_features, long n, float alpha);
 
 // NetworkInNetwork
 double scn_cpu_double_NetworkInNetwork_updateOutput(
-    THDoubleTensor *input_features, THDoubleTensor *output_features,
-    THDoubleTensor *weight, THDoubleTensor *bias);
+  THDoubleTensor *input_features, THDoubleTensor *output_features,
+  THDoubleTensor *weight, THDoubleTensor *bias);
 void scn_cpu_double_NetworkInNetwork_updateGradInput(
-    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-    THDoubleTensor *weight);
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  THDoubleTensor *weight);
 void scn_cpu_double_NetworkInNetwork_accGradParameters(
-    THDoubleTensor *input_features, THDoubleTensor *d_output_features,
-    THDoubleTensor *d_weight, THDoubleTensor *d_bias);
-// ActivePooling
-void scn_cpu_float1ActivePooling_updateOutput(THLongTensor *inputSize, void **m,
-                                              THFloatTensor *input_features,
-                                              THFloatTensor *output_features,
-                                              void *rulesBuffer, _Bool average);
+  THDoubleTensor *input_features, THDoubleTensor *d_output_features,
+  THDoubleTensor *d_weight, THDoubleTensor *d_bias);
+  // ActivePooling
+void scn_cpu_float1ActivePooling_updateOutput(
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_float1ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *d_input_features,
-    THFloatTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_float1SparseToDense_updateOutput(THLongTensor *inputSize, void **m,
-                                              THFloatTensor *input_features,
-                                              THFloatTensor *output_features,
-                                              void *rulesBuffer);
+void scn_cpu_float1SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer);
 void scn_cpu_float1SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_float1ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THFloatTensor *input_features, THFloatTensor *output_features,
-    THFloatTensor *weight, THFloatTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_float1ValidConvolution_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);
-// ActivePooling
-void scn_cpu_float2ActivePooling_updateOutput(THLongTensor *inputSize, void **m,
-                                              THFloatTensor *input_features,
-                                              THFloatTensor *output_features,
-                                              void *rulesBuffer, _Bool average);
+  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);
+  // ActivePooling
+void scn_cpu_float2ActivePooling_updateOutput(
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_float2ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *d_input_features,
-    THFloatTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_float2SparseToDense_updateOutput(THLongTensor *inputSize, void **m,
-                                              THFloatTensor *input_features,
-                                              THFloatTensor *output_features,
-                                              void *rulesBuffer);
+void scn_cpu_float2SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer);
 void scn_cpu_float2SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_float2ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THFloatTensor *input_features, THFloatTensor *output_features,
-    THFloatTensor *weight, THFloatTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_float2ValidConvolution_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);
-// ActivePooling
-void scn_cpu_float3ActivePooling_updateOutput(THLongTensor *inputSize, void **m,
-                                              THFloatTensor *input_features,
-                                              THFloatTensor *output_features,
-                                              void *rulesBuffer, _Bool average);
+  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);
+  // ActivePooling
+void scn_cpu_float3ActivePooling_updateOutput(
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_float3ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *d_input_features,
-    THFloatTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_float3SparseToDense_updateOutput(THLongTensor *inputSize, void **m,
-                                              THFloatTensor *input_features,
-                                              THFloatTensor *output_features,
-                                              void *rulesBuffer);
+void scn_cpu_float3SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer);
 void scn_cpu_float3SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_float3ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THFloatTensor *input_features, THFloatTensor *output_features,
-    THFloatTensor *weight, THFloatTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_float3ValidConvolution_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);
-// ActivePooling
-void scn_cpu_float4ActivePooling_updateOutput(THLongTensor *inputSize, void **m,
-                                              THFloatTensor *input_features,
-                                              THFloatTensor *output_features,
-                                              void *rulesBuffer, _Bool average);
+  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);
+  // ActivePooling
+void scn_cpu_float4ActivePooling_updateOutput(
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_float4ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *d_input_features,
-    THFloatTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_float4SparseToDense_updateOutput(THLongTensor *inputSize, void **m,
-                                              THFloatTensor *input_features,
-                                              THFloatTensor *output_features,
-                                              void *rulesBuffer);
+void scn_cpu_float4SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer);
 void scn_cpu_float4SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_float4ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THFloatTensor *input_features, THFloatTensor *output_features,
-    THFloatTensor *weight, THFloatTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_float4ValidConvolution_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);
-// ActivePooling
-void scn_cpu_float5ActivePooling_updateOutput(THLongTensor *inputSize, void **m,
-                                              THFloatTensor *input_features,
-                                              THFloatTensor *output_features,
-                                              void *rulesBuffer, _Bool average);
+  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);
+  // ActivePooling
+void scn_cpu_float5ActivePooling_updateOutput(
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_float5ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *d_input_features,
-    THFloatTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_float5SparseToDense_updateOutput(THLongTensor *inputSize, void **m,
-                                              THFloatTensor *input_features,
-                                              THFloatTensor *output_features,
-                                              void *rulesBuffer);
+void scn_cpu_float5SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer);
 void scn_cpu_float5SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_float5ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THFloatTensor *input_features, THFloatTensor *output_features,
-    THFloatTensor *weight, THFloatTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_float5ValidConvolution_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);
-// ActivePooling
-void scn_cpu_float6ActivePooling_updateOutput(THLongTensor *inputSize, void **m,
-                                              THFloatTensor *input_features,
-                                              THFloatTensor *output_features,
-                                              void *rulesBuffer, _Bool average);
+  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);
+  // ActivePooling
+void scn_cpu_float6ActivePooling_updateOutput(
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_float6ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *d_input_features,
-    THFloatTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_float6SparseToDense_updateOutput(THLongTensor *inputSize, void **m,
-                                              THFloatTensor *input_features,
-                                              THFloatTensor *output_features,
-                                              void *rulesBuffer);
+void scn_cpu_float6SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer);
 void scn_cpu_float6SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_float6ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THFloatTensor *input_features, THFloatTensor *output_features,
-    THFloatTensor *weight, THFloatTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_float6ValidConvolution_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);
-// ActivePooling
-void scn_cpu_float7ActivePooling_updateOutput(THLongTensor *inputSize, void **m,
-                                              THFloatTensor *input_features,
-                                              THFloatTensor *output_features,
-                                              void *rulesBuffer, _Bool average);
+  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);
+  // ActivePooling
+void scn_cpu_float7ActivePooling_updateOutput(
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_float7ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *d_input_features,
-    THFloatTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_float7SparseToDense_updateOutput(THLongTensor *inputSize, void **m,
-                                              THFloatTensor *input_features,
-                                              THFloatTensor *output_features,
-                                              void *rulesBuffer);
+void scn_cpu_float7SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer);
 void scn_cpu_float7SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_float7ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THFloatTensor *input_features, THFloatTensor *output_features,
-    THFloatTensor *weight, THFloatTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_float7ValidConvolution_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);
-// ActivePooling
-void scn_cpu_float8ActivePooling_updateOutput(THLongTensor *inputSize, void **m,
-                                              THFloatTensor *input_features,
-                                              THFloatTensor *output_features,
-                                              void *rulesBuffer, _Bool average);
+  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);
+  // ActivePooling
+void scn_cpu_float8ActivePooling_updateOutput(
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_float8ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *d_input_features,
-    THFloatTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_float8SparseToDense_updateOutput(THLongTensor *inputSize, void **m,
-                                              THFloatTensor *input_features,
-                                              THFloatTensor *output_features,
-                                              void *rulesBuffer);
+void scn_cpu_float8SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer);
 void scn_cpu_float8SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_float8ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THFloatTensor *input_features, THFloatTensor *output_features,
-    THFloatTensor *weight, THFloatTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_float8ValidConvolution_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);
-// ActivePooling
-void scn_cpu_float9ActivePooling_updateOutput(THLongTensor *inputSize, void **m,
-                                              THFloatTensor *input_features,
-                                              THFloatTensor *output_features,
-                                              void *rulesBuffer, _Bool average);
+  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);
+  // ActivePooling
+void scn_cpu_float9ActivePooling_updateOutput(
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_float9ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *d_input_features,
-    THFloatTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_float9SparseToDense_updateOutput(THLongTensor *inputSize, void **m,
-                                              THFloatTensor *input_features,
-                                              THFloatTensor *output_features,
-                                              void *rulesBuffer);
+void scn_cpu_float9SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer);
 void scn_cpu_float9SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_float9ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THFloatTensor *input_features, THFloatTensor *output_features,
-    THFloatTensor *weight, THFloatTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_float9ValidConvolution_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);
-// ActivePooling
+  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);
+  // ActivePooling
 void scn_cpu_float10ActivePooling_updateOutput(
-    THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-    THFloatTensor *output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_float10ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *d_input_features,
-    THFloatTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_float10SparseToDense_updateOutput(THLongTensor *inputSize,
-                                               void **m,
-                                               THFloatTensor *input_features,
-                                               THFloatTensor *output_features,
-                                               void *rulesBuffer);
+void scn_cpu_float10SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *output_features, void *rulesBuffer);
 void scn_cpu_float10SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THFloatTensor *input_features,
-    THFloatTensor *d_input_features, THFloatTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THFloatTensor *input_features,
+  THFloatTensor *d_input_features, THFloatTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_float10ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THFloatTensor *input_features, THFloatTensor *output_features,
-    THFloatTensor *weight, THFloatTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THFloatTensor *input_features, THFloatTensor *output_features, THFloatTensor *weight,
+  THFloatTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_float10ValidConvolution_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);
-// ActivePooling
+  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);
+  // ActivePooling
 void scn_cpu_double1ActivePooling_updateOutput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_double1ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *d_input_features,
-    THDoubleTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_double1SparseToDense_updateOutput(THLongTensor *inputSize,
-                                               void **m,
-                                               THDoubleTensor *input_features,
-                                               THDoubleTensor *output_features,
-                                               void *rulesBuffer);
+void scn_cpu_double1SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer);
 void scn_cpu_double1SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_double1ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THDoubleTensor *input_features, THDoubleTensor *output_features,
-    THDoubleTensor *weight, THDoubleTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_double1ValidConvolution_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);
-// ActivePooling
+  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);
+  // ActivePooling
 void scn_cpu_double2ActivePooling_updateOutput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_double2ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *d_input_features,
-    THDoubleTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_double2SparseToDense_updateOutput(THLongTensor *inputSize,
-                                               void **m,
-                                               THDoubleTensor *input_features,
-                                               THDoubleTensor *output_features,
-                                               void *rulesBuffer);
+void scn_cpu_double2SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer);
 void scn_cpu_double2SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_double2ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THDoubleTensor *input_features, THDoubleTensor *output_features,
-    THDoubleTensor *weight, THDoubleTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_double2ValidConvolution_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);
-// ActivePooling
+  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);
+  // ActivePooling
 void scn_cpu_double3ActivePooling_updateOutput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_double3ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *d_input_features,
-    THDoubleTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_double3SparseToDense_updateOutput(THLongTensor *inputSize,
-                                               void **m,
-                                               THDoubleTensor *input_features,
-                                               THDoubleTensor *output_features,
-                                               void *rulesBuffer);
+void scn_cpu_double3SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer);
 void scn_cpu_double3SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_double3ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THDoubleTensor *input_features, THDoubleTensor *output_features,
-    THDoubleTensor *weight, THDoubleTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_double3ValidConvolution_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);
-// ActivePooling
+  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);
+  // ActivePooling
 void scn_cpu_double4ActivePooling_updateOutput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_double4ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *d_input_features,
-    THDoubleTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_double4SparseToDense_updateOutput(THLongTensor *inputSize,
-                                               void **m,
-                                               THDoubleTensor *input_features,
-                                               THDoubleTensor *output_features,
-                                               void *rulesBuffer);
+void scn_cpu_double4SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer);
 void scn_cpu_double4SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_double4ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THDoubleTensor *input_features, THDoubleTensor *output_features,
-    THDoubleTensor *weight, THDoubleTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_double4ValidConvolution_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);
-// ActivePooling
+  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);
+  // ActivePooling
 void scn_cpu_double5ActivePooling_updateOutput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_double5ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *d_input_features,
-    THDoubleTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_double5SparseToDense_updateOutput(THLongTensor *inputSize,
-                                               void **m,
-                                               THDoubleTensor *input_features,
-                                               THDoubleTensor *output_features,
-                                               void *rulesBuffer);
+void scn_cpu_double5SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer);
 void scn_cpu_double5SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_double5ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THDoubleTensor *input_features, THDoubleTensor *output_features,
-    THDoubleTensor *weight, THDoubleTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_double5ValidConvolution_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);
-// ActivePooling
+  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);
+  // ActivePooling
 void scn_cpu_double6ActivePooling_updateOutput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_double6ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *d_input_features,
-    THDoubleTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_double6SparseToDense_updateOutput(THLongTensor *inputSize,
-                                               void **m,
-                                               THDoubleTensor *input_features,
-                                               THDoubleTensor *output_features,
-                                               void *rulesBuffer);
+void scn_cpu_double6SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer);
 void scn_cpu_double6SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_double6ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THDoubleTensor *input_features, THDoubleTensor *output_features,
-    THDoubleTensor *weight, THDoubleTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_double6ValidConvolution_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);
-// ActivePooling
+  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);
+  // ActivePooling
 void scn_cpu_double7ActivePooling_updateOutput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_double7ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *d_input_features,
-    THDoubleTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_double7SparseToDense_updateOutput(THLongTensor *inputSize,
-                                               void **m,
-                                               THDoubleTensor *input_features,
-                                               THDoubleTensor *output_features,
-                                               void *rulesBuffer);
+void scn_cpu_double7SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer);
 void scn_cpu_double7SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_double7ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THDoubleTensor *input_features, THDoubleTensor *output_features,
-    THDoubleTensor *weight, THDoubleTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_double7ValidConvolution_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);
-// ActivePooling
+  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);
+  // ActivePooling
 void scn_cpu_double8ActivePooling_updateOutput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_double8ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *d_input_features,
-    THDoubleTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_double8SparseToDense_updateOutput(THLongTensor *inputSize,
-                                               void **m,
-                                               THDoubleTensor *input_features,
-                                               THDoubleTensor *output_features,
-                                               void *rulesBuffer);
+void scn_cpu_double8SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer);
 void scn_cpu_double8SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_double8ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THDoubleTensor *input_features, THDoubleTensor *output_features,
-    THDoubleTensor *weight, THDoubleTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_double8ValidConvolution_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);
-// ActivePooling
+  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);
+  // ActivePooling
 void scn_cpu_double9ActivePooling_updateOutput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_double9ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *d_input_features,
-    THDoubleTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_double9SparseToDense_updateOutput(THLongTensor *inputSize,
-                                               void **m,
-                                               THDoubleTensor *input_features,
-                                               THDoubleTensor *output_features,
-                                               void *rulesBuffer);
+void scn_cpu_double9SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer);
 void scn_cpu_double9SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_double9ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THDoubleTensor *input_features, THDoubleTensor *output_features,
-    THDoubleTensor *weight, THDoubleTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_double9ValidConvolution_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);
-// ActivePooling
+  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);
+  // ActivePooling
 void scn_cpu_double10ActivePooling_updateOutput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer, _Bool average);
 void scn_cpu_double10ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *d_input_features,
-    THDoubleTensor *d_output_features, void *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, long nFeaturesToDrop,
+  void *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_cpu_double10SparseToDense_updateOutput(THLongTensor *inputSize,
-                                                void **m,
-                                                THDoubleTensor *input_features,
-                                                THDoubleTensor *output_features,
-                                                void *rulesBuffer);
+void scn_cpu_double10SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *output_features, void *rulesBuffer);
 void scn_cpu_double10SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
-    THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
-    void *rulesBuffer);
+  THLongTensor *inputSize, void **m, THDoubleTensor *input_features,
+  THDoubleTensor *d_input_features, THDoubleTensor *d_output_features,
+  void *rulesBuffer);
 
 double scn_cpu_double10ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THDoubleTensor *input_features, THDoubleTensor *output_features,
-    THDoubleTensor *weight, THDoubleTensor *bias, long filterVolume,
-    void *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THDoubleTensor *input_features, THDoubleTensor *output_features, THDoubleTensor *weight,
+  THDoubleTensor *bias, long filterVolume, void *rulesBuffer);
 void scn_cpu_double10ValidConvolution_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);
+  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);

PyTorch/sparseconvnet/SCN/header_gpu.h

@@ -5,870 +5,828 @@
 // LICENSE file in the root directory of this source tree.
 
 void scn_gpu_float_AffineReluTrivialConvolution_updateOutput(
-    THCudaTensor *input_features, THCudaTensor *output_features,
-    THCudaTensor *affineWeight, THCudaTensor *affineBias,
-    THCudaTensor *convWeight);
+  THCudaTensor *input_features, THCudaTensor *output_features,
+  THCudaTensor *affineWeight, THCudaTensor *affineBias, THCudaTensor *convWeight);
 void scn_gpu_float_AffineReluTrivialConvolution_backward(
-    THCudaTensor *input_features, THCudaTensor *d_input_features,
-    THCudaTensor *d_output_features, THCudaTensor *affineWeight,
-    THCudaTensor *d_affineWeight, THCudaTensor *affineBias,
-    THCudaTensor *d_affineBias, THCudaTensor *convWeight,
-    THCudaTensor *d_convWeight, _Bool additiveGrad);
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *affineWeight,
+  THCudaTensor *d_affineWeight, THCudaTensor *affineBias, THCudaTensor *d_affineBias,
+  THCudaTensor *convWeight, THCudaTensor *d_convWeight, _Bool additiveGrad);
 
 // BatchwiseMultiplicativeDropout
 void scn_gpu_float_BatchwiseMultiplicativeDropout_updateOutput(
-    THCudaTensor *input_features, THCudaTensor *output_features,
-    THCudaTensor *noise, long nPlanes, long input_stride, long output_stride,
-    float alpha);
+  THCudaTensor *input_features, THCudaTensor *output_features,
+  THCudaTensor *noise, long nPlanes, long input_stride, long output_stride,
+  float alpha);
 void scn_gpu_float_BatchwiseMultiplicativeDropout_updateGradInput(
-    THCudaTensor *input_features, THCudaTensor *d_input_features,
-    THCudaTensor *d_output_features, THCudaTensor *noise, long nPlanes,
-    long input_stride, long output_stride, float alpha);
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, THCudaTensor *noise, long nPlanes,
+  long input_stride, long output_stride, float alpha);
 
 // BatchNormalization
 void scn_gpu_float_BatchNormalization_updateOutput(
-    THCudaTensor *input_features, THCudaTensor *output_features,
-    THCudaTensor *saveMean, THCudaTensor *saveInvStd, THCudaTensor *runningMean,
-    THCudaTensor *runningVar, THCudaTensor *weight, THCudaTensor *bias,
-    float eps, float momentum, _Bool train, float leakiness);
+  THCudaTensor *input_features, THCudaTensor *output_features,
+  THCudaTensor *saveMean, THCudaTensor *saveInvStd, THCudaTensor *runningMean,
+  THCudaTensor *runningVar, THCudaTensor *weight, THCudaTensor *bias, float eps,
+  float momentum, _Bool train, float leakiness);
 void scn_gpu_float_BatchNormalization_backward(
-    THCudaTensor *input_features, THCudaTensor *d_input_features,
-    THCudaTensor *output_features, THCudaTensor *d_output_features,
-    THCudaTensor *saveMean, THCudaTensor *saveInvStd, THCudaTensor *runningMean,
-    THCudaTensor *runningVar, THCudaTensor *weight, THCudaTensor *bias,
-    THCudaTensor *d_weight, THCudaTensor *d_bias, float leakiness);
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *output_features, THCudaTensor *d_output_features, THCudaTensor *saveMean,
+  THCudaTensor *saveInvStd, THCudaTensor *runningMean, THCudaTensor *runningVar,
+  THCudaTensor *weight, THCudaTensor *bias, THCudaTensor *d_weight, THCudaTensor *d_bias,
+  float leakiness);
 // BatchNormalizationInTensor
 void scn_gpu_float_BatchNormalizationInTensor_updateOutput(
-    THCudaTensor *input_features, THCudaTensor *output_features,
-    THCudaTensor *saveMean, THCudaTensor *saveInvStd, THCudaTensor *runningMean,
-    THCudaTensor *runningVar, THCudaTensor *weight, THCudaTensor *bias,
-    float eps, float momentum, _Bool train, float leakiness);
+  THCudaTensor *input_features, THCudaTensor *output_features,
+  THCudaTensor *saveMean, THCudaTensor *saveInvStd, THCudaTensor *runningMean,
+  THCudaTensor *runningVar, THCudaTensor *weight, THCudaTensor *bias, float eps,
+  float momentum, _Bool train, float leakiness);
 
 // LeakyReLU
-void scn_gpu_float_LeakyReLU_updateOutput(THCudaTensor *input_features,
-                                          THCudaTensor *output_features, long n,
-                                          float alpha);
-void scn_gpu_float_LeakyReLU_updateGradInput(THCudaTensor *input_features,
-                                             THCudaTensor *d_input_features,
-                                             THCudaTensor *d_output_features,
-                                             long n, float alpha);
+void scn_gpu_float_LeakyReLU_updateOutput(
+  THCudaTensor *input_features, THCudaTensor *output_features, long n,
+  float alpha);
+void scn_gpu_float_LeakyReLU_updateGradInput(
+  THCudaTensor *input_features, THCudaTensor *d_input_features,
+  THCudaTensor *d_output_features, long n, float alpha);
 
 // NetworkInNetwork
 double scn_gpu_float_NetworkInNetwork_updateOutput(
-    THCudaTensor *input_features, THCudaTensor *output_features,
-    THCudaTensor *weight, THCudaTensor *bias);
+  THCudaTensor *input_features, THCudaTensor *output_features,
+  THCudaTensor *weight, THCudaTensor *bias);
 void scn_gpu_float_NetworkInNetwork_updateGradInput(
-    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-    THCudaTensor *weight);
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaTensor *weight);
 void scn_gpu_float_NetworkInNetwork_accGradParameters(
-    THCudaTensor *input_features, THCudaTensor *d_output_features,
-    THCudaTensor *d_weight, THCudaTensor *d_bias);
-// ActivePooling
-void scn_gpu_float1ActivePooling_updateOutput(THLongTensor *inputSize, void **m,
-                                              THCudaTensor *input_features,
-                                              THCudaTensor *output_features,
-                                              THCudaIntTensor *rulesBuffer,
-                                              _Bool average);
+  THCudaTensor *input_features, THCudaTensor *d_output_features,
+  THCudaTensor *d_weight, THCudaTensor *d_bias);
+
+void scn_gpu_float1ActivePooling_updateOutput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, _Bool average);
 void scn_gpu_float1ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *d_input_features,
-    THCudaTensor *d_output_features, THCudaIntTensor *rulesBuffer,
-    _Bool average);
+  THLongTensor *inputSize, void **m,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_gpu_float1SparseToDense_updateOutput(THLongTensor *inputSize, void **m,
-                                              THCudaTensor *input_features,
-                                              THCudaTensor *output_features,
-                                              THCudaIntTensor *rulesBuffer);
+void scn_gpu_float1SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float1SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer);
 
 double scn_gpu_float1ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THCudaTensor *input_features, THCudaTensor *output_features,
-    THCudaTensor *weight, THCudaTensor *bias, long filterVolume,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float1ValidConvolution_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);
-// ActivePooling
-void scn_gpu_float2ActivePooling_updateOutput(THLongTensor *inputSize, void **m,
-                                              THCudaTensor *input_features,
-                                              THCudaTensor *output_features,
-                                              THCudaIntTensor *rulesBuffer,
-                                              _Bool average);
+  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);
+  // ActivePooling
+void scn_gpu_float2ActivePooling_updateOutput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, _Bool average);
 void scn_gpu_float2ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *d_input_features,
-    THCudaTensor *d_output_features, THCudaIntTensor *rulesBuffer,
-    _Bool average);
+  THLongTensor *inputSize, void **m,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_gpu_float2SparseToDense_updateOutput(THLongTensor *inputSize, void **m,
-                                              THCudaTensor *input_features,
-                                              THCudaTensor *output_features,
-                                              THCudaIntTensor *rulesBuffer);
+void scn_gpu_float2SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float2SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer);
 
 double scn_gpu_float2ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THCudaTensor *input_features, THCudaTensor *output_features,
-    THCudaTensor *weight, THCudaTensor *bias, long filterVolume,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float2ValidConvolution_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);
-// ActivePooling
-void scn_gpu_float3ActivePooling_updateOutput(THLongTensor *inputSize, void **m,
-                                              THCudaTensor *input_features,
-                                              THCudaTensor *output_features,
-                                              THCudaIntTensor *rulesBuffer,
-                                              _Bool average);
+  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);
+  // ActivePooling
+void scn_gpu_float3ActivePooling_updateOutput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, _Bool average);
 void scn_gpu_float3ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *d_input_features,
-    THCudaTensor *d_output_features, THCudaIntTensor *rulesBuffer,
-    _Bool average);
+  THLongTensor *inputSize, void **m,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_gpu_float3SparseToDense_updateOutput(THLongTensor *inputSize, void **m,
-                                              THCudaTensor *input_features,
-                                              THCudaTensor *output_features,
-                                              THCudaIntTensor *rulesBuffer);
+void scn_gpu_float3SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float3SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer);
 
 double scn_gpu_float3ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THCudaTensor *input_features, THCudaTensor *output_features,
-    THCudaTensor *weight, THCudaTensor *bias, long filterVolume,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float3ValidConvolution_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);
-// ActivePooling
-void scn_gpu_float4ActivePooling_updateOutput(THLongTensor *inputSize, void **m,
-                                              THCudaTensor *input_features,
-                                              THCudaTensor *output_features,
-                                              THCudaIntTensor *rulesBuffer,
-                                              _Bool average);
+  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);
+  // ActivePooling
+void scn_gpu_float4ActivePooling_updateOutput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, _Bool average);
 void scn_gpu_float4ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *d_input_features,
-    THCudaTensor *d_output_features, THCudaIntTensor *rulesBuffer,
-    _Bool average);
+  THLongTensor *inputSize, void **m,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_gpu_float4SparseToDense_updateOutput(THLongTensor *inputSize, void **m,
-                                              THCudaTensor *input_features,
-                                              THCudaTensor *output_features,
-                                              THCudaIntTensor *rulesBuffer);
+void scn_gpu_float4SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float4SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer);
 
 double scn_gpu_float4ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THCudaTensor *input_features, THCudaTensor *output_features,
-    THCudaTensor *weight, THCudaTensor *bias, long filterVolume,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float4ValidConvolution_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);
-// ActivePooling
-void scn_gpu_float5ActivePooling_updateOutput(THLongTensor *inputSize, void **m,
-                                              THCudaTensor *input_features,
-                                              THCudaTensor *output_features,
-                                              THCudaIntTensor *rulesBuffer,
-                                              _Bool average);
+  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);
+  // ActivePooling
+void scn_gpu_float5ActivePooling_updateOutput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, _Bool average);
 void scn_gpu_float5ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *d_input_features,
-    THCudaTensor *d_output_features, THCudaIntTensor *rulesBuffer,
-    _Bool average);
+  THLongTensor *inputSize, void **m,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_gpu_float5SparseToDense_updateOutput(THLongTensor *inputSize, void **m,
-                                              THCudaTensor *input_features,
-                                              THCudaTensor *output_features,
-                                              THCudaIntTensor *rulesBuffer);
+void scn_gpu_float5SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float5SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer);
 
 double scn_gpu_float5ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THCudaTensor *input_features, THCudaTensor *output_features,
-    THCudaTensor *weight, THCudaTensor *bias, long filterVolume,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float5ValidConvolution_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);
-// ActivePooling
-void scn_gpu_float6ActivePooling_updateOutput(THLongTensor *inputSize, void **m,
-                                              THCudaTensor *input_features,
-                                              THCudaTensor *output_features,
-                                              THCudaIntTensor *rulesBuffer,
-                                              _Bool average);
+  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);
+  // ActivePooling
+void scn_gpu_float6ActivePooling_updateOutput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, _Bool average);
 void scn_gpu_float6ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *d_input_features,
-    THCudaTensor *d_output_features, THCudaIntTensor *rulesBuffer,
-    _Bool average);
+  THLongTensor *inputSize, void **m,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_gpu_float6SparseToDense_updateOutput(THLongTensor *inputSize, void **m,
-                                              THCudaTensor *input_features,
-                                              THCudaTensor *output_features,
-                                              THCudaIntTensor *rulesBuffer);
+void scn_gpu_float6SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float6SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer);
 
 double scn_gpu_float6ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THCudaTensor *input_features, THCudaTensor *output_features,
-    THCudaTensor *weight, THCudaTensor *bias, long filterVolume,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float6ValidConvolution_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);
-// ActivePooling
-void scn_gpu_float7ActivePooling_updateOutput(THLongTensor *inputSize, void **m,
-                                              THCudaTensor *input_features,
-                                              THCudaTensor *output_features,
-                                              THCudaIntTensor *rulesBuffer,
-                                              _Bool average);
+  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);
+  // ActivePooling
+void scn_gpu_float7ActivePooling_updateOutput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, _Bool average);
 void scn_gpu_float7ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *d_input_features,
-    THCudaTensor *d_output_features, THCudaIntTensor *rulesBuffer,
-    _Bool average);
+  THLongTensor *inputSize, void **m,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_gpu_float7SparseToDense_updateOutput(THLongTensor *inputSize, void **m,
-                                              THCudaTensor *input_features,
-                                              THCudaTensor *output_features,
-                                              THCudaIntTensor *rulesBuffer);
+void scn_gpu_float7SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float7SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer);
 
 double scn_gpu_float7ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THCudaTensor *input_features, THCudaTensor *output_features,
-    THCudaTensor *weight, THCudaTensor *bias, long filterVolume,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float7ValidConvolution_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);
-// ActivePooling
-void scn_gpu_float8ActivePooling_updateOutput(THLongTensor *inputSize, void **m,
-                                              THCudaTensor *input_features,
-                                              THCudaTensor *output_features,
-                                              THCudaIntTensor *rulesBuffer,
-                                              _Bool average);
+  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);
+  // ActivePooling
+void scn_gpu_float8ActivePooling_updateOutput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, _Bool average);
 void scn_gpu_float8ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *d_input_features,
-    THCudaTensor *d_output_features, THCudaIntTensor *rulesBuffer,
-    _Bool average);
+  THLongTensor *inputSize, void **m,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_gpu_float8SparseToDense_updateOutput(THLongTensor *inputSize, void **m,
-                                              THCudaTensor *input_features,
-                                              THCudaTensor *output_features,
-                                              THCudaIntTensor *rulesBuffer);
+void scn_gpu_float8SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float8SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer);
 
 double scn_gpu_float8ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THCudaTensor *input_features, THCudaTensor *output_features,
-    THCudaTensor *weight, THCudaTensor *bias, long filterVolume,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float8ValidConvolution_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);
-// ActivePooling
-void scn_gpu_float9ActivePooling_updateOutput(THLongTensor *inputSize, void **m,
-                                              THCudaTensor *input_features,
-                                              THCudaTensor *output_features,
-                                              THCudaIntTensor *rulesBuffer,
-                                              _Bool average);
+  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);
+  // ActivePooling
+void scn_gpu_float9ActivePooling_updateOutput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, _Bool average);
 void scn_gpu_float9ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *d_input_features,
-    THCudaTensor *d_output_features, THCudaIntTensor *rulesBuffer,
-    _Bool average);
+  THLongTensor *inputSize, void **m,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_gpu_float9SparseToDense_updateOutput(THLongTensor *inputSize, void **m,
-                                              THCudaTensor *input_features,
-                                              THCudaTensor *output_features,
-                                              THCudaIntTensor *rulesBuffer);
+void scn_gpu_float9SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float9SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer);
 
 double scn_gpu_float9ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THCudaTensor *input_features, THCudaTensor *output_features,
-    THCudaTensor *weight, THCudaTensor *bias, long filterVolume,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float9ValidConvolution_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);
-// ActivePooling
+  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);
+  // ActivePooling
 void scn_gpu_float10ActivePooling_updateOutput(
-    THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-    THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, _Bool average);
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer, _Bool average);
 void scn_gpu_float10ActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *d_input_features,
-    THCudaTensor *d_output_features, THCudaIntTensor *rulesBuffer,
-    _Bool average);
+  THLongTensor *inputSize, void **m,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer, _Bool average);
 
 // Average Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *filterSize, THLongTensor *filterStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // Max Pooling
 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);
+  THLongTensor *inputSize, THLongTensor *outputSize,
+  THLongTensor *poolSize, THLongTensor *poolStride, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, long nFeaturesToDrop,
+  THCudaIntTensor *rulesBuffer);
 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);
+  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);
 
 // SparseToDense
-void scn_gpu_float10SparseToDense_updateOutput(THLongTensor *inputSize,
-                                               void **m,
-                                               THCudaTensor *input_features,
-                                               THCudaTensor *output_features,
-                                               THCudaIntTensor *rulesBuffer);
+void scn_gpu_float10SparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *output_features, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float10SparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THCudaTensor *input_features,
-    THCudaTensor *d_input_features, THCudaTensor *d_output_features,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, void **m, THCudaTensor *input_features,
+  THCudaTensor *d_input_features, THCudaTensor *d_output_features,
+  THCudaIntTensor *rulesBuffer);
 
 double scn_gpu_float10ValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THCudaTensor *input_features, THCudaTensor *output_features,
-    THCudaTensor *weight, THCudaTensor *bias, long filterVolume,
-    THCudaIntTensor *rulesBuffer);
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THCudaTensor *input_features, THCudaTensor *output_features, THCudaTensor *weight,
+  THCudaTensor *bias, long filterVolume, THCudaIntTensor *rulesBuffer);
 void scn_gpu_float10ValidConvolution_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);
+  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);

PyTorch/sparseconvnet/legacy/inputBatch.py

@@ -33,7 +33,25 @@ class InputBatch(SparseConvNetTensor):
             self.metadata.ffi, self.features, location, vector, overwrite)
 
     def setLocations(self, locations, vectors, overwrite=False):
-        l =locations.narrow(1,0,self.dimension)
+        """
+        To set n locations in d dimensions, locations can be
+        - A size (n,d) LongTensor, giving d-dimensional coordinates -- points
+          are added to the current sample, or
+        - A size (n,d+1) LongTensor; the extra column specifies the sample
+          number (within the minibatch of samples).
+
+          Example with d=3 and n=2:
+          Set
+          locations = LongTensor([[1,2,3],
+                                  [4,5,6]])
+          to add points to the current sample at (1,2,3) and (4,5,6).
+          Set
+          locations = LongTensor([[1,2,3,7],
+                                  [4,5,6,9]])
+          to add point (1,2,3) to sample 7, and (4,5,6) to sample 9 (0-indexed).
+
+        """
+        l = locations.narrow(1,0,self.dimension)
         assert l.min() >= 0 and (self.spatial_size.expand_as(l) - l).min() > 0
         dim_fn(self.dimension, 'setInputSpatialLocations')(
             self.metadata.ffi, self.features, locations, vectors, overwrite)

Torch/C.lua

@@ -25,35 +25,33 @@ return function (sparseconvnet)
   end
 
   cdef = [[
-  void scn_ptrCopyA(long *dst, void **src);
-  void scn_ptrCopyB(void **dst, long *src);
-  double scn_ruleBookBits();
-  void scn_2_drawCurve(void **m, THFloatTensor *features, THFloatTensor *stroke);
+void scn_ptrCopyA(long *dst, void **src);
+void scn_ptrCopyB(void **dst, long *src);
+double scn_ruleBookBits();
+void scn_2_drawCurve(void **m, THFloatTensor *features, THFloatTensor *stroke);
   ]]
   if fc then fc:write(cdef) end
   ffi.cdef(cdef)
   sparseconvnet.ruleBookBits=F['scn_ruleBookBits']()
 
   cdef = [[
-  double scn_DIMENSION_addSampleFromThresholdedTensor(
-    void **m, THFloatTensor *features_, THFloatTensor *tensor_,
-    THLongTensor *offset_, THLongTensor *spatialSize_, float threshold);
-  void scn_DIMENSION_batchAddSample(void **m);
-  void scn_DIMENSION_createMetadataForDenseToSparse(
-    void **m, THLongTensor *spatialSize_, THLongTensor *pad, THLongTensor *nz,
-    long batchSize);
-  void scn_DIMENSION_freeMetadata(void **metadata);
-  void scn_DIMENSION_generateRuleBooks3s2(void **m);
-  void scn_DIMENSION_generateRuleBooks2s2(void **m);
-  void scn_DIMENSION_setInputSpatialSize(void **m, THLongTensor *spatialSize);
-  void scn_DIMENSION_setInputSpatialLocation(void **m,
-    THFloatTensor *features, THLongTensor *location, THFloatTensor *vec,
-    bool overwrite);
-  void scn_5_getSpatialLocations(void **m,
-    THLongTensor *spatialSize, THLongTensor *locations);
-  void scn_DIMENSION_setInputSpatialLocations(void **m,
-    THFloatTensor *features, THLongTensor *locations, THFloatTensor *vecs,
-    bool overwrite);
+double scn_DIMENSION_addSampleFromThresholdedTensor(
+  void **m, THFloatTensor *features_, THFloatTensor *tensor_,
+  THLongTensor *offset_, THLongTensor *spatialSize_, float threshold);
+void scn_DIMENSION_batchAddSample(void **m);
+void scn_DIMENSION_createMetadataForDenseToSparse(
+  void **m, THLongTensor *spatialSize_, THLongTensor *pad, THLongTensor *nz,
+  long batchSize);
+void scn_DIMENSION_freeMetadata(void **metadata);
+void scn_DIMENSION_generateRuleBooks3s2(void **m);
+void scn_DIMENSION_generateRuleBooks2s2(void **m);
+void scn_DIMENSION_setInputSpatialSize(void **m, THLongTensor *spatialSize);
+void scn_DIMENSION_setInputSpatialLocation(void **m, THFloatTensor *features,
+  THLongTensor *location, THFloatTensor *vec, bool overwrite);
+void scn_DIMENSION_setInputSpatialLocations(void **m, THFloatTensor *features,
+  THLongTensor *locations, THFloatTensor *vecs, bool overwrite);
+void scn_DIMENSION_getSpatialLocations(void **m, THLongTensor *spatialSize,
+  THLongTensor *locations);
   ]]
 
   for DIMENSION = 1,10 do
@@ -66,62 +64,62 @@ return function (sparseconvnet)
   --type GPU half, float, double; int_cpu and int_gpu
 
   cdef = [[
-  void scn_ARCH_REAL_AffineReluTrivialConvolution_updateOutput(
-    THTensor *input_features, THTensor *output_features,
-    THTensor *affineWeight, THTensor *affineBias, THTensor *convWeight);
-  void scn_ARCH_REAL_AffineReluTrivialConvolution_backward(
-    THTensor *input_features, THTensor *d_input_features,
-    THTensor *d_output_features, THTensor *affineWeight,
-    THTensor *d_affineWeight, THTensor *affineBias, THTensor *d_affineBias,
-    THTensor *convWeight, THTensor *d_convWeight, bool additiveGrad);
+void scn_ARCH_REAL_AffineReluTrivialConvolution_updateOutput(
+  THTensor *input_features, THTensor *output_features,
+  THTensor *affineWeight, THTensor *affineBias, THTensor *convWeight);
+void scn_ARCH_REAL_AffineReluTrivialConvolution_backward(
+  THTensor *input_features, THTensor *d_input_features,
+  THTensor *d_output_features, THTensor *affineWeight,
+  THTensor *d_affineWeight, THTensor *affineBias, THTensor *d_affineBias,
+  THTensor *convWeight, THTensor *d_convWeight, bool additiveGrad);
 
-  // BatchwiseMultiplicativeDropout
-  void scn_ARCH_REAL_BatchwiseMultiplicativeDropout_updateOutput(
-    THTensor *input_features, THTensor *output_features,
-    THTensor *noise, long nPlanes, long input_stride, long output_stride,
-    float alpha);
-  void scn_ARCH_REAL_BatchwiseMultiplicativeDropout_updateGradInput(
-    THTensor *input_features, THTensor *d_input_features,
-    THTensor *d_output_features, THTensor *noise, long nPlanes,
-    long input_stride, long output_stride, float alpha);
+// BatchwiseMultiplicativeDropout
+void scn_ARCH_REAL_BatchwiseMultiplicativeDropout_updateOutput(
+  THTensor *input_features, THTensor *output_features,
+  THTensor *noise, long nPlanes, long input_stride, long output_stride,
+  float alpha);
+void scn_ARCH_REAL_BatchwiseMultiplicativeDropout_updateGradInput(
+  THTensor *input_features, THTensor *d_input_features,
+  THTensor *d_output_features, THTensor *noise, long nPlanes,
+  long input_stride, long output_stride, float alpha);
 
-  // BatchNormalization
-  void scn_ARCH_REAL_BatchNormalization_updateOutput(
-    THTensor *input_features, THTensor *output_features,
-    THTensor *saveMean, THTensor *saveInvStd, THTensor *runningMean,
-    THTensor *runningVar, THTensor *weight, THTensor *bias, REAL eps,
-    REAL momentum, bool train, REAL leakiness);
-  void scn_ARCH_REAL_BatchNormalization_backward(
-    THTensor *input_features, THTensor *d_input_features,
-    THTensor *output_features, THTensor *d_output_features, THTensor *saveMean,
-    THTensor *saveInvStd, THTensor *runningMean, THTensor *runningVar,
-    THTensor *weight, THTensor *bias, THTensor *d_weight, THTensor *d_bias,
-    REAL leakiness);
-  // BatchNormalizationInTensor
-  void scn_ARCH_REAL_BatchNormalizationInTensor_updateOutput(
-    THTensor *input_features, THTensor *output_features,
-    THTensor *saveMean, THTensor *saveInvStd, THTensor *runningMean,
-    THTensor *runningVar, THTensor *weight, THTensor *bias, REAL eps,
-    REAL momentum, bool train, REAL leakiness);
+// BatchNormalization
+void scn_ARCH_REAL_BatchNormalization_updateOutput(
+  THTensor *input_features, THTensor *output_features,
+  THTensor *saveMean, THTensor *saveInvStd, THTensor *runningMean,
+  THTensor *runningVar, THTensor *weight, THTensor *bias, REAL eps,
+  REAL momentum, bool train, REAL leakiness);
+void scn_ARCH_REAL_BatchNormalization_backward(
+  THTensor *input_features, THTensor *d_input_features,
+  THTensor *output_features, THTensor *d_output_features, THTensor *saveMean,
+  THTensor *saveInvStd, THTensor *runningMean, THTensor *runningVar,
+  THTensor *weight, THTensor *bias, THTensor *d_weight, THTensor *d_bias,
+  REAL leakiness);
+// BatchNormalizationInTensor
+void scn_ARCH_REAL_BatchNormalizationInTensor_updateOutput(
+  THTensor *input_features, THTensor *output_features,
+  THTensor *saveMean, THTensor *saveInvStd, THTensor *runningMean,
+  THTensor *runningVar, THTensor *weight, THTensor *bias, REAL eps,
+  REAL momentum, bool train, REAL leakiness);
 
-  // LeakyReLU
-  void scn_ARCH_REAL_LeakyReLU_updateOutput(
-    THTensor *input_features, THTensor *output_features, long n,
-    float alpha);
-  void scn_ARCH_REAL_LeakyReLU_updateGradInput(
-    THTensor *input_features, THTensor *d_input_features,
-    THTensor *d_output_features, long n, float alpha);
+// LeakyReLU
+void scn_ARCH_REAL_LeakyReLU_updateOutput(
+  THTensor *input_features, THTensor *output_features, long n,
+  float alpha);
+void scn_ARCH_REAL_LeakyReLU_updateGradInput(
+  THTensor *input_features, THTensor *d_input_features,
+  THTensor *d_output_features, long n, float alpha);
 
-  // NetworkInNetwork
-  double scn_ARCH_REAL_NetworkInNetwork_updateOutput(
-    THTensor *input_features, THTensor *output_features,
-    THTensor *weight, THTensor *bias);
-  void scn_ARCH_REAL_NetworkInNetwork_updateGradInput(
-    THTensor *d_input_features, THTensor *d_output_features,
-    THTensor *weight);
-  void scn_ARCH_REAL_NetworkInNetwork_accGradParameters(
-    THTensor *input_features, THTensor *d_output_features,
-    THTensor *d_weight, THTensor *d_bias);
+// NetworkInNetwork
+double scn_ARCH_REAL_NetworkInNetwork_updateOutput(
+  THTensor *input_features, THTensor *output_features,
+  THTensor *weight, THTensor *bias);
+void scn_ARCH_REAL_NetworkInNetwork_updateGradInput(
+  THTensor *d_input_features, THTensor *d_output_features,
+  THTensor *weight);
+void scn_ARCH_REAL_NetworkInNetwork_accGradParameters(
+  THTensor *input_features, THTensor *d_output_features,
+  THTensor *d_weight, THTensor *d_bias);
   ]]
 
   for _,v in ipairs({{'float', 'THFloatTensor'}, {'double','THDoubleTensor'}}) do
@@ -149,83 +147,83 @@ return function (sparseconvnet)
   end
 
   cdef = [[
-  // ActivePooling
-  void scn_ARCH_REAL_DIMENSIONActivePooling_updateOutput(
-    THLongTensor *inputSize, void **m, THTensor *input_features,
-    THTensor *output_features, THITensor *rulesBuffer, bool average);
-  void scn_ARCH_REAL_DIMENSIONActivePooling_updateGradInput(
-    THLongTensor *inputSize, void **m,
-    THTensor *d_input_features, THTensor *d_output_features,
-    THITensor *rulesBuffer, bool average);
+// ActivePooling
+void scn_ARCH_REAL_DIMENSIONActivePooling_updateOutput(
+  THLongTensor *inputSize, void **m, THTensor *input_features,
+  THTensor *output_features, THITensor *rulesBuffer, bool average);
+void scn_ARCH_REAL_DIMENSIONActivePooling_updateGradInput(
+  THLongTensor *inputSize, void **m,
+  THTensor *d_input_features, THTensor *d_output_features,
+  THITensor *rulesBuffer, bool average);
 
-  // Average Pooling
-  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);
-  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);
+// Average Pooling
+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);
+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);
 
-  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);
-  void scn_ARCH_REAL_DIMENSIONConvolution_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, THITensor *rulesBuffer);
+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);
+void scn_ARCH_REAL_DIMENSIONConvolution_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, THITensor *rulesBuffer);
 
-  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);
-  void scn_ARCH_REAL_DIMENSIONDeconvolution_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, THITensor *rulesBuffer);
+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);
+void scn_ARCH_REAL_DIMENSIONDeconvolution_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, THITensor *rulesBuffer);
 
-  // Max Pooling
-  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);
-  void scn_ARCH_REAL_DIMENSIONMaxPooling_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, THITensor *rulesBuffer);
+// Max Pooling
+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);
+void scn_ARCH_REAL_DIMENSIONMaxPooling_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, THITensor *rulesBuffer);
 
-  // SparseToDense
-  void scn_ARCH_REAL_DIMENSIONSparseToDense_updateOutput(
-    THLongTensor *inputSize, void **m, THTensor *input_features,
-    THTensor *output_features, THITensor *rulesBuffer);
-  void scn_ARCH_REAL_DIMENSIONSparseToDense_updateGradInput(
-    THLongTensor *inputSize, void **m, THTensor *input_features,
-    THTensor *d_input_features, THTensor *d_output_features,
-    THITensor *rulesBuffer);
+// SparseToDense
+void scn_ARCH_REAL_DIMENSIONSparseToDense_updateOutput(
+  THLongTensor *inputSize, void **m, THTensor *input_features,
+  THTensor *output_features, THITensor *rulesBuffer);
+void scn_ARCH_REAL_DIMENSIONSparseToDense_updateGradInput(
+  THLongTensor *inputSize, void **m, THTensor *input_features,
+  THTensor *d_input_features, THTensor *d_output_features,
+  THITensor *rulesBuffer);
 
-  double scn_ARCH_REAL_DIMENSIONValidConvolution_updateOutput(
-    THLongTensor *inputSize, THLongTensor *filterSize, void **m,
-    THTensor *input_features, THTensor *output_features, THTensor *weight,
-    THTensor *bias, long filterVolume, THITensor *rulesBuffer);
-  void scn_ARCH_REAL_DIMENSIONValidConvolution_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);
+double scn_ARCH_REAL_DIMENSIONValidConvolution_updateOutput(
+  THLongTensor *inputSize, THLongTensor *filterSize, void **m,
+  THTensor *input_features, THTensor *output_features, THTensor *weight,
+  THTensor *bias, long filterVolume, THITensor *rulesBuffer);
+void scn_ARCH_REAL_DIMENSIONValidConvolution_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);
   ]]
 
   for _,v in ipairs({{'float', 'THFloatTensor'}, {'double','THDoubleTensor'}}) do