diff --git a/.clang-format b/.clang-format
index 17cfc2415..19d6c8bfb 100644
--- a/.clang-format
+++ b/.clang-format
@@ -2,7 +2,7 @@
 Language:        Cpp
 # BasedOnStyle:  LLVM
 AccessModifierOffset: -2
-AlignAfterOpenBracket: Align
+AlignAfterOpenBracket: BlockIndent
 AlignArrayOfStructures: None
 AlignConsecutiveMacros: None
 AlignConsecutiveAssignments: None
@@ -26,8 +26,8 @@ AlwaysBreakBeforeMultilineStrings: false
 AlwaysBreakTemplateDeclarations: MultiLine
 AttributeMacros:
   - __capability
-BinPackArguments: true
-BinPackParameters: true
+BinPackArguments: false
+BinPackParameters: false
 BraceWrapping:
   AfterCaseLabel:  false
   AfterClass:      false
diff --git a/example-models b/example-models
index d40894b03..3cfbcfd06 160000
--- a/example-models
+++ b/example-models
@@ -1 +1 @@
-Subproject commit d40894b03f840a32da43a5adea0531ffc1db216e
+Subproject commit 3cfbcfd062f60492507d21ff0e91559b3bdd6550
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_activation.h b/hls4ml/templates/catapult/nnet_utils/nnet_activation.h
index fb72460b9..d610dab2c 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_activation.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_activation.h
@@ -112,10 +112,20 @@ template <class data_T, class res_T, typename CONFIG_T> void relu1(data_T data[C
 //       Sigmoid Activation
 // *************************************************
 
-template </*unsigned K,*/ int W1, int I1, bool S1, ac_q_mode Q1, ac_o_mode O1, int W2, int I2, bool S2, ac_q_mode Q2,
-          ac_o_mode O2>
-void ac_sigmoid_pwl_wrapper(const ac_fixed<W1, I1, S1, Q1, O1>(&input) /*[K]*/,
-                            ac_fixed<W2, I2, S2, Q2, O2>(&output) /*[K]*/) {
+template <
+    /*unsigned K,*/ int W1,
+    int I1,
+    bool S1,
+    ac_q_mode Q1,
+    ac_o_mode O1,
+    int W2,
+    int I2,
+    bool S2,
+    ac_q_mode Q2,
+    ac_o_mode O2>
+void ac_sigmoid_pwl_wrapper(
+    const ac_fixed<W1, I1, S1, Q1, O1>(&input) /*[K]*/, ac_fixed<W2, I2, S2, Q2, O2>(&output) /*[K]*/
+) {
     ac_fixed<W2, I2, false, Q2, O2> tmp; //[K];
     ac_math::ac_sigmoid_pwl<AC_TRN, W1, I1, true, Q1, O1, W2, I2, Q2, O2>(input, tmp);
     output = tmp;
@@ -541,12 +551,42 @@ void softmax(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_in]) {
 #else
 // This is a workaround to help the template deduction to work correctly and fix the inconsistency that HLS4ML expects
 // softmax output to be signed but AC Math softmax knows it is always unsigned
-template <unsigned K, int W1, int I1, bool S1, ac_q_mode Q1, ac_o_mode O1, int W2, int I2, bool S2, ac_q_mode Q2,
-          ac_o_mode O2>
+template <
+    unsigned K,
+    int W1,
+    int I1,
+    bool S1,
+    ac_q_mode Q1,
+    ac_o_mode O1,
+    int W2,
+    int I2,
+    bool S2,
+    ac_q_mode Q2,
+    ac_o_mode O2>
 void ac_softmax_pwl_wrapper(const ac_fixed<W1, I1, S1, Q1, O1> (&input)[K], ac_fixed<W2, I2, S2, Q2, O2> (&output)[K]) {
     ac_fixed<W2, I2, false, Q2, O2> tmp[K];
-    ac_math::ac_softmax_pwl<AC_TRN, false, 0, 0, AC_TRN, AC_WRAP, false, 0, 0, AC_TRN, AC_WRAP, K, W1, I1, S1, Q1, O1, W2,
-                            I2, Q2, O2>(input, tmp);
+    ac_math::ac_softmax_pwl<
+        AC_TRN,
+        false,
+        0,
+        0,
+        AC_TRN,
+        AC_WRAP,
+        false,
+        0,
+        0,
+        AC_TRN,
+        AC_WRAP,
+        K,
+        W1,
+        I1,
+        S1,
+        Q1,
+        O1,
+        W2,
+        I2,
+        Q2,
+        O2>(input, tmp);
     for (unsigned int x = 0; x < K; x++)
         output[x] = tmp[x];
 }
@@ -785,8 +825,18 @@ void softplus(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_in]) {
 }
 
 #else
-template <ac_q_mode pwl_Q = AC_TRN, int W, int I, bool S, ac_q_mode Q, ac_o_mode O, int outW, int outI, bool outS,
-          ac_q_mode outQ, ac_o_mode outO>
+template <
+    ac_q_mode pwl_Q = AC_TRN,
+    int W,
+    int I,
+    bool S,
+    ac_q_mode Q,
+    ac_o_mode O,
+    int outW,
+    int outI,
+    bool outS,
+    ac_q_mode outQ,
+    ac_o_mode outO>
 void ac_softplus_pwl_wrapper(const ac_fixed<W, I, S, Q, O>(&input), ac_fixed<outW, outI, outS, outQ, outO>(&output)) {
     ac_fixed<outW, outI, false, outQ, outO> tmp;
     ac_math::ac_softplus_pwl<AC_TRN, W, I, S, Q, O, outW, outI, outQ, outO>(input, tmp);
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_array.h b/hls4ml/templates/catapult/nnet_utils/nnet_array.h
old mode 100755
new mode 100644
index cd3b73cf7..a99d2cf22
--- a/hls4ml/templates/catapult/nnet_utils/nnet_array.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_array.h
@@ -24,8 +24,10 @@ void transpose_2d(data_T data[CONFIG_T::height * CONFIG_T::width], res_T data_t[
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void transpose_3d(data_T data[CONFIG_T::depth * CONFIG_T::height * CONFIG_T::width],
-                  res_T data_t[CONFIG_T::depth * CONFIG_T::height * CONFIG_T::width]) {
+void transpose_3d(
+    data_T data[CONFIG_T::depth * CONFIG_T::height * CONFIG_T::width],
+    res_T data_t[CONFIG_T::depth * CONFIG_T::height * CONFIG_T::width]
+) {
     unsigned dims[3] = {CONFIG_T::depth, CONFIG_T::height, CONFIG_T::width};
     unsigned dims_t[3];
     dims_t[0] = dims[CONFIG_T::perm[0]];
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_batchnorm.h b/hls4ml/templates/catapult/nnet_utils/nnet_batchnorm.h
index 1db18043e..709824bfb 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_batchnorm.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_batchnorm.h
@@ -28,9 +28,12 @@ struct batchnorm_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void normalize(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_in],
-               typename CONFIG_T::scale_t scale[CONFIG_T::n_scale_bias],
-               typename CONFIG_T::bias_t bias[CONFIG_T::n_scale_bias]) {
+void normalize(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_in],
+    typename CONFIG_T::scale_t scale[CONFIG_T::n_scale_bias],
+    typename CONFIG_T::bias_t bias[CONFIG_T::n_scale_bias]
+) {
     data_T cache;
 
     // Use a function_instantiate in case it helps to explicitly optimize unchanging weights/biases
@@ -81,8 +84,9 @@ struct batchnorm_quantized_tanh_config {
 };
 
 template <class data_T, typename CONFIG_T>
-void normalize_binary_tanh(data_T data[CONFIG_T::n_in], ac_int<1, false> res[CONFIG_T::n_in],
-                           data_T threshold[CONFIG_T::n_in]) {
+void normalize_binary_tanh(
+    data_T data[CONFIG_T::n_in], ac_int<1, false> res[CONFIG_T::n_in], data_T threshold[CONFIG_T::n_in]
+) {
     //#pragma HLS PIPELINE
     //#pragma HLS ARRAY_PARTITION variable=res complete
 
@@ -101,8 +105,12 @@ void normalize_binary_tanh(data_T data[CONFIG_T::n_in], ac_int<1, false> res[CON
 }
 
 template <class data_T, typename CONFIG_T>
-void normalize_ternary_tanh(data_T data[CONFIG_T::n_in], ac_int<2, true> res[CONFIG_T::n_in],
-                            data_T threshold_hi[CONFIG_T::n_in], data_T threshold_lo[CONFIG_T::n_in]) {
+void normalize_ternary_tanh(
+    data_T data[CONFIG_T::n_in],
+    ac_int<2, true> res[CONFIG_T::n_in],
+    data_T threshold_hi[CONFIG_T::n_in],
+    data_T threshold_lo[CONFIG_T::n_in]
+) {
     //#pragma HLS PIPELINE
     //#pragma HLS ARRAY_PARTITION variable=res complete
 
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_batchnorm_stream.h b/hls4ml/templates/catapult/nnet_utils/nnet_batchnorm_stream.h
index 48085f82d..98e734da3 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_batchnorm_stream.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_batchnorm_stream.h
@@ -14,8 +14,12 @@ namespace nnet {
 // ****************************************************
 
 template <class data_T, class res_T, typename CONFIG_T>
-void normalize(ac_channel<data_T> &data, ac_channel<res_T> &res, typename CONFIG_T::scale_t scale[CONFIG_T::n_scale_bias],
-               typename CONFIG_T::bias_t bias[CONFIG_T::n_scale_bias]) {
+void normalize(
+    ac_channel<data_T> &data,
+    ac_channel<res_T> &res,
+    typename CONFIG_T::scale_t scale[CONFIG_T::n_scale_bias],
+    typename CONFIG_T::bias_t bias[CONFIG_T::n_scale_bias]
+) {
     //#pragma HLS ARRAY_PARTITION variable=scale complete
     //#pragma HLS ARRAY_PARTITION variable=bias complete
 
@@ -42,7 +46,8 @@ void normalize(ac_channel<data_T> &data, ac_channel<res_T> &res, typename CONFIG
                 norm_index = j % CONFIG_T::n_filt;
             }
             out_data[j] = CONFIG_T::template product<typename data_T::value_type, typename CONFIG_T::scale_t>::product(
-                              in_data[j], scale[norm_index]) +
+                              in_data[j], scale[norm_index]
+                          ) +
                           bias[norm_index];
         }
 
@@ -54,8 +59,11 @@ void normalize(ac_channel<data_T> &data, ac_channel<res_T> &res, typename CONFIG
 //       Merged Batch Normalization and Quantized Tanh
 // ****************************************************
 template <class data_T, typename CONFIG_T>
-void normalize_binary_tanh(ac_channel<data_T> &data, ac_channel<nnet::array<ac_int<1, false>, CONFIG_T::n_in>> &res,
-                           typename data_T::value_type threshold[CONFIG_T::n_in]) {
+void normalize_binary_tanh(
+    ac_channel<data_T> &data,
+    ac_channel<nnet::array<ac_int<1, false>, CONFIG_T::n_in>> &res,
+    typename data_T::value_type threshold[CONFIG_T::n_in]
+) {
     //#pragma HLS ARRAY_PARTITION variable=threshold complete
 
 BinaryNormLoop:
@@ -76,9 +84,12 @@ void normalize_binary_tanh(ac_channel<data_T> &data, ac_channel<nnet::array<ac_i
 }
 
 template <class data_T, typename CONFIG_T>
-void normalize_ternary_tanh(ac_channel<data_T> &data, ac_channel<nnet::array<ac_int<2, true>, CONFIG_T::n_in>> &res,
-                            typename data_T::value_type threshold_hi[CONFIG_T::n_in],
-                            typename data_T::value_type threshold_lo[CONFIG_T::n_in]) {
+void normalize_ternary_tanh(
+    ac_channel<data_T> &data,
+    ac_channel<nnet::array<ac_int<2, true>, CONFIG_T::n_in>> &res,
+    typename data_T::value_type threshold_hi[CONFIG_T::n_in],
+    typename data_T::value_type threshold_lo[CONFIG_T::n_in]
+) {
     //#pragma HLS ARRAY_PARTITION variable=threshold_hi complete
     //#pragma HLS ARRAY_PARTITION variable=threshold_lo complete
 
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_code_gen.h b/hls4ml/templates/catapult/nnet_utils/nnet_code_gen.h
old mode 100755
new mode 100644
index e4db43682..4e30599e6
--- a/hls4ml/templates/catapult/nnet_utils/nnet_code_gen.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_code_gen.h
@@ -8,19 +8,22 @@ namespace nnet {
 
 template <class data_T, typename CONFIG_T> class FillConv1DBuffer {
   public:
-    static void fill_buffer(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                            data_T buffer[CONFIG_T::n_pixels][CONFIG_T::filt_width * CONFIG_T::n_chan],
-                            const unsigned partition) {
+    static void fill_buffer(
+        data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+        data_T buffer[CONFIG_T::n_pixels][CONFIG_T::filt_width * CONFIG_T::n_chan],
+        const unsigned partition
+    ) {
         // To be implemented in subclasses
     }
 };
 
 template <class data_T, typename CONFIG_T> class FillConv2DBuffer {
   public:
-    static void
-    fill_buffer(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
-                data_T buffer[CONFIG_T::n_pixels][CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan],
-                const unsigned partition) {
+    static void fill_buffer(
+        data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
+        data_T buffer[CONFIG_T::n_pixels][CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan],
+        const unsigned partition
+    ) {
         // To be implemented in subclasses
     }
 };
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_conv1d.h b/hls4ml/templates/catapult/nnet_utils/nnet_conv1d.h
old mode 100755
new mode 100644
index 98e075d4a..a3717b731
--- a/hls4ml/templates/catapult/nnet_utils/nnet_conv1d.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_conv1d.h
@@ -33,9 +33,12 @@ struct conv1d_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan], res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_1d_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     if (CONFIG_T::strategy == nnet::latency) {
         conv_1d_latency_cl<data_T, res_T, CONFIG_T>(data, res, weights, biases);
     } else {
@@ -44,10 +47,12 @@ void conv_1d_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan], res_T res[CO
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_1d_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                          res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                          typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                          typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_1d_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::filt_width == 1);
 
     if (CONFIG_T::strategy == nnet::latency) {
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_conv1d_latency.h b/hls4ml/templates/catapult/nnet_utils/nnet_conv1d_latency.h
old mode 100755
new mode 100644
index 0323b1ac4..df2b58dce
--- a/hls4ml/templates/catapult/nnet_utils/nnet_conv1d_latency.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_conv1d_latency.h
@@ -9,8 +9,8 @@ namespace nnet {
 // Computes multiplier limit
 // This function should not be synthesized into firmware
 template <typename CONFIG_T>
-int compute_multiplier_limit(
-    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt]) {
+int compute_multiplier_limit(typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt]
+) {
     int n_mult = 0;
     for (int ii = 0; ii < CONFIG_T::out_width; ii++) {
         for (int ff = 0; ff < CONFIG_T::n_filt; ff++) {
@@ -39,10 +39,12 @@ int compute_multiplier_limit(
 } // end compute_n_mult
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_latency_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                        res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                        typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                        typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_1d_latency_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
 
     typename CONFIG_T::accum_t mult[CONFIG_T::out_width * CONFIG_T::n_filt * CONFIG_T::n_chan * CONFIG_T::filt_width];
     typename CONFIG_T::accum_t acc[CONFIG_T::out_width][CONFIG_T::n_filt];
@@ -121,10 +123,12 @@ void conv_1d_latency_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_1d_latency_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                                  res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                                  typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                                  typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_1d_latency_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::filt_width == 1);
 
     typename CONFIG_T::accum_t mult[CONFIG_T::out_width * CONFIG_T::n_filt * CONFIG_T::n_chan];
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_conv1d_resource.h b/hls4ml/templates/catapult/nnet_utils/nnet_conv1d_resource.h
index 143a1271b..cc1a0ddab 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_conv1d_resource.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_conv1d_resource.h
@@ -7,8 +7,10 @@
 namespace nnet {
 
 template <class data_T, typename CONFIG_T>
-void im2col_1d(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-               data_T data_col[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::out_width]) {
+void im2col_1d(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    data_T data_col[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::out_width]
+) {
     // int index = 0;
     for (int channel = CONFIG_T::n_chan; channel--; data += CONFIG_T::in_width) {
         //#pragma HLS PIPELINE II=1 rewind
@@ -30,9 +32,12 @@ void im2col_1d(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_full(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan], res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                  typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                  typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_1d_full(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     data_T data_conv[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::out_width];
     data_T data_col[CONFIG_T::filt_width * CONFIG_T::n_chan];
     res_T res_col[CONFIG_T::n_filt];
@@ -56,8 +61,11 @@ void conv_1d_full(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan], res_T res[
 }
 
 template <class data_T, typename CONFIG_T>
-void im2col_1d_cf_idx(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                      data_T data_col[CONFIG_T::filt_width * CONFIG_T::n_chan], const int col) {
+void im2col_1d_cf_idx(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    data_T data_col[CONFIG_T::filt_width * CONFIG_T::n_chan],
+    const int col
+) {
 ChannelLoop:
     for (int channel = 0; channel < CONFIG_T::n_chan; channel++) {
     //#pragma HLS PIPELINE II=1 rewind
@@ -76,8 +84,11 @@ void im2col_1d_cf_idx(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
 }
 
 template <class data_T, typename CONFIG_T>
-void im2col_1d_cf(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                  data_T data_col[CONFIG_T::n_chan * CONFIG_T::filt_width], const int col) {
+void im2col_1d_cf(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    data_T data_col[CONFIG_T::n_chan * CONFIG_T::filt_width],
+    const int col
+) {
     int index = 0;
 ChannelLoop:
     for (int channel = CONFIG_T::n_chan; channel--; data += CONFIG_T::in_width) {
@@ -97,10 +108,12 @@ void im2col_1d_cf(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_resource_cf(data_T data[CONFIG_T::n_chan * CONFIG_T::in_width],
-                         res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                         typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                         typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_1d_resource_cf(
+    data_T data[CONFIG_T::n_chan * CONFIG_T::in_width],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     const int nin = CONFIG_T::n_chan * CONFIG_T::filt_width;
     const int nout = CONFIG_T::n_filt;
     const int rufactor = CONFIG_T::reuse_factor;
@@ -131,8 +144,11 @@ void conv_1d_resource_cf(data_T data[CONFIG_T::n_chan * CONFIG_T::in_width],
 }
 
 template <class data_T, typename CONFIG_T>
-void im2col_1d_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                  data_T data_col[CONFIG_T::filt_width * CONFIG_T::n_chan], const int col) {
+void im2col_1d_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    data_T data_col[CONFIG_T::filt_width * CONFIG_T::n_chan],
+    const int col
+) {
     int index = 0;
 KernelLoop:
     for (int kernel_col = 0; kernel_col < CONFIG_T::filt_width; kernel_col++) {
@@ -152,8 +168,9 @@ void im2col_1d_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
 }
 
 template <class data_T, typename CONFIG_T>
-void im2col_1d_pointwise_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan], data_T data_col[CONFIG_T::n_chan],
-                            const int col) {
+void im2col_1d_pointwise_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan], data_T data_col[CONFIG_T::n_chan], const int col
+) {
     int index = 0;
 ChannelLoop:
     for (int channel = 0; channel < CONFIG_T::n_chan; channel++) {
@@ -170,10 +187,12 @@ void im2col_1d_pointwise_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_resource_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                         res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                         typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                         typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_1d_resource_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     const int nin = CONFIG_T::n_chan * CONFIG_T::filt_width;
     const int nout = CONFIG_T::n_filt;
     const int rufactor = CONFIG_T::reuse_factor;
@@ -203,10 +222,12 @@ void conv_1d_resource_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_1d_resource_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                                   res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                                   typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                                   typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_1d_resource_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::filt_width == 1);
 
     const int nin = CONFIG_T::n_chan;
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_conv1d_stream.h b/hls4ml/templates/catapult/nnet_utils/nnet_conv1d_stream.h
index 48f6244ce..f5d9e0207 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_conv1d_stream.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_conv1d_stream.h
@@ -16,15 +16,19 @@ void compute_scaled_indices_1d(const unsigned w_idx, ac_int<CONFIG_T::filt_width
         // #pragma HLS UNROLL
         unsigned sw_idx =
             CONFIG_T::template scale_index<CONFIG_T::filt_width, CONFIG_T::stride_width, CONFIG_T::in_width>::scale_index(
-                wp_idx + p);
+                wp_idx + p
+            );
         pixel_idx[p] = CONFIG_T::pixels[sw_idx];
     }
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_encoded_cl(ac_channel<data_T> &data, ac_channel<res_T> &res,
-                        typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                        typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_1d_encoded_cl(
+    ac_channel<data_T> &data,
+    ac_channel<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
 
     ac_channel<typename data_T::value_type> data_window[CONFIG_T::filt_width * CONFIG_T::n_chan];
@@ -52,15 +56,19 @@ void conv_1d_encoded_cl(ac_channel<data_T> &data, ac_channel<res_T> &res,
             //#pragma HLS PIPELINE II=CONFIG_T::reuse_factor
         }
         compute_scaled_indices_1d<data_T, CONFIG_T>(i_iw, pixel_idx);
-        compute_output_encoded<data_T, res_T, CONFIG_T>(data.read(), data_window, res, res_pack, outputs_ready, weights,
-                                                        biases, pixel_idx);
+        compute_output_encoded<data_T, res_T, CONFIG_T>(
+            data.read(), data_window, res, res_pack, outputs_ready, weights, biases, pixel_idx
+        );
     }
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_buffer_cl(ac_channel<data_T> &data, ac_channel<res_T> &res,
-                       typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                       typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_1d_buffer_cl(
+    ac_channel<data_T> &data,
+    ac_channel<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
 
     constexpr int ce_reuse_factor = CONFIG_T::reuse_factor * (CONFIG_T::strategy == nnet::latency);
@@ -76,9 +84,12 @@ void conv_1d_buffer_cl(ac_channel<data_T> &data, ac_channel<res_T> &res,
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_cl(ac_channel<data_T> &data, ac_channel<res_T> &res,
-                typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_1d_cl(
+    ac_channel<data_T> &data,
+    ac_channel<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     //#pragma HLS inline region
     switch (CONFIG_T::implementation) {
     case conv_implementation::linebuffer:
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_conv2d.h b/hls4ml/templates/catapult/nnet_utils/nnet_conv2d.h
old mode 100755
new mode 100644
index 01476a044..f439c6400
--- a/hls4ml/templates/catapult/nnet_utils/nnet_conv2d.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_conv2d.h
@@ -44,7 +44,8 @@ void conv_2d_cf(
     data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
     res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     if (CONFIG_T::strategy == nnet::latency) {
         conv_2d_latency_cf<data_T, res_T, CONFIG_T>(data, res, weights, biases);
     } else {
@@ -57,7 +58,8 @@ void conv_2d_cl(
     data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
     res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     if (CONFIG_T::strategy == nnet::latency) {
         conv_2d_latency_cl<data_T, res_T, CONFIG_T>(data, res, weights, biases);
     } else {
@@ -66,10 +68,12 @@ void conv_2d_cl(
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
-                          res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
-                          typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                          typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_2d_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::filt_width == 1);
 
     if (CONFIG_T::strategy == nnet::latency) {
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_conv2d_latency.h b/hls4ml/templates/catapult/nnet_utils/nnet_conv2d_latency.h
index 29dd8ca63..9c3155f7b 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_conv2d_latency.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_conv2d_latency.h
@@ -9,8 +9,9 @@ namespace nnet {
 // Computes multiplier limit
 // This function should not be synthesized into firmware
 template <typename CONFIG_T>
-int compute_multiplier_limit_conv2d(typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width *
-                                                                        CONFIG_T::n_chan * CONFIG_T::n_filt]) {
+int compute_multiplier_limit_conv2d(
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt]
+) {
     int n_mult = 0;
 
     for (int oh = 0; oh < CONFIG_T::out_height; oh++) {
@@ -52,10 +53,12 @@ void conv_2d_latency_cf(
     data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
     res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
 
-    typename CONFIG_T::accum_t mult[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt * CONFIG_T::n_chan *
-                                    CONFIG_T::filt_height * CONFIG_T::filt_width];
+    typename CONFIG_T::accum_t mult
+        [CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt * CONFIG_T::n_chan * CONFIG_T::filt_height *
+         CONFIG_T::filt_width];
     typename CONFIG_T::accum_t acc[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt];
 
     //#pragma HLS ARRAY_PARTITION variable=mult complete dim=0
@@ -175,10 +178,12 @@ void conv_2d_latency_cl(
     data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
     res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
 
-    typename CONFIG_T::accum_t mult[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt * CONFIG_T::n_chan *
-                                    CONFIG_T::filt_height * CONFIG_T::filt_width];
+    typename CONFIG_T::accum_t mult
+        [CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt * CONFIG_T::n_chan * CONFIG_T::filt_height *
+         CONFIG_T::filt_width];
     typename CONFIG_T::accum_t acc[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt];
 
     //#pragma HLS ARRAY_PARTITION variable=mult complete dim=0
@@ -293,10 +298,12 @@ void conv_2d_latency_cl(
 } // end conv2d
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_2d_latency_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
-                                  res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
-                                  typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                                  typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_2d_latency_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
 
     typename CONFIG_T::accum_t mult[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt * CONFIG_T::n_chan];
     typename CONFIG_T::accum_t acc[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt];
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_conv2d_resource.h b/hls4ml/templates/catapult/nnet_utils/nnet_conv2d_resource.h
index c5e386b5e..55ffa355d 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_conv2d_resource.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_conv2d_resource.h
@@ -7,9 +7,11 @@
 namespace nnet {
 
 template <class data_T, typename CONFIG_T>
-void im2col_2d(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
-               data_T data_col[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::out_height *
-                               CONFIG_T::out_width]) {
+void im2col_2d(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
+    data_T data_col
+        [CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::out_height * CONFIG_T::out_width]
+) {
     const int output_h = (CONFIG_T::in_height + CONFIG_T::pad_top + CONFIG_T::pad_bottom -
                           (CONFIG_T::dilation_height * (CONFIG_T::filt_height - 1) + 1)) /
                              CONFIG_T::stride_height +
@@ -52,9 +54,10 @@ void conv_2d_full(
     data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
     res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
-    data_T data_conv[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::out_height *
-                     CONFIG_T::out_width];
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
+    data_T data_conv
+        [CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::out_height * CONFIG_T::out_width];
     data_T data_col[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan];
     res_T res_col[CONFIG_T::n_filt];
 
@@ -77,9 +80,12 @@ void conv_2d_full(
 }
 
 template <class data_T, typename CONFIG_T>
-void im2col_2d_cf(data_T data[CONFIG_T::n_chan * CONFIG_T::in_height * CONFIG_T::in_width],
-                  data_T data_col[CONFIG_T::n_chan * CONFIG_T::filt_height * CONFIG_T::filt_width], const int row,
-                  const int col) {
+void im2col_2d_cf(
+    data_T data[CONFIG_T::n_chan * CONFIG_T::in_height * CONFIG_T::in_width],
+    data_T data_col[CONFIG_T::n_chan * CONFIG_T::filt_height * CONFIG_T::filt_width],
+    const int row,
+    const int col
+) {
     const int channel_size = CONFIG_T::in_height * CONFIG_T::in_width;
     int index = 0;
     for (int channel = CONFIG_T::n_chan; channel--; data += channel_size) {
@@ -111,7 +117,8 @@ void conv_2d_resource_cf(
     data_T data[CONFIG_T::n_chan * CONFIG_T::in_height * CONFIG_T::in_width],
     res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     const int nin = CONFIG_T::n_chan * CONFIG_T::filt_width;
     const int nout = CONFIG_T::n_filt;
     const int rufactor = CONFIG_T::reuse_factor;
@@ -147,9 +154,12 @@ void conv_2d_resource_cf(
 }
 
 template <class data_T, typename CONFIG_T>
-void im2col_2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
-                  data_T data_col[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan], const int row,
-                  const int col) {
+void im2col_2d_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
+    data_T data_col[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan],
+    const int row,
+    const int col
+) {
     int index = 0;
     for (int kernel_row = 0; kernel_row < CONFIG_T::filt_height; kernel_row++) {
         int input_row = -CONFIG_T::pad_top + kernel_row * CONFIG_T::dilation_height + row * CONFIG_T::stride_height;
@@ -173,8 +183,12 @@ void im2col_2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_
 }
 
 template <class data_T, typename CONFIG_T>
-void im2col_2d_pointwise_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
-                            data_T data_col[CONFIG_T::n_chan], const int row, const int col) {
+void im2col_2d_pointwise_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
+    data_T data_col[CONFIG_T::n_chan],
+    const int row,
+    const int col
+) {
     int index = 0;
     int input_row = -CONFIG_T::pad_top + row * CONFIG_T::stride_height;
 
@@ -199,7 +213,8 @@ void conv_2d_resource_cl(
     data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
     res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     const int nin = CONFIG_T::n_chan * CONFIG_T::filt_width;
     const int nout = CONFIG_T::n_filt;
     const int rufactor = CONFIG_T::reuse_factor;
@@ -233,10 +248,12 @@ void conv_2d_resource_cl(
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_2d_resource_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
-                                   res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
-                                   typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                                   typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_2d_resource_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::filt_height == 1 && CONFIG_T::filt_width == 1);
 
     const int nin = CONFIG_T::n_chan;
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_conv2d_stream.h b/hls4ml/templates/catapult/nnet_utils/nnet_conv2d_stream.h
index 7e76be12a..6dac73a08 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_conv2d_stream.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_conv2d_stream.h
@@ -9,27 +9,31 @@
 namespace nnet {
 
 template <class data_T, typename CONFIG_T>
-void compute_scaled_indices_2d(const unsigned h_idx, const unsigned w_idx,
-                               ac_int<CONFIG_T::filt_height * CONFIG_T::filt_width, false> *pixel_idx) {
-    const unsigned sh_idx = CONFIG_T::template scale_index_height<CONFIG_T::filt_height, CONFIG_T::stride_height,
-                                                                  CONFIG_T::in_height>::scale_index(h_idx);
+void compute_scaled_indices_2d(
+    const unsigned h_idx, const unsigned w_idx, ac_int<CONFIG_T::filt_height * CONFIG_T::filt_width, false> *pixel_idx
+) {
+    const unsigned sh_idx = CONFIG_T::
+        template scale_index_height<CONFIG_T::filt_height, CONFIG_T::stride_height, CONFIG_T::in_height>::scale_index(h_idx);
     unsigned wp_idx = w_idx * (data_T::size / CONFIG_T::n_chan);
 
 ComputeIndex:
     for (unsigned p = 0; p < data_T::size / CONFIG_T::n_chan; p++) {
         // #pragma HLS UNROLL
 
-        unsigned sw_idx = CONFIG_T::template scale_index_width<CONFIG_T::filt_width, CONFIG_T::stride_width,
-                                                               CONFIG_T::in_width>::scale_index(wp_idx + p);
+        unsigned sw_idx =
+            CONFIG_T::template scale_index_width<CONFIG_T::filt_width, CONFIG_T::stride_width, CONFIG_T::in_width>::
+                scale_index(wp_idx + p);
         pixel_idx[p] = CONFIG_T::pixels[sh_idx * CONFIG_T::min_width + sw_idx];
     }
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
 void conv_2d_encoded_cl(
-    ac_channel<data_T> &data, ac_channel<res_T> &res,
+    ac_channel<data_T> &data,
+    ac_channel<res_T> &res,
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_top == 0 && CONFIG_T::pad_bottom == 0 && CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
     assert(CONFIG_T::filt_height == CONFIG_T::filt_width);
 
@@ -60,8 +64,9 @@ void conv_2d_encoded_cl(
                 //#pragma HLS PIPELINE II=CONFIG_T::reuse_factor
             }
             compute_scaled_indices_2d<data_T, CONFIG_T>(i_ih, i_iw, pixel_idx);
-            compute_output_encoded<data_T, res_T, CONFIG_T>(data.read(), data_window, res, res_pack, outputs_ready, weights,
-                                                            biases, pixel_idx);
+            compute_output_encoded<data_T, res_T, CONFIG_T>(
+                data.read(), data_window, res, res_pack, outputs_ready, weights, biases, pixel_idx
+            );
         }
     }
 }
@@ -69,9 +74,11 @@ void conv_2d_encoded_cl(
 // Line Buffer
 template <class data_T, class res_T, typename CONFIG_T>
 void conv_2d_buffer_cl(
-    ac_channel<data_T> &data, ac_channel<res_T> &res,
+    ac_channel<data_T> &data,
+    ac_channel<res_T> &res,
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_top == 0 && CONFIG_T::pad_bottom == 0 && CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
 
     static ap_shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[MAX(CONFIG_T::filt_height - 1, 1)]
@@ -99,9 +106,11 @@ void conv_2d_buffer_cl(
 
 template <class data_T, class res_T, typename CONFIG_T>
 void conv_2d_cl(
-    ac_channel<data_T> &data, ac_channel<res_T> &res,
+    ac_channel<data_T> &data,
+    ac_channel<res_T> &res,
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     //#pragma HLS inline region
     switch (CONFIG_T::implementation) {
     case conv_implementation::linebuffer:
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_conv_stream.h b/hls4ml/templates/catapult/nnet_utils/nnet_conv_stream.h
index 4d92cbf69..47cc2cf2e 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_conv_stream.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_conv_stream.h
@@ -77,10 +77,14 @@ template <unsigned K, unsigned S, unsigned W> class scale_index_unscaled {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void mult_buffer(ac_channel<typename data_T::value_type> data_window[CONFIG_T::kernel_size * CONFIG_T::n_chan],
-                 res_T &res_pack, ac_channel<res_T> &res_stream, unsigned &outputs_ready,
-                 typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                 typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void mult_buffer(
+    ac_channel<typename data_T::value_type> data_window[CONFIG_T::kernel_size * CONFIG_T::n_chan],
+    res_T &res_pack,
+    ac_channel<res_T> &res_stream,
+    unsigned &outputs_ready,
+    typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     //#pragma HLS INLINE
 
     typename data_T::value_type data[CONFIG_T::kernel_size * CONFIG_T::n_chan];
@@ -97,10 +101,12 @@ void mult_buffer(ac_channel<typename data_T::value_type> data_window[CONFIG_T::k
     //#pragma HLS INLINE region
     if (CONFIG_T::strategy == nnet::latency) {
         dense_latency<typename data_T::value_type, typename res_T::value_type, typename CONFIG_T::mult_config>(
-            data, res, weights, biases);
+            data, res, weights, biases
+        );
     } else {
         dense_resource<typename data_T::value_type, typename res_T::value_type, typename CONFIG_T::mult_config>(
-            data, res, weights, biases);
+            data, res, weights, biases
+        );
     }
 
 CastLoop:
@@ -126,12 +132,16 @@ void mult_buffer(ac_channel<typename data_T::value_type> data_window[CONFIG_T::k
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void compute_output_encoded(const data_T &in_elem,
-                            ac_channel<typename data_T::value_type> data_window[CONFIG_T::kernel_size * CONFIG_T::n_chan],
-                            ac_channel<res_T> &res, res_T &res_pack, unsigned &outputs_ready,
-                            typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                            typename CONFIG_T::bias_t biases[CONFIG_T::n_filt],
-                            ac_int<CONFIG_T::kernel_size, false> *pixel_idx) {
+void compute_output_encoded(
+    const data_T &in_elem,
+    ac_channel<typename data_T::value_type> data_window[CONFIG_T::kernel_size * CONFIG_T::n_chan],
+    ac_channel<res_T> &res,
+    res_T &res_pack,
+    unsigned &outputs_ready,
+    typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt],
+    ac_int<CONFIG_T::kernel_size, false> *pixel_idx
+) {
     //#pragma HLS INLINE
     constexpr int ce_reuse_factor = CONFIG_T::reuse_factor;
     (void)ce_reuse_factor;
@@ -158,8 +168,9 @@ void compute_output_encoded(const data_T &in_elem,
 //       Line Buffer Implementation (Phil's)
 // *************************************************
 template <class data_T, typename CONFIG_T>
-void kernel_shift_1d(const data_T &in_elem,
-                     typename data_T::value_type kernel_window[CONFIG_T::filt_width * CONFIG_T::n_chan]) {
+void kernel_shift_1d(
+    const data_T &in_elem, typename data_T::value_type kernel_window[CONFIG_T::filt_width * CONFIG_T::n_chan]
+) {
     //#pragma HLS inline
     //#pragma HLS PIPELINE II = 1
 
@@ -188,7 +199,8 @@ void kernel_shift_1d(const data_T &in_elem,
 template <class data_T, typename CONFIG_T>
 void kernel_shift_2d(
     typename data_T::value_type shift_buffer[CONFIG_T::filt_height][CONFIG_T::n_chan],
-    typename data_T::value_type kernel_window[CONFIG_T::filt_width * CONFIG_T::filt_height * CONFIG_T::n_chan]) {
+    typename data_T::value_type kernel_window[CONFIG_T::filt_width * CONFIG_T::filt_height * CONFIG_T::n_chan]
+) {
     //#pragma HLS inline
 
     // Shift kernel_window by one step to the left (manual shift operation)
@@ -223,7 +235,8 @@ void shift_line_buffer(
     const data_T &in_elem,
     ap_shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[MAX(CONFIG_T::filt_height - 1, 1)]
                                                                              [CONFIG_T::n_chan],
-    typename data_T::value_type kernel_window[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan]) {
+    typename data_T::value_type kernel_window[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan]
+) {
 
     //#pragma HLS PIPELINE
 
@@ -245,8 +258,9 @@ void shift_line_buffer(
     LineBufferShift:
         for (unsigned i_ih = 1; i_ih < CONFIG_T::filt_height; i_ih++) {
             // #pragma HLS UNROLL
-            typename data_T::value_type pop_elem = line_buffer[i_ih - 1][i_ic].shift(
-                shift_buffer[CONFIG_T::filt_height - i_ih][i_ic]); // Shift the line buffer, return the popped pixel
+            typename data_T::value_type pop_elem =
+                line_buffer[i_ih - 1][i_ic].shift(shift_buffer[CONFIG_T::filt_height - i_ih][i_ic]
+                ); // Shift the line buffer, return the popped pixel
             shift_buffer[CONFIG_T::filt_height - i_ih - 1][i_ic] =
                 pop_elem; // Popped element placed back into shift_buffer, one row up.
         }
@@ -261,7 +275,8 @@ void compute_output_buffer_2d(
                                                                              [CONFIG_T::n_chan],
     ac_channel<res_T> &res_stream,
     typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     //#pragma HLS INLINE
 
     // Thresholds
@@ -294,10 +309,12 @@ void compute_output_buffer_2d(
         //#pragma HLS INLINE region
         if (CONFIG_T::strategy == nnet::latency) {
             dense_latency<typename data_T::value_type, typename res_T::value_type, typename CONFIG_T::mult_config>(
-                kernel_data, res_out, weights, biases);
+                kernel_data, res_out, weights, biases
+            );
         } else {
             dense_resource<typename data_T::value_type, typename res_T::value_type, typename CONFIG_T::mult_config>(
-                kernel_data, res_out, weights, biases);
+                kernel_data, res_out, weights, biases
+            );
         }
 
         // Pack output
@@ -334,9 +351,11 @@ void compute_output_buffer_2d(
 // Conv 1D compute output
 template <class data_T, class res_T, typename CONFIG_T>
 void compute_output_buffer_1d(
-    const data_T &in_elem, ac_channel<res_T> &res_stream,
+    const data_T &in_elem,
+    ac_channel<res_T> &res_stream,
     typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     //#pragma HLS INLINE
 
     // Thresholds
@@ -365,10 +384,12 @@ void compute_output_buffer_1d(
         //#pragma HLS INLINE region
         if (CONFIG_T::strategy == nnet::latency) {
             dense_latency<typename data_T::value_type, typename res_T::value_type, typename CONFIG_T::mult_config>(
-                kernel_data, res_out, weights, biases);
+                kernel_data, res_out, weights, biases
+            );
         } else {
             dense_resource<typename data_T::value_type, typename res_T::value_type, typename CONFIG_T::mult_config>(
-                kernel_data, res_out, weights, biases);
+                kernel_data, res_out, weights, biases
+            );
         }
 
         // Pack output
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_dense.h b/hls4ml/templates/catapult/nnet_utils/nnet_dense.h
index 64b927cc6..4e0aaa37d 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_dense.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_dense.h
@@ -33,9 +33,12 @@ struct dense_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-           typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-           typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
     //#pragma HLS inline
     if (CONFIG_T::strategy == nnet::latency) {
         dense_latency<data_T, res_T, CONFIG_T>(data, res, weights, biases);
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_dense_compressed.h b/hls4ml/templates/catapult/nnet_utils/nnet_dense_compressed.h
index f3f27b6db..2df155f96 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_dense_compressed.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_dense_compressed.h
@@ -28,8 +28,9 @@
 namespace nnet {
 
 template <typename CONFIG_T>
-void fill_mult(typename CONFIG_T::index_t index, typename CONFIG_T::accum_t mult[CONFIG_T::n_out],
-               typename CONFIG_T::accum_t weight) {
+void fill_mult(
+    typename CONFIG_T::index_t index, typename CONFIG_T::accum_t mult[CONFIG_T::n_out], typename CONFIG_T::accum_t weight
+) {
     for (unsigned k = 0; k < CONFIG_T::n_out; k++) {
         // #pragma HLS UNROLL
         if (k == index)
@@ -38,9 +39,12 @@ void fill_mult(typename CONFIG_T::index_t index, typename CONFIG_T::accum_t mult
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_compressed(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                      typename CONFIG_T::weight_t weights[CONFIG_T::n_nonzeros],
-                      typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense_compressed(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_nonzeros],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
 
     const int multiplier_limit = DIV_ROUNDUP(CONFIG_T::n_nonzeros, CONFIG_T::reuse_factor);
 
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_dense_latency.h b/hls4ml/templates/catapult/nnet_utils/nnet_dense_latency.h
index 40e5cd2b9..a63aff2ff 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_dense_latency.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_dense_latency.h
@@ -11,9 +11,12 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_latency(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                   typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-                   typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense_latency(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
     constexpr int ce_reuse_factor = CONFIG_T::reuse_factor;
     // Partial unroll config
     constexpr int prod1_unroll =
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_dense_resource.h b/hls4ml/templates/catapult/nnet_utils/nnet_dense_resource.h
index 5bcd1a54b..93abc32a5 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_dense_resource.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_dense_resource.h
@@ -11,9 +11,12 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_resource_rf_leq_nin(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                               typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-                               typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense_resource_rf_leq_nin(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
 
     const int rufactor = CONFIG_T::reuse_factor;
     const int multfactor = MIN(CONFIG_T::n_in, CONFIG_T::reuse_factor);
@@ -54,7 +57,8 @@ void dense_resource_rf_leq_nin(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::
             //#pragma HLS UNROLL
 
             acc[out_index] += static_cast<typename CONFIG_T::accum_t>(
-                CONFIG_T::template product<data_T, typename CONFIG_T::weight_t>::product(data[in_index], weights[w_index]));
+                CONFIG_T::template product<data_T, typename CONFIG_T::weight_t>::product(data[in_index], weights[w_index])
+            );
 
             // Increment w_index
             w_index += rufactor;
@@ -82,9 +86,12 @@ void dense_resource_rf_leq_nin(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_resource_rf_gt_nin_rem0(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                                   typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-                                   typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense_resource_rf_gt_nin_rem0(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
 
     const int rufactor = MIN(CONFIG_T::reuse_factor, CONFIG_T::n_in * CONFIG_T::n_out);
     const int multfactor = MIN(CONFIG_T::n_in, CONFIG_T::reuse_factor);
@@ -136,7 +143,8 @@ void dense_resource_rf_gt_nin_rem0(data_T data[CONFIG_T::n_in], res_T res[CONFIG
         for (unsigned int im = 0; im < block_factor; im++) {
             //#pragma HLS UNROLL
             acc[out_index] += static_cast<typename CONFIG_T::accum_t>(
-                CONFIG_T::template product<data_T, typename CONFIG_T::weight_t>::product(data[in_index], weights[w_index]));
+                CONFIG_T::template product<data_T, typename CONFIG_T::weight_t>::product(data[in_index], weights[w_index])
+            );
 
             w_index += rufactor;
             if (w_index >= CONFIG_T::n_in * CONFIG_T::n_out)
@@ -160,9 +168,12 @@ void dense_resource_rf_gt_nin_rem0(data_T data[CONFIG_T::n_in], res_T res[CONFIG
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_resource_rf_gt_nin(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                              typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-                              typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense_resource_rf_gt_nin(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
 
     const int rufactor = CONFIG_T::reuse_factor;
     const int multfactor = MIN(CONFIG_T::n_in, CONFIG_T::reuse_factor);
@@ -242,9 +253,12 @@ void dense_resource_rf_gt_nin(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_resource(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-                    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense_resource(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
 
     //#pragma HLS INLINE region
 
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_dense_stream.h b/hls4ml/templates/catapult/nnet_utils/nnet_dense_stream.h
index 665d2f43f..8b5514aa0 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_dense_stream.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_dense_stream.h
@@ -10,9 +10,12 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_wrapper(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                   typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-                   typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense_wrapper(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
     //#pragma HLS INLINE region
     if (CONFIG_T::strategy == nnet::latency) {
         //#pragma HLS PIPELINE II=CONFIG_T::reuse_factor
@@ -23,9 +26,12 @@ void dense_wrapper(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense(ac_channel<data_T> &data_stream, ac_channel<res_T> &res_stream,
-           typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-           typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense(
+    ac_channel<data_T> &data_stream,
+    ac_channel<res_T> &res_stream,
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
     typename data_T::value_type data[CONFIG_T::n_in];
     //#pragma HLS ARRAY_PARTITION variable=data complete
 
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_embed.h b/hls4ml/templates/catapult/nnet_utils/nnet_embed.h
index 4cdf507f9..ac73e2f58 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_embed.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_embed.h
@@ -21,8 +21,11 @@ struct embed_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void embedding(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_in * CONFIG_T::n_out],
-               typename CONFIG_T::embeddings_t embeddings[CONFIG_T::vocab_size * CONFIG_T::n_out]) {
+void embedding(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::embeddings_t embeddings[CONFIG_T::vocab_size * CONFIG_T::n_out]
+) {
 
     //#pragma HLS PIPELINE II=CONFIG_T::reuse_factor
     // This can save a few cycles, but it will create a large multiplexer due to
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_embed_stream.h b/hls4ml/templates/catapult/nnet_utils/nnet_embed_stream.h
index 137810087..19212cd06 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_embed_stream.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_embed_stream.h
@@ -8,8 +8,11 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void embedding(ac_channel<data_T> &data, ac_channel<res_T> &res,
-               typename CONFIG_T::embeddings_t embeddings[CONFIG_T::vocab_size * CONFIG_T::n_out]) {
+void embedding(
+    ac_channel<data_T> &data,
+    ac_channel<res_T> &res,
+    typename CONFIG_T::embeddings_t embeddings[CONFIG_T::vocab_size * CONFIG_T::n_out]
+) {
     data_T in_data = data.read();
     constexpr int ce_reuse_factor = CONFIG_T::reuse_factor;
     (void)ce_reuse_factor;
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_garnet.h b/hls4ml/templates/catapult/nnet_utils/nnet_garnet.h
index 7451110fb..fb2b36cd8 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_garnet.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_garnet.h
@@ -96,15 +96,15 @@ template <class CONFIG_T> typename CONFIG_T::edge_weight_t compute_edge_weight(t
 }
 
 template <class dividend_T, class exponent_T>
-inline typename std::enable_if<std::is_class<dividend_T>::value, dividend_T>::type normalize_log2(dividend_T dividend,
-                                                                                                  exponent_T exponent) {
+inline typename std::enable_if<std::is_class<dividend_T>::value, dividend_T>::type
+normalize_log2(dividend_T dividend, exponent_T exponent) {
     //#pragma HLS INLINE
     return dividend >> exponent;
 }
 
 template <class dividend_T, class exponent_T>
-inline typename std::enable_if<not std::is_class<dividend_T>::value, dividend_T>::type normalize_log2(dividend_T dividend,
-                                                                                                      exponent_T exponent) {
+inline typename std::enable_if<not std::is_class<dividend_T>::value, dividend_T>::type
+normalize_log2(dividend_T dividend, exponent_T exponent) {
     //#pragma HLS INLINE
     return dividend / std::pow(2., exponent);
 }
@@ -300,8 +300,8 @@ template <class CONFIG_T, class res_T> struct SingleVertexResSetter {
 };
 
 template <class CONFIG_T, class data_getter_T, class arrays_local_T, class arrays_T>
-inline void compute_weights_aggregates(data_getter_T const &data_getter, unsigned iv, arrays_local_T &arrays_local,
-                                       arrays_T &arrays) {
+inline void
+compute_weights_aggregates(data_getter_T const &data_getter, unsigned iv, arrays_local_T &arrays_local, arrays_T &arrays) {
     //#pragma HLS INLINE
 
 Aggregators:
@@ -355,8 +355,9 @@ inline typename CONFIG_T::aggr_t compute_output_base_core(arrays_T const &arrays
 }
 
 template <class CONFIG_T, class arrays_T>
-inline void compute_output_base(arrays_T const &arrays,
-                                typename CONFIG_T::aggr_t output_base[CONFIG_T::n_out_features * CONFIG_T::n_aggregators]) {
+inline void compute_output_base(
+    arrays_T const &arrays, typename CONFIG_T::aggr_t output_base[CONFIG_T::n_out_features * CONFIG_T::n_aggregators]
+) {
     //#pragma HLS INLINE
 
 OutFeatures:
@@ -371,10 +372,12 @@ inline void compute_output_base(arrays_T const &arrays,
 }
 
 template <class CONFIG_T, class arrays_T, class res_setter_T>
-inline void
-compute_vertex_output(arrays_T const &arrays, unsigned iv,
-                      typename CONFIG_T::aggr_t const output_base[CONFIG_T::n_out_features * CONFIG_T::n_aggregators],
-                      res_setter_T &res_setter) {
+inline void compute_vertex_output(
+    arrays_T const &arrays,
+    unsigned iv,
+    typename CONFIG_T::aggr_t const output_base[CONFIG_T::n_out_features * CONFIG_T::n_aggregators],
+    res_setter_T &res_setter
+) {
     //#pragma HLS INLINE
 
     typename arrays_T::edge_weight_t edge_weights[CONFIG_T::n_aggregators];
@@ -467,8 +470,9 @@ void distribute(nvtx_T const nvtx, arrays_T const &arrays, res_T res[CONFIG_T::n
 }
 
 template <class CONFIG_T, class output_biases_T, class arrays_T, class res_T>
-void set_output(output_biases_T const &output_transform_biases, arrays_T const &arrays,
-                res_T res[CONFIG_T::n_out_features]) {
+void set_output(
+    output_biases_T const &output_transform_biases, arrays_T const &arrays, res_T res[CONFIG_T::n_out_features]
+) {
     //#pragma HLS PIPELINE
 
 OutFeatures:
@@ -533,8 +537,13 @@ void distribute_aggregate(nvtx_T const nvtx, prev_arrays_T const &prev_arrays, c
     current_arrays.set_means_normalized(nvtx, means_accum);
 }
 
-template <class prev_layer_t, class current_layer_t, class last_layer_t, class nvtx_T, class prev_arrays_T,
-          class last_arrays_T>
+template <
+    class prev_layer_t,
+    class current_layer_t,
+    class last_layer_t,
+    class nvtx_T,
+    class prev_arrays_T,
+    class last_arrays_T>
 inline typename std::enable_if<std::is_same<current_layer_t, last_layer_t>::value>::type
 sublayer(nvtx_T const nvtx, prev_arrays_T const &prev_arrays, last_arrays_T &last_arrays) {
     //#pragma HLS INLINE
@@ -542,8 +551,13 @@ sublayer(nvtx_T const nvtx, prev_arrays_T const &prev_arrays, last_arrays_T &las
     distribute_aggregate<prev_layer_t, current_layer_t>(nvtx, prev_arrays, last_arrays);
 }
 
-template <class prev_layer_t, class current_layer_t, class last_layer_t, class nvtx_T, class prev_arrays_T,
-          class last_arrays_T>
+template <
+    class prev_layer_t,
+    class current_layer_t,
+    class last_layer_t,
+    class nvtx_T,
+    class prev_arrays_T,
+    class last_arrays_T>
 inline typename std::enable_if<not std::is_same<current_layer_t, last_layer_t>::value>::type
 sublayer(nvtx_T const nvtx, prev_arrays_T const &prev_arrays, last_arrays_T &last_arrays) {
     //#pragma HLS INLINE
@@ -601,9 +615,11 @@ struct garnet_config {
 
 // vertices -> vertices
 template <class data_T, class nvtx_T, class res_T, typename CONFIG_T>
-typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::no_collapse>::type
-garnet(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features], nvtx_T const nvtx[1],
-       res_T res[CONFIG_T::n_vertices * CONFIG_T::n_out_features]) {
+typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::no_collapse>::type garnet(
+    data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features],
+    nvtx_T const nvtx[1],
+    res_T res[CONFIG_T::n_vertices * CONFIG_T::n_out_features]
+) {
     //#pragma HLS DATAFLOW
 
     garnet_utils::WeightsAndMeans<CONFIG_T> arrays;
@@ -615,9 +631,11 @@ garnet(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features], nvtx_T
 
 // vertices -> out features
 template <class data_T, class nvtx_T, class res_T, class CONFIG_T>
-typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::collapse_mean>::type
-garnet(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features], nvtx_T const nvtx[1],
-       res_T res[CONFIG_T::n_out_features]) {
+typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::collapse_mean>::type garnet(
+    data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features],
+    nvtx_T const nvtx[1],
+    res_T res[CONFIG_T::n_out_features]
+) {
     //#pragma HLS DATAFLOW
 
     garnet_utils::Means<CONFIG_T> arrays;
@@ -631,9 +649,11 @@ garnet(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features], nvtx_T
 
 // vertices -> vertices
 template <class data_T, class nvtx_T, class res_T, class CONFIG_T>
-typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::no_collapse>::type
-garnet_stack(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features], nvtx_T const nvtx[1],
-             res_T res[CONFIG_T::n_vertices * CONFIG_T::n_out_features]) {
+typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::no_collapse>::type garnet_stack(
+    data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features],
+    nvtx_T const nvtx[1],
+    res_T res[CONFIG_T::n_vertices * CONFIG_T::n_out_features]
+) {
     //#pragma HLS DATAFLOW
 
     typedef typename CONFIG_T::template sublayer_t<0> first_layer_t;
@@ -645,17 +665,20 @@ garnet_stack(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features],
 
     garnet_utils::aggregate<first_layer_t>(data, nvtx[0], arrays_first);
 
-    garnet_utils::sublayer<first_layer_t, typename first_layer_t::next_layer_t, last_layer_t>(nvtx[0], arrays_first,
-                                                                                              arrays_last);
+    garnet_utils::sublayer<first_layer_t, typename first_layer_t::next_layer_t, last_layer_t>(
+        nvtx[0], arrays_first, arrays_last
+    );
 
     garnet_utils::distribute<last_layer_t>(nvtx[0], arrays_last, res);
 }
 
 // vertices -> out features
 template <class data_T, class nvtx_T, class res_T, class CONFIG_T>
-typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::collapse_mean>::type
-garnet_stack(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features], nvtx_T const nvtx[1],
-             res_T res[CONFIG_T::n_out_features]) {
+typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::collapse_mean>::type garnet_stack(
+    data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features],
+    nvtx_T const nvtx[1],
+    res_T res[CONFIG_T::n_out_features]
+) {
     //#pragma HLS DATAFLOW
 
     typedef typename CONFIG_T::template sublayer_t<0> first_layer_t;
@@ -667,8 +690,9 @@ garnet_stack(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features],
 
     garnet_utils::aggregate<first_layer_t>(data, nvtx[0], arrays_first);
 
-    garnet_utils::sublayer<first_layer_t, typename first_layer_t::next_layer_t, last_layer_t>(nvtx[0], arrays_first,
-                                                                                              arrays_last);
+    garnet_utils::sublayer<first_layer_t, typename first_layer_t::next_layer_t, last_layer_t>(
+        nvtx[0], arrays_first, arrays_last
+    );
 
     garnet_utils::OutputBiasNormalizer<last_layer_t, nvtx_T> normalize_bias(nvtx[0]);
 
@@ -677,9 +701,11 @@ garnet_stack(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features],
 
 /* Reference (dumb) implementation returning (Vertices, Features) */
 template <class data_T, class nvtx_T, class res_T, typename CONFIG_T>
-typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::no_collapse>::type
-garnet_ref(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features], nvtx_T const nvtx[1],
-           res_T res[CONFIG_T::n_vertices * CONFIG_T::n_out_features]) {
+typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::no_collapse>::type garnet_ref(
+    data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features],
+    nvtx_T const nvtx[1],
+    res_T res[CONFIG_T::n_vertices * CONFIG_T::n_out_features]
+) {
     typename CONFIG_T::edge_weight_t edge_weights[CONFIG_T::n_vertices * CONFIG_T::n_aggregators];
     typename CONFIG_T::aggr_t propagated_features[CONFIG_T::n_vertices * CONFIG_T::n_propagate];
 
@@ -781,9 +807,11 @@ garnet_ref(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features], nv
 
 /* Reference (dumb) implementation returning (Features) - output averaged over vertices already */
 template <class data_T, class nvtx_T, class res_T, typename CONFIG_T>
-typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::collapse_mean>::type
-garnet_ref(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features], nvtx_T const nvtx[1],
-           res_T res[CONFIG_T::n_out_features]) {
+typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::collapse_mean>::type garnet_ref(
+    data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features],
+    nvtx_T const nvtx[1],
+    res_T res[CONFIG_T::n_out_features]
+) {
     typename CONFIG_T::aggr_t vertex_res[CONFIG_T::n_vertices * CONFIG_T::n_out_features];
 
     garnet_ref<CONFIG_T>(data, nvtx, vertex_res);
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_image.h b/hls4ml/templates/catapult/nnet_utils/nnet_image.h
old mode 100755
new mode 100644
index 26947fae0..b6dc45466
--- a/hls4ml/templates/catapult/nnet_utils/nnet_image.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_image.h
@@ -16,8 +16,10 @@ struct resize_config {
 };
 
 template <class data_T, typename CONFIG_T>
-void resize_nearest(data_T image[CONFIG_T::height * CONFIG_T::width * CONFIG_T::n_chan],
-                    data_T resized[CONFIG_T::new_height * CONFIG_T::new_width * CONFIG_T::n_chan]) {
+void resize_nearest(
+    data_T image[CONFIG_T::height * CONFIG_T::width * CONFIG_T::n_chan],
+    data_T resized[CONFIG_T::new_height * CONFIG_T::new_width * CONFIG_T::n_chan]
+) {
     int y_ratio = (int)((CONFIG_T::height << 16) / CONFIG_T::new_height) + 1;
     int x_ratio = (int)((CONFIG_T::width << 16) / CONFIG_T::new_width) + 1;
     int x2, y2;
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_math.h b/hls4ml/templates/catapult/nnet_utils/nnet_math.h
index c25f7187b..80f7c2d15 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_math.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_math.h
@@ -92,8 +92,10 @@ template <class T> void sincos_lut(const T &input, T output[2]) {
         if ((luTdex1 % (1 << (AP_MAX(T::width - T::iwidth - 12, 0)))) > (1 << (AP_MAX(T::width - T::iwidth - 13, 0)))) {
             luTdex = luTdex + 1;
         }
-        typedef ac_fixed<AP_MAX((AP_MAX(T::width - T::iwidth - 3, 1) + T::width - T::iwidth - 12), 1),
-                         AP_MAX(T::width - T::iwidth - 3, 1), false>
+        typedef ac_fixed<
+            AP_MAX((AP_MAX(T::width - T::iwidth - 3, 1) + T::width - T::iwidth - 12), 1),
+            AP_MAX(T::width - T::iwidth - 3, 1),
+            false>
             datatype;
         datatype x = (datatype)luTdex1;
         x = x >> AP_MAX(T::width - T::iwidth - 12, 0);
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_merge.h b/hls4ml/templates/catapult/nnet_utils/nnet_merge.h
index 9cba03071..624b36ebb 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_merge.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_merge.h
@@ -105,8 +105,11 @@ void dot1d(input1_T data1[CONFIG_T::n_in], input2_T data2[CONFIG_T::n_in], res_T
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate1d(input1_T data1[CONFIG_T::n_elem1_0], input2_T data2[CONFIG_T::n_elem2_0],
-                   res_T res[CONFIG_T::n_elem1_0 + CONFIG_T::n_elem2_0]) {
+void concatenate1d(
+    input1_T data1[CONFIG_T::n_elem1_0],
+    input2_T data2[CONFIG_T::n_elem2_0],
+    res_T res[CONFIG_T::n_elem1_0 + CONFIG_T::n_elem2_0]
+) {
     for (int ii = 0; ii < CONFIG_T::n_elem1_0; ii++) {
         res[ii] = data1[ii];
     }
@@ -116,9 +119,11 @@ void concatenate1d(input1_T data1[CONFIG_T::n_elem1_0], input2_T data2[CONFIG_T:
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate2d_0(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
-                     input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1],
-                     res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 + CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1]) {
+void concatenate2d_0(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1],
+    res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 + CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1]
+) {
     for (int ii = 0; ii < CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1; ii++) {
         res[ii] = data1[ii];
     }
@@ -128,9 +133,11 @@ void concatenate2d_0(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate2d_1(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
-                     input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1],
-                     res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 + CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1]) {
+void concatenate2d_1(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1],
+    res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 + CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1]
+) {
     for (int ii = 0; ii < CONFIG_T::n_elem1_0; ii++) {
         for (int jj = 0; jj < CONFIG_T::n_elem1_1; jj++) {
             res[ii * (CONFIG_T::n_elem1_1 + CONFIG_T::n_elem2_1) + jj] = data1[ii * CONFIG_T::n_elem1_1 + jj];
@@ -143,9 +150,11 @@ void concatenate2d_1(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate2d(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
-                   input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1],
-                   res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 + CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1]) {
+void concatenate2d(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1],
+    res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 + CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1]
+) {
     if (CONFIG_T::axis == 2 || CONFIG_T::axis == -1) {
         concatenate2d_1<input1_T, input2_T, res_T, CONFIG_T>(data1, data2, res);
     } else {
@@ -154,10 +163,13 @@ void concatenate2d(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate3d_0(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
-                     input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
-                     res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
-                               CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]) {
+void concatenate3d_0(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
+    res_T
+        res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
+            CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]
+) {
     for (int ii = 0; ii < CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2; ii++) {
         res[ii] = data1[ii];
     }
@@ -167,10 +179,13 @@ void concatenate3d_0(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 *
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate3d_1(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
-                     input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
-                     res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
-                               CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]) {
+void concatenate3d_1(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
+    res_T
+        res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
+            CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]
+) {
     for (int ii = 0; ii < CONFIG_T::n_elem1_0; ii++) {
         for (int jj = 0; jj < CONFIG_T::n_elem1_1; jj++) {
             for (int kk = 0; kk < CONFIG_T::n_elem1_2; kk++) {
@@ -192,10 +207,13 @@ void concatenate3d_1(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 *
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate3d_2(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
-                     input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
-                     res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
-                               CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]) {
+void concatenate3d_2(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
+    res_T
+        res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
+            CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]
+) {
     for (int ii = 0; ii < CONFIG_T::n_elem1_0; ii++) {
         for (int jj = 0; jj < CONFIG_T::n_elem1_1; jj++) {
             for (int kk = 0; kk < CONFIG_T::n_elem1_2; kk++) {
@@ -215,10 +233,13 @@ void concatenate3d_2(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 *
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate3d(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
-                   input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
-                   res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
-                             CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]) {
+void concatenate3d(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
+    res_T
+        res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
+            CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]
+) {
     if (CONFIG_T::axis == 3 || CONFIG_T::axis == -1) {
         concatenate3d_2<input1_T, input2_T, res_T, CONFIG_T>(data1, data2, res);
     } else if (CONFIG_T::axis == 2 || CONFIG_T::axis == -2) {
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_mult.h b/hls4ml/templates/catapult/nnet_utils/nnet_mult.h
old mode 100755
new mode 100644
index 7379eec48..48cfa4e87
--- a/hls4ml/templates/catapult/nnet_utils/nnet_mult.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_mult.h
@@ -86,8 +86,8 @@ template <class x_T, class w_T> class weight_exponential : public Product {
     // Construct the return type from the multiplication equivalent to the largest shifts
     // ap_int<pow2(decltype(w_T::weight)::width-1)-1> is the type if the multiplicand equivalent to the largest lshift <<
     // ap_fixed<pow2(decltype(w_T::weight)::width-1)-1,0> is the type of the multiplicand equivalent to the largest rshift >>
-    using r_T = decltype(x_T(0) * (ac_int<pow2(decltype(w_T::weight)::width - 1) - 1, true>(1) +
-                                   ac_fixed<pow2(decltype(w_T::weight)::width - 1) - 1, 0, true>(1)));
+    using r_T =
+        decltype(x_T(0) * (ac_int<pow2(decltype(w_T::weight)::width - 1) - 1, true>(1) + ac_fixed<pow2(decltype(w_T::weight)::width - 1) - 1, 0, true>(1)));
     static r_T product(x_T a, w_T w) {
         // Shift product for exponential weights
         //#pragma HLS INLINE
@@ -101,17 +101,17 @@ template <class x_T, class w_T> class weight_exponential : public Product {
 } // namespace product
 
 template <class data_T, class res_T, typename CONFIG_T>
-inline typename std::enable_if<std::is_same<data_T, ac_int<1, false>>::value &&
-                                   std::is_same<typename CONFIG_T::weight_t, ac_int<1, false>>::value,
-                               ac_int<nnet::ceillog2(CONFIG_T::n_in) + 2, true>>::type
+inline typename std::enable_if<
+    std::is_same<data_T, ac_int<1, false>>::value && std::is_same<typename CONFIG_T::weight_t, ac_int<1, false>>::value,
+    ac_int<nnet::ceillog2(CONFIG_T::n_in) + 2, true>>::type
 cast(typename CONFIG_T::accum_t x) {
     return (ac_int<nnet::ceillog2(CONFIG_T::n_in) + 2, true>)(x - CONFIG_T::n_in / 2) * 2;
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-inline typename std::enable_if<std::is_same<data_T, ac_int<1, false>>::value &&
-                                   !std::is_same<typename CONFIG_T::weight_t, ac_int<1, false>>::value,
-                               res_T>::type
+inline typename std::enable_if<
+    std::is_same<data_T, ac_int<1, false>>::value && !std::is_same<typename CONFIG_T::weight_t, ac_int<1, false>>::value,
+    res_T>::type
 cast(typename CONFIG_T::accum_t x) {
     return (res_T)x;
 }
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_padding.h b/hls4ml/templates/catapult/nnet_utils/nnet_padding.h
old mode 100755
new mode 100644
index 47986523f..4c8cf4b95
--- a/hls4ml/templates/catapult/nnet_utils/nnet_padding.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_padding.h
@@ -68,8 +68,10 @@ struct padding2d_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void zeropad2d_cf(data_T data[CONFIG_T::n_chan * CONFIG_T::in_height * CONFIG_T::in_width],
-                  data_T res[CONFIG_T::n_chan * CONFIG_T::out_height * CONFIG_T::out_width]) {
+void zeropad2d_cf(
+    data_T data[CONFIG_T::n_chan * CONFIG_T::in_height * CONFIG_T::in_width],
+    data_T res[CONFIG_T::n_chan * CONFIG_T::out_height * CONFIG_T::out_width]
+) {
     //#pragma HLS PIPELINE
 
     for (int k = 0; k < CONFIG_T::n_chan; k++) {
@@ -101,8 +103,10 @@ void zeropad2d_cf(data_T data[CONFIG_T::n_chan * CONFIG_T::in_height * CONFIG_T:
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void zeropad2d_cl(data_T data[CONFIG_T::n_chan * CONFIG_T::in_height * CONFIG_T::in_width],
-                  res_T res[CONFIG_T::n_chan * CONFIG_T::out_height * CONFIG_T::out_width]) {
+void zeropad2d_cl(
+    data_T data[CONFIG_T::n_chan * CONFIG_T::in_height * CONFIG_T::in_width],
+    res_T res[CONFIG_T::n_chan * CONFIG_T::out_height * CONFIG_T::out_width]
+) {
     //#pragma HLS PIPELINE
 
     for (int i = 0; i < CONFIG_T::pad_top; i++) {
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_pooling.h b/hls4ml/templates/catapult/nnet_utils/nnet_pooling.h
index d6ab38a96..6cc2d2975 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_pooling.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_pooling.h
@@ -200,8 +200,10 @@ template <typename CONFIG_T> constexpr int pool_op_limit() {
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pooling2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt],
-                  res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt]) {
+void pooling2d_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt],
+    res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt]
+) {
     constexpr int ce_reuse_factor = CONFIG_T::reuse_factor;
     (void)ce_reuse_factor;
     //#pragma HLS PIPELINE II=CONFIG_T::reuse_factor
@@ -236,9 +238,9 @@ void pooling2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_
                                 img_overlap++;
                             }
                         } else {
-                            pool[kk * CONFIG_T::stride_width + ll] =
-                                data[(ii + kk - CONFIG_T::pad_top) * CONFIG_T::in_width * CONFIG_T::n_filt +
-                                     (jj + ll - CONFIG_T::pad_left) * CONFIG_T::n_filt + ff];
+                            pool[kk * CONFIG_T::stride_width + ll] = data
+                                [(ii + kk - CONFIG_T::pad_top) * CONFIG_T::in_width * CONFIG_T::n_filt +
+                                 (jj + ll - CONFIG_T::pad_left) * CONFIG_T::n_filt + ff];
                             img_overlap++;
                         }
                     }
@@ -262,8 +264,10 @@ void pooling2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pooling2d_cf(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt],
-                  res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt]) {
+void pooling2d_cf(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt],
+    res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt]
+) {
     constexpr int ce_reuse_factor = CONFIG_T::reuse_factor;
     (void)ce_reuse_factor;
     //#pragma HLS PIPELINE II=CONFIG_T::reuse_factor
@@ -298,9 +302,9 @@ void pooling2d_cf(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_
                                 img_overlap++;
                             }
                         } else {
-                            pool[kk * CONFIG_T::stride_width + ll] =
-                                data[(ii + kk - CONFIG_T::pad_top) * CONFIG_T::in_width +
-                                     ff * CONFIG_T::in_width * CONFIG_T::in_height + ll + jj - CONFIG_T::pad_left];
+                            pool[kk * CONFIG_T::stride_width + ll] = data
+                                [(ii + kk - CONFIG_T::pad_top) * CONFIG_T::in_width +
+                                 ff * CONFIG_T::in_width * CONFIG_T::in_height + ll + jj - CONFIG_T::pad_left];
                             img_overlap++;
                         }
                     }
@@ -324,8 +328,9 @@ void pooling2d_cf(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void global_pooling2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt],
-                         res_T res[CONFIG_T::n_filt]) {
+void global_pooling2d_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt], res_T res[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
     assert(CONFIG_T::pad_top == 0 && CONFIG_T::pad_bottom == 0);
     assert(CONFIG_T::pool_width == CONFIG_T::stride_width);
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_pooling_stream.h b/hls4ml/templates/catapult/nnet_utils/nnet_pooling_stream.h
index 051a27a54..ac0857a94 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_pooling_stream.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_pooling_stream.h
@@ -34,9 +34,14 @@ template <unsigned TABLE_SIZE, unsigned POOL_SIZE> void init_pool_table(unsigned
 
 template <class data_T, class res_T, typename CONFIG_T>
 void compute_pool_encoded_2d(
-    const unsigned h_idx, const unsigned w_idx, const data_T &in_elem,
+    const unsigned h_idx,
+    const unsigned w_idx,
+    const data_T &in_elem,
     ac_channel<typename data_T::value_type> data_window[CONFIG_T::pool_height * CONFIG_T::pool_width * CONFIG_T::n_filt],
-    ac_channel<res_T> &res, res_T &res_pack, unsigned &outputs_ready) {
+    ac_channel<res_T> &res,
+    res_T &res_pack,
+    unsigned &outputs_ready
+) {
     // Nearest H without unused pixels on the right
     constexpr unsigned nH =
         ((CONFIG_T::in_height - CONFIG_T::pool_height) / CONFIG_T::stride_height) * CONFIG_T::stride_height +
@@ -90,7 +95,8 @@ void compute_pool_encoded_2d(
         for (unsigned c = 0; c < CONFIG_T::n_filt; c++) {
             if (filt_mask > 0)
                 data_window[c * CONFIG_T::pool_height * CONFIG_T::pool_width + filt_mask.to_uint() - 1].write(
-                    in_elem[p * CONFIG_T::n_filt + c]);
+                    in_elem[p * CONFIG_T::n_filt + c]
+                );
         }
 
         if (filt_mask == CONFIG_T::pool_height * CONFIG_T::pool_width) {
@@ -104,11 +110,13 @@ void compute_pool_encoded_2d(
                     1) { // Saves resources if we don't pack output, compiler will remove the else branch
                     res_pack[c] =
                         reduce_pool<typename CONFIG_T::accum_t, CONFIG_T::pool_height * CONFIG_T::pool_width, CONFIG_T>(
-                            pool_window);
+                            pool_window
+                        );
                 } else {
                     res_pack[outputs_ready * CONFIG_T::n_filt + c] =
                         reduce_pool<typename CONFIG_T::accum_t, CONFIG_T::pool_height * CONFIG_T::pool_width, CONFIG_T>(
-                            pool_window);
+                            pool_window
+                        );
                 }
             }
             if (res_T::size / CONFIG_T::n_filt ==
@@ -152,8 +160,9 @@ void pooling2d_encoded_cl(ac_channel<data_T> &data, ac_channel<res_T> &res) {
             if (res_T::size / CONFIG_T::n_filt == 1) {
                 //#pragma HLS PIPELINE II=pack_factor
             }
-            compute_pool_encoded_2d<data_T, res_T, CONFIG_T>(i_ih, i_iw, data.read(), data_window, res, res_pack,
-                                                             outputs_ready);
+            compute_pool_encoded_2d<data_T, res_T, CONFIG_T>(
+                i_ih, i_iw, data.read(), data_window, res, res_pack, outputs_ready
+            );
         }
     }
 }
@@ -162,10 +171,12 @@ void pooling2d_encoded_cl(ac_channel<data_T> &data, ac_channel<res_T> &res) {
 //       Line Buffer Implementation (Phil's)
 // *************************************************
 template <class data_T, class res_T, typename CONFIG_T>
-void compute_pool_buffer_2d(const data_T &in_elem,
-                            ap_shift_reg<typename data_T::value_type, CONFIG_T::in_width>
-                                line_buffer[MAX(CONFIG_T::pool_height - 1, 1)][CONFIG_T::n_filt],
-                            ac_channel<res_T> &res) {
+void compute_pool_buffer_2d(
+    const data_T &in_elem,
+    ap_shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[MAX(CONFIG_T::pool_height - 1, 1)]
+                                                                             [CONFIG_T::n_filt],
+    ac_channel<res_T> &res
+) {
     //#pragma HLS INLINE
     const static int lShiftX = CONFIG_T::pool_width - 1;
     const static int lShiftY = CONFIG_T::pool_height - 1;
@@ -200,8 +211,8 @@ void compute_pool_buffer_2d(const data_T &in_elem,
 
             // Compute Pooling
             res_pack[i_ic] =
-                reduce_pool<typename data_T::value_type, CONFIG_T::pool_height * CONFIG_T::pool_width, CONFIG_T>(
-                    pool_window);
+                reduce_pool<typename data_T::value_type, CONFIG_T::pool_height * CONFIG_T::pool_width, CONFIG_T>(pool_window
+                );
         }
 
         // Write to output
@@ -266,9 +277,14 @@ template <class data_T, class res_T, typename CONFIG_T> void pooling2d_cl(ac_cha
 // *************************************************
 
 template <class data_T, class res_T, typename CONFIG_T>
-void compute_pool_encoded_1d(const unsigned w_idx, const data_T &in_elem,
-                             ac_channel<typename data_T::value_type> data_window[CONFIG_T::pool_width * CONFIG_T::n_filt],
-                             ac_channel<res_T> &res, res_T &res_pack, unsigned &outputs_ready) {
+void compute_pool_encoded_1d(
+    const unsigned w_idx,
+    const data_T &in_elem,
+    ac_channel<typename data_T::value_type> data_window[CONFIG_T::pool_width * CONFIG_T::n_filt],
+    ac_channel<res_T> &res,
+    res_T &res_pack,
+    unsigned &outputs_ready
+) {
     // Nearest W without unused pixels on the right
     constexpr unsigned nW =
         ((CONFIG_T::n_in - CONFIG_T::pool_width) / CONFIG_T::stride_width) * CONFIG_T::stride_width + CONFIG_T::pool_width;
@@ -481,7 +497,8 @@ void compute_global_pool(const data_T &in_elem, typename CONFIG_T::accum_t data_
             data_pack[p] = in_elem[p * CONFIG_T::n_filt + c];
         }
         data_window[c] = reduce_global_pool<typename CONFIG_T::accum_t, data_T::size / CONFIG_T::n_filt, CONFIG_T>(
-            data_window[c], data_pack);
+            data_window[c], data_pack
+        );
     }
 }
 
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_recurrent.h b/hls4ml/templates/catapult/nnet_utils/nnet_recurrent.h
old mode 100755
new mode 100644
index f08d4d105..95039bc75
--- a/hls4ml/templates/catapult/nnet_utils/nnet_recurrent.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_recurrent.h
@@ -46,11 +46,16 @@ struct lstm_config {
 //  Originall had a version allows for the state in each layer to be saved, moved this to above (this requires are LARGE
 //  dense network at the end)
 template <class data_T, class res_T, typename CONFIG_T>
-void lstm(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG_T::n_state],
-          res_T s_newstate[CONFIG_T::n_state], typename CONFIG_T::weight_t param[CONFIG_T::n_state * 4 * CONFIG_T::n_in],
-          typename CONFIG_T::weight_t param_r[CONFIG_T::n_state * 4 * CONFIG_T::n_state],
-          typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 4],
-          typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 4]) {
+void lstm(
+    bool reset_state,
+    data_T data[CONFIG_T::n_in],
+    res_T h_newstate[CONFIG_T::n_state],
+    res_T s_newstate[CONFIG_T::n_state],
+    typename CONFIG_T::weight_t param[CONFIG_T::n_state * 4 * CONFIG_T::n_in],
+    typename CONFIG_T::weight_t param_r[CONFIG_T::n_state * 4 * CONFIG_T::n_state],
+    typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 4],
+    typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 4]
+) {
     // Initialize the state variable -- will maintain state between function calls
 
     typename CONFIG_T::accum_t tmpres[CONFIG_T::n_state * 4];
@@ -88,11 +93,13 @@ void lstm(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG
     }
 
     CONFIG_T::template activation_recr<data_T, typename CONFIG_T::weight_t, typename CONFIG_T::ACT_CONFIG_LSTM>::activation(
-        inputacc_ifo, tmpres_ifo);
+        inputacc_ifo, tmpres_ifo
+    );
 
     // Now for the confusion matrix
     CONFIG_T::template activation<data_T, typename CONFIG_T::weight_t, typename CONFIG_T::ACT_CONFIG_T>::activation(
-        inputacc_c, tmpres_c);
+        inputacc_c, tmpres_c
+    );
 
     // Operation: s=g*i+sold*f (update state with buffer to avoid timing issues)
     for (int iacc = 0; iacc < (CONFIG_T::n_state); iacc++) {
@@ -101,7 +108,8 @@ void lstm(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG
     }
     // Operation: h=act(s)*o
     CONFIG_T::template activation<data_T, typename CONFIG_T::weight_t, typename CONFIG_T::ACT_CONFIG_T>::activation(
-        s_newstate, s_actstate);
+        s_newstate, s_actstate
+    );
 
     for (int iacc = 0; iacc < CONFIG_T::n_state; iacc++) {
         //#pragma HLS UNROLL
@@ -110,12 +118,16 @@ void lstm(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void lstm_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG_T::n_state],
-                 res_T s_newstate[CONFIG_T::n_state],
-                 typename CONFIG_T::weight_t param[CONFIG_T::n_state * 4 * CONFIG_T::n_in],
-                 typename CONFIG_T::weight_t param_r[CONFIG_T::n_state * 4 * CONFIG_T::n_state],
-                 typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 4],
-                 typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 4]) {
+void lstm_static(
+    bool reset_state,
+    data_T data[CONFIG_T::n_in],
+    res_T h_newstate[CONFIG_T::n_state],
+    res_T s_newstate[CONFIG_T::n_state],
+    typename CONFIG_T::weight_t param[CONFIG_T::n_state * 4 * CONFIG_T::n_in],
+    typename CONFIG_T::weight_t param_r[CONFIG_T::n_state * 4 * CONFIG_T::n_state],
+    typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 4],
+    typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 4]
+) {
     static res_T h_state[CONFIG_T::n_state];
     static res_T s_state[CONFIG_T::n_state];
     // Initialize the state variable -- will maintain state between function calls
@@ -148,8 +160,9 @@ void lstm_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate
     }
 
     nnet::dense<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config1>(data, tmpres, param, param_b);
-    nnet::dense<res_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config2>(h_state, tmpres_state, param_r,
-                                                                                    param_br);
+    nnet::dense<res_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config2>(
+        h_state, tmpres_state, param_r, param_br
+    );
 
     for (int iacc = 0; iacc < (3 * CONFIG_T::n_state); iacc++) {
         //#pragma HLS UNROLL
@@ -165,11 +178,13 @@ void lstm_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate
     }
 
     CONFIG_T::template activation_recr<data_T, typename CONFIG_T::weight_t, typename CONFIG_T::ACT_CONFIG_LSTM>::activation(
-        inputacc_ifo, tmpres_ifo);
+        inputacc_ifo, tmpres_ifo
+    );
 
     // Now for the confusion matrix
     CONFIG_T::template activation<data_T, typename CONFIG_T::weight_t, typename CONFIG_T::ACT_CONFIG_T>::activation(
-        inputacc_c, tmpres_c);
+        inputacc_c, tmpres_c
+    );
 
     // Operation: s=g*i+sold*f (update state with buffer to avoid timing issues)
     for (int iacc = 0; iacc < (CONFIG_T::n_state); iacc++) {
@@ -179,7 +194,8 @@ void lstm_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate
     }
     // Operation: h=act(s)*o
     CONFIG_T::template activation<data_T, typename CONFIG_T::weight_t, typename CONFIG_T::ACT_CONFIG_T>::activation(
-        s_state, s_actstate);
+        s_state, s_actstate
+    );
 
     for (int iacc = 0; iacc < CONFIG_T::n_state; iacc++) {
         //#pragma HLS UNROLL
@@ -189,11 +205,14 @@ void lstm_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void lstm_stack(data_T data[CONFIG_T::n_sequence * CONFIG_T::n_in], res_T res[CONFIG_T::n_sequence_out * CONFIG_T::n_state],
-                typename CONFIG_T::weight_t param[CONFIG_T::n_state * 4 * CONFIG_T::n_in],
-                typename CONFIG_T::weight_t param_r[CONFIG_T::n_state * 4 * CONFIG_T::n_state],
-                typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 4],
-                typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 4]) {
+void lstm_stack(
+    data_T data[CONFIG_T::n_sequence * CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_sequence_out * CONFIG_T::n_state],
+    typename CONFIG_T::weight_t param[CONFIG_T::n_state * 4 * CONFIG_T::n_in],
+    typename CONFIG_T::weight_t param_r[CONFIG_T::n_state * 4 * CONFIG_T::n_state],
+    typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 4],
+    typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 4]
+) {
 
     res_T h_newstate[CONFIG_T::n_state];
     res_T s_newstate[CONFIG_T::n_state];
@@ -214,11 +233,13 @@ void lstm_stack(data_T data[CONFIG_T::n_sequence * CONFIG_T::n_in], res_T res[CO
             data_in[j] = data[j + iloop * CONFIG_T::n_in];
         }
         if (CONFIG_T::use_static)
-            nnet::lstm_static<data_T, res_T, CONFIG_T>(reset_state, data_in, h_newstate, s_newstate, param, param_r, param_b,
-                                                       param_br);
+            nnet::lstm_static<data_T, res_T, CONFIG_T>(
+                reset_state, data_in, h_newstate, s_newstate, param, param_r, param_b, param_br
+            );
         else
-            nnet::lstm<data_T, res_T, CONFIG_T>(reset_state, data_in, h_newstate, s_newstate, param, param_r, param_b,
-                                                param_br);
+            nnet::lstm<data_T, res_T, CONFIG_T>(
+                reset_state, data_in, h_newstate, s_newstate, param, param_r, param_b, param_br
+            );
         if (CONFIG_T::n_sequence_out > 1)
             for (int i = CONFIG_T::n_state * iloop, j = 0; i < (CONFIG_T::n_state * (iloop + 1)); i++, j++) {
                 //#pragma HLS UNROLL
@@ -234,11 +255,14 @@ void lstm_stack(data_T data[CONFIG_T::n_sequence * CONFIG_T::n_in], res_T res[CO
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void lstm_stack(ac_channel<data_T> &data_stream, ac_channel<res_T> &res_stream,
-                typename CONFIG_T::weight_t param[CONFIG_T::n_state * 4 * CONFIG_T::n_in],
-                typename CONFIG_T::weight_t param_r[CONFIG_T::n_state * 4 * CONFIG_T::n_state],
-                typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 4],
-                typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 4]) {
+void lstm_stack(
+    ac_channel<data_T> &data_stream,
+    ac_channel<res_T> &res_stream,
+    typename CONFIG_T::weight_t param[CONFIG_T::n_state * 4 * CONFIG_T::n_in],
+    typename CONFIG_T::weight_t param_r[CONFIG_T::n_state * 4 * CONFIG_T::n_state],
+    typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 4],
+    typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 4]
+) {
 
     typename res_T::value_type h_newstate[CONFIG_T::n_state];
     typename res_T::value_type s_newstate[CONFIG_T::n_state];
@@ -267,10 +291,12 @@ void lstm_stack(ac_channel<data_T> &data_stream, ac_channel<res_T> &res_stream,
         }
         if (CONFIG_T::use_static)
             nnet::lstm_static<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(
-                reset_state, data_in, h_newstate, s_newstate, param, param_r, param_b, param_br);
+                reset_state, data_in, h_newstate, s_newstate, param, param_r, param_b, param_br
+            );
         else
             nnet::lstm<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(
-                reset_state, data_in, h_newstate, s_newstate, param, param_r, param_b, param_br);
+                reset_state, data_in, h_newstate, s_newstate, param, param_r, param_b, param_br
+            );
         if (CONFIG_T::n_sequence_out > 1) {
             res_T res_pack;
         //#pragma HLS DATA_PACK variable=res_pack
@@ -324,12 +350,16 @@ struct gru_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void gru(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG_T::n_state],
-         typename CONFIG_T::weight_t param[CONFIG_T::n_state * 3 * CONFIG_T::n_in], // TODO - Check the layout of the param
-                                                                                    // weights - refer page in copy!!
-         typename CONFIG_T::weight_t param_zr[CONFIG_T::n_state * 3 * CONFIG_T::n_state],
-         typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 3],
-         typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 3]) {
+void gru(
+    bool reset_state,
+    data_T data[CONFIG_T::n_in],
+    res_T h_newstate[CONFIG_T::n_state],
+    typename CONFIG_T::weight_t param[CONFIG_T::n_state * 3 * CONFIG_T::n_in], // TODO - Check the layout of the param
+                                                                               // weights - refer page in copy!!
+    typename CONFIG_T::weight_t param_zr[CONFIG_T::n_state * 3 * CONFIG_T::n_state],
+    typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 3],
+    typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 3]
+) {
     // Initialize the state variable -- will maintain state between function calls
     typename CONFIG_T::accum_t tmpres[CONFIG_T::n_state * 3];
     typename CONFIG_T::accum_t tmpres_state_zr[CONFIG_T::n_state * 3];
@@ -349,8 +379,9 @@ void gru(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG_
     //#pragma HLS ARRAY_PARTITION variable=inputacc_h      complete
 
     nnet::dense<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config1>(data, tmpres, param, param_b);
-    nnet::dense<res_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config2>(h_newstate, tmpres_state_zr, param_zr,
-                                                                                    param_br);
+    nnet::dense<res_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config2>(
+        h_newstate, tmpres_state_zr, param_zr, param_br
+    );
 
     // Adding the individual vectors from the multiplication of tmpres = Wx*x(t); tmpres_state_zr = Wh*h(t-1); tmpres
     // initialized with biases -- DONE
@@ -361,8 +392,10 @@ void gru(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG_
     }
 
     // Activation function Sub layer -- START
-    CONFIG_T::template activation_recr<typename CONFIG_T::accum_t, typename CONFIG_T::weight_t,
-                                       typename CONFIG_T::ACT_CONFIG_GRU>::activation(inputacc_zr, tmpres_zr);
+    CONFIG_T::template activation_recr<
+        typename CONFIG_T::accum_t,
+        typename CONFIG_T::weight_t,
+        typename CONFIG_T::ACT_CONFIG_GRU>::activation(inputacc_zr, tmpres_zr);
 
     // Activation function Sub layer -- END
 
@@ -380,8 +413,8 @@ void gru(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG_
     }
 
     // Now run the activation on this guy
-    CONFIG_T::template activation<typename CONFIG_T::accum_t, typename CONFIG_T::weight_t,
-                                  typename CONFIG_T::ACT_CONFIG_T>::activation(inputacc_h, tmpres_h);
+    CONFIG_T::template activation<typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, typename CONFIG_T::ACT_CONFIG_T>::
+        activation(inputacc_h, tmpres_h);
 
     // Mix the stat with the previous state
     for (int iacc = 0; iacc < (CONFIG_T::n_state); iacc++) {
@@ -391,11 +424,15 @@ void gru(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG_
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void gru_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG_T::n_state],
-                typename CONFIG_T::weight_t param[CONFIG_T::n_state * 3 * CONFIG_T::n_in],
-                typename CONFIG_T::weight_t param_zr[CONFIG_T::n_state * 3 * CONFIG_T::n_state],
-                typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 3],
-                typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 3]) {
+void gru_static(
+    bool reset_state,
+    data_T data[CONFIG_T::n_in],
+    res_T h_newstate[CONFIG_T::n_state],
+    typename CONFIG_T::weight_t param[CONFIG_T::n_state * 3 * CONFIG_T::n_in],
+    typename CONFIG_T::weight_t param_zr[CONFIG_T::n_state * 3 * CONFIG_T::n_state],
+    typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 3],
+    typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 3]
+) {
     // Initialize the state variable -- will maintain state between function calls
 
     static res_T h_state[CONFIG_T::n_state];
@@ -425,8 +462,9 @@ void gru_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[
     }
 
     nnet::dense<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config1>(data, tmpres, param, param_b);
-    nnet::dense<res_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config2>(h_state, tmpres_state_zr, param_zr,
-                                                                                    param_br);
+    nnet::dense<res_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config2>(
+        h_state, tmpres_state_zr, param_zr, param_br
+    );
 
     // Adding the individual vectors from the multiplication of tmpres = Wx*x(t); tmpres_state_zr = Wh*h(t-1); tmpres
     // initialized with biases -- DONE
@@ -437,8 +475,10 @@ void gru_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[
     }
 
     // Activation function Sub layer -- START
-    CONFIG_T::template activation_recr<typename CONFIG_T::accum_t, typename CONFIG_T::weight_t,
-                                       typename CONFIG_T::ACT_CONFIG_GRU>::activation(inputacc_zr, tmpres_zr);
+    CONFIG_T::template activation_recr<
+        typename CONFIG_T::accum_t,
+        typename CONFIG_T::weight_t,
+        typename CONFIG_T::ACT_CONFIG_GRU>::activation(inputacc_zr, tmpres_zr);
 
     // Activation function Sub layer -- END
 
@@ -456,8 +496,8 @@ void gru_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[
     }
 
     // Now run the activation on this guy
-    CONFIG_T::template activation<typename CONFIG_T::accum_t, typename CONFIG_T::weight_t,
-                                  typename CONFIG_T::ACT_CONFIG_T>::activation(inputacc_h, tmpres_h);
+    CONFIG_T::template activation<typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, typename CONFIG_T::ACT_CONFIG_T>::
+        activation(inputacc_h, tmpres_h);
 
     // Mix the stat with the previous state
     for (int iacc = 0; iacc < (CONFIG_T::n_state); iacc++) {
@@ -468,11 +508,14 @@ void gru_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void gru_stack(data_T data[CONFIG_T::n_sequence * CONFIG_T::n_in], res_T res[CONFIG_T::n_sequence_out * CONFIG_T::n_state],
-               typename CONFIG_T::weight_t param[CONFIG_T::n_state * 3 * CONFIG_T::n_in],
-               typename CONFIG_T::weight_t param_zr[CONFIG_T::n_state * 3 * CONFIG_T::n_state],
-               typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 3],
-               typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 3]) {
+void gru_stack(
+    data_T data[CONFIG_T::n_sequence * CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_sequence_out * CONFIG_T::n_state],
+    typename CONFIG_T::weight_t param[CONFIG_T::n_state * 3 * CONFIG_T::n_in],
+    typename CONFIG_T::weight_t param_zr[CONFIG_T::n_state * 3 * CONFIG_T::n_state],
+    typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 3],
+    typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 3]
+) {
 
     res_T h_state[CONFIG_T::n_state];
     data_T data_in[CONFIG_T::n_in];
@@ -509,11 +552,14 @@ void gru_stack(data_T data[CONFIG_T::n_sequence * CONFIG_T::n_in], res_T res[CON
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void gru_stack(ac_channel<data_T> &data_stream, ac_channel<res_T> &res_stream,
-               typename CONFIG_T::weight_t param[CONFIG_T::n_state * 3 * CONFIG_T::n_in],
-               typename CONFIG_T::weight_t param_zr[CONFIG_T::n_state * 3 * CONFIG_T::n_state],
-               typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 3],
-               typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 3]) {
+void gru_stack(
+    ac_channel<data_T> &data_stream,
+    ac_channel<res_T> &res_stream,
+    typename CONFIG_T::weight_t param[CONFIG_T::n_state * 3 * CONFIG_T::n_in],
+    typename CONFIG_T::weight_t param_zr[CONFIG_T::n_state * 3 * CONFIG_T::n_state],
+    typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 3],
+    typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 3]
+) {
 
     typename res_T::value_type h_newstate[CONFIG_T::n_state];
     //#pragma HLS ARRAY_PARTITION variable=h_newstate complete
@@ -538,10 +584,12 @@ void gru_stack(ac_channel<data_T> &data_stream, ac_channel<res_T> &res_stream,
         }
         if (CONFIG_T::use_static)
             nnet::gru_static<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(
-                reset_state, data_in, h_newstate, param, param_zr, param_b, param_br);
+                reset_state, data_in, h_newstate, param, param_zr, param_b, param_br
+            );
         else
-            nnet::gru<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(reset_state, data_in, h_newstate,
-                                                                                         param, param_zr, param_b, param_br);
+            nnet::gru<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(
+                reset_state, data_in, h_newstate, param, param_zr, param_b, param_br
+            );
         if (CONFIG_T::n_sequence_out > 1) {
             res_T res_pack;
         //#pragma HLS DATA_PACK variable=res_pack
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_sepconv1d_stream.h b/hls4ml/templates/catapult/nnet_utils/nnet_sepconv1d_stream.h
index eb5ef9f7d..d19557243 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_sepconv1d_stream.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_sepconv1d_stream.h
@@ -9,9 +9,12 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void depthwise_conv_1d_encoded_cl(ac_channel<data_T> &data, ac_channel<res_T> &res,
-                                  typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan],
-                                  typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+void depthwise_conv_1d_encoded_cl(
+    ac_channel<data_T> &data,
+    ac_channel<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     assert(CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
 
     ac_channel<typename data_T::value_type> data_window[CONFIG_T::filt_width * CONFIG_T::n_chan];
@@ -39,15 +42,19 @@ void depthwise_conv_1d_encoded_cl(ac_channel<data_T> &data, ac_channel<res_T> &r
             //#pragma HLS PIPELINE II=CONFIG_T::reuse_factor
         }
         compute_scaled_indices_1d<data_T, CONFIG_T>(i_iw, pixel_idx);
-        compute_depthwise_output_encoded<data_T, res_T, CONFIG_T>(data.read(), data_window, res, res_pack, outputs_ready,
-                                                                  weights, biases, pixel_idx);
+        compute_depthwise_output_encoded<data_T, res_T, CONFIG_T>(
+            data.read(), data_window, res, res_pack, outputs_ready, weights, biases, pixel_idx
+        );
     }
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void depthwise_conv_1d_buffer_cl(ac_channel<data_T> &data, ac_channel<res_T> &res,
-                                 typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan],
-                                 typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+void depthwise_conv_1d_buffer_cl(
+    ac_channel<data_T> &data,
+    ac_channel<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     assert(CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
 
     constexpr int ce_reuse_factor = CONFIG_T::reuse_factor * (CONFIG_T::strategy == nnet::latency);
@@ -63,9 +70,12 @@ void depthwise_conv_1d_buffer_cl(ac_channel<data_T> &data, ac_channel<res_T> &re
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void depthwise_conv_1d_cl(ac_channel<data_T> &data, ac_channel<res_T> &res,
-                          typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan],
-                          typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+void depthwise_conv_1d_cl(
+    ac_channel<data_T> &data,
+    ac_channel<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     #pragma HLS inline recursive
     switch (CONFIG_T::implementation) {
     case conv_implementation::linebuffer:
@@ -78,9 +88,12 @@ void depthwise_conv_1d_cl(ac_channel<data_T> &data, ac_channel<res_T> &res,
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_1d_cl(ac_channel<data_T> &data, ac_channel<res_T> &res,
-                          typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                          typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_1d_cl(
+    ac_channel<data_T> &data,
+    ac_channel<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
     assert(CONFIG_T::filt_width == 1);
 
@@ -104,23 +117,28 @@ void pointwise_conv_1d_cl(ac_channel<data_T> &data, ac_channel<res_T> &res,
 }
 
 template <class data_T, class dw_res_T, class res_T, typename CONFIG_T>
-void separable_conv_1d_cl(ac_channel<data_T> &data, ac_channel<res_T> &res,
-                          typename CONFIG_T::depthwise_config::weight_t
-                              depthwise_weights[CONFIG_T::depthwise_config::filt_width * CONFIG_T::depthwise_config::n_chan],
-                          typename CONFIG_T::pointwise_config::weight_t
-                              pointwise_weights[CONFIG_T::pointwise_config::n_chan * CONFIG_T::pointwise_config::n_filt],
-                          typename CONFIG_T::depthwise_config::bias_t depthwise_biases[CONFIG_T::depthwise_config::n_chan],
-                          typename CONFIG_T::pointwise_config::bias_t pointwise_biases[CONFIG_T::pointwise_config::n_filt]) {
+void separable_conv_1d_cl(
+    ac_channel<data_T> &data,
+    ac_channel<res_T> &res,
+    typename CONFIG_T::depthwise_config::weight_t
+        depthwise_weights[CONFIG_T::depthwise_config::filt_width * CONFIG_T::depthwise_config::n_chan],
+    typename CONFIG_T::pointwise_config::weight_t
+        pointwise_weights[CONFIG_T::pointwise_config::n_chan * CONFIG_T::pointwise_config::n_filt],
+    typename CONFIG_T::depthwise_config::bias_t depthwise_biases[CONFIG_T::depthwise_config::n_chan],
+    typename CONFIG_T::pointwise_config::bias_t pointwise_biases[CONFIG_T::pointwise_config::n_filt]
+) {
     //#pragma HLS DATAFLOW
 
     ac_channel<dw_res_T> depthwise_res;
     unsigned res_depth = CONFIG_T::depthwise_config::out_width;
     //#pragma HLS STREAM variable=depthwise_res depth=res_depth
 
-    depthwise_conv_1d_cl<data_T, dw_res_T, typename CONFIG_T::depthwise_config>(data, depthwise_res, depthwise_weights,
-                                                                                depthwise_biases);
-    pointwise_conv_1d_cl<dw_res_T, res_T, typename CONFIG_T::pointwise_config>(depthwise_res, res, pointwise_weights,
-                                                                               pointwise_biases);
+    depthwise_conv_1d_cl<data_T, dw_res_T, typename CONFIG_T::depthwise_config>(
+        data, depthwise_res, depthwise_weights, depthwise_biases
+    );
+    pointwise_conv_1d_cl<dw_res_T, res_T, typename CONFIG_T::pointwise_config>(
+        depthwise_res, res, pointwise_weights, pointwise_biases
+    );
 }
 
 } // namespace nnet
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_sepconv2d.h b/hls4ml/templates/catapult/nnet_utils/nnet_sepconv2d.h
index d98dd8c31..67d89f76a 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_sepconv2d.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_sepconv2d.h
@@ -11,7 +11,8 @@ void depthwise_conv_2d_cl(
     data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
     res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_chan],
     typename CONFIG_T::weight_t depthwise_weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan],
-    typename CONFIG_T::bias_t depthwise_biases[CONFIG_T::n_chan]) {
+    typename CONFIG_T::bias_t depthwise_biases[CONFIG_T::n_chan]
+) {
     const int in_height = CONFIG_T::in_height;
     const int in_width = CONFIG_T::in_width;
     const int n_chan = CONFIG_T::n_chan;
@@ -55,26 +56,32 @@ void depthwise_conv_2d_cl(
 }
 
 template <class data_T, class dw_res_T, class res_T, typename CONFIG_T>
-void separable_conv_2d_cl(data_T data[CONFIG_T::depthwise_config::in_height * CONFIG_T::depthwise_config::in_width *
-                                      CONFIG_T::depthwise_config::n_chan],
-                          res_T res[CONFIG_T::pointwise_config::out_height * CONFIG_T::pointwise_config::out_width *
-                                    CONFIG_T::pointwise_config::n_filt],
-                          typename CONFIG_T::depthwise_config::weight_t
-                              depthwise_weights[CONFIG_T::depthwise_config::filt_height *
-                                                CONFIG_T::depthwise_config::filt_width * CONFIG_T::depthwise_config::n_chan],
-                          typename CONFIG_T::pointwise_config::weight_t
-                              pointwise_weights[CONFIG_T::pointwise_config::n_chan * CONFIG_T::pointwise_config::n_filt],
-                          typename CONFIG_T::depthwise_config::bias_t depthwise_biases[CONFIG_T::depthwise_config::n_chan],
-                          typename CONFIG_T::pointwise_config::bias_t pointwise_biases[CONFIG_T::pointwise_config::n_filt]) {
+void separable_conv_2d_cl(
+    data_T data
+        [CONFIG_T::depthwise_config::in_height * CONFIG_T::depthwise_config::in_width * CONFIG_T::depthwise_config::n_chan],
+    res_T
+        res[CONFIG_T::pointwise_config::out_height * CONFIG_T::pointwise_config::out_width *
+            CONFIG_T::pointwise_config::n_filt],
+    typename CONFIG_T::depthwise_config::weight_t depthwise_weights
+        [CONFIG_T::depthwise_config::filt_height * CONFIG_T::depthwise_config::filt_width *
+         CONFIG_T::depthwise_config::n_chan],
+    typename CONFIG_T::pointwise_config::weight_t
+        pointwise_weights[CONFIG_T::pointwise_config::n_chan * CONFIG_T::pointwise_config::n_filt],
+    typename CONFIG_T::depthwise_config::bias_t depthwise_biases[CONFIG_T::depthwise_config::n_chan],
+    typename CONFIG_T::pointwise_config::bias_t pointwise_biases[CONFIG_T::pointwise_config::n_filt]
+) {
 
     //#pragma HLS INLINE region
 
-    dw_res_T depthwise_results[CONFIG_T::depthwise_config::out_height * CONFIG_T::depthwise_config::out_width *
-                               CONFIG_T::depthwise_config::n_chan];
-    depthwise_conv_2d_cl<data_T, dw_res_T, typename CONFIG_T::depthwise_config>(data, depthwise_results, depthwise_weights,
-                                                                                depthwise_biases);
-    pointwise_conv_2d_cl<dw_res_T, res_T, typename CONFIG_T::pointwise_config>(depthwise_results, res, pointwise_weights,
-                                                                               pointwise_biases);
+    dw_res_T depthwise_results
+        [CONFIG_T::depthwise_config::out_height * CONFIG_T::depthwise_config::out_width *
+         CONFIG_T::depthwise_config::n_chan];
+    depthwise_conv_2d_cl<data_T, dw_res_T, typename CONFIG_T::depthwise_config>(
+        data, depthwise_results, depthwise_weights, depthwise_biases
+    );
+    pointwise_conv_2d_cl<dw_res_T, res_T, typename CONFIG_T::pointwise_config>(
+        depthwise_results, res, pointwise_weights, pointwise_biases
+    );
 }
 
 } // namespace nnet
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_sepconv2d_stream.h b/hls4ml/templates/catapult/nnet_utils/nnet_sepconv2d_stream.h
index a4f7d4faa..a74533c28 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_sepconv2d_stream.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_sepconv2d_stream.h
@@ -11,9 +11,11 @@ namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
 void depthwise_conv_2d_encoded_cl(
-    ac_channel<data_T> &data, ac_channel<res_T> &res,
+    ac_channel<data_T> &data,
+    ac_channel<res_T> &res,
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     assert(CONFIG_T::pad_top == 0 && CONFIG_T::pad_bottom == 0 && CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
     assert(CONFIG_T::filt_height == CONFIG_T::filt_width);
 
@@ -45,8 +47,9 @@ void depthwise_conv_2d_encoded_cl(
             //     #pragma HLS PIPELINE II=CONFIG_T::reuse_factor
             // }
             compute_scaled_indices_2d<data_T, CONFIG_T>(i_ih, i_iw, pixel_idx);
-            compute_depthwise_output_encoded<data_T, res_T, CONFIG_T>(data.read(), data_window, res, res_pack, outputs_ready,
-                                                                      weights, biases, pixel_idx);
+            compute_depthwise_output_encoded<data_T, res_T, CONFIG_T>(
+                data.read(), data_window, res, res_pack, outputs_ready, weights, biases, pixel_idx
+            );
         }
     }
 }
@@ -54,9 +57,11 @@ void depthwise_conv_2d_encoded_cl(
 // Line Buffer Implementation (Phil's)
 template <class data_T, class res_T, typename CONFIG_T>
 void depthwise_conv_2d_buffer_cl(
-    ac_channel<data_T> &data, ac_channel<res_T> &res,
+    ac_channel<data_T> &data,
+    ac_channel<res_T> &res,
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     assert(CONFIG_T::pad_top == 0 && CONFIG_T::pad_bottom == 0 && CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
 
     static ap_shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[CONFIG_T::filt_height - 1]
@@ -84,9 +89,11 @@ void depthwise_conv_2d_buffer_cl(
 
 template <class data_T, class res_T, typename CONFIG_T>
 void depthwise_conv_2d_cl(
-    ac_channel<data_T> &data, ac_channel<res_T> &res,
+    ac_channel<data_T> &data,
+    ac_channel<res_T> &res,
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     // #pragma HLS inline recursive
     switch (CONFIG_T::implementation) {
     case conv_implementation::linebuffer:
@@ -99,9 +106,12 @@ void depthwise_conv_2d_cl(
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_2d_cl(ac_channel<data_T> &data, ac_channel<res_T> &res,
-                          typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                          typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_2d_cl(
+    ac_channel<data_T> &data,
+    ac_channel<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_top == 0 && CONFIG_T::pad_bottom == 0 && CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
     assert(CONFIG_T::filt_height == 1 && CONFIG_T::filt_width == 1);
 
@@ -128,24 +138,29 @@ void pointwise_conv_2d_cl(ac_channel<data_T> &data, ac_channel<res_T> &res,
 }
 
 template <class data_T, class dw_res_T, class res_T, typename CONFIG_T>
-void separable_conv_2d_cl(ac_channel<data_T> &data, ac_channel<res_T> &res,
-                          typename CONFIG_T::depthwise_config::weight_t
-                              depthwise_weights[CONFIG_T::depthwise_config::filt_height *
-                                                CONFIG_T::depthwise_config::filt_width * CONFIG_T::depthwise_config::n_chan],
-                          typename CONFIG_T::pointwise_config::weight_t
-                              pointwise_weights[CONFIG_T::pointwise_config::n_chan * CONFIG_T::pointwise_config::n_filt],
-                          typename CONFIG_T::depthwise_config::bias_t depthwise_biases[CONFIG_T::depthwise_config::n_chan],
-                          typename CONFIG_T::pointwise_config::bias_t pointwise_biases[CONFIG_T::pointwise_config::n_filt]) {
+void separable_conv_2d_cl(
+    ac_channel<data_T> &data,
+    ac_channel<res_T> &res,
+    typename CONFIG_T::depthwise_config::weight_t depthwise_weights
+        [CONFIG_T::depthwise_config::filt_height * CONFIG_T::depthwise_config::filt_width *
+         CONFIG_T::depthwise_config::n_chan],
+    typename CONFIG_T::pointwise_config::weight_t
+        pointwise_weights[CONFIG_T::pointwise_config::n_chan * CONFIG_T::pointwise_config::n_filt],
+    typename CONFIG_T::depthwise_config::bias_t depthwise_biases[CONFIG_T::depthwise_config::n_chan],
+    typename CONFIG_T::pointwise_config::bias_t pointwise_biases[CONFIG_T::pointwise_config::n_filt]
+) {
     // #pragma HLS DATAFLOW
 
     static ac_channel<dw_res_T> depthwise_res;
     unsigned res_depth = CONFIG_T::depthwise_config::out_height * CONFIG_T::depthwise_config::out_width;
     // #pragma HLS STREAM variable=depthwise_res depth=res_depth
 
-    depthwise_conv_2d_cl<data_T, dw_res_T, typename CONFIG_T::depthwise_config>(data, depthwise_res, depthwise_weights,
-                                                                                depthwise_biases);
-    pointwise_conv_2d_cl<dw_res_T, res_T, typename CONFIG_T::pointwise_config>(depthwise_res, res, pointwise_weights,
-                                                                               pointwise_biases);
+    depthwise_conv_2d_cl<data_T, dw_res_T, typename CONFIG_T::depthwise_config>(
+        data, depthwise_res, depthwise_weights, depthwise_biases
+    );
+    pointwise_conv_2d_cl<dw_res_T, res_T, typename CONFIG_T::pointwise_config>(
+        depthwise_res, res, pointwise_weights, pointwise_biases
+    );
 }
 
 } // namespace nnet
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_sepconv_stream.h b/hls4ml/templates/catapult/nnet_utils/nnet_sepconv_stream.h
index 753d260a7..ecd9aaf51 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_sepconv_stream.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_sepconv_stream.h
@@ -9,9 +9,12 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void depthwise_product(data_T data[CONFIG_T::kernel_size * CONFIG_T::n_chan], res_T res[CONFIG_T::n_chan],
-                       typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan],
-                       typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+void depthwise_product(
+    data_T data[CONFIG_T::kernel_size * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::n_chan],
+    typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     // #pragma HLS INLINE
 
     typename CONFIG_T::accum_t mult[CONFIG_T::kernel_size * CONFIG_T::n_chan];
@@ -36,7 +39,8 @@ void depthwise_product(data_T data[CONFIG_T::kernel_size * CONFIG_T::n_chan], re
         for (int ii = 0; ii < CONFIG_T::kernel_size * CONFIG_T::n_chan; ii++) {
             // #pragma HLS UNROLL
             mult[ii] = CONFIG_T::mult_config::template product<data_T, typename CONFIG_T::mult_config::weight_t>::product(
-                data[ii], weights[ii]);
+                data[ii], weights[ii]
+            );
         }
 
     // Initialize accumulator with input biases
@@ -66,10 +70,14 @@ void depthwise_product(data_T data[CONFIG_T::kernel_size * CONFIG_T::n_chan], re
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void depthwise_mult_buffer(ac_channel<typename data_T::value_type> data_window[CONFIG_T::kernel_size * CONFIG_T::n_chan],
-                           res_T &res_pack, ac_channel<res_T> &res_stream, unsigned &outputs_ready,
-                           typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan],
-                           typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+void depthwise_mult_buffer(
+    ac_channel<typename data_T::value_type> data_window[CONFIG_T::kernel_size * CONFIG_T::n_chan],
+    res_T &res_pack,
+    ac_channel<res_T> &res_stream,
+    unsigned &outputs_ready,
+    typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     //#pragma HLS INLINE
 
     typename data_T::value_type data[CONFIG_T::kernel_size * CONFIG_T::n_chan];
@@ -114,10 +122,15 @@ void depthwise_mult_buffer(ac_channel<typename data_T::value_type> data_window[C
 
 template <class data_T, class res_T, typename CONFIG_T>
 void compute_depthwise_output_encoded(
-    const data_T &in_elem, ac_channel<typename data_T::value_type> data_window[CONFIG_T::kernel_size * CONFIG_T::n_chan],
-    ac_channel<res_T> &res, res_T &res_pack, unsigned &outputs_ready,
+    const data_T &in_elem,
+    ac_channel<typename data_T::value_type> data_window[CONFIG_T::kernel_size * CONFIG_T::n_chan],
+    ac_channel<res_T> &res,
+    res_T &res_pack,
+    unsigned &outputs_ready,
     typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan], ac_int<CONFIG_T::kernel_size, false> *pixel_idx) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan],
+    ac_int<CONFIG_T::kernel_size, false> *pixel_idx
+) {
     //#pragma HLS INLINE
 
     constexpr int ce_reuse_factor = CONFIG_T::reuse_factor;
@@ -142,9 +155,12 @@ void compute_depthwise_output_encoded(
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_mult_buffer(const data_T &data_pack, ac_channel<res_T> &res_stream,
-                           typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                           typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_mult_buffer(
+    const data_T &data_pack,
+    ac_channel<res_T> &res_stream,
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     //#pragma HLS INLINE
 
     typename data_T::value_type data[CONFIG_T::n_chan];
@@ -165,10 +181,12 @@ void pointwise_mult_buffer(const data_T &data_pack, ac_channel<res_T> &res_strea
     //#pragma HLS INLINE recursive
     if (CONFIG_T::strategy == nnet::latency) {
         dense_latency<typename data_T::value_type, typename res_T::value_type, typename CONFIG_T::mult_config>(
-            data, res, weights, biases);
+            data, res, weights, biases
+        );
     } else {
         dense_resource<typename data_T::value_type, typename res_T::value_type, typename CONFIG_T::mult_config>(
-            data, res, weights, biases);
+            data, res, weights, biases
+        );
     }
 
 CastLoop:
@@ -182,9 +200,12 @@ void pointwise_mult_buffer(const data_T &data_pack, ac_channel<res_T> &res_strea
 
 // Line Buffer Implementation (Phil's)
 template <class data_T, class res_T, typename CONFIG_T>
-void compute_depthwise_output_buffer_1d(const data_T &in_elem, ac_channel<res_T> &res_stream,
-                                        typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan],
-                                        typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+void compute_depthwise_output_buffer_1d(
+    const data_T &in_elem,
+    ac_channel<res_T> &res_stream,
+    typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     //#pragma HLS INLINE
 
     // Thresholds
@@ -211,8 +232,9 @@ void compute_depthwise_output_buffer_1d(const data_T &in_elem, ac_channel<res_T>
         // Dense multiply
         //#pragma HLS INLINE recursive
         if (CONFIG_T::strategy == nnet::latency) {
-            depthwise_product<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(kernel_data, res_out,
-                                                                                                 weights, biases);
+            depthwise_product<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(
+                kernel_data, res_out, weights, biases
+            );
         } else {
             assert("Resource strategy for DepthwiseConv1D is not supported." && false);
         }
@@ -240,12 +262,14 @@ void compute_depthwise_output_buffer_1d(const data_T &in_elem, ac_channel<res_T>
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void compute_depthwise_output_buffer_2d(const data_T &in_elem,
-                                        ap_shift_reg<typename data_T::value_type, CONFIG_T::in_width>
-                                            line_buffer[MAX(CONFIG_T::filt_height - 1, 1)][CONFIG_T::n_chan],
-                                        ac_channel<res_T> &res_stream,
-                                        typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan],
-                                        typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+void compute_depthwise_output_buffer_2d(
+    const data_T &in_elem,
+    ap_shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[MAX(CONFIG_T::filt_height - 1, 1)]
+                                                                             [CONFIG_T::n_chan],
+    ac_channel<res_T> &res_stream,
+    typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     //#pragma HLS INLINE
 
     // Thresholds
@@ -276,8 +300,9 @@ void compute_depthwise_output_buffer_2d(const data_T &in_elem,
         // Dense multiply
         //#pragma HLS INLINE recursive
         if (CONFIG_T::strategy == nnet::latency) {
-            depthwise_product<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(kernel_data, res_out,
-                                                                                                 weights, biases);
+            depthwise_product<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(
+                kernel_data, res_out, weights, biases
+            );
         } else {
             assert("Resource strategy for DepthwiseConv2D is not supported." && false);
         }
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_stream.h b/hls4ml/templates/catapult/nnet_utils/nnet_stream.h
index c76bfba5a..c1217f609 100644
--- a/hls4ml/templates/catapult/nnet_utils/nnet_stream.h
+++ b/hls4ml/templates/catapult/nnet_utils/nnet_stream.h
@@ -126,8 +126,9 @@ void broadcast_stream_1x1xC(ac_channel<data_T> &data, ac_channel<res_T> &res) {
 
 template <class data_T, class res_T, typename CONFIG_T>
 void broadcast_stream_HxWx1(ac_channel<data_T> &data, ac_channel<res_T> &res) {
-    assert(CONFIG_T::in_chan == 1 && CONFIG_T::in_height == CONFIG_T::out_height &&
-           CONFIG_T::in_width == CONFIG_T::out_width);
+    assert(
+        CONFIG_T::in_chan == 1 && CONFIG_T::in_height == CONFIG_T::out_height && CONFIG_T::in_width == CONFIG_T::out_width
+    );
 BroadcastLoop:
     for (int i = 0; i < CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::in_chan / data_T::size; i++) {
         //#pragma HLS PIPELINE
@@ -146,8 +147,7 @@ template <class data_T, class res_T, typename CONFIG_T>
 void broadcast_stream(ac_channel<data_T> &data, ac_channel<res_T> &res) {
     if (CONFIG_T::in_height == 1 && CONFIG_T::in_width == 1 && CONFIG_T::in_chan == CONFIG_T::out_chan) {
         broadcast_stream_1x1xC<data_T, res_T, CONFIG_T>(data, res);
-    } else if (CONFIG_T::in_chan == 1 && CONFIG_T::in_height == CONFIG_T::out_height &&
-               CONFIG_T::in_width == CONFIG_T::out_width) {
+    } else if (CONFIG_T::in_chan == 1 && CONFIG_T::in_height == CONFIG_T::out_height && CONFIG_T::in_width == CONFIG_T::out_width) {
         broadcast_stream_HxWx1<data_T, res_T, CONFIG_T>(data, res);
     }
 }
diff --git a/hls4ml/templates/oneapi/firmware/myproject.h b/hls4ml/templates/oneapi/firmware/myproject.h
index 082ae5dc8..d6d462410 100644
--- a/hls4ml/templates/oneapi/firmware/myproject.h
+++ b/hls4ml/templates/oneapi/firmware/myproject.h
@@ -19,8 +19,8 @@ struct MyProject {
 
     // kernel property method to config invocation interface
     auto get(sycl::ext::oneapi::experimental::properties_tag) {
-        return sycl::ext::oneapi::experimental::properties{sycl::ext::intel::experimental::streaming_interface<>,
-                                                           sycl::ext::intel::experimental::pipelined<>};
+        return sycl::ext::oneapi::experimental::properties{
+            sycl::ext::intel::experimental::streaming_interface<>, sycl::ext::intel::experimental::pipelined<>};
     }
 
     SYCL_EXTERNAL void operator()() const;
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_activation_stream.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_activation_stream.h
index 13de5ab3b..f77f05a36 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_activation_stream.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_activation_stream.h
@@ -11,8 +11,8 @@ namespace nnet {
 // *************************************************
 template <class data_pipe, class res_pipe, typename CONFIG_T> void linear_stream() {
 LinearActLoop:
-    [[intel::initiation_interval(
-        1)]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
+    [[intel::initiation_interval(1
+    )]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
         auto in_data = data_pipe::read();
         typename ExtractPipeType<res_pipe>::value_type out_data;
 
@@ -31,8 +31,8 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void linear_stream
 // *************************************************
 template <class data_pipe, class res_pipe, typename CONFIG_T> void relu_stream() {
 ReLUActLoop:
-    [[intel::initiation_interval(
-        1)]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
+    [[intel::initiation_interval(1
+    )]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
         auto in_data = data_pipe::read();
         typename ExtractPipeType<res_pipe>::value_type out_data;
 
@@ -58,10 +58,8 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void leaky_relu_st
     constexpr unsigned pipeline = std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{} / multiplier_limit;
 
 LeakyReLUActLoop:
-    [[intel::initiation_interval(pipeline)]] for (int i = 0;
-                                                  i < CONFIG_T::n_in /
-                                                          std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{};
-                                                  i++) {
+    [[intel::initiation_interval(pipeline
+    )]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
         auto in_data = data_pipe::read();
         typename ExtractPipeType<res_pipe>::value_type out_data;
 
@@ -84,8 +82,8 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void leaky_relu_st
 template <class data_pipe, class res_pipe, typename CONFIG_T>
 void thresholded_relu_stream(typename CONFIG_T::param_t theta) {
 ThresholdedReLUActLoop:
-    [[intel::initiation_interval(
-        1)]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
+    [[intel::initiation_interval(1
+    )]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
         auto in_data = data_pipe::read();
         typename ExtractPipeType<res_pipe>::value_type out_data;
 
@@ -113,10 +111,8 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void elu_stream(ty
     constexpr unsigned pipeline = std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{} / multiplier_limit;
 
 EluActLoop:
-    [[intel::initiation_interval(pipeline)]] for (int i = 0;
-                                                  i < CONFIG_T::n_in /
-                                                          std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{};
-                                                  i++) {
+    [[intel::initiation_interval(pipeline
+    )]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
         auto in_data = data_pipe::read();
         typename ExtractPipeType<res_pipe>::value_type out_data;
 
@@ -145,8 +141,8 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void selu_stream()
 #include "activation_tables/selu_table.tb"
 
 SeluActLoop:
-    [[intel::initiation_interval(
-        1)]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
+    [[intel::initiation_interval(1
+    )]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
         auto in_data = data_pipe::read();
         typename ExtractPipeType<res_pipe>::value_type out_data;
 
@@ -178,10 +174,8 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void prelu_stream(
     constexpr unsigned pipeline = std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{} / multiplier_limit;
 
 PReLUActLoop:
-    [[intel::initiation_interval(pipeline)]] for (int i = 0;
-                                                  i < CONFIG_T::n_in /
-                                                          std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{};
-                                                  i++) {
+    [[intel::initiation_interval(pipeline
+    )]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
         auto in_data = data_pipe::read();
         typename ExtractPipeType<res_pipe>::value_type out_data;
 
@@ -205,8 +199,8 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void softplus_stre
 #include "activation_tables/softplus_table.tb"
 
 SoftplusActLoop:
-    [[intel::initiation_interval(
-        1)]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
+    [[intel::initiation_interval(1
+    )]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
         auto in_data = data_pipe::read();
         typename ExtractPipeType<res_pipe>::value_type out_data;
 
@@ -235,8 +229,8 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void softsign_stre
     static const int MAX_VALUE = 8;
 
 SoftsignActLoop:
-    [[intel::initiation_interval(
-        1)]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
+    [[intel::initiation_interval(1
+    )]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
         auto in_data = data_pipe::read();
         typename ExtractPipeType<res_pipe>::value_type out_data;
 
@@ -281,10 +275,8 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void softmax_stabl
         data_array[std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{}];
 
 SoftmaxArrayLoop:
-    [[intel::initiation_interval(pipeline)]] for (unsigned i = 0;
-                                                  i < CONFIG_T::n_in /
-                                                          std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{};
-                                                  i++) {
+    [[intel::initiation_interval(pipeline
+    )]] for (unsigned i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{}; i++) {
         auto in_pack = data_pipe::read();
 
     SoftmaxArrayPackLoop:
@@ -295,14 +287,18 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void softmax_stabl
 
         // Find the max and compute all delta(x_i, x_max)
         Op_max<typename ExtractPipeType<data_pipe>::value_type::value_type> op_max;
-        [[intel::fpga_register]] typename ExtractPipeType<data_pipe>::value_type::value_type x_max =
-            reduce<typename ExtractPipeType<data_pipe>::value_type::value_type,
-                   std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{},
-                   Op_max<typename ExtractPipeType<data_pipe>::value_type::value_type>>(data_array, op_max);
+        [[intel::fpga_register]] typename ExtractPipeType<data_pipe>::value_type::value_type x_max = reduce<
+            typename ExtractPipeType<data_pipe>::value_type::value_type,
+            std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{},
+            Op_max<typename ExtractPipeType<data_pipe>::value_type::value_type>>(data_array, op_max);
 
         // For the diffs, use the same type as the input but force rounding and saturation
-        [[intel::fpga_register]] ac_fixed<ExtractPipeType<data_pipe>::value_type::value_type::width,
-                                          ExtractPipeType<data_pipe>::value_type::value_type::i_width, true, AC_RND, AC_SAT>
+        [[intel::fpga_register]] ac_fixed<
+            ExtractPipeType<data_pipe>::value_type::value_type::width,
+            ExtractPipeType<data_pipe>::value_type::value_type::i_width,
+            true,
+            AC_RND,
+            AC_SAT>
             d_xi_xmax[std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{}];
         #pragma unroll
         for (unsigned j = 0; j < std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{}; j++) {
@@ -314,17 +310,18 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void softmax_stabl
         typename CONFIG_T::exp_table_t exp_res[std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{}];
         #pragma unroll
         for (unsigned j = 0; j < std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{}; j++) {
-            exp_res[j] =
-                exp_table[softmax_stable_idx_from_real_val<typename ExtractPipeType<data_pipe>::value_type::value_type,
-                                                           CONFIG_T>(d_xi_xmax[j])];
+            exp_res[j] = exp_table[softmax_stable_idx_from_real_val<
+                typename ExtractPipeType<data_pipe>::value_type::value_type,
+                CONFIG_T>(d_xi_xmax[j])];
         }
 
         // Explicitly sum the results with an adder tree.
         // Rounding & Saturation mode, which improve accuracy, prevent Vivado from expression balancing
         Op_add<typename CONFIG_T::exp_table_t> op_add;
-        [[intel::fpga_register]] typename CONFIG_T::exp_table_t exp_sum =
-            reduce<typename CONFIG_T::exp_table_t, std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{},
-                   Op_add<typename CONFIG_T::exp_table_t>>(exp_res, op_add);
+        [[intel::fpga_register]] typename CONFIG_T::exp_table_t exp_sum = reduce<
+            typename CONFIG_T::exp_table_t,
+            std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{},
+            Op_add<typename CONFIG_T::exp_table_t>>(exp_res, op_add);
 
         [[intel::fpga_register]] typename CONFIG_T::inv_table_t inv_exp_sum =
             invert_table[softmax_stable_idx_from_real_val<typename CONFIG_T::exp_table_t, CONFIG_T>(exp_sum)];
@@ -357,17 +354,16 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void softmax_laten
     typename CONFIG_T::exp_table_t exp_res[std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{}];
 
 SoftmaxExpLoop:
-    [[intel::initiation_interval(pipeline)]] for (unsigned i = 0;
-                                                  i < CONFIG_T::n_in /
-                                                          std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{};
-                                                  i++) {
+    [[intel::initiation_interval(pipeline
+    )]] for (unsigned i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{}; i++) {
         auto in_pack = data_pipe::read();
 
     SoftmaxExpPackLoop:
         #pragma unroll
         for (unsigned j = 0; j < std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{}; j++) {
             exp_res[j] = exp_table_latency[softmax_latency_idx_from_real_val<
-                typename ExtractPipeType<data_pipe>::value_type::value_type, CONFIG_T>(in_pack[j])];
+                typename ExtractPipeType<data_pipe>::value_type::value_type,
+                CONFIG_T>(in_pack[j])];
         }
 
         // Explicitly sum the results with an adder tree.
@@ -404,10 +400,8 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void softmax_legac
         data_cache[std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{}];
 
 SoftmaxInitLoop:
-    [[intel::initiation_interval(1)]] for (unsigned s = 0;
-                                           s < CONFIG_T::n_in /
-                                                   std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{};
-                                           s++) {
+    [[intel::initiation_interval(1
+    )]] for (unsigned s = 0; s < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{}; s++) {
         auto in_pack = data_pipe::read();
 
     SoftmaxInitPackLoop:
@@ -456,8 +450,8 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void softmax_legac
 }
 
 template <class data_pipe, class res_pipe, typename CONFIG_T> void softmax_argmax_stream() {
-    [[intel::initiation_interval(
-        1)]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
+    [[intel::initiation_interval(1
+    )]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
         auto in_data = data_pipe::read();
         typename ExtractPipeType<res_pipe>::value_type out_data;
 
@@ -470,7 +464,8 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void softmax_argma
         [[intel::fpga_register]] int idx = 0;
 
         [[intel::initiation_interval(1)]] for (int i = 1;
-                                               i < std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
+                                               i < std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{};
+                                               i++) {
             if (in_data[i] > maximum) {
                 maximum = in_data[i];
                 idx = i;
@@ -514,10 +509,8 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void dense_tanh_st
     constexpr unsigned pipeline = std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{} / multiplier_limit;
 
 TanHActLoop:
-    [[intel::initiation_interval(pipeline)]] for (int i = 0;
-                                                  i < CONFIG_T::n_in /
-                                                          std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{};
-                                                  i++) {
+    [[intel::initiation_interval(pipeline
+    )]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
 
         auto in_data = data_pipe::read();
         typename ExtractPipeType<res_pipe>::value_type out_data;
@@ -560,10 +553,8 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void sigmoid_strea
     constexpr unsigned pipeline = std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{} / multiplier_limit;
 
 SigmoidActLoop:
-    [[intel::initiation_interval(pipeline)]] for (int i = 0;
-                                                  i < CONFIG_T::n_in /
-                                                          std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{};
-                                                  i++) {
+    [[intel::initiation_interval(pipeline
+    )]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
         auto in_data = data_pipe::read();
         typename ExtractPipeType<res_pipe>::value_type out_data;
 
@@ -604,10 +595,8 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void hard_sigmoid_
     constexpr unsigned pipeline = std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{} / multiplier_limit;
 
 HardSigmoidActLoop:
-    [[intel::initiation_interval(pipeline)]] for (int i = 0;
-                                                  i < CONFIG_T::n_in /
-                                                          std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{};
-                                                  i++) {
+    [[intel::initiation_interval(pipeline
+    )]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
 
         auto in_data = data_pipe::read();
         typename ExtractPipeType<res_pipe>::value_type out_data;
@@ -634,10 +623,8 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void hard_tanh_str
     constexpr unsigned pipeline = std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{} / multiplier_limit;
 
 HardSigmoidActLoop:
-    [[intel::initiation_interval(pipeline)]] for (int i = 0;
-                                                  i < CONFIG_T::n_in /
-                                                          std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{};
-                                                  i++) {
+    [[intel::initiation_interval(pipeline
+    )]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
 
         auto in_data = data_pipe::read();
         typename ExtractPipeType<res_pipe>::value_type out_data;
@@ -662,8 +649,8 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void hard_tanh_str
 // *************************************************
 template <class data_pipe, class res_pipe, typename CONFIG_T> void binary_tanh_stream() {
 BinaryTanHActLoop:
-    [[intel::initiation_interval(
-        1)]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
+    [[intel::initiation_interval(1
+    )]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
 
         [[intel::fpga_register]] auto in_data = data_pipe::read();
         [[intel::fpga_register]] typename ExtractPipeType<res_pipe>::value_type out_data;
@@ -686,8 +673,8 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void binary_tanh_s
 // *************************************************
 template <class data_pipe, class res_pipe, typename CONFIG_T> void ternary_tanh_stream() {
 TernaryTanHActLoop:
-    [[intel::initiation_interval(
-        1)]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
+    [[intel::initiation_interval(1
+    )]] for (int i = 0; i < CONFIG_T::n_in / std::tuple_size<typename ExtractPipeType<res_pipe>::value_type>{}; i++) {
 
         [[intel::fpga_register]] auto in_data = data_pipe::read();
         [[intel::fpga_register]] typename ExtractPipeType<res_pipe>::value_type out_data;
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_batchnorm.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_batchnorm.h
index f8e5bcb79..3039ef05b 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_batchnorm.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_batchnorm.h
@@ -29,8 +29,9 @@ struct batchnorm_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void normalize(const data_T &data, res_T &res, const typename CONFIG_T::scale_t &scale,
-               const typename CONFIG_T::bias_t &bias) {
+void normalize(
+    const data_T &data, res_T &res, const typename CONFIG_T::scale_t &scale, const typename CONFIG_T::bias_t &bias
+) {
 // Calcuate result
 Result:
     #pragma unroll
@@ -38,13 +39,15 @@ void normalize(const data_T &data, res_T &res, const typename CONFIG_T::scale_t
         if (CONFIG_T::n_filt == -1) {
             res[ires] =
                 CONFIG_T::template product<typename data_T::value_type, typename CONFIG_T::scale_t::value_type>::product(
-                    data[ires], scale[ires]) +
+                    data[ires], scale[ires]
+                ) +
                 bias[ires];
         } else {
             int norm_index = ires % CONFIG_T::n_filt;
             res[ires] =
                 CONFIG_T::template product<typename data_T::value_type, typename CONFIG_T::scale_t::value_type>::product(
-                    data[ires], scale[norm_index]) +
+                    data[ires], scale[norm_index]
+                ) +
                 bias[norm_index];
         }
     }
@@ -82,8 +85,12 @@ void normalize_binary_tanh(const data_T &data, res_T &res, const typename CONFIG
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void normalize_ternary_tanh(const data_T &data, res_T &res, const typename CONFIG_T::threshold_hi_t &threshold_hi,
-                            const typename CONFIG_T::threshold_lo_t &threshold_lo) {
+void normalize_ternary_tanh(
+    const data_T &data,
+    res_T &res,
+    const typename CONFIG_T::threshold_hi_t &threshold_hi,
+    const typename CONFIG_T::threshold_lo_t &threshold_lo
+) {
     #pragma unroll
     for (int ii = 0; ii < CONFIG_T::n_in; ii++) {
         ac_int<2, true> cache;
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_batchnorm_stream.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_batchnorm_stream.h
index 128b3ac1a..259ae5026 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_batchnorm_stream.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_batchnorm_stream.h
@@ -17,8 +17,9 @@ void normalize_stream(typename CONFIG_T::scale_t scale, typename CONFIG_T::bias_
     constexpr unsigned multiplier_limit = DIV_ROUNDUP(CONFIG_T::n_in, CONFIG_T::reuse_factor);
     constexpr unsigned pipeline = CONFIG_T::n_in / multiplier_limit;
     constexpr auto datasize = std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{};
-    CONFIG_T::template product<typename ExtractPipeType<data_pipe>::value_type::value_type,
-                               typename CONFIG_T::scale_t::value_type>::limit(multiplier_limit);
+    CONFIG_T::template product<
+        typename ExtractPipeType<data_pipe>::value_type::value_type,
+        typename CONFIG_T::scale_t::value_type>::limit(multiplier_limit);
 
 BatchNormLoop:
     [[intel::initiation_interval(pipeline)]] for (int i = 0; i < CONFIG_T::n_in / datasize; i++) {
@@ -33,10 +34,10 @@ void normalize_stream(typename CONFIG_T::scale_t scale, typename CONFIG_T::bias_
                 norm_index = i * datasize + j;
             else
                 norm_index = j % CONFIG_T::n_filt;
-            out_data[j] =
-                CONFIG_T::template product<typename ExtractPipeType<data_pipe>::value_type::value_type,
-                                           typename CONFIG_T::scale_t::value_type>::product(in_data[j], scale[norm_index]) +
-                bias[norm_index];
+            out_data[j] = CONFIG_T::template product<
+                              typename ExtractPipeType<data_pipe>::value_type::value_type,
+                              typename CONFIG_T::scale_t::value_type>::product(in_data[j], scale[norm_index]) +
+                          bias[norm_index];
         }
 
         res_pipe::write(out_data);
@@ -72,8 +73,9 @@ void normalize_binary_tanh_stream(typename CONFIG_T::threshold_t threshold) {
 }
 
 template <class data_pipe, class res_pipe, typename CONFIG_T>
-void normalize_ternary_tanh_stream(typename CONFIG_T::threshold_hi_t threshold_hi,
-                                   typename CONFIG_T::threshold_lo_t threshold_lo) {
+void normalize_ternary_tanh_stream(
+    typename CONFIG_T::threshold_hi_t threshold_hi, typename CONFIG_T::threshold_lo_t threshold_lo
+) {
     constexpr auto datasize = std::tuple_size<typename ExtractPipeType<data_pipe>::value_type>{};
 
 TernaryNormLoop:
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv1d.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv1d.h
index 38560f120..db35afde0 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv1d.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv1d.h
@@ -44,14 +44,16 @@ struct conv1d_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_cl(const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights,
-                const typename CONFIG_T::bias_t &biases) {
+void conv_1d_cl(
+    const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights, const typename CONFIG_T::bias_t &biases
+) {
     conv_1d_resource_cl<data_T, res_T, CONFIG_T>(data, res, weights, biases);
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_1d_cl(const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights,
-                          const typename CONFIG_T::bias_t &biases) {
+void pointwise_conv_1d_cl(
+    const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights, const typename CONFIG_T::bias_t &biases
+) {
     assert(CONFIG_T::filt_width == 1);
     pointwise_conv_1d_resource_cl<data_T, res_T, CONFIG_T>(data, res, weights, biases);
 }
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv1d_resource.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv1d_resource.h
index 85009d4a3..03ce26078 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv1d_resource.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv1d_resource.h
@@ -37,8 +37,9 @@ void im2col_1d_cl(const data_T &data, data_col_T &data_col, const int col) {
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_im2col_cl(const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights,
-                       const typename CONFIG_T::bias_t &biases) {
+void conv_1d_im2col_cl(
+    const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights, const typename CONFIG_T::bias_t &biases
+) {
     // im2col performs no filter transformations; therefore, filter size remains constant
     assert(CONFIG_T::filt_width == CONFIG_T::impl_filt_width);
 
@@ -86,8 +87,9 @@ inline void winograd_transform_input_tile_3x1_kernel(const data_T I[4], res_T D[
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void winograd_conv1d_3x1_kernel_cl(const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights,
-                                   const typename CONFIG_T::bias_t &biases) {
+void winograd_conv1d_3x1_kernel_cl(
+    const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights, const typename CONFIG_T::bias_t &biases
+) {
     // Ensure Winograd conditions are met
     assert(CONFIG_T::filt_width == 3);
     assert(CONFIG_T::stride_width == 1);
@@ -175,8 +177,9 @@ void im2col_1d_pointwise_cl(const data_T &data, data_col_T &data_col, const int
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_1d_resource_cl(const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights,
-                                   const typename CONFIG_T::bias_t &biases) {
+void pointwise_conv_1d_resource_cl(
+    const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights, const typename CONFIG_T::bias_t &biases
+) {
     assert(CONFIG_T::filt_width == 1);
 
     // Unroll factor for loop traversing input image, derived from parallelization_factor
@@ -213,8 +216,9 @@ void pointwise_conv_1d_resource_cl(const data_T &data, res_T &res, const typenam
 //      Top-level function - handles different implementations
 // ****************************************************************
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_resource_cl(const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights,
-                         const typename CONFIG_T::bias_t &biases) {
+void conv_1d_resource_cl(
+    const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights, const typename CONFIG_T::bias_t &biases
+) {
     static constexpr bool winograd_conditions =
         // Winograd's minimal filtering algorithm not applicable to stride != 1
         CONFIG_T::stride_width == 1 &&
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv1d_stream.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv1d_stream.h
index 1ffd11774..3efe9ae43 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv1d_stream.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv1d_stream.h
@@ -58,7 +58,8 @@ void shift_line_buffer_1d(
     const data_T &in_elem,
     nnet::shift_reg<typename data_T::value_type, CONFIG_T::pad_left + CONFIG_T::in_width + CONFIG_T::pad_right>
         line_buffer[CONFIG_T::n_chan],
-    typename data_T::value_type shift_buffer[CONFIG_T::n_chan]) {
+    typename data_T::value_type shift_buffer[CONFIG_T::n_chan]
+) {
 // For every channel, insert the incoming pixel at end of the shift buffer
 UpdateBuffer:
     #pragma unroll
@@ -87,8 +88,12 @@ void compute_output_buffer_1d(
     const data_T &in_elem,
     nnet::shift_reg<typename data_T::value_type, CONFIG_T::pad_left + CONFIG_T::in_width + CONFIG_T::pad_right>
         line_buffer[CONFIG_T::n_chan],
-    data_window_T &kernel_window, const typename CONFIG_T::weight_t &weights, const typename CONFIG_T::bias_t &biases,
-    int &pX, int &sX) {
+    data_window_T &kernel_window,
+    const typename CONFIG_T::weight_t &weights,
+    const typename CONFIG_T::bias_t &biases,
+    int &pX,
+    int &sX
+) {
 
     using res_T = typename ExtractPipeType<res_pipe>::value_type;
 
@@ -153,22 +158,25 @@ void conv_1d_cl_stream(typename CONFIG_T::weight_t weights, typename CONFIG_T::b
 // Input image left-side padding
 PaddingLeftWidth:
     for (int col = 0; col < CONFIG_T::pad_left; col++) {
-        compute_output_buffer_1d<data_arr_T, data_window_T, res_pipe, CONFIG_T>(padds, line_buffer, kernel_window, weights,
-                                                                                biases, pX, sX);
+        compute_output_buffer_1d<data_arr_T, data_window_T, res_pipe, CONFIG_T>(
+            padds, line_buffer, kernel_window, weights, biases, pX, sX
+        );
     }
 
 // Read input image
 ReadInputWidth:
     for (int col = 0; col < CONFIG_T::in_width; col++) {
-        compute_output_buffer_1d<data_arr_T, data_window_T, res_pipe, CONFIG_T>(data_pipe::read(), line_buffer,
-                                                                                kernel_window, weights, biases, pX, sX);
+        compute_output_buffer_1d<data_arr_T, data_window_T, res_pipe, CONFIG_T>(
+            data_pipe::read(), line_buffer, kernel_window, weights, biases, pX, sX
+        );
     }
 
 // Input image right-side padding
 PaddingRightWidth:
     for (int col = 0; col < CONFIG_T::pad_right; col++) {
-        compute_output_buffer_1d<data_arr_T, data_window_T, res_pipe, CONFIG_T>(padds, line_buffer, kernel_window, weights,
-                                                                                biases, pX, sX);
+        compute_output_buffer_1d<data_arr_T, data_window_T, res_pipe, CONFIG_T>(
+            padds, line_buffer, kernel_window, weights, biases, pX, sX
+        );
     }
 }
 
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv2d.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv2d.h
index 79b1508c5..8c7bc7384 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv2d.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv2d.h
@@ -50,14 +50,16 @@ struct conv2d_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_2d_cl(const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights,
-                const typename CONFIG_T::bias_t &biases) {
+void conv_2d_cl(
+    const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights, const typename CONFIG_T::bias_t &biases
+) {
     conv_2d_resource_cl<data_T, res_T, CONFIG_T>(data, res, weights, biases);
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_2d_cl(const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights,
-                          const typename CONFIG_T::bias_t &biases) {
+void pointwise_conv_2d_cl(
+    const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights, const typename CONFIG_T::bias_t &biases
+) {
     assert(CONFIG_T::filt_height == 1 && CONFIG_T::filt_width == 1);
     pointwise_conv_2d_resource_cl<data_T, res_T, CONFIG_T>(data, res, weights, biases);
 }
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv2d_resource.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv2d_resource.h
index 7265d90e1..c61a2e4b5 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv2d_resource.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv2d_resource.h
@@ -47,8 +47,9 @@ void im2col_2d_cl(const data_T &data, data_col_T &data_col, const int row, const
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_2d_im2col_cl(const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights,
-                       const typename CONFIG_T::bias_t &biases) {
+void conv_2d_im2col_cl(
+    const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights, const typename CONFIG_T::bias_t &biases
+) {
     // im2col performs no filter transformations; therefore, filter size remains constant
     assert(CONFIG_T::filt_height == CONFIG_T::impl_filt_height && CONFIG_T::filt_width == CONFIG_T::impl_filt_width);
 
@@ -118,8 +119,9 @@ inline void winograd_transform_input_tile_3x3_kernel(const data_T I[16], res_T D
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void winograd_conv2d_3x3_kernel_cl(const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights,
-                                   const typename CONFIG_T::bias_t &biases) {
+void winograd_conv2d_3x3_kernel_cl(
+    const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights, const typename CONFIG_T::bias_t &biases
+) {
     // Ensure Winograd conditions are met
     assert(CONFIG_T::filt_height == 3 && CONFIG_T::filt_width == 3);
     assert(CONFIG_T::stride_height == 1 && CONFIG_T::stride_width == 1);
@@ -184,20 +186,24 @@ void winograd_conv2d_3x3_kernel_cl(const data_T &data, res_T &res, const typenam
 
                     // Explicitly transform intermediate result Z = A'YA and save to output
                     res[CONFIG_T::n_filt * (row * CONFIG_T::out_width + col) + filter] +=
-                        static_cast<typename res_T::value_type>(Y[0] + Y[1] + Y[2] + Y[4] + Y[5] + Y[6] + Y[8] + Y[9] +
-                                                                Y[10]);
+                        static_cast<typename res_T::value_type>(
+                            Y[0] + Y[1] + Y[2] + Y[4] + Y[5] + Y[6] + Y[8] + Y[9] + Y[10]
+                        );
                     if ((col + 1) < CONFIG_T::out_height)
                         res[CONFIG_T::n_filt * (row * CONFIG_T::out_width + (col + 1)) + filter] +=
-                            static_cast<typename res_T::value_type>(Y[1] - Y[2] - Y[3] + Y[5] - Y[6] - Y[7] + Y[9] - Y[10] -
-                                                                    Y[11]);
+                            static_cast<typename res_T::value_type>(
+                                Y[1] - Y[2] - Y[3] + Y[5] - Y[6] - Y[7] + Y[9] - Y[10] - Y[11]
+                            );
                     if ((row + 1) < CONFIG_T::out_width)
                         res[CONFIG_T::n_filt * ((row + 1) * CONFIG_T::out_width + col) + filter] +=
-                            static_cast<typename res_T::value_type>(Y[4] + Y[5] + Y[6] - Y[8] - Y[9] - Y[10] - Y[12] -
-                                                                    Y[13] - Y[14]);
+                            static_cast<typename res_T::value_type>(
+                                Y[4] + Y[5] + Y[6] - Y[8] - Y[9] - Y[10] - Y[12] - Y[13] - Y[14]
+                            );
                     if ((row + 1) < (CONFIG_T::out_width) && (col + 1) < CONFIG_T::out_height)
                         res[CONFIG_T::n_filt * ((row + 1) * CONFIG_T::out_width + (col + 1)) + filter] +=
-                            static_cast<typename res_T::value_type>(Y[5] - Y[6] - Y[7] - Y[9] + Y[10] + Y[11] + Y[15] -
-                                                                    Y[13] + Y[14]);
+                            static_cast<typename res_T::value_type>(
+                                Y[5] - Y[6] - Y[7] - Y[9] + Y[10] + Y[11] + Y[15] - Y[13] + Y[14]
+                            );
                 }
             }
         }
@@ -231,8 +237,9 @@ void im2col_2d_pointwise_cl(const data_T &data, data_col_T &data_col, const int
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_2d_resource_cl(const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights,
-                                   const typename CONFIG_T::bias_t &biases) {
+void pointwise_conv_2d_resource_cl(
+    const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights, const typename CONFIG_T::bias_t &biases
+) {
     assert(CONFIG_T::filt_height == 1 && CONFIG_T::filt_width == 1);
 
     // Unroll factors for loop traversing input image, derived from parallelization_factor
@@ -272,8 +279,9 @@ void pointwise_conv_2d_resource_cl(const data_T &data, res_T &res, const typenam
 //      Top-level function - handles different implementations
 // ****************************************************************
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_2d_resource_cl(const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights,
-                         const typename CONFIG_T::bias_t &biases) {
+void conv_2d_resource_cl(
+    const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights, const typename CONFIG_T::bias_t &biases
+) {
     static constexpr bool winograd_conditions =
         // Winograd's minimal filtering algorithm not applicable to stride != 1
         CONFIG_T::stride_height == 1 && CONFIG_T::stride_width == 1 &&
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv2d_stream.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv2d_stream.h
index 08f0eaa87..04a8f5119 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv2d_stream.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_conv2d_stream.h
@@ -16,8 +16,9 @@ namespace nnet {
  * Values from shift_buffer are inserted into kernel_window, updating the values to be convolved
  */
 template <class data_T, class data_window_T, typename CONFIG_T>
-void kernel_shift_2d(typename data_T::value_type shift_buffer[CONFIG_T::filt_height][CONFIG_T::n_chan],
-                     data_window_T &kernel_window) {
+void kernel_shift_2d(
+    typename data_T::value_type shift_buffer[CONFIG_T::filt_height][CONFIG_T::n_chan], data_window_T &kernel_window
+) {
 /*
  * Manually shift kernel_window by one step to the left
  * Not possible to use nnet::shift_reg<T, N> as the kernel window is convolved with the kernel weights using dense matrix
@@ -47,8 +48,9 @@ void kernel_shift_2d(typename data_T::value_type shift_buffer[CONFIG_T::filt_hei
     KernelPushChannel:
         #pragma unroll
         for (int channel = 0; channel < CONFIG_T::n_chan; channel++) {
-            kernel_window[(CONFIG_T::filt_width - 1) * CONFIG_T::n_chan + col * CONFIG_T::filt_width * CONFIG_T::n_chan +
-                          channel] = shift_buffer[col][channel];
+            kernel_window
+                [(CONFIG_T::filt_width - 1) * CONFIG_T::n_chan + col * CONFIG_T::filt_width * CONFIG_T::n_chan + channel] =
+                    shift_buffer[col][channel];
         }
     }
 }
@@ -69,7 +71,8 @@ void shift_line_buffer_2d(
     const data_T &in_elem,
     nnet::shift_reg<typename data_T::value_type, CONFIG_T::pad_left + CONFIG_T::in_width + CONFIG_T::pad_right>
         line_buffer[MAX(CONFIG_T::filt_height - 1, 1)][CONFIG_T::n_chan],
-    typename data_T::value_type shift_buffer[CONFIG_T::filt_height][CONFIG_T::n_chan]) {
+    typename data_T::value_type shift_buffer[CONFIG_T::filt_height][CONFIG_T::n_chan]
+) {
 // For every channel, insert the incoming pixel at end of the shift buffer
 UpdateBuffer:
     #pragma unroll
@@ -114,8 +117,14 @@ void compute_output_buffer_2d(
     const data_T &in_elem,
     nnet::shift_reg<typename data_T::value_type, CONFIG_T::pad_left + CONFIG_T::in_width + CONFIG_T::pad_right>
         line_buffer[MAX(CONFIG_T::filt_height - 1, 1)][CONFIG_T::n_chan],
-    data_window_T &kernel_window, const typename CONFIG_T::weight_t &weights, const typename CONFIG_T::bias_t &biases,
-    int &pX, int &pY, int &sX, int &sY) {
+    data_window_T &kernel_window,
+    const typename CONFIG_T::weight_t &weights,
+    const typename CONFIG_T::bias_t &biases,
+    int &pX,
+    int &pY,
+    int &sX,
+    int &sY
+) {
 
     using res_T = typename ExtractPipeType<res_pipe>::value_type;
 
@@ -196,8 +205,9 @@ void conv_2d_cl_stream(typename CONFIG_T::weight_t weights, typename CONFIG_T::b
     [[intel::loop_coalesce(2)]] for (int row = 0; row < CONFIG_T::pad_top; row++) {
     PaddingTopWidth:
         for (int col = 0; col < CONFIG_T::pad_left + CONFIG_T::in_width + CONFIG_T::pad_right; col++) {
-            compute_output_buffer_2d<data_arr_T, data_window_T, res_pipe, CONFIG_T>(padds, line_buffer, kernel_window,
-                                                                                    weights, biases, pX, pY, sX, sY);
+            compute_output_buffer_2d<data_arr_T, data_window_T, res_pipe, CONFIG_T>(
+                padds, line_buffer, kernel_window, weights, biases, pX, pY, sX, sY
+            );
         }
     }
 
@@ -206,22 +216,25 @@ void conv_2d_cl_stream(typename CONFIG_T::weight_t weights, typename CONFIG_T::b
     // Input image left-side padding
     PaddingLeftWidth:
         for (int col = 0; col < CONFIG_T::pad_left; col++) {
-            compute_output_buffer_2d<data_arr_T, data_window_T, res_pipe, CONFIG_T>(padds, line_buffer, kernel_window,
-                                                                                    weights, biases, pX, pY, sX, sY);
+            compute_output_buffer_2d<data_arr_T, data_window_T, res_pipe, CONFIG_T>(
+                padds, line_buffer, kernel_window, weights, biases, pX, pY, sX, sY
+            );
         }
 
     // Read input image
     ReadInputWidth:
         for (int col = 0; col < CONFIG_T::in_width; col++) {
             compute_output_buffer_2d<data_arr_T, data_window_T, res_pipe, CONFIG_T>(
-                data_pipe::read(), line_buffer, kernel_window, weights, biases, pX, pY, sX, sY);
+                data_pipe::read(), line_buffer, kernel_window, weights, biases, pX, pY, sX, sY
+            );
         }
 
     // Input image right-side padding
     PaddingRightWidth:
         for (int col = 0; col < CONFIG_T::pad_right; col++) {
-            compute_output_buffer_2d<data_arr_T, data_window_T, res_pipe, CONFIG_T>(padds, line_buffer, kernel_window,
-                                                                                    weights, biases, pX, pY, sX, sY);
+            compute_output_buffer_2d<data_arr_T, data_window_T, res_pipe, CONFIG_T>(
+                padds, line_buffer, kernel_window, weights, biases, pX, pY, sX, sY
+            );
         }
     }
 
@@ -230,8 +243,9 @@ void conv_2d_cl_stream(typename CONFIG_T::weight_t weights, typename CONFIG_T::b
     [[intel::loop_coalesce(2)]] for (int row = 0; row < CONFIG_T::pad_bottom; row++) {
     PaddingBottomWidth:
         for (int col = 0; col < CONFIG_T::pad_left + CONFIG_T::in_width + CONFIG_T::pad_right; col++) {
-            compute_output_buffer_2d<data_arr_T, data_window_T, res_pipe, CONFIG_T>(padds, line_buffer, kernel_window,
-                                                                                    weights, biases, pX, pY, sX, sY);
+            compute_output_buffer_2d<data_arr_T, data_window_T, res_pipe, CONFIG_T>(
+                padds, line_buffer, kernel_window, weights, biases, pX, pY, sX, sY
+            );
         }
     }
 }
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_dense.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_dense.h
index dc7618908..39ce539e3 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_dense.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_dense.h
@@ -37,10 +37,13 @@ struct dense_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_rf_gt(const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights,
-                 const typename CONFIG_T::bias_t &biases) {
-    assert((CONFIG_T::multiplier_limit % CONFIG_T::n_out == 0 || CONFIG_T::reuse_factor >= CONFIG_T::n_in) &&
-           "The current Reuse Factor is not allowed");
+void dense_rf_gt(
+    const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights, const typename CONFIG_T::bias_t &biases
+) {
+    assert(
+        (CONFIG_T::multiplier_limit % CONFIG_T::n_out == 0 || CONFIG_T::reuse_factor >= CONFIG_T::n_in) &&
+        "The current Reuse Factor is not allowed"
+    );
     assert((CONFIG_T::reuse_factor > CONFIG_T::n_in) && "This function is correct only for RF > N_IN");
     //#pragma ii CONFIG_T::reuse_factor
     [[intel::fpga_register]] typename CONFIG_T::accum_t acc[CONFIG_T::n_out];
@@ -74,7 +77,8 @@ void dense_rf_gt(const data_T &data, res_T &res, const typename CONFIG_T::weight
             // Modified this
             tmp_acc[im] =
                 CONFIG_T::template product<typename data_T::value_type, typename CONFIG_T::weight_t::value_type>::product(
-                    data[data_index], weights[w_index]);
+                    data[data_index], weights[w_index]
+                );
         }
         [[intel::fpga_register]] typename CONFIG_T::accum_t mult[CONFIG_T::multiplier_limit];
     ResetMult:
@@ -103,10 +107,13 @@ void dense_rf_gt(const data_T &data, res_T &res, const typename CONFIG_T::weight
     }
 }
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_rf_lt(const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights,
-                 const typename CONFIG_T::bias_t &biases) {
-    assert((CONFIG_T::multiplier_limit % CONFIG_T::n_out == 0 || CONFIG_T::reuse_factor >= CONFIG_T::n_in) &&
-           "The current Reuse Factor is not allowed");
+void dense_rf_lt(
+    const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights, const typename CONFIG_T::bias_t &biases
+) {
+    assert(
+        (CONFIG_T::multiplier_limit % CONFIG_T::n_out == 0 || CONFIG_T::reuse_factor >= CONFIG_T::n_in) &&
+        "The current Reuse Factor is not allowed"
+    );
     assert((CONFIG_T::multiplier_limit == CONFIG_T::block_factor) && "This function is correct only for RF <= N_IN");
 
     [[intel::fpga_register]] typename CONFIG_T::accum_t acc[CONFIG_T::n_out];
@@ -127,7 +134,8 @@ void dense_rf_lt(const data_T &data, res_T &res, const typename CONFIG_T::weight
             // Modified this
             mult[im] =
                 CONFIG_T::template product<typename data_T::value_type, typename CONFIG_T::weight_t::value_type>::product(
-                    data[in_index], weights[w_index]);
+                    data[in_index], weights[w_index]
+                );
             in_index += CONFIG_T::reuse_factor;
             if (in_index >= CONFIG_T::n_in)
                 in_index = ir;
@@ -152,8 +160,9 @@ void dense_rf_lt(const data_T &data, res_T &res, const typename CONFIG_T::weight
     }
 }
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_resource(const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights,
-                    const typename CONFIG_T::bias_t &biases) {
+void dense_resource(
+    const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights, const typename CONFIG_T::bias_t &biases
+) {
     if (CONFIG_T::reuse_factor <= CONFIG_T::n_in) {
         dense_rf_lt<data_T, res_T, CONFIG_T>(data, res, weights, biases);
     } else {
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_dense_stream.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_dense_stream.h
index 92c9adc3b..8f37d1564 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_dense_stream.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_dense_stream.h
@@ -13,8 +13,10 @@ void dense_resource_stream(typename CONFIG_T::weight_t weights, typename CONFIG_
 
     [[intel::fpga_register]] typename ExtractPipeType<res_pipe>::value_type res;
     [[intel::fpga_register]] auto data = data_pipe::read();
-    dense_resource<typename ExtractPipeType<data_pipe>::value_type, typename ExtractPipeType<res_pipe>::value_type,
-                   CONFIG_T>(data, res, weights, biases);
+    dense_resource<
+        typename ExtractPipeType<data_pipe>::value_type,
+        typename ExtractPipeType<res_pipe>::value_type,
+        CONFIG_T>(data, res, weights, biases);
     res_pipe::write(res);
 }
 
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_merge.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_merge.h
index d1262f437..9e1a5e35d 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_merge.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_merge.h
@@ -89,7 +89,8 @@ void dot1d(const input1_T &data1, const input2_T &data2, res_T &res) {
     #pragma unroll multiplier_limit
     for (int i = 0; i < CONFIG_T::n_in; i++) {
         mult[i] = CONFIG_T::template product<typename input1_T::value_type, typename input2_T::value_type>::product(
-            data1[i], data2[i]);
+            data1[i], data2[i]
+        );
     }
 
     [[intel::fpga_register]] typename CONFIG_T::accum_t acc = 0;
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_merge_stream.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_merge_stream.h
index 60028ea52..ad5e924d3 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_merge_stream.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_merge_stream.h
@@ -85,7 +85,8 @@ template <class input1_pipe, class input2_pipe, class res_pipe, typename CONFIG_
         #pragma unroll
         for (int j = 0; j < outputSize; j++) {
             out_data[j] = static_cast<typename ExtractPipeType<res_pipe>::value_type::value_type>(
-                (in_data1[j] + in_data2[j]) / (typename ExtractPipeType<res_pipe>::value_type::value_type)2);
+                (in_data1[j] + in_data2[j]) / (typename ExtractPipeType<res_pipe>::value_type::value_type)2
+            );
         }
 
         res_pipe::write(out_data);
@@ -108,7 +109,8 @@ template <class input1_pipe, class input2_pipe, class res_pipe, typename CONFIG_
         #pragma unroll
         for (int j = 0; j < outputSize; j++) {
             out_data[j] = static_cast<typename ExtractPipeType<res_pipe>::value_type::value_type>(
-                (in_data1[j] > in_data2[j]) ? in_data1[j] : in_data2[j]);
+                (in_data1[j] > in_data2[j]) ? in_data1[j] : in_data2[j]
+            );
         }
 
         res_pipe::write(out_data);
@@ -131,7 +133,8 @@ template <class input1_pipe, class input2_pipe, class res_pipe, typename CONFIG_
         #pragma unroll
         for (int j = 0; j < outputSize; j++) {
             out_data[j] = static_cast<typename ExtractPipeType<res_pipe>::value_type::value_type>(
-                (in_data1[j] < in_data2[j]) ? in_data1[j] : in_data2[j]);
+                (in_data1[j] < in_data2[j]) ? in_data1[j] : in_data2[j]
+            );
         }
 
         res_pipe::write(out_data);
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_mult.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_mult.h
index c7dfc2d7c..88883a1f2 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_mult.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_mult.h
@@ -87,17 +87,17 @@ template <class x_T, class w_T> class weight_exponential : public Product {
 
 // TO-DO: These may need extra variants if ac_int types are used in more places
 template <class data_T, class res_T, typename CONFIG_T>
-inline typename std::enable_if<std::is_same<data_T, ac_int<1, false>>::value &&
-                                   std::is_same<typename CONFIG_T::weight_t, ac_int<1, false>>::value,
-                               ac_int<nnet::ceillog2(CONFIG_T::n_in) + 2, true>>::type
+inline typename std::enable_if<
+    std::is_same<data_T, ac_int<1, false>>::value && std::is_same<typename CONFIG_T::weight_t, ac_int<1, false>>::value,
+    ac_int<nnet::ceillog2(CONFIG_T::n_in) + 2, true>>::type
 cast(typename CONFIG_T::accum_t x) {
     return static_cast<ac_int<nnet::ceillog2(CONFIG_T::n_in) + 2, true>>(((x - CONFIG_T::n_in / 2) * 2).to_ac_int());
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-inline typename std::enable_if<std::is_same<data_T, ac_int<1, false>>::value &&
-                                   !std::is_same<typename CONFIG_T::weight_t, ac_int<1, false>>::value,
-                               res_T>::type
+inline typename std::enable_if<
+    std::is_same<data_T, ac_int<1, false>>::value && !std::is_same<typename CONFIG_T::weight_t, ac_int<1, false>>::value,
+    res_T>::type
 cast(typename CONFIG_T::accum_t x) {
     return static_cast<res_T>(x);
 }
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_pooling.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_pooling.h
index d4ae91533..0886f44be 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_pooling.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_pooling.h
@@ -118,7 +118,9 @@ template <class data_T, class res_T, typename CONFIG_T> void pooling1d_cl(const
             // Pooling operation
             res[(inp_col / CONFIG_T::stride_width) * CONFIG_T::n_filt + filt] = static_cast<typename res_T::value_type>(
                 pool_op<typename data_T::value_type, CONFIG_T::pool_width, CONFIG_T::pool_op, typename CONFIG_T::accum_t>(
-                    pool, img_overlap));
+                    pool, img_overlap
+                )
+            );
         }
     }
 }
@@ -139,7 +141,8 @@ template <class data_T, class res_T, typename CONFIG_T> void global_pooling1d_cl
         }
 
         res[filt] = static_cast<typename res_T::value_type>(
-            pool_op<typename data_T::value_type, CONFIG_T::n_in, CONFIG_T::pool_op, typename CONFIG_T::accum_t>(pool));
+            pool_op<typename data_T::value_type, CONFIG_T::n_in, CONFIG_T::pool_op, typename CONFIG_T::accum_t>(pool)
+        );
     }
 }
 
@@ -210,9 +213,9 @@ template <class data_T, class res_T, typename CONFIG_T> void pooling2d_cl(const
                                 img_overlap++;
                         } else {
                             // Current element is from input image
-                            pool[pool_col * CONFIG_T::stride_width + pool_row] =
-                                data[(inp_col + pool_col - CONFIG_T::pad_top) * CONFIG_T::in_width * CONFIG_T::n_filt +
-                                     (inp_width + pool_row - CONFIG_T::pad_left) * CONFIG_T::n_filt + filt];
+                            pool[pool_col * CONFIG_T::stride_width + pool_row] = data
+                                [(inp_col + pool_col - CONFIG_T::pad_top) * CONFIG_T::in_width * CONFIG_T::n_filt +
+                                 (inp_width + pool_row - CONFIG_T::pad_left) * CONFIG_T::n_filt + filt];
                             img_overlap++;
                         }
                     }
@@ -221,9 +224,11 @@ template <class data_T, class res_T, typename CONFIG_T> void pooling2d_cl(const
                 // Pooling operation
                 res[(inp_col / CONFIG_T::stride_height) * CONFIG_T::out_width * CONFIG_T::n_filt +
                     (inp_width / CONFIG_T::stride_width) * CONFIG_T::n_filt + filt] =
-                    static_cast<typename res_T::value_type>(
-                        pool_op<typename data_T::value_type, CONFIG_T::pool_height * CONFIG_T::pool_width, CONFIG_T::pool_op,
-                                typename CONFIG_T::accum_t>(pool, img_overlap));
+                    static_cast<typename res_T::value_type>(pool_op<
+                                                            typename data_T::value_type,
+                                                            CONFIG_T::pool_height * CONFIG_T::pool_width,
+                                                            CONFIG_T::pool_op,
+                                                            typename CONFIG_T::accum_t>(pool, img_overlap));
             }
         }
     }
@@ -246,9 +251,11 @@ template <class data_T, class res_T, typename CONFIG_T> void global_pooling2d_cl
             pool[i] = data[i * CONFIG_T::n_filt + filt];
         }
 
-        res[filt] = static_cast<typename res_T::value_type>(
-            pool_op<typename data_T::value_type, CONFIG_T::in_height * CONFIG_T::in_width, CONFIG_T::pool_op,
-                    typename CONFIG_T::accum_t>(pool));
+        res[filt] = static_cast<typename res_T::value_type>(pool_op<
+                                                            typename data_T::value_type,
+                                                            CONFIG_T::in_height * CONFIG_T::in_width,
+                                                            CONFIG_T::pool_op,
+                                                            typename CONFIG_T::accum_t>(pool));
     }
 }
 
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_pooling_stream.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_pooling_stream.h
index 9c30aab67..1c0894274 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_pooling_stream.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_pooling_stream.h
@@ -24,9 +24,13 @@ namespace nnet {
  *
  */
 template <class data_T, class data_window_T, class res_pipe, typename CONFIG_T>
-void compute_pool_buffer_1d(const data_T &in_elem,
-                            nnet::shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[CONFIG_T::n_filt],
-                            data_window_T &kernel_window, int &pX, int &sX) {
+void compute_pool_buffer_1d(
+    const data_T &in_elem,
+    nnet::shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[CONFIG_T::n_filt],
+    data_window_T &kernel_window,
+    int &pX,
+    int &sX
+) {
 
     using res_T = typename ExtractPipeType<res_pipe>::value_type;
 
@@ -59,7 +63,9 @@ void compute_pool_buffer_1d(const data_T &in_elem,
             // Step 3 - Pooling
             res_pack[filter] = static_cast<typename res_T::value_type>(
                 pool_op<typename data_T::value_type, CONFIG_T::pool_width, CONFIG_T::pool_op, typename CONFIG_T::accum_t>(
-                    pool_window));
+                    pool_window
+                )
+            );
         }
 
         // Write result to output stream
@@ -98,8 +104,9 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void pooling1d_cl_
 // Read input image
 ReadInputWidth:
     for (int col = 0; col < CONFIG_T::in_width; col++) {
-        compute_pool_buffer_1d<data_arr_T, data_window_T, res_pipe, CONFIG_T>(data_pipe::read(), line_buffer, kernel_window,
-                                                                              pX, sX);
+        compute_pool_buffer_1d<data_arr_T, data_window_T, res_pipe, CONFIG_T>(
+            data_pipe::read(), line_buffer, kernel_window, pX, sX
+        );
     }
 }
 
@@ -119,10 +126,16 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void pooling1d_cl_
  *
  */
 template <class data_T, class data_window_T, class res_pipe, typename CONFIG_T>
-void compute_pool_buffer_2d(const data_T &in_elem,
-                            nnet::shift_reg<typename data_T::value_type, CONFIG_T::in_width>
-                                line_buffer[CONFIG_T::pool_height - 1][CONFIG_T::n_filt],
-                            data_window_T &kernel_window, int &pX, int &pY, int &sX, int &sY) {
+void compute_pool_buffer_2d(
+    const data_T &in_elem,
+    nnet::shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[CONFIG_T::pool_height - 1]
+                                                                                [CONFIG_T::n_filt],
+    data_window_T &kernel_window,
+    int &pX,
+    int &pY,
+    int &sX,
+    int &sY
+) {
 
     using res_T = typename ExtractPipeType<res_pipe>::value_type;
 
@@ -154,9 +167,11 @@ void compute_pool_buffer_2d(const data_T &in_elem,
             }
 
             // Step 3 - Pooling
-            res_pack[filter] = static_cast<typename res_T::value_type>(
-                pool_op<typename data_T::value_type, CONFIG_T::pool_height * CONFIG_T::pool_width, CONFIG_T::pool_op,
-                        typename CONFIG_T::accum_t>(pool_window));
+            res_pack[filter] = static_cast<typename res_T::value_type>(pool_op<
+                                                                       typename data_T::value_type,
+                                                                       CONFIG_T::pool_height * CONFIG_T::pool_width,
+                                                                       CONFIG_T::pool_op,
+                                                                       typename CONFIG_T::accum_t>(pool_window));
         }
 
         // Write result to output stream
@@ -211,8 +226,9 @@ template <class data_pipe, class res_pipe, typename CONFIG_T> void pooling2d_cl_
     // Read input image
     ReadInputWidth:
         for (int col = 0; col < CONFIG_T::in_width; col++) {
-            compute_pool_buffer_2d<data_arr_T, data_window_T, res_pipe, CONFIG_T>(data_pipe::read(), line_buffer,
-                                                                                  kernel_window, pX, pY, sX, sY);
+            compute_pool_buffer_2d<data_arr_T, data_window_T, res_pipe, CONFIG_T>(
+                data_pipe::read(), line_buffer, kernel_window, pX, pY, sX, sY
+            );
         }
     }
 }
@@ -239,7 +255,8 @@ template <class data_T, class res_T, typename CONFIG_T> void compute_global_pool
     #pragma unroll
     for (unsigned i = 0; i < CONFIG_T::n_filt; i++) {
         data_input[i] = reduce_global_pool<typename CONFIG_T::accum_t, typename data_T::value_type, CONFIG_T::pool_op>(
-            data_input[i], in_elem[i]);
+            data_input[i], in_elem[i]
+        );
     }
 }
 
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_recurrent.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_recurrent.h
index 4c20f28d1..20be7a855 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_recurrent.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_recurrent.h
@@ -98,9 +98,14 @@ struct gru_config {
 };
 
 template <class data_T, class h_T, typename CONFIG_T>
-void gru_cell(const data_T &x, h_T &h, const typename CONFIG_T::weight_t &weights,
-              const typename CONFIG_T::recurrent_weight_t &recurrent_weights, const typename CONFIG_T::bias_t &bias,
-              const typename CONFIG_T::recurrent_bias_t &recurrent_bias) {
+void gru_cell(
+    const data_T &x,
+    h_T &h,
+    const typename CONFIG_T::weight_t &weights,
+    const typename CONFIG_T::recurrent_weight_t &recurrent_weights,
+    const typename CONFIG_T::bias_t &bias,
+    const typename CONFIG_T::recurrent_bias_t &recurrent_bias
+) {
     static constexpr int recurrent_unroll_factor = CONFIG_T::n_units / CONFIG_T::reuse_factor;
     // A matrix containing the values of matrix product between input (x) and weights (weights), for update, reset and
     // candidate state gates, for each of the units
@@ -113,8 +118,9 @@ void gru_cell(const data_T &x, h_T &h, const typename CONFIG_T::weight_t &weight
     // A matrix containing the values of matrix product between previou state (h) and recurrent weights (recurrent_weights),
     // for update, reset and candidate state gates, for each of the units
     [[intel::fpga_register]] accum_array_T mat_mul_h_wr;
-    nnet::dense_resource<h_T, accum_array_T, typename CONFIG_T::mult_config_h>(h, mat_mul_h_wr, recurrent_weights,
-                                                                               recurrent_bias);
+    nnet::dense_resource<h_T, accum_array_T, typename CONFIG_T::mult_config_h>(
+        h, mat_mul_h_wr, recurrent_weights, recurrent_bias
+    );
 
     // A vector containing both the values of z(t) and r(t) for every state
     using z_activ_array_T = array<typename CONFIG_T::accum_t, 2 * CONFIG_T::n_units>;
@@ -129,8 +135,8 @@ void gru_cell(const data_T &x, h_T &h, const typename CONFIG_T::weight_t &weight
 
     // Activation on z(t) and r(t)
     [[intel::fpga_register]] z_activ_array_T z_r_act;
-    CONFIG_T::template activation_recr<z_activ_array_T, z_activ_array_T,
-                                       typename CONFIG_T::ACT_CONFIG_RECURRENT_T>::activation(z_r, z_r_act);
+    CONFIG_T::template activation_recr<z_activ_array_T, z_activ_array_T, typename CONFIG_T::ACT_CONFIG_RECURRENT_T>::
+        activation(z_r, z_r_act);
 
     // A matrix containing the values of Hadamard product between r(t) = z_r_act[n_units:2*n_units] and h(t-1) = h
     using h_activ_array_T = array<typename CONFIG_T::accum_t, CONFIG_T::n_units>;
@@ -150,8 +156,9 @@ void gru_cell(const data_T &x, h_T &h, const typename CONFIG_T::weight_t &weight
 
     // Activation on candidate state
     [[intel::fpga_register]] h_activ_array_T h_cand_act;
-    CONFIG_T::template activation<h_activ_array_T, h_activ_array_T, typename CONFIG_T::ACT_CONFIG_T>::activation(h_cand,
-                                                                                                                 h_cand_act);
+    CONFIG_T::template activation<h_activ_array_T, h_activ_array_T, typename CONFIG_T::ACT_CONFIG_T>::activation(
+        h_cand, h_cand_act
+    );
 
     // Update state
     #pragma unroll recurrent_unroll_factor
@@ -161,9 +168,14 @@ void gru_cell(const data_T &x, h_T &h, const typename CONFIG_T::weight_t &weight
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void gru(const data_T &data, res_T &res, const typename CONFIG_T::weight_t &weights,
-         const typename CONFIG_T::recurrent_weight_t &recurrent_weights, const typename CONFIG_T::bias_t &bias,
-         const typename CONFIG_T::recurrent_bias_t &recurrent_bias) {
+void gru(
+    const data_T &data,
+    res_T &res,
+    const typename CONFIG_T::weight_t &weights,
+    const typename CONFIG_T::recurrent_weight_t &recurrent_weights,
+    const typename CONFIG_T::bias_t &bias,
+    const typename CONFIG_T::recurrent_bias_t &recurrent_bias
+) {
 
     using h_T = array<typename res_T::value_type, CONFIG_T::n_units>;
     [[intel::fpga_register]] data_T x;
@@ -229,8 +241,14 @@ struct simpleRNN_config {
 };
 
 template <class in_T, class h_T, typename CONFIG_T>
-void simple_rnn_cell(const in_T &inputs, h_T &hidden_state, h_T &hidden_state_o, const typename CONFIG_T::weight_t &kernel,
-                     const typename CONFIG_T::recurrent_weight_t &rec_kernel, const typename CONFIG_T::bias_t &bias) {
+void simple_rnn_cell(
+    const in_T &inputs,
+    h_T &hidden_state,
+    h_T &hidden_state_o,
+    const typename CONFIG_T::weight_t &kernel,
+    const typename CONFIG_T::recurrent_weight_t &rec_kernel,
+    const typename CONFIG_T::bias_t &bias
+) {
 
     using accum_array_T = array<typename CONFIG_T::accum_t, CONFIG_T::n_out>;
     // Weight multiplication
@@ -243,8 +261,9 @@ void simple_rnn_cell(const in_T &inputs, h_T &hidden_state, h_T &hidden_state_o,
 
     // Hidden state
     [[intel::fpga_register]] accum_array_T hiddenCand;
-    multiply_U<h_T, accum_array_T, typename CONFIG_T::recurrent_weight_t, CONFIG_T::n_out>(hidden_state, hiddenCand,
-                                                                                           rec_kernel);
+    multiply_U<h_T, accum_array_T, typename CONFIG_T::recurrent_weight_t, CONFIG_T::n_out>(
+        hidden_state, hiddenCand, rec_kernel
+    );
 
     // Vector addition
     [[intel::fpga_register]] accum_array_T afterAdd;
@@ -255,8 +274,13 @@ void simple_rnn_cell(const in_T &inputs, h_T &hidden_state, h_T &hidden_state_o,
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void simple_rnn(const data_T &data, res_T &res, const typename CONFIG_T::weight_t &kernel,
-                const typename CONFIG_T::recurrent_weight_t &rec_kernel, const typename CONFIG_T::bias_t &bias) {
+void simple_rnn(
+    const data_T &data,
+    res_T &res,
+    const typename CONFIG_T::weight_t &kernel,
+    const typename CONFIG_T::recurrent_weight_t &rec_kernel,
+    const typename CONFIG_T::bias_t &bias
+) {
 
     using in_T = array<typename data_T::value_type, CONFIG_T::n_in>;
     using h_T = array<typename res_T::value_type, CONFIG_T::n_out>;
@@ -345,13 +369,25 @@ struct lstm_config {
 };
 
 template <class in_T, class h_T, typename CONFIG_T>
-void lstm_cell(const in_T &inputs, h_T &hidden_state, h_T &hidden_state_o, h_T &cell_state, h_T &cell_state_o,
-               const typename CONFIG_T::weight_i_t &WI, const typename CONFIG_T::weight_f_t &WF,
-               const typename CONFIG_T::weight_c_t &WC, const typename CONFIG_T::weight_o_t &WO,
-               const typename CONFIG_T::recurrent_weight_i_t &RWI, const typename CONFIG_T::recurrent_weight_f_t &RWF,
-               const typename CONFIG_T::recurrent_weight_c_t &RWC, const typename CONFIG_T::recurrent_weight_o_t &RWO,
-               const typename CONFIG_T::bias_i_t &BI, const typename CONFIG_T::bias_f_t BF,
-               const typename CONFIG_T::bias_c_t &BC, const typename CONFIG_T::bias_o_t BO) {
+void lstm_cell(
+    const in_T &inputs,
+    h_T &hidden_state,
+    h_T &hidden_state_o,
+    h_T &cell_state,
+    h_T &cell_state_o,
+    const typename CONFIG_T::weight_i_t &WI,
+    const typename CONFIG_T::weight_f_t &WF,
+    const typename CONFIG_T::weight_c_t &WC,
+    const typename CONFIG_T::weight_o_t &WO,
+    const typename CONFIG_T::recurrent_weight_i_t &RWI,
+    const typename CONFIG_T::recurrent_weight_f_t &RWF,
+    const typename CONFIG_T::recurrent_weight_c_t &RWC,
+    const typename CONFIG_T::recurrent_weight_o_t &RWO,
+    const typename CONFIG_T::bias_i_t &BI,
+    const typename CONFIG_T::bias_f_t BF,
+    const typename CONFIG_T::bias_c_t &BC,
+    const typename CONFIG_T::bias_o_t BO
+) {
 
     using accum_array_T = array<typename CONFIG_T::accum_t, CONFIG_T::n_out>;
 
@@ -398,15 +434,17 @@ void lstm_cell(const in_T &inputs, h_T &hidden_state, h_T &hidden_state_o, h_T &
     add_bias<accum_array_T, accum_array_T, typename CONFIG_T::bias_i_t, CONFIG_T::n_out>(i_afterW, i_afterBias, BI);
 
     // Hidden Candidate
-    multiply_U<h_T, accum_array_T, typename CONFIG_T::recurrent_weight_i_t, CONFIG_T::n_out>(hidden_state, i_hiddenCand,
-                                                                                             RWI);
+    multiply_U<h_T, accum_array_T, typename CONFIG_T::recurrent_weight_i_t, CONFIG_T::n_out>(
+        hidden_state, i_hiddenCand, RWI
+    );
 
     // Vector addition
     add_vectors<accum_array_T, accum_array_T, accum_array_T, CONFIG_T::n_out>(i_afterBias, i_hiddenCand, i_afterAdd);
 
     // Activation
     CONFIG_T::template activation_recr<accum_array_T, accum_array_T, typename CONFIG_T::ACT_CONFIG_RECURRENT_T>::activation(
-        i_afterAdd, gate_i);
+        i_afterAdd, gate_i
+    );
 
     //-----------Gate F Calculations
     // Weight multiplication
@@ -416,15 +454,17 @@ void lstm_cell(const in_T &inputs, h_T &hidden_state, h_T &hidden_state_o, h_T &
     add_bias<accum_array_T, accum_array_T, typename CONFIG_T::bias_f_t, CONFIG_T::n_out>(f_afterW, f_afterBias, BF);
 
     // Hidden Candidate
-    multiply_U<h_T, accum_array_T, typename CONFIG_T::recurrent_weight_f_t, CONFIG_T::n_out>(hidden_state, f_hiddenCand,
-                                                                                             RWF);
+    multiply_U<h_T, accum_array_T, typename CONFIG_T::recurrent_weight_f_t, CONFIG_T::n_out>(
+        hidden_state, f_hiddenCand, RWF
+    );
 
     // Vector addition
     add_vectors<accum_array_T, accum_array_T, accum_array_T, CONFIG_T::n_out>(f_afterBias, f_hiddenCand, f_afterAdd);
 
     // Activation
     CONFIG_T::template activation_recr<accum_array_T, accum_array_T, typename CONFIG_T::ACT_CONFIG_RECURRENT_T>::activation(
-        f_afterAdd, gate_f);
+        f_afterAdd, gate_f
+    );
 
     //-----------Gate C Calculations
     // Weight multiplication
@@ -434,15 +474,17 @@ void lstm_cell(const in_T &inputs, h_T &hidden_state, h_T &hidden_state_o, h_T &
     add_bias<accum_array_T, accum_array_T, typename CONFIG_T::bias_c_t, CONFIG_T::n_out>(c_afterW, c_afterBias, BC);
 
     // Hidden Candidate
-    multiply_U<h_T, accum_array_T, typename CONFIG_T::recurrent_weight_c_t, CONFIG_T::n_out>(hidden_state, c_hiddenCand,
-                                                                                             RWC);
+    multiply_U<h_T, accum_array_T, typename CONFIG_T::recurrent_weight_c_t, CONFIG_T::n_out>(
+        hidden_state, c_hiddenCand, RWC
+    );
 
     // Vector addition
     add_vectors<accum_array_T, accum_array_T, accum_array_T, CONFIG_T::n_out>(c_afterBias, c_hiddenCand, c_afterAdd);
 
     // Activation
     CONFIG_T::template activation<accum_array_T, accum_array_T, typename CONFIG_T::ACT_CONFIG_RECURRENT_T>::activation(
-        c_afterAdd, gate_c);
+        c_afterAdd, gate_c
+    );
 
     //-----------gate I and C multiply
     // Vector multiplication
@@ -456,15 +498,17 @@ void lstm_cell(const in_T &inputs, h_T &hidden_state, h_T &hidden_state_o, h_T &
     add_bias<accum_array_T, accum_array_T, typename CONFIG_T::bias_o_t, CONFIG_T::n_out>(o_afterW, o_afterBias, BO);
 
     // Hidden Candidate
-    multiply_U<h_T, accum_array_T, typename CONFIG_T::recurrent_weight_o_t, CONFIG_T::n_out>(hidden_state, o_hiddenCand,
-                                                                                             RWO);
+    multiply_U<h_T, accum_array_T, typename CONFIG_T::recurrent_weight_o_t, CONFIG_T::n_out>(
+        hidden_state, o_hiddenCand, RWO
+    );
 
     // Vector addition
     add_vectors<accum_array_T, accum_array_T, accum_array_T, CONFIG_T::n_out>(o_afterBias, o_hiddenCand, o_afterAdd);
 
     // Activation
     CONFIG_T::template activation_recr<accum_array_T, accum_array_T, typename CONFIG_T::ACT_CONFIG_RECURRENT_T>::activation(
-        o_afterAdd, gate_o);
+        o_afterAdd, gate_o
+    );
 
     //-----------Cell State Calculation
     // Vector multiplication
@@ -476,7 +520,8 @@ void lstm_cell(const in_T &inputs, h_T &hidden_state, h_T &hidden_state_o, h_T &
     //-----------Forget gate Calculation
     // Activation
     CONFIG_T::template activation<accum_array_T, accum_array_T, typename CONFIG_T::ACT_CONFIG_RECURRENT_T>::activation(
-        cell_act_add, gate_forget);
+        cell_act_add, gate_forget
+    );
 
     // Vector multiplication
     multiply_vectors<accum_array_T, accum_array_T, accum_array_T, CONFIG_T::n_out>(gate_o, gate_forget, h);
@@ -490,12 +535,22 @@ void lstm_cell(const in_T &inputs, h_T &hidden_state, h_T &hidden_state_o, h_T &
 }
 
 template <class data_T, class res_T, class CONFIG_T>
-void lstm(const data_T &data, res_T &res, const typename CONFIG_T::weight_i_t &WI, const typename CONFIG_T::weight_f_t &WF,
-          const typename CONFIG_T::weight_c_t &WC, const typename CONFIG_T::weight_o_t &WO,
-          const typename CONFIG_T::recurrent_weight_i_t &RWI, const typename CONFIG_T::recurrent_weight_f_t &RWF,
-          const typename CONFIG_T::recurrent_weight_c_t &RWC, const typename CONFIG_T::recurrent_weight_o_t &RWO,
-          const typename CONFIG_T::bias_i_t &BI, const typename CONFIG_T::bias_f_t &BF,
-          const typename CONFIG_T::bias_c_t &BC, const typename CONFIG_T::bias_o_t &BO) {
+void lstm(
+    const data_T &data,
+    res_T &res,
+    const typename CONFIG_T::weight_i_t &WI,
+    const typename CONFIG_T::weight_f_t &WF,
+    const typename CONFIG_T::weight_c_t &WC,
+    const typename CONFIG_T::weight_o_t &WO,
+    const typename CONFIG_T::recurrent_weight_i_t &RWI,
+    const typename CONFIG_T::recurrent_weight_f_t &RWF,
+    const typename CONFIG_T::recurrent_weight_c_t &RWC,
+    const typename CONFIG_T::recurrent_weight_o_t &RWO,
+    const typename CONFIG_T::bias_i_t &BI,
+    const typename CONFIG_T::bias_f_t &BF,
+    const typename CONFIG_T::bias_c_t &BC,
+    const typename CONFIG_T::bias_o_t &BO
+) {
 
     // Note:  currently this does not support recurrent bias
 
@@ -533,8 +588,9 @@ void lstm(const data_T &data, res_T &res, const typename CONFIG_T::weight_i_t &W
         }
 
         // Do LSTM
-        lstm_cell<in_T, h_T, CONFIG_T>(in, hidden_state_temp, h, cell_state_temp, c, WI, WF, WC, WO, RWI, RWF, RWC, RWO, BI,
-                                       BF, BC, BO);
+        lstm_cell<in_T, h_T, CONFIG_T>(
+            in, hidden_state_temp, h, cell_state_temp, c, WI, WF, WC, WO, RWI, RWF, RWC, RWO, BI, BF, BC, BO
+        );
 
         // Write result
         #pragma unroll
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_recurrent_stream.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_recurrent_stream.h
index 7429419cd..831fd1f41 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_recurrent_stream.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_recurrent_stream.h
@@ -7,8 +7,12 @@
 
 namespace nnet {
 template <class data_pipe, class res_pipe, typename CONFIG_T>
-void gru_stream(typename CONFIG_T::weight_t weights, typename CONFIG_T::recurrent_weight_t recurrent_weights,
-                typename CONFIG_T::bias_t bias, typename CONFIG_T::recurrent_bias_t recurrent_bias) {
+void gru_stream(
+    typename CONFIG_T::weight_t weights,
+    typename CONFIG_T::recurrent_weight_t recurrent_weights,
+    typename CONFIG_T::bias_t bias,
+    typename CONFIG_T::recurrent_bias_t recurrent_bias
+) {
 
     using data_T = typename ExtractPipeType<data_pipe>::value_type;
     using res_T = typename ExtractPipeType<res_pipe>::value_type;
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_transpose.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_transpose.h
index 2c4991a13..fbd436c80 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_transpose.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_transpose.h
@@ -21,8 +21,8 @@ template <class data_T, class res_T, typename CONFIG_T> void transpose_2d(const
 
 template <class data_T, class res_T, typename CONFIG_T> void transpose_3d(const data_T &data, res_T &res) {
     static constexpr unsigned dim_data[3] = {CONFIG_T::depth, CONFIG_T::height, CONFIG_T::width};
-    static constexpr unsigned dim_res[3] = {dim_data[CONFIG_T::perm[0]], dim_data[CONFIG_T::perm[1]],
-                                            dim_data[CONFIG_T::perm[2]]};
+    static constexpr unsigned dim_res[3] = {
+        dim_data[CONFIG_T::perm[0]], dim_data[CONFIG_T::perm[1]], dim_data[CONFIG_T::perm[2]]};
 
     int index_data[3] = {0}, index_res[3] = {0};
 
@@ -37,7 +37,8 @@ template <class data_T, class res_T, typename CONFIG_T> void transpose_3d(const
 
                 res[index_res[0] * dim_res[1] * dim_res[2] + index_res[1] * dim_res[2] + index_res[2]] =
                     static_cast<typename res_T::value_type>(
-                        data[index_data[0] * dim_data[1] * dim_data[2] + index_data[1] * dim_data[2] + index_data[2]]);
+                        data[index_data[0] * dim_data[1] * dim_data[2] + index_data[1] * dim_data[2] + index_data[2]]
+                    );
             }
         }
     }
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_types.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_types.h
index 8cf883c1d..b88103da9 100644
--- a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_types.h
+++ b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_types.h
@@ -26,10 +26,20 @@ template <class T> constexpr T zero_array() {
 // This is a helper to extract the value_type of a pipe
 template <typename T> struct ExtractPipeType { typedef T value_type; };
 
-template <template <class, class, int32_t, class, typename...> class PipeClass, class PipeName, class PipeDataT,
-          int32_t kPipeMinCapacity, class PipeProperties, typename... Args>
-struct ExtractPipeType<PipeClass<PipeName, PipeDataT, kPipeMinCapacity, PipeProperties,
-                                 Args...>> // specialization
+template <
+    template <class, class, int32_t, class, typename...>
+    class PipeClass,
+    class PipeName,
+    class PipeDataT,
+    int32_t kPipeMinCapacity,
+    class PipeProperties,
+    typename... Args>
+struct ExtractPipeType<PipeClass<
+    PipeName,
+    PipeDataT,
+    kPipeMinCapacity,
+    PipeProperties,
+    Args...>> // specialization
 {
     typedef PipeDataT value_type;
 };
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_batchnorm.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_batchnorm.h
index 7b84a9c0f..7dffe736f 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_batchnorm.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_batchnorm.h
@@ -29,9 +29,12 @@ struct batchnorm_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void normalize(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_in],
-               const typename CONFIG_T::scale_t scale[CONFIG_T::n_scale_bias],
-               const typename CONFIG_T::bias_t bias[CONFIG_T::n_scale_bias]) {
+void normalize(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_in],
+    const typename CONFIG_T::scale_t scale[CONFIG_T::n_scale_bias],
+    const typename CONFIG_T::bias_t bias[CONFIG_T::n_scale_bias]
+) {
 // Calcuate result
 Result:
     #pragma unroll
@@ -64,8 +67,9 @@ struct batchnorm_quantized_tanh_config {
 };
 
 template <class data_T, typename CONFIG_T>
-void normalize_binary_tanh(data_T data[CONFIG_T::n_in], ac_int<1, false> res[CONFIG_T::n_in],
-                           const data_T threshold[CONFIG_T::n_scale_bias]) {
+void normalize_binary_tanh(
+    data_T data[CONFIG_T::n_in], ac_int<1, false> res[CONFIG_T::n_in], const data_T threshold[CONFIG_T::n_scale_bias]
+) {
     #pragma unroll
     for (int ii = 0; ii < CONFIG_T::n_in; ii++) {
         ac_int<1, false> cache;
@@ -81,9 +85,12 @@ void normalize_binary_tanh(data_T data[CONFIG_T::n_in], ac_int<1, false> res[CON
 }
 
 template <class data_T, typename CONFIG_T>
-void normalize_ternary_tanh(data_T data[CONFIG_T::n_in], ac_int<2, true> res[CONFIG_T::n_in],
-                            const data_T threshold_hi[CONFIG_T::n_scale_bias],
-                            const data_T threshold_lo[CONFIG_T::n_scale_bias]) {
+void normalize_ternary_tanh(
+    data_T data[CONFIG_T::n_in],
+    ac_int<2, true> res[CONFIG_T::n_in],
+    const data_T threshold_hi[CONFIG_T::n_scale_bias],
+    const data_T threshold_lo[CONFIG_T::n_scale_bias]
+) {
     #pragma unroll
     for (int ii = 0; ii < CONFIG_T::n_in; ii++) {
         ac_int<2, true> cache;
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_batchnorm_stream.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_batchnorm_stream.h
index 7a1f48d22..536d8d54a 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_batchnorm_stream.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_batchnorm_stream.h
@@ -12,8 +12,12 @@ namespace nnet {
 //       Streaming Batch Normalization
 // ****************************************************
 template <class data_T, class res_T, typename CONFIG_T>
-void normalize(stream<data_T> &data, stream<res_T> &res, const typename CONFIG_T::scale_t scale[CONFIG_T::n_scale_bias],
-               const typename CONFIG_T::bias_t bias[CONFIG_T::n_scale_bias]) {
+void normalize(
+    stream<data_T> &data,
+    stream<res_T> &res,
+    const typename CONFIG_T::scale_t scale[CONFIG_T::n_scale_bias],
+    const typename CONFIG_T::bias_t bias[CONFIG_T::n_scale_bias]
+) {
 
     constexpr unsigned multiplier_limit = DIV_ROUNDUP(CONFIG_T::n_in, CONFIG_T::reuse_factor);
     constexpr unsigned pipeline = CONFIG_T::n_in / multiplier_limit;
@@ -34,7 +38,8 @@ void normalize(stream<data_T> &data, stream<res_T> &res, const typename CONFIG_T
             else
                 norm_index = j % CONFIG_T::n_filt;
             out_data[j] = CONFIG_T::template product<typename data_T::value_type, typename CONFIG_T::scale_t>::product(
-                              in_data[j], scale[norm_index]) +
+                              in_data[j], scale[norm_index]
+                          ) +
                           bias[norm_index];
         }
 
@@ -46,8 +51,11 @@ void normalize(stream<data_T> &data, stream<res_T> &res, const typename CONFIG_T
 //       Merged Batch Normalization and Quantized Tanh
 // ****************************************************
 template <class data_T, typename CONFIG_T>
-void normalize_binary_tanh(stream<data_T> &data, stream<nnet::array<ac_int<1, false>, CONFIG_T::n_scale_bias>> &res,
-                           const typename data_T::value_type threshold[CONFIG_T::n_scale_bias]) {
+void normalize_binary_tanh(
+    stream<data_T> &data,
+    stream<nnet::array<ac_int<1, false>, CONFIG_T::n_scale_bias>> &res,
+    const typename data_T::value_type threshold[CONFIG_T::n_scale_bias]
+) {
 
 BinaryNormLoop:
     #pragma ii 1
@@ -72,9 +80,12 @@ void normalize_binary_tanh(stream<data_T> &data, stream<nnet::array<ac_int<1, fa
 }
 
 template <class data_T, typename CONFIG_T>
-void normalize_ternary_tanh(stream<data_T> &data, stream<nnet::array<ac_int<2, true>, CONFIG_T::n_scale_bias>> &res,
-                            const typename data_T::value_type threshold_hi[CONFIG_T::n_scale_bias],
-                            const typename data_T::value_type threshold_lo[CONFIG_T::n_scale_bias]) {
+void normalize_ternary_tanh(
+    stream<data_T> &data,
+    stream<nnet::array<ac_int<2, true>, CONFIG_T::n_scale_bias>> &res,
+    const typename data_T::value_type threshold_hi[CONFIG_T::n_scale_bias],
+    const typename data_T::value_type threshold_lo[CONFIG_T::n_scale_bias]
+) {
 
 TernaryNormLoop:
     #pragma ii 1
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv1d.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv1d.h
index 005b84217..5ec2ee05e 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv1d.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv1d.h
@@ -44,17 +44,22 @@ struct conv1d_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan], res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                const typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_1d_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    const typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     conv_1d_resource_cl<data_T, res_T, CONFIG_T>(data, res, weights, biases);
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_1d_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                          res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                          const typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                          const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_1d_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    const typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::filt_width == 1);
     pointwise_conv_1d_resource_cl<data_T, res_T, CONFIG_T>(data, res, weights, biases);
 }
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv1d_resource.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv1d_resource.h
index fa213ca17..6a88baf02 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv1d_resource.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv1d_resource.h
@@ -14,8 +14,11 @@ enum class conv1d_implementation { combination, im2col, winograd };
 // ****************************************************************
 
 template <class data_T, typename CONFIG_T>
-void im2col_1d_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                  data_T data_col[CONFIG_T::impl_filt_width * CONFIG_T::n_chan], const int col) {
+void im2col_1d_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    data_T data_col[CONFIG_T::impl_filt_width * CONFIG_T::n_chan],
+    const int col
+) {
     // im2col can be unrolled fully, since number of parallel executions = filt_w x n_chann ~ O(100) and very little DSP
     // usage
 
@@ -40,9 +43,11 @@ void im2col_1d_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
 
 template <class data_T, class res_T, typename CONFIG_T>
 void conv_1d_im2col_cl(
-    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan], res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
     const typename CONFIG_T::weight_t weights[CONFIG_T::impl_filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     // im2col performs no filter transformations; therefore, filter size remains constant
     assert(CONFIG_T::filt_width == CONFIG_T::impl_filt_width);
 
@@ -89,9 +94,11 @@ inline void winograd_transform_input_tile_3x1_kernel(const data_T I[4], res_T D[
 
 template <class data_T, class res_T, typename CONFIG_T>
 void winograd_conv1d_3x1_kernel_cl(
-    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan], res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
     const typename CONFIG_T::weight_t weights[CONFIG_T::impl_filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     // Ensure Winograd conditions are met
     assert(CONFIG_T::filt_width == 3);
     assert(CONFIG_T::stride_width == 1);
@@ -159,8 +166,9 @@ void winograd_conv1d_3x1_kernel_cl(
 // ****************************************************************
 
 template <class data_T, typename CONFIG_T>
-void im2col_1d_pointwise_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan], data_T data_col[CONFIG_T::n_chan],
-                            const int col) {
+void im2col_1d_pointwise_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan], data_T data_col[CONFIG_T::n_chan], const int col
+) {
     // pointwise_im2col can be unrolled fully, only one loop with n_chan iterations
 
     hls_register int index = 0;
@@ -178,10 +186,12 @@ void im2col_1d_pointwise_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_1d_resource_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                                   res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                                   const typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                                   const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_1d_resource_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    const typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::filt_width == 1);
 
     // Unroll factor for loop traversing input image, derived from parallelization_factor
@@ -217,9 +227,11 @@ void pointwise_conv_1d_resource_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_
 // ****************************************************************
 template <class data_T, class res_T, typename CONFIG_T>
 void conv_1d_resource_cl(
-    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan], res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
     const typename CONFIG_T::weight_t weights[CONFIG_T::impl_filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     static constexpr bool winograd_conditions =
         // Winograd's minimal filtering algorithm not applicable to stride != 1
         CONFIG_T::stride_width == 1 &&
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv1d_stream.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv1d_stream.h
index 4fbfafd24..056bf82e7 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv1d_stream.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv1d_stream.h
@@ -16,8 +16,10 @@ namespace nnet {
  * Values from shift_buffer are inserted into kernel_window, updating the values to be convolved
  */
 template <class data_T, typename CONFIG_T>
-void kernel_shift_1d(typename data_T::value_type shift_buffer[CONFIG_T::n_chan],
-                     typename data_T::value_type kernel_window[CONFIG_T::filt_width * CONFIG_T::n_chan]) {
+void kernel_shift_1d(
+    typename data_T::value_type shift_buffer[CONFIG_T::n_chan],
+    typename data_T::value_type kernel_window[CONFIG_T::filt_width * CONFIG_T::n_chan]
+) {
 /*
  * Manually shift kernel_window by one step to the left
  * Not possible to use nnet::shift_reg<T, N> as the kernel window is convolved with the kernel weights using dense matrix
@@ -59,7 +61,8 @@ void shift_line_buffer_1d(
     const data_T &in_elem,
     nnet::shift_reg<typename data_T::value_type, CONFIG_T::pad_left + CONFIG_T::in_width + CONFIG_T::pad_right>
         line_buffer[CONFIG_T::n_chan],
-    typename data_T::value_type shift_buffer[CONFIG_T::n_chan]) {
+    typename data_T::value_type shift_buffer[CONFIG_T::n_chan]
+) {
 // For every channel, insert the incoming pixel at end of the shift buffer
 UpdateBuffer:
     #pragma unroll
@@ -85,12 +88,14 @@ void shift_line_buffer_1d(
  */
 template <class data_T, class res_T, typename CONFIG_T>
 void compute_output_buffer_1d(
-    const data_T &in_elem, stream<res_T> &res_stream,
+    const data_T &in_elem,
+    stream<res_T> &res_stream,
     nnet::shift_reg<typename data_T::value_type, CONFIG_T::pad_left + CONFIG_T::in_width + CONFIG_T::pad_right>
         line_buffer[CONFIG_T::n_chan],
     typename data_T::value_type kernel_window[CONFIG_T::filt_width * CONFIG_T::n_chan],
     const typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     // Thresholds
     static constexpr int lShiftX = CONFIG_T::filt_width - 1;
 
@@ -112,7 +117,8 @@ void compute_output_buffer_1d(
         // Step 3 - Dense matrix multiplication
         hls_register typename res_T::value_type res_out[CONFIG_T::n_filt];
         dense_resource<typename data_T::value_type, typename res_T::value_type, typename CONFIG_T::mult_config>(
-            kernel_window, res_out, weights, biases);
+            kernel_window, res_out, weights, biases
+        );
 
         // Write result to output stream
         hls_register res_T res_pack;
@@ -136,13 +142,16 @@ void compute_output_buffer_1d(
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_cl(stream<data_T> &data, stream<res_T> &res,
-                const typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_1d_cl(
+    stream<data_T> &data,
+    stream<res_T> &res,
+    const typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     // Line buffer and kernel window
-    hls_register static nnet::shift_reg<typename data_T::value_type,
-                                        CONFIG_T::pad_left + CONFIG_T::in_width + CONFIG_T::pad_right>
-        line_buffer[CONFIG_T::n_chan];
+    hls_register static nnet::
+        shift_reg<typename data_T::value_type, CONFIG_T::pad_left + CONFIG_T::in_width + CONFIG_T::pad_right>
+            line_buffer[CONFIG_T::n_chan];
     hls_register static typename data_T::value_type kernel_window[CONFIG_T::filt_width * CONFIG_T::n_chan];
 
     // An array of length CONFIG_T::n_chan, with elements set to zero (padding for each channel)
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv2d.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv2d.h
index 55b635908..95fe1de03 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv2d.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv2d.h
@@ -50,19 +50,23 @@ struct conv2d_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
-                res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
-                const typename CONFIG_T::weight_t
-                    weights[CONFIG_T::impl_filt_height * CONFIG_T::impl_filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_2d_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
+    const typename CONFIG_T::weight_t
+        weights[CONFIG_T::impl_filt_height * CONFIG_T::impl_filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     conv_2d_resource_cl<data_T, res_T, CONFIG_T>(data, res, weights, biases);
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
-                          res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
-                          const typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                          const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_2d_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
+    const typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::filt_height == 1 && CONFIG_T::filt_width == 1);
     pointwise_conv_2d_resource_cl<data_T, res_T, CONFIG_T>(data, res, weights, biases);
 }
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv2d_resource.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv2d_resource.h
index 9dbbd9242..55737cc70 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv2d_resource.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv2d_resource.h
@@ -17,9 +17,12 @@ enum class conv2d_implementation { combination, im2col, winograd };
 // ****************************************************************
 
 template <class data_T, typename CONFIG_T>
-void im2col_2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
-                  data_T data_col[CONFIG_T::impl_filt_height * CONFIG_T::impl_filt_width * CONFIG_T::n_chan], const int row,
-                  const int col) {
+void im2col_2d_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
+    data_T data_col[CONFIG_T::impl_filt_height * CONFIG_T::impl_filt_width * CONFIG_T::n_chan],
+    const int row,
+    const int col
+) {
     // im2col can be unrolled fully, since number of parallel executions = filt_h x filt_w x n_chann ~ O(100) and very little
     // DSP usage
 
@@ -52,11 +55,13 @@ void im2col_2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_2d_im2col_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
-                       res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
-                       const typename CONFIG_T::weight_t weights[CONFIG_T::impl_filt_height * CONFIG_T::impl_filt_width *
-                                                                 CONFIG_T::n_chan * CONFIG_T::n_filt],
-                       const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_2d_im2col_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
+    const typename CONFIG_T::weight_t
+        weights[CONFIG_T::impl_filt_height * CONFIG_T::impl_filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     // im2col performs no filter transformations; therefore, filter size remains constant
     assert(CONFIG_T::filt_height == CONFIG_T::impl_filt_height && CONFIG_T::filt_width == CONFIG_T::impl_filt_width);
 
@@ -128,7 +133,8 @@ void winograd_conv2d_3x3_kernel_cl(
     res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
     const typename CONFIG_T::weight_t
         weights[CONFIG_T::n_filt * CONFIG_T::n_chan * CONFIG_T::impl_filt_height * CONFIG_T::impl_filt_width],
-    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     // Ensure Winograd conditions are met
     assert(CONFIG_T::filt_height == 3 && CONFIG_T::filt_width == 3);
     assert(CONFIG_T::stride_height == 1 && CONFIG_T::stride_width == 1);
@@ -214,8 +220,12 @@ void winograd_conv2d_3x3_kernel_cl(
 // ****************************************************************
 
 template <class data_T, typename CONFIG_T>
-void im2col_2d_pointwise_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
-                            data_T data_col[CONFIG_T::n_chan], const int row, const int col) {
+void im2col_2d_pointwise_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
+    data_T data_col[CONFIG_T::n_chan],
+    const int row,
+    const int col
+) {
     // pointwise_im2col can be unrolled fully, only one loop with n_chan iterations
 
     hls_register int index = 0;
@@ -237,10 +247,12 @@ void im2col_2d_pointwise_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_2d_resource_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
-                                   res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
-                                   const typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                                   const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_2d_resource_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
+    const typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::filt_height == 1 && CONFIG_T::filt_width == 1);
 
     // Unroll factors for loop traversing input image, derived from parallelization_factor
@@ -278,11 +290,13 @@ void pointwise_conv_2d_resource_cl(data_T data[CONFIG_T::in_height * CONFIG_T::i
 //      Top-level function - handles different implementations
 // ****************************************************************
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_2d_resource_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
-                         res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
-                         const typename CONFIG_T::weight_t weights[CONFIG_T::impl_filt_height * CONFIG_T::impl_filt_width *
-                                                                   CONFIG_T::n_chan * CONFIG_T::n_filt],
-                         const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_2d_resource_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
+    const typename CONFIG_T::weight_t
+        weights[CONFIG_T::impl_filt_height * CONFIG_T::impl_filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     static constexpr bool winograd_conditions =
         // Winograd's minimal filtering algorithm not applicable to stride != 1
         CONFIG_T::stride_height == 1 && CONFIG_T::stride_width == 1 &&
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv2d_stream.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv2d_stream.h
index c594da7e3..61e258428 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv2d_stream.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_conv2d_stream.h
@@ -18,7 +18,8 @@ namespace nnet {
 template <class data_T, typename CONFIG_T>
 void kernel_shift_2d(
     typename data_T::value_type shift_buffer[CONFIG_T::filt_height][CONFIG_T::n_chan],
-    typename data_T::value_type kernel_window[CONFIG_T::filt_width * CONFIG_T::filt_height * CONFIG_T::n_chan]) {
+    typename data_T::value_type kernel_window[CONFIG_T::filt_width * CONFIG_T::filt_height * CONFIG_T::n_chan]
+) {
 /*
  * Manually shift kernel_window by one step to the left
  * Not possible to use nnet::shift_reg<T, N> as the kernel window is convolved with the kernel weights using dense matrix
@@ -48,8 +49,9 @@ void kernel_shift_2d(
     KernelPushChannel:
         #pragma unroll
         for (int channel = 0; channel < CONFIG_T::n_chan; channel++) {
-            kernel_window[(CONFIG_T::filt_width - 1) * CONFIG_T::n_chan + col * CONFIG_T::filt_width * CONFIG_T::n_chan +
-                          channel] = shift_buffer[col][channel];
+            kernel_window
+                [(CONFIG_T::filt_width - 1) * CONFIG_T::n_chan + col * CONFIG_T::filt_width * CONFIG_T::n_chan + channel] =
+                    shift_buffer[col][channel];
         }
     }
 }
@@ -70,7 +72,8 @@ void shift_line_buffer_2d(
     const data_T &in_elem,
     nnet::shift_reg<typename data_T::value_type, CONFIG_T::pad_left + CONFIG_T::in_width + CONFIG_T::pad_right>
         line_buffer[MAX(CONFIG_T::filt_height - 1, 1)][CONFIG_T::n_chan],
-    typename data_T::value_type shift_buffer[CONFIG_T::filt_height][CONFIG_T::n_chan]) {
+    typename data_T::value_type shift_buffer[CONFIG_T::filt_height][CONFIG_T::n_chan]
+) {
 // For every channel, insert the incoming pixel at end of the shift buffer
 UpdateBuffer:
     #pragma unroll
@@ -112,12 +115,14 @@ void shift_line_buffer_2d(
  */
 template <class data_T, class res_T, typename CONFIG_T>
 void compute_output_buffer_2d(
-    const data_T &in_elem, stream<res_T> &res_stream,
+    const data_T &in_elem,
+    stream<res_T> &res_stream,
     nnet::shift_reg<typename data_T::value_type, CONFIG_T::pad_left + CONFIG_T::in_width + CONFIG_T::pad_right>
         line_buffer[MAX(CONFIG_T::filt_height - 1, 1)][CONFIG_T::n_chan],
     typename data_T::value_type kernel_window[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan],
     const typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     // Thresholds
     static constexpr int lShiftX = CONFIG_T::filt_width - 1;
     static constexpr int lShiftY = CONFIG_T::filt_height - 1;
@@ -142,7 +147,8 @@ void compute_output_buffer_2d(
         // Step 3 - Dense matrix multiplication
         hls_register typename res_T::value_type res_out[CONFIG_T::n_filt];
         dense_resource<typename data_T::value_type, typename res_T::value_type, typename CONFIG_T::mult_config>(
-            kernel_window, res_out, weights, biases);
+            kernel_window, res_out, weights, biases
+        );
 
         // Write result to output stream
         hls_register res_T res_pack;
@@ -175,15 +181,18 @@ void compute_output_buffer_2d(
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_2d_cl(stream<data_T> &data, stream<res_T> &res,
-                const typename CONFIG_T::weight_t
-                    weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_2d_cl(
+    stream<data_T> &data,
+    stream<res_T> &res,
+    const typename CONFIG_T::weight_t
+        weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
 
     // Line buffer and kernel window
-    hls_register static nnet::shift_reg<typename data_T::value_type,
-                                        CONFIG_T::pad_left + CONFIG_T::in_width + CONFIG_T::pad_right>
-        line_buffer[MAX(CONFIG_T::filt_height - 1, 1)][CONFIG_T::n_chan];
+    hls_register static nnet::
+        shift_reg<typename data_T::value_type, CONFIG_T::pad_left + CONFIG_T::in_width + CONFIG_T::pad_right>
+            line_buffer[MAX(CONFIG_T::filt_height - 1, 1)][CONFIG_T::n_chan];
     hls_register static
         typename data_T::value_type kernel_window[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan];
 
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_dense.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_dense.h
index aba080398..53b410da9 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_dense.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_dense.h
@@ -36,11 +36,16 @@ struct dense_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_rf_gt(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                 const typename CONFIG_T::weight_t weights[CONFIG_T::reuse_factor_rounded * CONFIG_T::block_factor_rounded],
-                 const typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
-    assert((CONFIG_T::multiplier_limit % CONFIG_T::n_out == 0 || CONFIG_T::reuse_factor >= CONFIG_T::n_in) &&
-           "The current Reuse Factor is not allowed");
+void dense_rf_gt(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t weights[CONFIG_T::reuse_factor_rounded * CONFIG_T::block_factor_rounded],
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
+    assert(
+        (CONFIG_T::multiplier_limit % CONFIG_T::n_out == 0 || CONFIG_T::reuse_factor >= CONFIG_T::n_in) &&
+        "The current Reuse Factor is not allowed"
+    );
     assert((CONFIG_T::reuse_factor > CONFIG_T::n_in) && "This function is correct only for RF > N_IN");
     //#pragma ii CONFIG_T::reuse_factor
     hls_register typename CONFIG_T::accum_t acc[CONFIG_T::n_out];
@@ -104,11 +109,16 @@ void dense_rf_gt(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
     }
 }
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_rf_lt(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                 const typename CONFIG_T::weight_t weights[CONFIG_T::reuse_factor_rounded * CONFIG_T::block_factor_rounded],
-                 const typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
-    assert((CONFIG_T::multiplier_limit % CONFIG_T::n_out == 0 || CONFIG_T::reuse_factor >= CONFIG_T::n_in) &&
-           "The current Reuse Factor is not allowed");
+void dense_rf_lt(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t weights[CONFIG_T::reuse_factor_rounded * CONFIG_T::block_factor_rounded],
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
+    assert(
+        (CONFIG_T::multiplier_limit % CONFIG_T::n_out == 0 || CONFIG_T::reuse_factor >= CONFIG_T::n_in) &&
+        "The current Reuse Factor is not allowed"
+    );
     assert((CONFIG_T::multiplier_limit == CONFIG_T::block_factor) && "This function is correct only for RF <= N_IN");
 
     hls_register typename CONFIG_T::accum_t acc[CONFIG_T::n_out];
@@ -156,9 +166,11 @@ void dense_rf_lt(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
 }
 template <class data_T, class res_T, typename CONFIG_T>
 void dense_resource(
-    data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
     const typename CONFIG_T::weight_t weights[CONFIG_T::reuse_factor_rounded * CONFIG_T::block_factor_rounded],
-    const typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
     if (CONFIG_T::reuse_factor <= CONFIG_T::n_in) {
         dense_rf_lt<data_T, res_T, CONFIG_T>(data, res, weights, biases);
     } else {
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_dense_compressed.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_dense_compressed.h
index 5619e299f..59c793bde 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_dense_compressed.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_dense_compressed.h
@@ -7,9 +7,12 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_compressed(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                      const typename CONFIG_T::weight_t weights[CONFIG_T::n_nonzeros],
-                      const typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense_compressed(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t weights[CONFIG_T::n_nonzeros],
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
 
     hls_register typename CONFIG_T::accum_t acc[CONFIG_T::n_out];
 
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_dense_stream.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_dense_stream.h
index 5a9b38553..ba80c4a65 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_dense_stream.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_dense_stream.h
@@ -8,9 +8,12 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_resource(stream<data_T> &data_stream, stream<res_T> &res_stream,
-                    const typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-                    const typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense_resource(
+    stream<data_T> &data_stream,
+    stream<res_T> &res_stream,
+    const typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    const typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
     hls_register typename data_T::value_type data[CONFIG_T::n_in];
     hls_register typename res_T::value_type res[CONFIG_T::n_out];
 
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_embed.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_embed.h
index 5191239b6..31dc29f47 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_embed.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_embed.h
@@ -21,8 +21,11 @@ struct embed_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void embedding(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_in * CONFIG_T::n_out],
-               const typename CONFIG_T::embeddings_t embeddings[CONFIG_T::vocab_size * CONFIG_T::n_out]) {
+void embedding(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_in * CONFIG_T::n_out],
+    const typename CONFIG_T::embeddings_t embeddings[CONFIG_T::vocab_size * CONFIG_T::n_out]
+) {
 
     /*
      * Can store embeddings[] in a register, but a large multiiplexer
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_embed_stream.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_embed_stream.h
index 51e54e991..94ae72e7f 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_embed_stream.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_embed_stream.h
@@ -4,8 +4,11 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void embedding(stream<data_T> &data, stream<res_T> &res,
-               const typename CONFIG_T::embeddings_t embeddings[CONFIG_T::vocab_size * CONFIG_T::n_out]) {
+void embedding(
+    stream<data_T> &data,
+    stream<res_T> &res,
+    const typename CONFIG_T::embeddings_t embeddings[CONFIG_T::vocab_size * CONFIG_T::n_out]
+) {
     data_T in_data = data.read();
 
 InputSequence:
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_merge.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_merge.h
index 1ee9a9f56..688d702c3 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_merge.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_merge.h
@@ -102,8 +102,11 @@ void dot1d(input1_T data1[CONFIG_T::n_in], input2_T data2[CONFIG_T::n_in], res_T
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate1d(input1_T data1[CONFIG_T::n_elem1_0], input2_T data2[CONFIG_T::n_elem2_0],
-                   res_T res[CONFIG_T::n_elem1_0 + CONFIG_T::n_elem2_0]) {
+void concatenate1d(
+    input1_T data1[CONFIG_T::n_elem1_0],
+    input2_T data2[CONFIG_T::n_elem2_0],
+    res_T res[CONFIG_T::n_elem1_0 + CONFIG_T::n_elem2_0]
+) {
     #pragma unroll
     for (int i = 0; i < CONFIG_T::n_elem1_0; i++) {
         res[i] = static_cast<res_T>(data1[i]);
@@ -116,9 +119,11 @@ void concatenate1d(input1_T data1[CONFIG_T::n_elem1_0], input2_T data2[CONFIG_T:
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate2d_0(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
-                     input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1],
-                     res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 + CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1]) {
+void concatenate2d_0(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1],
+    res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 + CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1]
+) {
     #pragma unroll
     for (int i = 0; i < CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1; i++) {
         res[i] = static_cast<res_T>(data1[i]);
@@ -131,9 +136,11 @@ void concatenate2d_0(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate2d_1(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
-                     input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1],
-                     res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 + CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1]) {
+void concatenate2d_1(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1],
+    res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 + CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1]
+) {
     for (int i = 0; i < CONFIG_T::n_elem1_0; i++) {
         #pragma unroll
         for (int j = 0; j < CONFIG_T::n_elem1_1; j++) {
@@ -150,9 +157,11 @@ void concatenate2d_1(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate2d(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
-                   input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1],
-                   res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 + CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1]) {
+void concatenate2d(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1],
+    res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 + CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1]
+) {
     if (CONFIG_T::axis == 2 || CONFIG_T::axis == -1) {
         concatenate2d_1<input1_T, input2_T, res_T, CONFIG_T>(data1, data2, res);
     } else {
@@ -161,10 +170,13 @@ void concatenate2d(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate3d_0(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
-                     input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
-                     res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
-                               CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]) {
+void concatenate3d_0(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
+    res_T
+        res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
+            CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]
+) {
     #pragma unroll
     for (int i = 0; i < CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2; i++) {
         res[i] = static_cast<res_T>(data1[i]);
@@ -177,10 +189,13 @@ void concatenate3d_0(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 *
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate3d_1(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
-                     input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
-                     res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
-                               CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]) {
+void concatenate3d_1(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
+    res_T
+        res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
+            CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]
+) {
     for (int i = 0; i < CONFIG_T::n_elem1_0; i++) {
         for (int j = 0; j < CONFIG_T::n_elem1_1; j++) {
             #pragma unroll
@@ -205,10 +220,13 @@ void concatenate3d_1(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 *
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate3d_2(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
-                     input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
-                     res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
-                               CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]) {
+void concatenate3d_2(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
+    res_T
+        res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
+            CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]
+) {
     for (int i = 0; i < CONFIG_T::n_elem1_0; i++) {
         for (int j = 0; j < CONFIG_T::n_elem1_1; j++) {
 
@@ -232,10 +250,13 @@ void concatenate3d_2(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 *
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate3d(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
-                   input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
-                   res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
-                             CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]) {
+void concatenate3d(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
+    res_T
+        res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
+            CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]
+) {
     if (CONFIG_T::axis == 3 || CONFIG_T::axis == -1) {
         concatenate3d_2<input1_T, input2_T, res_T, CONFIG_T>(data1, data2, res);
     } else if (CONFIG_T::axis == 2 || CONFIG_T::axis == -2) {
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_merge_stream.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_merge_stream.h
index 428d3236a..47077e443 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_merge_stream.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_merge_stream.h
@@ -107,8 +107,9 @@ void maximum(stream<input1_T> &data1, stream<input2_T> &data2, stream<res_T> &re
     MaxPack:
         #pragma unroll
         for (int j = 0; j < res_T::size; j++) {
-            out_data[j] = static_cast<typename res_T::value_type>(out_data[j] = (in_data1[j] > in_data2[j]) ? in_data1[j]
-                                                                                                            : in_data2[j]);
+            out_data[j] = static_cast<typename res_T::value_type>(
+                out_data[j] = (in_data1[j] > in_data2[j]) ? in_data1[j] : in_data2[j]
+            );
         }
 
         res.write(out_data);
@@ -130,8 +131,9 @@ void minimum(stream<input1_T> &data1, stream<input2_T> &data2, stream<res_T> &re
     MinPack:
         #pragma unroll
         for (int j = 0; j < res_T::size; j++) {
-            out_data[j] = static_cast<typename res_T::value_type>(out_data[j] = (in_data1[j] < in_data2[j]) ? in_data1[j]
-                                                                                                            : in_data2[j]);
+            out_data[j] = static_cast<typename res_T::value_type>(
+                out_data[j] = (in_data1[j] < in_data2[j]) ? in_data1[j] : in_data2[j]
+            );
         }
 
         res.write(out_data);
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_mult.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_mult.h
index 5be772832..65b61d291 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_mult.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_mult.h
@@ -87,17 +87,17 @@ template <class x_T, class w_T> class weight_exponential : public Product {
 
 // TO-DO: These may need extra variants if ac_int types are used in more places
 template <class data_T, class res_T, typename CONFIG_T>
-inline typename std::enable_if<std::is_same<data_T, ac_int<1, false>>::value &&
-                                   std::is_same<typename CONFIG_T::weight_t, ac_int<1, false>>::value,
-                               ac_int<nnet::ceillog2(CONFIG_T::n_in) + 2, true>>::type
+inline typename std::enable_if<
+    std::is_same<data_T, ac_int<1, false>>::value && std::is_same<typename CONFIG_T::weight_t, ac_int<1, false>>::value,
+    ac_int<nnet::ceillog2(CONFIG_T::n_in) + 2, true>>::type
 cast(typename CONFIG_T::accum_t x) {
     return static_cast<ac_int<nnet::ceillog2(CONFIG_T::n_in) + 2, true>>(((x - CONFIG_T::n_in / 2) * 2).to_ac_int());
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-inline typename std::enable_if<std::is_same<data_T, ac_int<1, false>>::value &&
-                                   !std::is_same<typename CONFIG_T::weight_t, ac_int<1, false>>::value,
-                               res_T>::type
+inline typename std::enable_if<
+    std::is_same<data_T, ac_int<1, false>>::value && !std::is_same<typename CONFIG_T::weight_t, ac_int<1, false>>::value,
+    res_T>::type
 cast(typename CONFIG_T::accum_t x) {
     return static_cast<res_T>(x);
 }
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_padding.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_padding.h
index a95f9ab00..b0f7a1da1 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_padding.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_padding.h
@@ -52,8 +52,10 @@ struct padding2d_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void zeropad2d_cl(data_T data[CONFIG_T::n_chan * CONFIG_T::in_height * CONFIG_T::in_width],
-                  res_T res[CONFIG_T::n_chan * CONFIG_T::out_height * CONFIG_T::out_width]) {
+void zeropad2d_cl(
+    data_T data[CONFIG_T::n_chan * CONFIG_T::in_height * CONFIG_T::in_width],
+    res_T res[CONFIG_T::n_chan * CONFIG_T::out_height * CONFIG_T::out_width]
+) {
     for (int i = 0; i < CONFIG_T::pad_top; i++) {
         for (int j = 0; j < CONFIG_T::out_width; j++) {
             #pragma unroll
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_pooling.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_pooling.h
index 6bc254db9..bf1585f46 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_pooling.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_pooling.h
@@ -217,8 +217,10 @@ struct pooling2d_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pooling2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt],
-                  res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt]) {
+void pooling2d_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt],
+    res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt]
+) {
     // Add padding and reduce input width to area covered by pooling function
     static constexpr int full_padded_width = CONFIG_T::in_width + CONFIG_T::pad_left + CONFIG_T::pad_right;
     static constexpr int full_padded_height = CONFIG_T::in_height + CONFIG_T::pad_top + CONFIG_T::pad_bottom;
@@ -260,9 +262,9 @@ void pooling2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_
                                 img_overlap++;
                         } else {
                             // Current element is from input image
-                            pool[pool_col * CONFIG_T::stride_width + pool_row] =
-                                data[(inp_col + pool_col - CONFIG_T::pad_top) * CONFIG_T::in_width * CONFIG_T::n_filt +
-                                     (inp_width + pool_row - CONFIG_T::pad_left) * CONFIG_T::n_filt + filt];
+                            pool[pool_col * CONFIG_T::stride_width + pool_row] = data
+                                [(inp_col + pool_col - CONFIG_T::pad_top) * CONFIG_T::in_width * CONFIG_T::n_filt +
+                                 (inp_width + pool_row - CONFIG_T::pad_left) * CONFIG_T::n_filt + filt];
                             img_overlap++;
                         }
                     }
@@ -271,23 +273,24 @@ void pooling2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_
                 // Pooling operation
                 res[(inp_col / CONFIG_T::stride_height) * CONFIG_T::out_width * CONFIG_T::n_filt +
                     (inp_width / CONFIG_T::stride_width) * CONFIG_T::n_filt + filt] =
-                    static_cast<res_T>(
-                        pool_op<data_T, CONFIG_T::pool_height * CONFIG_T::pool_width, CONFIG_T::pool_op>(pool));
+                    static_cast<res_T>(pool_op<data_T, CONFIG_T::pool_height * CONFIG_T::pool_width, CONFIG_T::pool_op>(pool)
+                    );
 
                 // If the pool op is Average, the zero-padding needs to be removed from the results
                 if (CONFIG_T::pool_op == Average)
                     res[(inp_col / CONFIG_T::stride_height) * CONFIG_T::out_width * CONFIG_T::n_filt +
                         (inp_width / CONFIG_T::stride_width) * CONFIG_T::n_filt + filt] *=
-                        (static_cast<data_T>(CONFIG_T::pool_height) * static_cast<data_T>(CONFIG_T::pool_width) /
-                         img_overlap);
+                        (static_cast<data_T>(CONFIG_T::pool_height) * static_cast<data_T>(CONFIG_T::pool_width) / img_overlap
+                        );
             }
         }
     }
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void global_pooling2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt],
-                         res_T res[CONFIG_T::n_filt]) {
+void global_pooling2d_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt], res_T res[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
     assert(CONFIG_T::pad_top == 0 && CONFIG_T::pad_bottom == 0);
     assert(CONFIG_T::pool_width == CONFIG_T::stride_width);
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_pooling_stream.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_pooling_stream.h
index 2560072e5..e25c77c8b 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_pooling_stream.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_pooling_stream.h
@@ -24,9 +24,12 @@ namespace nnet {
  *
  */
 template <class data_T, class res_T, typename CONFIG_T>
-void compute_pool_buffer_1d(const data_T &in_elem, stream<res_T> &res_stream,
-                            nnet::shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[CONFIG_T::n_filt],
-                            typename data_T::value_type kernel_window[CONFIG_T::pool_width * CONFIG_T::n_filt]) {
+void compute_pool_buffer_1d(
+    const data_T &in_elem,
+    stream<res_T> &res_stream,
+    nnet::shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[CONFIG_T::n_filt],
+    typename data_T::value_type kernel_window[CONFIG_T::pool_width * CONFIG_T::n_filt]
+) {
     // Thresholds
     static constexpr int lShiftX = CONFIG_T::pool_width - 1;
 
@@ -61,7 +64,8 @@ void compute_pool_buffer_1d(const data_T &in_elem, stream<res_T> &res_stream,
 
             // Step 3 - Pooling
             res_pack[filter] = static_cast<typename res_T::value_type>(
-                pool_op<typename data_T::value_type, CONFIG_T::pool_width, CONFIG_T::pool_op>(pool_window));
+                pool_op<typename data_T::value_type, CONFIG_T::pool_width, CONFIG_T::pool_op>(pool_window)
+            );
         }
 
         // Write result to output stream
@@ -111,10 +115,12 @@ template <class data_T, class res_T, typename CONFIG_T> void pooling1d_cl(stream
  */
 template <class data_T, class res_T, typename CONFIG_T>
 void compute_pool_buffer_2d(
-    const data_T &in_elem, stream<res_T> &res_stream,
+    const data_T &in_elem,
+    stream<res_T> &res_stream,
     nnet::shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[CONFIG_T::pool_height - 1]
                                                                                 [CONFIG_T::n_filt],
-    typename data_T::value_type kernel_window[CONFIG_T::pool_height * CONFIG_T::pool_width * CONFIG_T::n_filt]) {
+    typename data_T::value_type kernel_window[CONFIG_T::pool_height * CONFIG_T::pool_width * CONFIG_T::n_filt]
+) {
     // Thresholds
     static constexpr int lShiftX = CONFIG_T::pool_width - 1;
     static constexpr int lShiftY = CONFIG_T::pool_height - 1;
@@ -153,7 +159,9 @@ void compute_pool_buffer_2d(
             // Step 3 - Pooling
             res_pack[filter] = static_cast<typename res_T::value_type>(
                 pool_op<typename data_T::value_type, CONFIG_T::pool_height * CONFIG_T::pool_width, CONFIG_T::pool_op>(
-                    pool_window));
+                    pool_window
+                )
+            );
         }
 
         // Write result to output stream
@@ -243,7 +251,8 @@ void compute_global_pool(const data_T &in_elem, typename CONFIG_T::accum_t data_
     #pragma unroll
     for (unsigned i = 0; i < CONFIG_T::n_filt; i++) {
         data_input[i] = reduce_global_pool<typename CONFIG_T::accum_t, typename data_T::value_type, CONFIG_T::pool_op>(
-            data_input[i], in_elem[i]);
+            data_input[i], in_elem[i]
+        );
     }
 }
 
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_recurrent.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_recurrent.h
index dbcf8e41a..81f6dca4e 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_recurrent.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_recurrent.h
@@ -97,23 +97,28 @@ struct gru_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void gru_cell(data_T x[CONFIG_T::n_in], res_T h[CONFIG_T::n_units],
-              const typename CONFIG_T::weight_t weights[3 * CONFIG_T::n_units * CONFIG_T::n_in],
-              const typename CONFIG_T::weight_t recurrent_weights[3 * CONFIG_T::n_units * CONFIG_T::n_units],
-              const typename CONFIG_T::bias_t bias[3 * CONFIG_T::n_units],
-              const typename CONFIG_T::bias_t recurrent_bias[3 * CONFIG_T::n_units]) {
+void gru_cell(
+    data_T x[CONFIG_T::n_in],
+    res_T h[CONFIG_T::n_units],
+    const typename CONFIG_T::weight_t weights[3 * CONFIG_T::n_units * CONFIG_T::n_in],
+    const typename CONFIG_T::weight_t recurrent_weights[3 * CONFIG_T::n_units * CONFIG_T::n_units],
+    const typename CONFIG_T::bias_t bias[3 * CONFIG_T::n_units],
+    const typename CONFIG_T::bias_t recurrent_bias[3 * CONFIG_T::n_units]
+) {
     static constexpr int recurrent_unroll_factor = CONFIG_T::n_units / CONFIG_T::reuse_factor;
     // A matrix containing the values of matrix product between input (x) and weights (weights), for update, reset and
     // candidate state gates, for each of the units
     hls_register typename CONFIG_T::accum_t mat_mul_x_w[3 * CONFIG_T::n_units];
-    nnet::dense_resource<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config_x>(x, mat_mul_x_w, weights,
-                                                                                               bias);
+    nnet::dense_resource<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config_x>(
+        x, mat_mul_x_w, weights, bias
+    );
 
     // A matrix containing the values of matrix product between previou state (h) and recurrent weights (recurrent_weights),
     // for update, reset and candidate state gates, for each of the units
     hls_register typename CONFIG_T::accum_t mat_mul_h_wr[3 * CONFIG_T::n_units];
     nnet::dense_resource<res_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config_h>(
-        h, mat_mul_h_wr, recurrent_weights, recurrent_bias);
+        h, mat_mul_h_wr, recurrent_weights, recurrent_bias
+    );
 
     // A vector containing both the values of z(t) and r(t) for every state
     hls_register typename CONFIG_T::accum_t z_r[2 * CONFIG_T::n_units];
@@ -127,8 +132,10 @@ void gru_cell(data_T x[CONFIG_T::n_in], res_T h[CONFIG_T::n_units],
 
     // Activation on z(t) and r(t)
     hls_register typename CONFIG_T::accum_t z_r_act[2 * CONFIG_T::n_units];
-    CONFIG_T::template activation_recr<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t,
-                                       typename CONFIG_T::ACT_CONFIG_RECURRENT_T>::activation(z_r, z_r_act);
+    CONFIG_T::template activation_recr<
+        typename CONFIG_T::accum_t,
+        typename CONFIG_T::accum_t,
+        typename CONFIG_T::ACT_CONFIG_RECURRENT_T>::activation(z_r, z_r_act);
 
     // A matrix containing the values of Hadamard product between r(t) = z_r_act[n_units:2*n_units] and h(t-1) = h
     hls_register typename CONFIG_T::accum_t hadamard_r_h[CONFIG_T::n_units];
@@ -150,26 +157,30 @@ void gru_cell(data_T x[CONFIG_T::n_in], res_T h[CONFIG_T::n_units],
 
     // Activation on candidate state
     hls_register typename CONFIG_T::accum_t h_cand_act[CONFIG_T::n_units];
-    CONFIG_T::template activation<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t,
-                                  typename CONFIG_T::ACT_CONFIG_T>::activation(h_cand, h_cand_act);
+    CONFIG_T::template activation<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t, typename CONFIG_T::ACT_CONFIG_T>::
+        activation(h_cand, h_cand_act);
 
     // Update state
     #pragma unroll recurrent_unroll_factor
     for (int i = 0; i < (CONFIG_T::n_units); i++) {
         if (CONFIG_T::pytorch_order)
-            h[i] = static_cast<res_T>(h_cand_act[i] * (1 - z_r_act[i + CONFIG_T::n_units]) +
-                                      h[i] * z_r_act[i + CONFIG_T::n_units]);
+            h[i] = static_cast<res_T>(
+                h_cand_act[i] * (1 - z_r_act[i + CONFIG_T::n_units]) + h[i] * z_r_act[i + CONFIG_T::n_units]
+            );
         else
             h[i] = static_cast<res_T>(h_cand_act[i] * (1 - z_r_act[i]) + h[i] * z_r_act[i]);
     }
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void gru(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_outputs * CONFIG_T::n_units],
-         const typename CONFIG_T::weight_t weights[3 * CONFIG_T::n_units * CONFIG_T::n_in],
-         const typename CONFIG_T::weight_t recurrent_weights[3 * CONFIG_T::n_units * CONFIG_T::n_units],
-         const typename CONFIG_T::bias_t bias[3 * CONFIG_T::n_units],
-         const typename CONFIG_T::bias_t recurrent_bias[3 * CONFIG_T::n_units]) {
+void gru(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_outputs * CONFIG_T::n_units],
+    const typename CONFIG_T::weight_t weights[3 * CONFIG_T::n_units * CONFIG_T::n_in],
+    const typename CONFIG_T::weight_t recurrent_weights[3 * CONFIG_T::n_units * CONFIG_T::n_units],
+    const typename CONFIG_T::bias_t bias[3 * CONFIG_T::n_units],
+    const typename CONFIG_T::bias_t recurrent_bias[3 * CONFIG_T::n_units]
+) {
 
     hls_register data_T x[CONFIG_T::n_in];
     hls_register res_T h[CONFIG_T::n_units];
@@ -235,25 +246,31 @@ struct simpleRNN_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void simple_rnn_cell(data_T inputs[CONFIG_T::n_in], res_T hidden_state[CONFIG_T::n_out],
-                     res_T hidden_state_o[CONFIG_T::n_out],
-                     const typename CONFIG_T::weight_t kernel[CONFIG_T::n_in * CONFIG_T::n_out],
-                     const typename CONFIG_T::weight_t rec_kernel[CONFIG_T::n_out * CONFIG_T::n_out],
-                     const typename CONFIG_T::bias_t bias[CONFIG_T::n_out]) {
+void simple_rnn_cell(
+    data_T inputs[CONFIG_T::n_in],
+    res_T hidden_state[CONFIG_T::n_out],
+    res_T hidden_state_o[CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t kernel[CONFIG_T::n_in * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t rec_kernel[CONFIG_T::n_out * CONFIG_T::n_out],
+    const typename CONFIG_T::bias_t bias[CONFIG_T::n_out]
+) {
     // Weight multiplication
     typename CONFIG_T::accum_t afterW[CONFIG_T::n_out] hls_register;
     multiply_W<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, CONFIG_T::n_in, CONFIG_T::n_out>(
-        inputs, afterW, kernel);
+        inputs, afterW, kernel
+    );
 
     // Bias addition
     typename CONFIG_T::accum_t afterBias[CONFIG_T::n_out] hls_register;
     add_bias<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t, typename CONFIG_T::bias_t, CONFIG_T::n_out>(
-        afterW, afterBias, bias);
+        afterW, afterBias, bias
+    );
 
     // Hidden state
     typename CONFIG_T::accum_t hiddenCand[CONFIG_T::n_out] hls_register;
-    multiply_U<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, CONFIG_T::n_out>(hidden_state, hiddenCand,
-                                                                                                 rec_kernel);
+    multiply_U<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, CONFIG_T::n_out>(
+        hidden_state, hiddenCand, rec_kernel
+    );
 
     // Vector addition
     typename CONFIG_T::accum_t afterAdd[CONFIG_T::n_out];
@@ -261,14 +278,18 @@ void simple_rnn_cell(data_T inputs[CONFIG_T::n_in], res_T hidden_state[CONFIG_T:
 
     // Activation
     CONFIG_T::template activation<typename CONFIG_T::accum_t, data_T, typename CONFIG_T::ACT_CONFIG_T>::activation(
-        afterAdd, hidden_state_o);
+        afterAdd, hidden_state_o
+    );
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void simple_rnn(data_T data[CONFIG_T::n_timesteps * CONFIG_T::n_in], res_T res[CONFIG_T::n_outputs * CONFIG_T::n_out],
-                const typename CONFIG_T::weight_t kernel[CONFIG_T::n_in * CONFIG_T::n_out],
-                const typename CONFIG_T::weight_t rec_kernel[CONFIG_T::n_out * CONFIG_T::n_out],
-                const typename CONFIG_T::bias_t bias[CONFIG_T::n_out]) {
+void simple_rnn(
+    data_T data[CONFIG_T::n_timesteps * CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_outputs * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t kernel[CONFIG_T::n_in * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t rec_kernel[CONFIG_T::n_out * CONFIG_T::n_out],
+    const typename CONFIG_T::bias_t bias[CONFIG_T::n_out]
+) {
     res_T hidden_state[CONFIG_T::n_out][CONFIG_T::n_timesteps + 1] hls_register;
     res_T hidden_state_temp[CONFIG_T::n_out] hls_register;
     res_T h[CONFIG_T::n_out] hls_register;
@@ -352,31 +373,38 @@ struct simpleRNN_pytorch_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void simple_rnn_pytorch_cell(data_T inputs[CONFIG_T::n_in], res_T hidden_state[CONFIG_T::n_out],
-                             res_T hidden_state_o[CONFIG_T::n_out],
-                             const typename CONFIG_T::weight_t kernel[CONFIG_T::n_in * CONFIG_T::n_out],
-                             const typename CONFIG_T::weight_t rec_kernel[CONFIG_T::n_out * CONFIG_T::n_out],
-                             const typename CONFIG_T::bias_t bias[CONFIG_T::n_out],
-                             const typename CONFIG_T::bias_t rec_bias[CONFIG_T::n_out]) {
+void simple_rnn_pytorch_cell(
+    data_T inputs[CONFIG_T::n_in],
+    res_T hidden_state[CONFIG_T::n_out],
+    res_T hidden_state_o[CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t kernel[CONFIG_T::n_in * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t rec_kernel[CONFIG_T::n_out * CONFIG_T::n_out],
+    const typename CONFIG_T::bias_t bias[CONFIG_T::n_out],
+    const typename CONFIG_T::bias_t rec_bias[CONFIG_T::n_out]
+) {
     // Weight multiplication
     typename CONFIG_T::accum_t afterW[CONFIG_T::n_out] hls_register;
     multiply_W<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, CONFIG_T::n_in, CONFIG_T::n_out>(
-        inputs, afterW, kernel);
+        inputs, afterW, kernel
+    );
 
     // Bias addition
     typename CONFIG_T::accum_t afterBias[CONFIG_T::n_out] hls_register;
     add_bias<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t, typename CONFIG_T::bias_t, CONFIG_T::n_out>(
-        afterW, afterBias, bias);
+        afterW, afterBias, bias
+    );
 
     // Hidden state
     typename CONFIG_T::accum_t hiddenCand[CONFIG_T::n_out] hls_register;
-    multiply_U<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, CONFIG_T::n_out>(hidden_state, hiddenCand,
-                                                                                                 rec_kernel);
+    multiply_U<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, CONFIG_T::n_out>(
+        hidden_state, hiddenCand, rec_kernel
+    );
 
     // Hidden state bias addition
     typename CONFIG_T::accum_t hiddenBias[CONFIG_T::n_out] hls_register;
     add_bias<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t, typename CONFIG_T::bias_t, CONFIG_T::n_out>(
-        hiddenCand, hiddenBias, rec_bias);
+        hiddenCand, hiddenBias, rec_bias
+    );
 
     // Vector addition
     typename CONFIG_T::accum_t afterAdd[CONFIG_T::n_out];
@@ -384,16 +412,19 @@ void simple_rnn_pytorch_cell(data_T inputs[CONFIG_T::n_in], res_T hidden_state[C
 
     // Activation
     CONFIG_T::template activation<typename CONFIG_T::accum_t, data_T, typename CONFIG_T::ACT_CONFIG_T>::activation(
-        afterAdd, hidden_state_o);
+        afterAdd, hidden_state_o
+    );
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void simple_rnn_pytorch(data_T data[CONFIG_T::n_timesteps * CONFIG_T::n_in],
-                        res_T res[CONFIG_T::n_outputs * CONFIG_T::n_out],
-                        const typename CONFIG_T::weight_t kernel[CONFIG_T::n_in * CONFIG_T::n_out],
-                        const typename CONFIG_T::weight_t rec_kernel[CONFIG_T::n_out * CONFIG_T::n_out],
-                        const typename CONFIG_T::bias_t bias[CONFIG_T::n_out],
-                        const typename CONFIG_T::bias_t rec_bias[CONFIG_T::n_out]) {
+void simple_rnn_pytorch(
+    data_T data[CONFIG_T::n_timesteps * CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_outputs * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t kernel[CONFIG_T::n_in * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t rec_kernel[CONFIG_T::n_out * CONFIG_T::n_out],
+    const typename CONFIG_T::bias_t bias[CONFIG_T::n_out],
+    const typename CONFIG_T::bias_t rec_bias[CONFIG_T::n_out]
+) {
     res_T hidden_state[CONFIG_T::n_out][CONFIG_T::n_timesteps + 1] hls_register;
     res_T hidden_state_temp[CONFIG_T::n_out] hls_register;
     res_T h[CONFIG_T::n_out] hls_register;
@@ -479,18 +510,25 @@ struct lstm_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void lstm_cell(data_T inputs[CONFIG_T::n_in], res_T hidden_state[CONFIG_T::n_out], res_T hidden_state_o[CONFIG_T::n_out],
-               res_T cell_state[CONFIG_T::n_out], res_T cell_state_o[CONFIG_T::n_out],
-               const typename CONFIG_T::weight_t WI[CONFIG_T::n_in * CONFIG_T::n_out],
-               const typename CONFIG_T::weight_t WF[CONFIG_T::n_in * CONFIG_T::n_out],
-               const typename CONFIG_T::weight_t WC[CONFIG_T::n_in * CONFIG_T::n_out],
-               const typename CONFIG_T::weight_t WO[CONFIG_T::n_in * CONFIG_T::n_out],
-               const typename CONFIG_T::weight_t RWI[CONFIG_T::n_out * CONFIG_T::n_out],
-               const typename CONFIG_T::weight_t RWF[CONFIG_T::n_out * CONFIG_T::n_out],
-               const typename CONFIG_T::weight_t RWC[CONFIG_T::n_out * CONFIG_T::n_out],
-               const typename CONFIG_T::weight_t RWO[CONFIG_T::n_out * CONFIG_T::n_out],
-               const typename CONFIG_T::bias_t BI[CONFIG_T::n_out], const typename CONFIG_T::bias_t BF[CONFIG_T::n_out],
-               const typename CONFIG_T::bias_t BC[CONFIG_T::n_out], const typename CONFIG_T::bias_t BO[CONFIG_T::n_out]) {
+void lstm_cell(
+    data_T inputs[CONFIG_T::n_in],
+    res_T hidden_state[CONFIG_T::n_out],
+    res_T hidden_state_o[CONFIG_T::n_out],
+    res_T cell_state[CONFIG_T::n_out],
+    res_T cell_state_o[CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t WI[CONFIG_T::n_in * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t WF[CONFIG_T::n_in * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t WC[CONFIG_T::n_in * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t WO[CONFIG_T::n_in * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t RWI[CONFIG_T::n_out * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t RWF[CONFIG_T::n_out * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t RWC[CONFIG_T::n_out * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t RWO[CONFIG_T::n_out * CONFIG_T::n_out],
+    const typename CONFIG_T::bias_t BI[CONFIG_T::n_out],
+    const typename CONFIG_T::bias_t BF[CONFIG_T::n_out],
+    const typename CONFIG_T::bias_t BC[CONFIG_T::n_out],
+    const typename CONFIG_T::bias_t BO[CONFIG_T::n_out]
+) {
 
     // Internals definitions
     typename CONFIG_T::accum_t i_afterW[CONFIG_T::n_out] hls_register;
@@ -530,65 +568,83 @@ void lstm_cell(data_T inputs[CONFIG_T::n_in], res_T hidden_state[CONFIG_T::n_out
     //-----------Gate I Calculations
     // Weight multiplication
     multiply_W<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, CONFIG_T::n_in, CONFIG_T::n_out>(
-        inputs, i_afterW, WI);
+        inputs, i_afterW, WI
+    );
 
     // Bias addition
     add_bias<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t, typename CONFIG_T::bias_t, CONFIG_T::n_out>(
-        i_afterW, i_afterBias, BI);
+        i_afterW, i_afterBias, BI
+    );
 
     // Hidden Candidate
-    multiply_U<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, CONFIG_T::n_out>(hidden_state, i_hiddenCand,
-                                                                                                 RWI);
+    multiply_U<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, CONFIG_T::n_out>(
+        hidden_state, i_hiddenCand, RWI
+    );
 
     // Vector addition
-    add_vectors<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t, CONFIG_T::n_out>(i_afterBias, i_hiddenCand,
-                                                                                         i_afterAdd);
+    add_vectors<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t, CONFIG_T::n_out>(
+        i_afterBias, i_hiddenCand, i_afterAdd
+    );
 
     // Activation
-    CONFIG_T::template activation_recr<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t,
-                                       typename CONFIG_T::ACT_CONFIG_RECURRENT_T>::activation(i_afterAdd, gate_i);
+    CONFIG_T::template activation_recr<
+        typename CONFIG_T::accum_t,
+        typename CONFIG_T::accum_t,
+        typename CONFIG_T::ACT_CONFIG_RECURRENT_T>::activation(i_afterAdd, gate_i);
 
     //-----------Gate F Calculations
     // Weight multiplication
     multiply_W<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, CONFIG_T::n_in, CONFIG_T::n_out>(
-        inputs, f_afterW, WF);
+        inputs, f_afterW, WF
+    );
 
     // Bias addition
     add_bias<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t, typename CONFIG_T::bias_t, CONFIG_T::n_out>(
-        f_afterW, f_afterBias, BF);
+        f_afterW, f_afterBias, BF
+    );
 
     // Hidden Candidate
-    multiply_U<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, CONFIG_T::n_out>(hidden_state, f_hiddenCand,
-                                                                                                 RWF);
+    multiply_U<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, CONFIG_T::n_out>(
+        hidden_state, f_hiddenCand, RWF
+    );
 
     // Vector addition
-    add_vectors<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t, CONFIG_T::n_out>(f_afterBias, f_hiddenCand,
-                                                                                         f_afterAdd);
+    add_vectors<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t, CONFIG_T::n_out>(
+        f_afterBias, f_hiddenCand, f_afterAdd
+    );
 
     // Activation
-    CONFIG_T::template activation_recr<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t,
-                                       typename CONFIG_T::ACT_CONFIG_RECURRENT_T>::activation(f_afterAdd, gate_f);
+    CONFIG_T::template activation_recr<
+        typename CONFIG_T::accum_t,
+        typename CONFIG_T::accum_t,
+        typename CONFIG_T::ACT_CONFIG_RECURRENT_T>::activation(f_afterAdd, gate_f);
 
     //-----------Gate C Calculations
     // Weight multiplication
     multiply_W<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, CONFIG_T::n_in, CONFIG_T::n_out>(
-        inputs, c_afterW, WC);
+        inputs, c_afterW, WC
+    );
 
     // Bias addition
     add_bias<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t, typename CONFIG_T::bias_t, CONFIG_T::n_out>(
-        c_afterW, c_afterBias, BC);
+        c_afterW, c_afterBias, BC
+    );
 
     // Hidden Candidate
-    multiply_U<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, CONFIG_T::n_out>(hidden_state, c_hiddenCand,
-                                                                                                 RWC);
+    multiply_U<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, CONFIG_T::n_out>(
+        hidden_state, c_hiddenCand, RWC
+    );
 
     // Vector addition
-    add_vectors<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t, CONFIG_T::n_out>(c_afterBias, c_hiddenCand,
-                                                                                         c_afterAdd);
+    add_vectors<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t, CONFIG_T::n_out>(
+        c_afterBias, c_hiddenCand, c_afterAdd
+    );
 
     // Activation
-    CONFIG_T::template activation<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t,
-                                  typename CONFIG_T::ACT_CONFIG_RECURRENT_T>::activation(c_afterAdd, gate_c);
+    CONFIG_T::template activation<
+        typename CONFIG_T::accum_t,
+        typename CONFIG_T::accum_t,
+        typename CONFIG_T::ACT_CONFIG_RECURRENT_T>::activation(c_afterAdd, gate_c);
 
     //-----------gate I and C multiply
     // Vector multiplication
@@ -597,36 +653,45 @@ void lstm_cell(data_T inputs[CONFIG_T::n_in], res_T hidden_state[CONFIG_T::n_out
     //-----------Gate O Calculations
     // Weight multiplication
     multiply_W<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, CONFIG_T::n_in, CONFIG_T::n_out>(
-        inputs, o_afterW, WO);
+        inputs, o_afterW, WO
+    );
 
     // Bias addition
     add_bias<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t, typename CONFIG_T::bias_t, CONFIG_T::n_out>(
-        o_afterW, o_afterBias, BO);
+        o_afterW, o_afterBias, BO
+    );
 
     // Hidden Candidate
-    multiply_U<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, CONFIG_T::n_out>(hidden_state, o_hiddenCand,
-                                                                                                 RWO);
+    multiply_U<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, CONFIG_T::n_out>(
+        hidden_state, o_hiddenCand, RWO
+    );
 
     // Vector addition
-    add_vectors<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t, CONFIG_T::n_out>(o_afterBias, o_hiddenCand,
-                                                                                         o_afterAdd);
+    add_vectors<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t, CONFIG_T::n_out>(
+        o_afterBias, o_hiddenCand, o_afterAdd
+    );
 
     // Activation
-    CONFIG_T::template activation_recr<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t,
-                                       typename CONFIG_T::ACT_CONFIG_RECURRENT_T>::activation(o_afterAdd, gate_o);
+    CONFIG_T::template activation_recr<
+        typename CONFIG_T::accum_t,
+        typename CONFIG_T::accum_t,
+        typename CONFIG_T::ACT_CONFIG_RECURRENT_T>::activation(o_afterAdd, gate_o);
 
     //-----------Cell State Calculation
     // Vector multiplication
     multiply_vectors<typename CONFIG_T::accum_t, res_T, CONFIG_T::n_out>(gate_f, cell_state, cell_act_multp);
 
     // Vector addition
-    add_vectors<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t, CONFIG_T::n_out>(gate_ic, cell_act_multp,
-                                                                                         cell_act_add);
+    add_vectors<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t, CONFIG_T::n_out>(
+        gate_ic, cell_act_multp, cell_act_add
+    );
 
     //-----------Forget gate Calculation
     // Activation
-    CONFIG_T::template activation<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t,
-                                  typename CONFIG_T::ACT_CONFIG_RECURRENT_T>::activation(cell_act_add, gate_forget);
+    CONFIG_T::template activation<
+        typename CONFIG_T::accum_t,
+        typename CONFIG_T::accum_t,
+        typename CONFIG_T::ACT_CONFIG_RECURRENT_T>::activation(cell_act_add, gate_forget);
 
     // Vector multiplication
     multiply_vectors<typename CONFIG_T::accum_t, typename CONFIG_T::accum_t, CONFIG_T::n_out>(gate_o, gate_forget, h);
@@ -640,17 +705,22 @@ void lstm_cell(data_T inputs[CONFIG_T::n_in], res_T hidden_state[CONFIG_T::n_out
 }
 
 template <class data_T, class res_T, class CONFIG_T>
-void lstm(data_T data[CONFIG_T::n_timesteps * CONFIG_T::n_in], res_T res[CONFIG_T::n_outputs * CONFIG_T::n_out],
-          const typename CONFIG_T::weight_t WI[CONFIG_T::n_in * CONFIG_T::n_out],
-          const typename CONFIG_T::weight_t WF[CONFIG_T::n_in * CONFIG_T::n_out],
-          const typename CONFIG_T::weight_t WC[CONFIG_T::n_in * CONFIG_T::n_out],
-          const typename CONFIG_T::weight_t WO[CONFIG_T::n_in * CONFIG_T::n_out],
-          const typename CONFIG_T::weight_t RWI[CONFIG_T::n_out * CONFIG_T::n_out],
-          const typename CONFIG_T::weight_t RWF[CONFIG_T::n_out * CONFIG_T::n_out],
-          const typename CONFIG_T::weight_t RWC[CONFIG_T::n_out * CONFIG_T::n_out],
-          const typename CONFIG_T::weight_t RWO[CONFIG_T::n_out * CONFIG_T::n_out],
-          const typename CONFIG_T::bias_t BI[CONFIG_T::n_out], const typename CONFIG_T::bias_t BF[CONFIG_T::n_out],
-          const typename CONFIG_T::bias_t BC[CONFIG_T::n_out], const typename CONFIG_T::bias_t BO[CONFIG_T::n_out]) {
+void lstm(
+    data_T data[CONFIG_T::n_timesteps * CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_outputs * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t WI[CONFIG_T::n_in * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t WF[CONFIG_T::n_in * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t WC[CONFIG_T::n_in * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t WO[CONFIG_T::n_in * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t RWI[CONFIG_T::n_out * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t RWF[CONFIG_T::n_out * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t RWC[CONFIG_T::n_out * CONFIG_T::n_out],
+    const typename CONFIG_T::weight_t RWO[CONFIG_T::n_out * CONFIG_T::n_out],
+    const typename CONFIG_T::bias_t BI[CONFIG_T::n_out],
+    const typename CONFIG_T::bias_t BF[CONFIG_T::n_out],
+    const typename CONFIG_T::bias_t BC[CONFIG_T::n_out],
+    const typename CONFIG_T::bias_t BO[CONFIG_T::n_out]
+) {
     res_T hidden_state[CONFIG_T::n_out][CONFIG_T::n_timesteps + 1] hls_register;
     res_T hidden_state_temp[CONFIG_T::n_out] hls_register;
     res_T cell_state[CONFIG_T::n_out][CONFIG_T::n_timesteps + 1] hls_register;
@@ -683,8 +753,9 @@ void lstm(data_T data[CONFIG_T::n_timesteps * CONFIG_T::n_in], res_T res[CONFIG_
         }
 
         // Do LSTM
-        lstm_cell<data_T, res_T, CONFIG_T>(in, hidden_state_temp, h, cell_state_temp, c, WI, WF, WC, WO, RWI, RWF, RWC, RWO,
-                                           BI, BF, BC, BO);
+        lstm_cell<data_T, res_T, CONFIG_T>(
+            in, hidden_state_temp, h, cell_state_temp, c, WI, WF, WC, WO, RWI, RWF, RWC, RWO, BI, BF, BC, BO
+        );
 
         // Write result
         #pragma unroll
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_recurrent_stream.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_recurrent_stream.h
index d43942835..a086a29bd 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_recurrent_stream.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_recurrent_stream.h
@@ -7,11 +7,14 @@
 
 namespace nnet {
 template <class data_T, class res_T, typename CONFIG_T>
-void gru(stream<data_T> &data_stream, stream<res_T> &res_stream,
-         const typename CONFIG_T::weight_t weights[3 * CONFIG_T::n_units * CONFIG_T::n_in],
-         const typename CONFIG_T::weight_t recurrent_weights[3 * CONFIG_T::n_units * CONFIG_T::n_units],
-         const typename CONFIG_T::bias_t bias[3 * CONFIG_T::n_units],
-         const typename CONFIG_T::bias_t recurrent_bias[3 * CONFIG_T::n_units]) {
+void gru(
+    stream<data_T> &data_stream,
+    stream<res_T> &res_stream,
+    const typename CONFIG_T::weight_t weights[3 * CONFIG_T::n_units * CONFIG_T::n_in],
+    const typename CONFIG_T::weight_t recurrent_weights[3 * CONFIG_T::n_units * CONFIG_T::n_units],
+    const typename CONFIG_T::bias_t bias[3 * CONFIG_T::n_units],
+    const typename CONFIG_T::bias_t recurrent_bias[3 * CONFIG_T::n_units]
+) {
 
     hls_register typename res_T::value_type h[CONFIG_T::n_units];
     #pragma unroll
@@ -31,8 +34,9 @@ void gru(stream<data_T> &data_stream, stream<res_T> &res_stream,
             x[i_pack] = data_pack[i_pack];
         }
 
-        nnet::gru_cell<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(x, h, weights, recurrent_weights,
-                                                                                          bias, recurrent_bias);
+        nnet::gru_cell<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(
+            x, h, weights, recurrent_weights, bias, recurrent_bias
+        );
 
         if (CONFIG_T::return_sequences) {
             res_T res_pack;
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_resize.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_resize.h
index a8e3ffe85..618cb1f67 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_resize.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_resize.h
@@ -14,8 +14,10 @@ struct resize_config {
 };
 
 template <class data_T, typename CONFIG_T>
-void resize_nearest(data_T image[CONFIG_T::height * CONFIG_T::width * CONFIG_T::n_chan],
-                    data_T resized[CONFIG_T::new_height * CONFIG_T::new_width * CONFIG_T::n_chan]) {
+void resize_nearest(
+    data_T image[CONFIG_T::height * CONFIG_T::width * CONFIG_T::n_chan],
+    data_T resized[CONFIG_T::new_height * CONFIG_T::new_width * CONFIG_T::n_chan]
+) {
     int y_ratio = (int)((CONFIG_T::height << 16) / CONFIG_T::new_height) + 1;
     int x_ratio = (int)((CONFIG_T::width << 16) / CONFIG_T::new_width) + 1;
 
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_transpose.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_transpose.h
index 05fd5fe76..777c9f6dd 100644
--- a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_transpose.h
+++ b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_transpose.h
@@ -21,11 +21,13 @@ void transpose_2d(data_T data[CONFIG_T::height * CONFIG_T::width], res_T res[CON
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void transpose_3d(data_T data[CONFIG_T::depth * CONFIG_T::height * CONFIG_T::width],
-                  res_T res[CONFIG_T::depth * CONFIG_T::height * CONFIG_T::width]) {
+void transpose_3d(
+    data_T data[CONFIG_T::depth * CONFIG_T::height * CONFIG_T::width],
+    res_T res[CONFIG_T::depth * CONFIG_T::height * CONFIG_T::width]
+) {
     static constexpr unsigned dim_data[3] = {CONFIG_T::depth, CONFIG_T::height, CONFIG_T::width};
-    static constexpr unsigned dim_res[3] = {dim_data[CONFIG_T::perm[0]], dim_data[CONFIG_T::perm[1]],
-                                            dim_data[CONFIG_T::perm[2]]};
+    static constexpr unsigned dim_res[3] = {
+        dim_data[CONFIG_T::perm[0]], dim_data[CONFIG_T::perm[1]], dim_data[CONFIG_T::perm[2]]};
 
     int index_data[3] = {0}, index_res[3] = {0};
 
@@ -39,7 +41,8 @@ void transpose_3d(data_T data[CONFIG_T::depth * CONFIG_T::height * CONFIG_T::wid
                 index_res[2] = index_data[CONFIG_T::perm[2]];
 
                 res[index_res[0] * dim_res[1] * dim_res[2] + index_res[1] * dim_res[2] + index_res[2]] = static_cast<res_T>(
-                    data[index_data[0] * dim_data[1] * dim_data[2] + index_data[1] * dim_data[2] + index_data[2]]);
+                    data[index_data[0] * dim_data[1] * dim_data[2] + index_data[1] * dim_data[2] + index_data[2]]
+                );
             }
         }
     }
diff --git a/hls4ml/templates/vitis/nnet_utils/nnet_conv1d.h b/hls4ml/templates/vitis/nnet_utils/nnet_conv1d.h
index 52a404672..c3ae9ed40 100644
--- a/hls4ml/templates/vitis/nnet_utils/nnet_conv1d.h
+++ b/hls4ml/templates/vitis/nnet_utils/nnet_conv1d.h
@@ -32,9 +32,12 @@ struct conv1d_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan], res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_1d_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     // Inlining helps reduce latency, but may also cause timing issues in some cases, use carefully.
     //#pragma HLS INLINE recursive
 
@@ -46,10 +49,12 @@ void conv_1d_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan], res_T res[CO
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_1d_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                          res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                          typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                          typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_1d_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::filt_width == 1);
 
     // Inlining helps reduce latency, but may also cause timing issues in some cases, use carefully.
diff --git a/hls4ml/templates/vitis/nnet_utils/nnet_conv1d_latency.h b/hls4ml/templates/vitis/nnet_utils/nnet_conv1d_latency.h
index 1bf25cc89..7368e8e56 100644
--- a/hls4ml/templates/vitis/nnet_utils/nnet_conv1d_latency.h
+++ b/hls4ml/templates/vitis/nnet_utils/nnet_conv1d_latency.h
@@ -8,10 +8,12 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_latency_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                        res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                        typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                        typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_1d_latency_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     constexpr unsigned mult_n_in = CONFIG_T::filt_width * CONFIG_T::n_chan;
     constexpr unsigned mult_n_out = CONFIG_T::n_filt;
 
@@ -52,7 +54,8 @@ void conv_1d_latency_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
                     #pragma HLS UNROLL
                     mult[i_in * mult_n_out + i_out] =
                         CONFIG_T::mult_config::template product<data_T, typename CONFIG_T::mult_config::weight_t>::product(
-                            cache, weights[i_in * mult_n_out + i_out]);
+                            cache, weights[i_in * mult_n_out + i_out]
+                        );
                 }
             }
 
diff --git a/hls4ml/templates/vitis/nnet_utils/nnet_conv1d_resource.h b/hls4ml/templates/vitis/nnet_utils/nnet_conv1d_resource.h
index e3e53d186..ed0cc33fc 100644
--- a/hls4ml/templates/vitis/nnet_utils/nnet_conv1d_resource.h
+++ b/hls4ml/templates/vitis/nnet_utils/nnet_conv1d_resource.h
@@ -7,19 +7,24 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_resource_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                         res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                         typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                         typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_1d_resource_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     constexpr unsigned mult_n_in = CONFIG_T::filt_width * CONFIG_T::n_chan;
     constexpr unsigned mult_n_out = CONFIG_T::n_filt;
     constexpr unsigned block_factor = DIV_ROUNDUP(mult_n_in * mult_n_out, CONFIG_T::reuse_factor);
     constexpr unsigned multscale = block_factor / mult_n_out;
 
-    assert((block_factor % mult_n_out == 0 || CONFIG_T::reuse_factor >= mult_n_in) &&
-           "The current Reuse Factor is not allowed");
-    assert((CONFIG_T::reuse_factor <= CONFIG_T::filt_width * CONFIG_T::n_chan) &&
-           "This function is correct only for RF <= FILT_WIDTH * N_CHAN");
+    assert(
+        (block_factor % mult_n_out == 0 || CONFIG_T::reuse_factor >= mult_n_in) && "The current Reuse Factor is not allowed"
+    );
+    assert(
+        (CONFIG_T::reuse_factor <= CONFIG_T::filt_width * CONFIG_T::n_chan) &&
+        "This function is correct only for RF <= FILT_WIDTH * N_CHAN"
+    );
 
     // Treating weights as 2d is required to make sure Vitis doesn't use urem cores to calculate indices.
     // Also, we don't apply ARRAY_RESHAPE pragma as Vitis figures this out on its own.
@@ -69,7 +74,9 @@ void conv_1d_resource_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
 
                     acc[i_pxl][i_out] += static_cast<typename CONFIG_T::accum_t>(
                         CONFIG_T::mult_config::template product<data_T, typename CONFIG_T::mult_config::weight_t>::product(
-                            data_buf[i_pxl][i_in], weights_2d[i_blk][i_rf]));
+                            data_buf[i_pxl][i_in], weights_2d[i_blk][i_rf]
+                        )
+                    );
                 }
 
                 // Increment i_in
diff --git a/hls4ml/templates/vitis/nnet_utils/nnet_conv1d_stream.h b/hls4ml/templates/vitis/nnet_utils/nnet_conv1d_stream.h
index 49b284949..cee925119 100644
--- a/hls4ml/templates/vitis/nnet_utils/nnet_conv1d_stream.h
+++ b/hls4ml/templates/vitis/nnet_utils/nnet_conv1d_stream.h
@@ -8,11 +8,16 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
-                typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
-    assert(CONFIG_T::implementation == conv_implementation::linebuffer &&
-           "Only \"linebuffer\" implementation is supported in Vitis HLS.");
+void conv_1d_cl(
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
+    assert(
+        CONFIG_T::implementation == conv_implementation::linebuffer &&
+        "Only \"linebuffer\" implementation is supported in Vitis HLS."
+    );
 
     assert(CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
 
diff --git a/hls4ml/templates/vitis/nnet_utils/nnet_conv2d.h b/hls4ml/templates/vitis/nnet_utils/nnet_conv2d.h
index 7095428bd..b76600adf 100644
--- a/hls4ml/templates/vitis/nnet_utils/nnet_conv2d.h
+++ b/hls4ml/templates/vitis/nnet_utils/nnet_conv2d.h
@@ -43,7 +43,8 @@ void conv_2d_cl(
     data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
     res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     // Inlining helps reduce latency, but may also cause timing issues in some cases, use carefully.
     //#pragma HLS INLINE recursive
 
@@ -55,10 +56,12 @@ void conv_2d_cl(
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
-                          res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
-                          typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                          typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_2d_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::filt_width == 1);
 
     // Inlining helps reduce latency, but may also cause timing issues in some cases, use carefully.
diff --git a/hls4ml/templates/vitis/nnet_utils/nnet_conv2d_latency.h b/hls4ml/templates/vitis/nnet_utils/nnet_conv2d_latency.h
index c286e86f0..511dbebfb 100644
--- a/hls4ml/templates/vitis/nnet_utils/nnet_conv2d_latency.h
+++ b/hls4ml/templates/vitis/nnet_utils/nnet_conv2d_latency.h
@@ -12,7 +12,8 @@ void conv_2d_latency_cl(
     data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
     res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     constexpr unsigned mult_n_in = CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan;
     constexpr unsigned mult_n_out = CONFIG_T::n_filt;
 
@@ -53,7 +54,8 @@ void conv_2d_latency_cl(
                     #pragma HLS UNROLL
                     mult[i_in * mult_n_out + i_out] =
                         CONFIG_T::mult_config::template product<data_T, typename CONFIG_T::mult_config::weight_t>::product(
-                            cache, weights[i_in * mult_n_out + i_out]);
+                            cache, weights[i_in * mult_n_out + i_out]
+                        );
                 }
             }
 
diff --git a/hls4ml/templates/vitis/nnet_utils/nnet_conv2d_resource.h b/hls4ml/templates/vitis/nnet_utils/nnet_conv2d_resource.h
index e427bd708..81277730a 100644
--- a/hls4ml/templates/vitis/nnet_utils/nnet_conv2d_resource.h
+++ b/hls4ml/templates/vitis/nnet_utils/nnet_conv2d_resource.h
@@ -11,7 +11,8 @@ void conv_2d_resource_cl(
     data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
     res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     constexpr unsigned mult_n_in = CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan;
     constexpr unsigned mult_n_out = CONFIG_T::n_filt;
     constexpr unsigned block_factor = DIV_ROUNDUP(mult_n_in * mult_n_out, CONFIG_T::reuse_factor);
@@ -19,10 +20,13 @@ void conv_2d_resource_cl(
     constexpr unsigned multiplier_limit = DIV_ROUNDUP(mult_n_in * mult_n_out, CONFIG_T::reuse_factor);
     constexpr unsigned multscale = multiplier_limit / mult_n_out;
 
-    assert((multiplier_limit % mult_n_out == 0 || CONFIG_T::reuse_factor >= mult_n_in) &&
-           "The current Reuse Factor is not allowed");
-    assert((multiplier_limit == block_factor) &&
-           "This function is correct only for RF <= FILT_HEIGHT * FILT_WIDTH * N_CHAN");
+    assert(
+        (multiplier_limit % mult_n_out == 0 || CONFIG_T::reuse_factor >= mult_n_in) &&
+        "The current Reuse Factor is not allowed"
+    );
+    assert(
+        (multiplier_limit == block_factor) && "This function is correct only for RF <= FILT_HEIGHT * FILT_WIDTH * N_CHAN"
+    );
 
     // Treating weights as 2d is required to make sure Vitis doesn't use urem cores to calculate indices.
     // Also, we don't apply ARRAY_RESHAPE pragma as Vitis figures this out on its own.
@@ -72,7 +76,9 @@ void conv_2d_resource_cl(
 
                     acc[i_pxl][i_out] += static_cast<typename CONFIG_T::accum_t>(
                         CONFIG_T::mult_config::template product<data_T, typename CONFIG_T::mult_config::weight_t>::product(
-                            data_buf[i_pxl][i_in], weights_2d[i_blk][i_rf]));
+                            data_buf[i_pxl][i_in], weights_2d[i_blk][i_rf]
+                        )
+                    );
                 }
 
                 // Increment i_in
diff --git a/hls4ml/templates/vitis/nnet_utils/nnet_conv2d_stream.h b/hls4ml/templates/vitis/nnet_utils/nnet_conv2d_stream.h
index b1648e790..bf6424e35 100644
--- a/hls4ml/templates/vitis/nnet_utils/nnet_conv2d_stream.h
+++ b/hls4ml/templates/vitis/nnet_utils/nnet_conv2d_stream.h
@@ -11,9 +11,11 @@ namespace nnet {
 // Line Buffer
 template <class data_T, class res_T, typename CONFIG_T>
 void conv_2d_buffer_latency_cl(
-    hls::stream<data_T> &data, hls::stream<res_T> &res,
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_top == 0 && CONFIG_T::pad_bottom == 0 && CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
 
     static ap_shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[MAX(CONFIG_T::filt_height - 1, 1)]
@@ -38,9 +40,11 @@ void conv_2d_buffer_latency_cl(
 
 template <class data_T, class res_T, typename CONFIG_T>
 void conv_2d_buffer_resource_cl(
-    hls::stream<data_T> &data, hls::stream<res_T> &res,
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_top == 0 && CONFIG_T::pad_bottom == 0 && CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
 
     static ap_shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[MAX(CONFIG_T::filt_height - 1, 1)]
@@ -64,11 +68,15 @@ void conv_2d_buffer_resource_cl(
 
 template <class data_T, class res_T, typename CONFIG_T>
 void conv_2d_cl(
-    hls::stream<data_T> &data, hls::stream<res_T> &res,
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
-    assert(CONFIG_T::implementation == conv_implementation::linebuffer &&
-           "Only \"linebuffer\" implementation is supported in Vitis HLS.");
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
+    assert(
+        CONFIG_T::implementation == conv_implementation::linebuffer &&
+        "Only \"linebuffer\" implementation is supported in Vitis HLS."
+    );
 
     #pragma HLS INLINE recursive
     if (CONFIG_T::strategy == nnet::latency) {
diff --git a/hls4ml/templates/vitis/nnet_utils/nnet_dense_stream.h b/hls4ml/templates/vitis/nnet_utils/nnet_dense_stream.h
index a2bc1eb29..5f74046e3 100644
--- a/hls4ml/templates/vitis/nnet_utils/nnet_dense_stream.h
+++ b/hls4ml/templates/vitis/nnet_utils/nnet_dense_stream.h
@@ -10,17 +10,23 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_latency_wrapper(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                           typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-                           typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense_latency_wrapper(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
     #pragma HLS PIPELINE II=CONFIG_T::reuse_factor
     dense_latency<data_T, res_T, CONFIG_T>(data, res, weights, biases);
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_resource_wrapper(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                            typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-                            typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense_resource_wrapper(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
     dense_resource<data_T, res_T, CONFIG_T>(data, res, weights, biases);
 }
 
@@ -79,9 +85,12 @@ void res_write(typename res_T::value_type res[CONFIG_T::n_out], hls::stream<res_
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense(hls::stream<data_T> &data_stream, hls::stream<res_T> &res_stream,
-           typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-           typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense(
+    hls::stream<data_T> &data_stream,
+    hls::stream<res_T> &res_stream,
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
     #pragma HLS INLINE recursive
 
     typename data_T::value_type data[CONFIG_T::n_in];
@@ -94,8 +103,9 @@ void dense(hls::stream<data_T> &data_stream, hls::stream<res_T> &res_stream,
     if (CONFIG_T::strategy == nnet::latency) {
         dense_latency_wrapper<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(data, res, weights, biases);
     } else {
-        dense_resource_wrapper<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(data, res, weights,
-                                                                                                  biases);
+        dense_resource_wrapper<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(
+            data, res, weights, biases
+        );
     }
     res_write<res_T, CONFIG_T>(res, res_stream);
 }
diff --git a/hls4ml/templates/vitis/nnet_utils/nnet_pooling.h b/hls4ml/templates/vitis/nnet_utils/nnet_pooling.h
index 93d23d268..f1c7f8fed 100644
--- a/hls4ml/templates/vitis/nnet_utils/nnet_pooling.h
+++ b/hls4ml/templates/vitis/nnet_utils/nnet_pooling.h
@@ -170,8 +170,10 @@ template <typename CONFIG_T> constexpr int pool_op_limit() {
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pooling2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt],
-                  res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt]) {
+void pooling2d_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt],
+    res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt]
+) {
     #pragma HLS PIPELINE II=CONFIG_T::reuse_factor
 
     // TODO partition the arrays according to the reuse factor
@@ -216,16 +218,21 @@ void pooling2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_
 
                 res[(ii / CONFIG_T::stride_height) * CONFIG_T::out_width * CONFIG_T::n_filt +
                     (jj / CONFIG_T::stride_width) * CONFIG_T::n_filt + ff] =
-                    pool_op<data_T, CONFIG_T::pool_height * CONFIG_T::pool_width, CONFIG_T::pool_op,
-                            typename CONFIG_T::accum_t>(pool, patch_size);
+                    pool_op<
+                        data_T,
+                        CONFIG_T::pool_height * CONFIG_T::pool_width,
+                        CONFIG_T::pool_op,
+                        typename CONFIG_T::accum_t>(pool, patch_size);
             }
         }
     }
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pooling2d_cf(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt],
-                  res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt]) {
+void pooling2d_cf(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt],
+    res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt]
+) {
     #pragma HLS PIPELINE II=CONFIG_T::reuse_factor
 
     // TODO partition the arrays according to the reuse factor
@@ -258,9 +265,9 @@ void pooling2d_cf(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_
                             if (CONFIG_T::count_pad)
                                 img_overlap++;
                         } else {
-                            pool[kk * CONFIG_T::stride_width + ll] =
-                                data[(ii + kk - CONFIG_T::pad_top) * CONFIG_T::in_width +
-                                     ff * CONFIG_T::in_width * CONFIG_T::in_height + ll + jj - CONFIG_T::pad_left];
+                            pool[kk * CONFIG_T::stride_width + ll] = data
+                                [(ii + kk - CONFIG_T::pad_top) * CONFIG_T::in_width +
+                                 ff * CONFIG_T::in_width * CONFIG_T::in_height + ll + jj - CONFIG_T::pad_left];
                             img_overlap++;
                         }
                     }
@@ -270,8 +277,11 @@ void pooling2d_cf(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_
                 // not overlapping padding region
                 res[(ii / CONFIG_T::stride_height) * CONFIG_T::out_width + (jj / CONFIG_T::stride_width) +
                     ff * CONFIG_T::out_height * CONFIG_T::out_width] =
-                    pool_op<data_T, CONFIG_T::pool_height * CONFIG_T::pool_width, CONFIG_T::pool_op,
-                            typename CONFIG_T::accum_t>(pool);
+                    pool_op<
+                        data_T,
+                        CONFIG_T::pool_height * CONFIG_T::pool_width,
+                        CONFIG_T::pool_op,
+                        typename CONFIG_T::accum_t>(pool);
                 // If the pool op is Average, the zero-padding needs to be removed from the results
                 if (CONFIG_T::pool_op == Average) {
                     data_T rescale =
@@ -285,8 +295,9 @@ void pooling2d_cf(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void global_pooling2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt],
-                         res_T res[CONFIG_T::n_filt]) {
+void global_pooling2d_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt], res_T res[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
     assert(CONFIG_T::pad_top == 0 && CONFIG_T::pad_bottom == 0);
     assert(CONFIG_T::pool_width == CONFIG_T::stride_width);
@@ -308,7 +319,8 @@ void global_pooling2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width *
         }
 
         res[filt] = static_cast<res_T>(
-            pool_op<data_T, CONFIG_T::in_height * CONFIG_T::in_width, CONFIG_T::pool_op, typename CONFIG_T::accum_t>(pool));
+            pool_op<data_T, CONFIG_T::in_height * CONFIG_T::in_width, CONFIG_T::pool_op, typename CONFIG_T::accum_t>(pool)
+        );
     }
 }
 
diff --git a/hls4ml/templates/vitis/nnet_utils/nnet_pooling_stream.h b/hls4ml/templates/vitis/nnet_utils/nnet_pooling_stream.h
index 37ff3c68b..5e64706db 100644
--- a/hls4ml/templates/vitis/nnet_utils/nnet_pooling_stream.h
+++ b/hls4ml/templates/vitis/nnet_utils/nnet_pooling_stream.h
@@ -27,10 +27,12 @@ template <class T, int N, class CONFIG_T> T reduce_pool(T x[N]) {
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void compute_pool_buffer_2d(const data_T &in_elem,
-                            ap_shift_reg<typename data_T::value_type, CONFIG_T::in_width>
-                                line_buffer[MAX(CONFIG_T::pool_height - 1, 1)][CONFIG_T::n_filt],
-                            hls::stream<res_T> &res) {
+void compute_pool_buffer_2d(
+    const data_T &in_elem,
+    ap_shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[MAX(CONFIG_T::pool_height - 1, 1)]
+                                                                             [CONFIG_T::n_filt],
+    hls::stream<res_T> &res
+) {
     #pragma HLS INLINE
     const static int lShiftX = CONFIG_T::pool_width - 1;
     const static int lShiftY = CONFIG_T::pool_height - 1;
@@ -94,8 +96,10 @@ void compute_pool_buffer_2d(const data_T &in_elem,
 
 template <class data_T, class res_T, typename CONFIG_T>
 void pooling2d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res) {
-    assert(CONFIG_T::implementation == conv_implementation::linebuffer &&
-           "Only \"linebuffer\" implementation is supported in Vitis HLS.");
+    assert(
+        CONFIG_T::implementation == conv_implementation::linebuffer &&
+        "Only \"linebuffer\" implementation is supported in Vitis HLS."
+    );
 
     #pragma HLS INLINE recursive
     assert(CONFIG_T::pad_top == 0 && CONFIG_T::pad_bottom == 0 && CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
@@ -175,8 +179,10 @@ void compute_pool_buffer_1d(const data_T &in_elem, hls::stream<res_T> &res) {
 
 template <class data_T, class res_T, typename CONFIG_T>
 void pooling1d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res) {
-    assert(CONFIG_T::implementation == conv_implementation::linebuffer &&
-           "Only \"linebuffer\" implementation is supported in Vitis HLS.");
+    assert(
+        CONFIG_T::implementation == conv_implementation::linebuffer &&
+        "Only \"linebuffer\" implementation is supported in Vitis HLS."
+    );
     assert(CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
 
     #pragma HLS inline recursive
@@ -220,7 +226,8 @@ void compute_global_pool(const data_T &in_elem, typename CONFIG_T::accum_t data_
             data_pack[p] = in_elem[p * CONFIG_T::n_filt + c];
         }
         data_window[c] = reduce_global_pool<typename CONFIG_T::accum_t, data_T::size / CONFIG_T::n_filt, CONFIG_T>(
-            data_window[c], data_pack);
+            data_window[c], data_pack
+        );
     }
 }
 
diff --git a/hls4ml/templates/vitis/nnet_utils/nnet_sepconv1d_stream.h b/hls4ml/templates/vitis/nnet_utils/nnet_sepconv1d_stream.h
index 20b6fecb4..51bce6ee2 100644
--- a/hls4ml/templates/vitis/nnet_utils/nnet_sepconv1d_stream.h
+++ b/hls4ml/templates/vitis/nnet_utils/nnet_sepconv1d_stream.h
@@ -9,9 +9,12 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void depthwise_conv_1d_buffer_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
-                                 typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan],
-                                 typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+void depthwise_conv_1d_buffer_cl(
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     assert(CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
 
     if (CONFIG_T::strategy == nnet::latency) {
@@ -29,19 +32,27 @@ void depthwise_conv_1d_buffer_cl(hls::stream<data_T> &data, hls::stream<res_T> &
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void depthwise_conv_1d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
-                          typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan],
-                          typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
-    assert(CONFIG_T::implementation == conv_implementation::linebuffer &&
-           "Only \"linebuffer\" implementation is supported in Vitis HLS.");
+void depthwise_conv_1d_cl(
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
+    assert(
+        CONFIG_T::implementation == conv_implementation::linebuffer &&
+        "Only \"linebuffer\" implementation is supported in Vitis HLS."
+    );
     #pragma HLS inline recursive
     depthwise_conv_1d_buffer_cl<data_T, res_T, CONFIG_T>(data, res, weights, biases);
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_1d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
-                          typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                          typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_1d_cl(
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
     assert(CONFIG_T::filt_width == 1);
 
@@ -71,17 +82,24 @@ void pointwise_conv_1d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
 }
 
 template <class data_T, class dw_res_T, class res_T, typename CONFIG_T>
-void separable_conv_1d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
-                          typename CONFIG_T::depthwise_config::weight_t
-                              depthwise_weights[CONFIG_T::depthwise_config::filt_width * CONFIG_T::depthwise_config::n_chan],
-                          typename CONFIG_T::pointwise_config::weight_t
-                              pointwise_weights[CONFIG_T::pointwise_config::n_chan * CONFIG_T::pointwise_config::n_filt],
-                          typename CONFIG_T::depthwise_config::bias_t depthwise_biases[CONFIG_T::depthwise_config::n_chan],
-                          typename CONFIG_T::pointwise_config::bias_t pointwise_biases[CONFIG_T::pointwise_config::n_filt]) {
-    assert(CONFIG_T::depthwise_config::implementation == conv_implementation::linebuffer &&
-           "Only \"linebuffer\" implementation is supported in Vitis HLS.");
-    assert(CONFIG_T::pointwise_config::implementation == conv_implementation::linebuffer &&
-           "Only \"linebuffer\" implementation is supported in Vitis HLS.");
+void separable_conv_1d_cl(
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
+    typename CONFIG_T::depthwise_config::weight_t
+        depthwise_weights[CONFIG_T::depthwise_config::filt_width * CONFIG_T::depthwise_config::n_chan],
+    typename CONFIG_T::pointwise_config::weight_t
+        pointwise_weights[CONFIG_T::pointwise_config::n_chan * CONFIG_T::pointwise_config::n_filt],
+    typename CONFIG_T::depthwise_config::bias_t depthwise_biases[CONFIG_T::depthwise_config::n_chan],
+    typename CONFIG_T::pointwise_config::bias_t pointwise_biases[CONFIG_T::pointwise_config::n_filt]
+) {
+    assert(
+        CONFIG_T::depthwise_config::implementation == conv_implementation::linebuffer &&
+        "Only \"linebuffer\" implementation is supported in Vitis HLS."
+    );
+    assert(
+        CONFIG_T::pointwise_config::implementation == conv_implementation::linebuffer &&
+        "Only \"linebuffer\" implementation is supported in Vitis HLS."
+    );
 
     #pragma HLS DATAFLOW
 
@@ -89,10 +107,12 @@ void separable_conv_1d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
     unsigned res_depth = CONFIG_T::depthwise_config::out_width;
     #pragma HLS STREAM variable=depthwise_res depth=res_depth
 
-    depthwise_conv_1d_buffer_cl<data_T, dw_res_T, typename CONFIG_T::depthwise_config>(data, depthwise_res,
-                                                                                       depthwise_weights, depthwise_biases);
-    pointwise_conv_1d_cl<dw_res_T, res_T, typename CONFIG_T::pointwise_config>(depthwise_res, res, pointwise_weights,
-                                                                               pointwise_biases);
+    depthwise_conv_1d_buffer_cl<data_T, dw_res_T, typename CONFIG_T::depthwise_config>(
+        data, depthwise_res, depthwise_weights, depthwise_biases
+    );
+    pointwise_conv_1d_cl<dw_res_T, res_T, typename CONFIG_T::pointwise_config>(
+        depthwise_res, res, pointwise_weights, pointwise_biases
+    );
 }
 
 } // namespace nnet
diff --git a/hls4ml/templates/vitis/nnet_utils/nnet_sepconv2d_stream.h b/hls4ml/templates/vitis/nnet_utils/nnet_sepconv2d_stream.h
index a3747990e..f123f973d 100644
--- a/hls4ml/templates/vitis/nnet_utils/nnet_sepconv2d_stream.h
+++ b/hls4ml/templates/vitis/nnet_utils/nnet_sepconv2d_stream.h
@@ -11,9 +11,11 @@ namespace nnet {
 // Line Buffer Implementation (Phil's)
 template <class data_T, class res_T, typename CONFIG_T>
 void depthwise_conv_2d_buffer_cl(
-    hls::stream<data_T> &data, hls::stream<res_T> &res,
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     assert(CONFIG_T::pad_top == 0 && CONFIG_T::pad_bottom == 0 && CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
 
     static ap_shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[CONFIG_T::filt_height - 1]
@@ -28,8 +30,9 @@ void depthwise_conv_2d_buffer_cl(
                 #pragma HLS LOOP_FLATTEN
                 #pragma HLS PIPELINE II=CONFIG_T::reuse_factor
                 if (CONFIG_T::filt_height > 1) {
-                    compute_depthwise_output_buffer_2d<data_T, res_T, CONFIG_T>(data.read(), line_buffer, res, weights,
-                                                                                biases);
+                    compute_depthwise_output_buffer_2d<data_T, res_T, CONFIG_T>(
+                        data.read(), line_buffer, res, weights, biases
+                    );
                 } else {
                     compute_depthwise_output_buffer_1d<data_T, res_T, CONFIG_T>(data.read(), res, weights, biases);
                 }
@@ -42,8 +45,9 @@ void depthwise_conv_2d_buffer_cl(
             for (unsigned i_iw = 0; i_iw < CONFIG_T::in_width; i_iw++) {
                 #pragma HLS LOOP_FLATTEN
                 if (CONFIG_T::filt_height > 1) {
-                    compute_depthwise_output_buffer_2d<data_T, res_T, CONFIG_T>(data.read(), line_buffer, res, weights,
-                                                                                biases);
+                    compute_depthwise_output_buffer_2d<data_T, res_T, CONFIG_T>(
+                        data.read(), line_buffer, res, weights, biases
+                    );
                 } else {
                     compute_depthwise_output_buffer_1d<data_T, res_T, CONFIG_T>(data.read(), res, weights, biases);
                 }
@@ -53,9 +57,12 @@ void depthwise_conv_2d_buffer_cl(
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_2d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
-                          typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                          typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_2d_cl(
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_top == 0 && CONFIG_T::pad_bottom == 0 && CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
     assert(CONFIG_T::filt_height == 1 && CONFIG_T::filt_width == 1);
 
@@ -94,28 +101,39 @@ void pointwise_conv_2d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
 
 template <class data_T, class res_T, typename CONFIG_T>
 void depthwise_conv_2d_cl(
-    hls::stream<data_T> &data, hls::stream<res_T> &res,
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
-    assert(CONFIG_T::implementation == conv_implementation::linebuffer &&
-           "Only \"linebuffer\" implementation is supported in Vitis HLS.");
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
+    assert(
+        CONFIG_T::implementation == conv_implementation::linebuffer &&
+        "Only \"linebuffer\" implementation is supported in Vitis HLS."
+    );
     #pragma HLS inline recursive
     depthwise_conv_2d_buffer_cl<data_T, res_T, CONFIG_T>(data, res, weights, biases);
 }
 
 template <class data_T, class dw_res_T, class res_T, typename CONFIG_T>
-void separable_conv_2d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
-                          typename CONFIG_T::depthwise_config::weight_t
-                              depthwise_weights[CONFIG_T::depthwise_config::filt_height *
-                                                CONFIG_T::depthwise_config::filt_width * CONFIG_T::depthwise_config::n_chan],
-                          typename CONFIG_T::pointwise_config::weight_t
-                              pointwise_weights[CONFIG_T::pointwise_config::n_chan * CONFIG_T::pointwise_config::n_filt],
-                          typename CONFIG_T::depthwise_config::bias_t depthwise_biases[CONFIG_T::depthwise_config::n_chan],
-                          typename CONFIG_T::pointwise_config::bias_t pointwise_biases[CONFIG_T::pointwise_config::n_filt]) {
-    assert(CONFIG_T::depthwise_config::implementation == conv_implementation::linebuffer &&
-           "Only \"linebuffer\" implementation is supported in Vitis HLS.");
-    assert(CONFIG_T::pointwise_config::implementation == conv_implementation::linebuffer &&
-           "Only \"linebuffer\" implementation is supported in Vitis HLS.");
+void separable_conv_2d_cl(
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
+    typename CONFIG_T::depthwise_config::weight_t depthwise_weights
+        [CONFIG_T::depthwise_config::filt_height * CONFIG_T::depthwise_config::filt_width *
+         CONFIG_T::depthwise_config::n_chan],
+    typename CONFIG_T::pointwise_config::weight_t
+        pointwise_weights[CONFIG_T::pointwise_config::n_chan * CONFIG_T::pointwise_config::n_filt],
+    typename CONFIG_T::depthwise_config::bias_t depthwise_biases[CONFIG_T::depthwise_config::n_chan],
+    typename CONFIG_T::pointwise_config::bias_t pointwise_biases[CONFIG_T::pointwise_config::n_filt]
+) {
+    assert(
+        CONFIG_T::depthwise_config::implementation == conv_implementation::linebuffer &&
+        "Only \"linebuffer\" implementation is supported in Vitis HLS."
+    );
+    assert(
+        CONFIG_T::pointwise_config::implementation == conv_implementation::linebuffer &&
+        "Only \"linebuffer\" implementation is supported in Vitis HLS."
+    );
 
     #pragma HLS DATAFLOW
 
@@ -123,10 +141,12 @@ void separable_conv_2d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
     unsigned res_depth = CONFIG_T::depthwise_config::out_height * CONFIG_T::depthwise_config::out_width;
     #pragma HLS STREAM variable=depthwise_res depth=res_depth
 
-    depthwise_conv_2d_buffer_cl<data_T, dw_res_T, typename CONFIG_T::depthwise_config>(data, depthwise_res,
-                                                                                       depthwise_weights, depthwise_biases);
-    pointwise_conv_2d_cl<dw_res_T, res_T, typename CONFIG_T::pointwise_config>(depthwise_res, res, pointwise_weights,
-                                                                               pointwise_biases);
+    depthwise_conv_2d_buffer_cl<data_T, dw_res_T, typename CONFIG_T::depthwise_config>(
+        data, depthwise_res, depthwise_weights, depthwise_biases
+    );
+    pointwise_conv_2d_cl<dw_res_T, res_T, typename CONFIG_T::pointwise_config>(
+        depthwise_res, res, pointwise_weights, pointwise_biases
+    );
 }
 
 } // namespace nnet
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_activation.h b/hls4ml/templates/vivado/nnet_utils/nnet_activation.h
index 4683239d8..1abe80003 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_activation.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_activation.h
@@ -451,8 +451,9 @@ template <int table_size, class data_T> inline unsigned get_index_unary_lut(data
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void unary_lut(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_in],
-               typename CONFIG_T::table_t table[CONFIG_T::table_size]) {
+void unary_lut(
+    data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_in], typename CONFIG_T::table_t table[CONFIG_T::table_size]
+) {
     #pragma HLS function_instantiate variable=table
     #pragma HLS ARRAY_PARTITION variable=table
 
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_array.h b/hls4ml/templates/vivado/nnet_utils/nnet_array.h
index d179102a9..37bd349e4 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_array.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_array.h
@@ -24,8 +24,10 @@ void transpose_2d(data_T data[CONFIG_T::height * CONFIG_T::width], res_T data_t[
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void transpose_3d(data_T data[CONFIG_T::depth * CONFIG_T::height * CONFIG_T::width],
-                  res_T data_t[CONFIG_T::depth * CONFIG_T::height * CONFIG_T::width]) {
+void transpose_3d(
+    data_T data[CONFIG_T::depth * CONFIG_T::height * CONFIG_T::width],
+    res_T data_t[CONFIG_T::depth * CONFIG_T::height * CONFIG_T::width]
+) {
     unsigned dims[3] = {CONFIG_T::depth, CONFIG_T::height, CONFIG_T::width};
     unsigned dims_t[3];
     dims_t[0] = dims[CONFIG_T::perm[0]];
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_batchnorm.h b/hls4ml/templates/vivado/nnet_utils/nnet_batchnorm.h
index d8be45b73..9c3128e7d 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_batchnorm.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_batchnorm.h
@@ -28,9 +28,12 @@ struct batchnorm_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void normalize(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_in],
-               typename CONFIG_T::scale_t scale[CONFIG_T::n_scale_bias],
-               typename CONFIG_T::bias_t bias[CONFIG_T::n_scale_bias]) {
+void normalize(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_in],
+    typename CONFIG_T::scale_t scale[CONFIG_T::n_scale_bias],
+    typename CONFIG_T::bias_t bias[CONFIG_T::n_scale_bias]
+) {
     data_T cache;
 
     // Use a function_instantiate in case it helps to explicitly optimize unchanging weights/biases
@@ -78,8 +81,9 @@ struct batchnorm_quantized_tanh_config {
 };
 
 template <class data_T, typename CONFIG_T>
-void normalize_binary_tanh(data_T data[CONFIG_T::n_in], ap_uint<1> res[CONFIG_T::n_in],
-                           data_T threshold[CONFIG_T::n_scale_bias]) {
+void normalize_binary_tanh(
+    data_T data[CONFIG_T::n_in], ap_uint<1> res[CONFIG_T::n_in], data_T threshold[CONFIG_T::n_scale_bias]
+) {
     #pragma HLS PIPELINE
     #pragma HLS ARRAY_PARTITION variable=res complete
 
@@ -98,8 +102,12 @@ void normalize_binary_tanh(data_T data[CONFIG_T::n_in], ap_uint<1> res[CONFIG_T:
 }
 
 template <class data_T, typename CONFIG_T>
-void normalize_ternary_tanh(data_T data[CONFIG_T::n_in], ap_int<2> res[CONFIG_T::n_in],
-                            data_T threshold_hi[CONFIG_T::n_scale_bias], data_T threshold_lo[CONFIG_T::n_scale_bias]) {
+void normalize_ternary_tanh(
+    data_T data[CONFIG_T::n_in],
+    ap_int<2> res[CONFIG_T::n_in],
+    data_T threshold_hi[CONFIG_T::n_scale_bias],
+    data_T threshold_lo[CONFIG_T::n_scale_bias]
+) {
     #pragma HLS PIPELINE
     #pragma HLS ARRAY_PARTITION variable=res complete
 
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_batchnorm_stream.h b/hls4ml/templates/vivado/nnet_utils/nnet_batchnorm_stream.h
index a064677d0..48a84028c 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_batchnorm_stream.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_batchnorm_stream.h
@@ -13,8 +13,12 @@ namespace nnet {
 // ****************************************************
 
 template <class data_T, class res_T, typename CONFIG_T>
-void normalize(hls::stream<data_T> &data, hls::stream<res_T> &res, typename CONFIG_T::scale_t scale[CONFIG_T::n_scale_bias],
-               typename CONFIG_T::bias_t bias[CONFIG_T::n_scale_bias]) {
+void normalize(
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
+    typename CONFIG_T::scale_t scale[CONFIG_T::n_scale_bias],
+    typename CONFIG_T::bias_t bias[CONFIG_T::n_scale_bias]
+) {
     #pragma HLS ARRAY_PARTITION variable=scale complete
     #pragma HLS ARRAY_PARTITION variable=bias complete
 
@@ -39,7 +43,8 @@ void normalize(hls::stream<data_T> &data, hls::stream<res_T> &res, typename CONF
                 norm_index = j % CONFIG_T::n_filt;
             }
             out_data[j] = CONFIG_T::template product<typename data_T::value_type, typename CONFIG_T::scale_t>::product(
-                              in_data[j], scale[norm_index]) +
+                              in_data[j], scale[norm_index]
+                          ) +
                           bias[norm_index];
         }
 
@@ -51,8 +56,11 @@ void normalize(hls::stream<data_T> &data, hls::stream<res_T> &res, typename CONF
 //       Merged Batch Normalization and Quantized Tanh
 // ****************************************************
 template <class data_T, typename CONFIG_T>
-void normalize_binary_tanh(hls::stream<data_T> &data, hls::stream<nnet::array<ap_uint<1>, CONFIG_T::n_scale_bias>> &res,
-                           typename data_T::value_type threshold[CONFIG_T::n_scale_bias]) {
+void normalize_binary_tanh(
+    hls::stream<data_T> &data,
+    hls::stream<nnet::array<ap_uint<1>, CONFIG_T::n_scale_bias>> &res,
+    typename data_T::value_type threshold[CONFIG_T::n_scale_bias]
+) {
     #pragma HLS ARRAY_PARTITION variable=threshold complete
 
 BinaryNormLoop:
@@ -80,9 +88,12 @@ void normalize_binary_tanh(hls::stream<data_T> &data, hls::stream<nnet::array<ap
 }
 
 template <class data_T, typename CONFIG_T>
-void normalize_ternary_tanh(hls::stream<data_T> &data, hls::stream<nnet::array<ap_int<2>, CONFIG_T::n_scale_bias>> &res,
-                            typename data_T::value_type threshold_hi[CONFIG_T::n_scale_bias],
-                            typename data_T::value_type threshold_lo[CONFIG_T::n_scale_bias]) {
+void normalize_ternary_tanh(
+    hls::stream<data_T> &data,
+    hls::stream<nnet::array<ap_int<2>, CONFIG_T::n_scale_bias>> &res,
+    typename data_T::value_type threshold_hi[CONFIG_T::n_scale_bias],
+    typename data_T::value_type threshold_lo[CONFIG_T::n_scale_bias]
+) {
     #pragma HLS ARRAY_PARTITION variable=threshold_hi complete
     #pragma HLS ARRAY_PARTITION variable=threshold_lo complete
 
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_conv1d.h b/hls4ml/templates/vivado/nnet_utils/nnet_conv1d.h
index e2e0211b4..14281256b 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_conv1d.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_conv1d.h
@@ -32,9 +32,12 @@ struct conv1d_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan], res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_1d_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     #pragma HLS INLINE region
 
     if (CONFIG_T::strategy == nnet::latency) {
@@ -45,10 +48,12 @@ void conv_1d_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan], res_T res[CO
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_1d_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                          res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                          typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                          typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_1d_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::filt_width == 1);
 
     #pragma HLS INLINE region
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_conv1d_latency.h b/hls4ml/templates/vivado/nnet_utils/nnet_conv1d_latency.h
index 0d9afb10c..32888faee 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_conv1d_latency.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_conv1d_latency.h
@@ -8,10 +8,12 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_latency_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                        res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                        typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                        typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_1d_latency_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     constexpr unsigned mult_n_in = CONFIG_T::filt_width * CONFIG_T::n_chan;
     constexpr unsigned mult_n_out = CONFIG_T::n_filt;
 
@@ -52,7 +54,8 @@ void conv_1d_latency_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
                     #pragma HLS UNROLL
                     mult[i_in * mult_n_out + i_out] =
                         CONFIG_T::mult_config::template product<data_T, typename CONFIG_T::mult_config::weight_t>::product(
-                            cache, weights[i_in * mult_n_out + i_out]);
+                            cache, weights[i_in * mult_n_out + i_out]
+                        );
                 }
             }
 
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_conv1d_resource.h b/hls4ml/templates/vivado/nnet_utils/nnet_conv1d_resource.h
index 6e70158ad..ad5e86daf 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_conv1d_resource.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_conv1d_resource.h
@@ -7,19 +7,24 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_resource_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                         res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                         typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                         typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_1d_resource_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     constexpr unsigned mult_n_in = CONFIG_T::filt_width * CONFIG_T::n_chan;
     constexpr unsigned mult_n_out = CONFIG_T::n_filt;
     constexpr unsigned block_factor = DIV_ROUNDUP(mult_n_in * mult_n_out, CONFIG_T::reuse_factor);
     constexpr unsigned multscale = block_factor / mult_n_out;
 
-    assert((block_factor % mult_n_out == 0 || CONFIG_T::reuse_factor >= mult_n_in) &&
-           "The current Reuse Factor is not allowed");
-    assert((CONFIG_T::reuse_factor <= CONFIG_T::filt_width * CONFIG_T::n_chan) &&
-           "This function is correct only for RF <= FILT_WIDTH * N_CHAN");
+    assert(
+        (block_factor % mult_n_out == 0 || CONFIG_T::reuse_factor >= mult_n_in) && "The current Reuse Factor is not allowed"
+    );
+    assert(
+        (CONFIG_T::reuse_factor <= CONFIG_T::filt_width * CONFIG_T::n_chan) &&
+        "This function is correct only for RF <= FILT_WIDTH * N_CHAN"
+    );
 
     data_T data_buf[CONFIG_T::n_pixels][mult_n_in];
     #pragma HLS ARRAY_PARTITION variable=data_buf complete dim=0
@@ -66,7 +71,9 @@ void conv_1d_resource_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
 
                     acc[i_pxl][i_out] += static_cast<typename CONFIG_T::accum_t>(
                         CONFIG_T::mult_config::template product<data_T, typename CONFIG_T::mult_config::weight_t>::product(
-                            data_buf[i_pxl][i_in], weights[i_w]));
+                            data_buf[i_pxl][i_in], weights[i_w]
+                        )
+                    );
                 }
 
                 // Increment i_w
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_conv1d_stream.h b/hls4ml/templates/vivado/nnet_utils/nnet_conv1d_stream.h
index 2b481930b..9a6b31afc 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_conv1d_stream.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_conv1d_stream.h
@@ -16,15 +16,19 @@ void compute_scaled_indices_1d(const unsigned w_idx, ap_uint<CONFIG_T::filt_widt
         #pragma HLS UNROLL
         unsigned sw_idx =
             CONFIG_T::template scale_index<CONFIG_T::filt_width, CONFIG_T::stride_width, CONFIG_T::in_width>::scale_index(
-                wp_idx + p);
+                wp_idx + p
+            );
         pixel_idx[p] = CONFIG_T::pixels[sw_idx];
     }
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_encoded_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
-                        typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                        typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_1d_encoded_cl(
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
 
     hls::stream<typename data_T::value_type> data_window[CONFIG_T::filt_width * CONFIG_T::n_chan];
@@ -49,15 +53,19 @@ void conv_1d_encoded_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
             #pragma HLS PIPELINE II=CONFIG_T::reuse_factor
         }
         compute_scaled_indices_1d<data_T, CONFIG_T>(i_iw, pixel_idx);
-        compute_output_encoded<data_T, res_T, CONFIG_T>(data.read(), data_window, res, res_pack, outputs_ready, weights,
-                                                        biases, pixel_idx);
+        compute_output_encoded<data_T, res_T, CONFIG_T>(
+            data.read(), data_window, res, res_pack, outputs_ready, weights, biases, pixel_idx
+        );
     }
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_buffer_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
-                       typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                       typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_1d_buffer_cl(
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
 
     if (CONFIG_T::strategy == nnet::resource_unrolled && CONFIG_T::reuse_factor > 1) {
@@ -75,9 +83,12 @@ void conv_1d_buffer_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void conv_1d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
-                typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void conv_1d_cl(
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     #pragma HLS inline recursive
     switch (CONFIG_T::implementation) {
     case conv_implementation::linebuffer:
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_conv2d.h b/hls4ml/templates/vivado/nnet_utils/nnet_conv2d.h
index 71a88f448..c086a0a57 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_conv2d.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_conv2d.h
@@ -43,7 +43,8 @@ void conv_2d_cl(
     data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
     res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     #pragma HLS INLINE region
 
     if (CONFIG_T::strategy == nnet::latency) {
@@ -54,10 +55,12 @@ void conv_2d_cl(
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
-                          res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
-                          typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                          typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_2d_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::filt_width == 1);
 
     #pragma HLS INLINE region
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_conv2d_latency.h b/hls4ml/templates/vivado/nnet_utils/nnet_conv2d_latency.h
index 5114af782..6a05fd145 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_conv2d_latency.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_conv2d_latency.h
@@ -12,7 +12,8 @@ void conv_2d_latency_cl(
     data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
     res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     constexpr unsigned mult_n_in = CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan;
     constexpr unsigned mult_n_out = CONFIG_T::n_filt;
 
@@ -53,7 +54,8 @@ void conv_2d_latency_cl(
                     #pragma HLS UNROLL
                     mult[i_in * mult_n_out + i_out] =
                         CONFIG_T::mult_config::template product<data_T, typename CONFIG_T::mult_config::weight_t>::product(
-                            cache, weights[i_in * mult_n_out + i_out]);
+                            cache, weights[i_in * mult_n_out + i_out]
+                        );
                 }
             }
 
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_conv2d_resource.h b/hls4ml/templates/vivado/nnet_utils/nnet_conv2d_resource.h
index eb7e18e40..64541f1f0 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_conv2d_resource.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_conv2d_resource.h
@@ -11,17 +11,21 @@ void conv_2d_resource_cl(
     data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
     res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     constexpr unsigned mult_n_in = CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan;
     constexpr unsigned mult_n_out = CONFIG_T::n_filt;
     constexpr unsigned block_factor = DIV_ROUNDUP(mult_n_in * mult_n_out, CONFIG_T::reuse_factor);
 
     constexpr unsigned multscale = block_factor / mult_n_out;
 
-    assert((block_factor % mult_n_out == 0 || CONFIG_T::reuse_factor >= mult_n_in) &&
-           "The current Reuse Factor is not allowed");
-    assert((CONFIG_T::reuse_factor <= CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan) &&
-           "This function is correct only for RF <= FILT_HEIGHT * FILT_WIDTH * N_CHAN");
+    assert(
+        (block_factor % mult_n_out == 0 || CONFIG_T::reuse_factor >= mult_n_in) && "The current Reuse Factor is not allowed"
+    );
+    assert(
+        (CONFIG_T::reuse_factor <= CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan) &&
+        "This function is correct only for RF <= FILT_HEIGHT * FILT_WIDTH * N_CHAN"
+    );
 
     data_T data_buf[CONFIG_T::n_pixels][mult_n_in];
     #pragma HLS ARRAY_PARTITION variable=data_buf complete dim=0
@@ -68,7 +72,9 @@ void conv_2d_resource_cl(
 
                     acc[i_pxl][i_out] += static_cast<typename CONFIG_T::accum_t>(
                         CONFIG_T::mult_config::template product<data_T, typename CONFIG_T::mult_config::weight_t>::product(
-                            data_buf[i_pxl][i_in], weights[i_w]));
+                            data_buf[i_pxl][i_in], weights[i_w]
+                        )
+                    );
                 }
 
                 // Increment i_w
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_conv2d_stream.h b/hls4ml/templates/vivado/nnet_utils/nnet_conv2d_stream.h
index 1408b0db1..19e8b596e 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_conv2d_stream.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_conv2d_stream.h
@@ -9,27 +9,31 @@
 namespace nnet {
 
 template <class data_T, typename CONFIG_T>
-void compute_scaled_indices_2d(const unsigned h_idx, const unsigned w_idx,
-                               ap_uint<CONFIG_T::filt_height * CONFIG_T::filt_width> *pixel_idx) {
-    const unsigned sh_idx = CONFIG_T::template scale_index_height<CONFIG_T::filt_height, CONFIG_T::stride_height,
-                                                                  CONFIG_T::in_height>::scale_index(h_idx);
+void compute_scaled_indices_2d(
+    const unsigned h_idx, const unsigned w_idx, ap_uint<CONFIG_T::filt_height * CONFIG_T::filt_width> *pixel_idx
+) {
+    const unsigned sh_idx = CONFIG_T::
+        template scale_index_height<CONFIG_T::filt_height, CONFIG_T::stride_height, CONFIG_T::in_height>::scale_index(h_idx);
     unsigned wp_idx = w_idx * (data_T::size / CONFIG_T::n_chan);
 
 ComputeIndex:
     for (unsigned p = 0; p < data_T::size / CONFIG_T::n_chan; p++) {
         #pragma HLS UNROLL
 
-        unsigned sw_idx = CONFIG_T::template scale_index_width<CONFIG_T::filt_width, CONFIG_T::stride_width,
-                                                               CONFIG_T::in_width>::scale_index(wp_idx + p);
+        unsigned sw_idx =
+            CONFIG_T::template scale_index_width<CONFIG_T::filt_width, CONFIG_T::stride_width, CONFIG_T::in_width>::
+                scale_index(wp_idx + p);
         pixel_idx[p] = CONFIG_T::pixels[sh_idx * CONFIG_T::min_width + sw_idx];
     }
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
 void conv_2d_encoded_cl(
-    hls::stream<data_T> &data, hls::stream<res_T> &res,
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_top == 0 && CONFIG_T::pad_bottom == 0 && CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
     assert(CONFIG_T::filt_height == CONFIG_T::filt_width);
 
@@ -57,8 +61,9 @@ void conv_2d_encoded_cl(
                 #pragma HLS PIPELINE II=CONFIG_T::reuse_factor
             }
             compute_scaled_indices_2d<data_T, CONFIG_T>(i_ih, i_iw, pixel_idx);
-            compute_output_encoded<data_T, res_T, CONFIG_T>(data.read(), data_window, res, res_pack, outputs_ready, weights,
-                                                            biases, pixel_idx);
+            compute_output_encoded<data_T, res_T, CONFIG_T>(
+                data.read(), data_window, res, res_pack, outputs_ready, weights, biases, pixel_idx
+            );
         }
     }
 }
@@ -66,9 +71,11 @@ void conv_2d_encoded_cl(
 // Line Buffer
 template <class data_T, class res_T, typename CONFIG_T>
 void conv_2d_buffer_cl(
-    hls::stream<data_T> &data, hls::stream<res_T> &res,
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_top == 0 && CONFIG_T::pad_bottom == 0 && CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
 
     static ap_shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[MAX(CONFIG_T::filt_height - 1, 1)]
@@ -99,9 +106,11 @@ void conv_2d_buffer_cl(
 
 template <class data_T, class res_T, typename CONFIG_T>
 void conv_2d_cl(
-    hls::stream<data_T> &data, hls::stream<res_T> &res,
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     #pragma HLS inline recursive
     switch (CONFIG_T::implementation) {
     case conv_implementation::linebuffer:
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_conv_stream.h b/hls4ml/templates/vivado/nnet_utils/nnet_conv_stream.h
index dcd914dff..072efd228 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_conv_stream.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_conv_stream.h
@@ -77,10 +77,14 @@ template <unsigned K, unsigned S, unsigned W> class scale_index_unscaled {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void mult_buffer(hls::stream<typename data_T::value_type> data_window[CONFIG_T::kernel_size * CONFIG_T::n_chan],
-                 res_T &res_pack, hls::stream<res_T> &res_stream, unsigned &outputs_ready,
-                 typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                 typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void mult_buffer(
+    hls::stream<typename data_T::value_type> data_window[CONFIG_T::kernel_size * CONFIG_T::n_chan],
+    res_T &res_pack,
+    hls::stream<res_T> &res_stream,
+    unsigned &outputs_ready,
+    typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     #pragma HLS INLINE
 
     typename data_T::value_type data[CONFIG_T::kernel_size * CONFIG_T::n_chan];
@@ -95,8 +99,10 @@ void mult_buffer(hls::stream<typename data_T::value_type> data_window[CONFIG_T::
     }
 
     #pragma HLS INLINE recursive
-    CONFIG_T::mult_config::template kernel<typename data_T::value_type, typename res_T::value_type,
-                                           typename CONFIG_T::mult_config>::dense(data, res, weights, biases);
+    CONFIG_T::mult_config::
+        template kernel<typename data_T::value_type, typename res_T::value_type, typename CONFIG_T::mult_config>::dense(
+            data, res, weights, biases
+        );
 
 CastLoop:
     for (unsigned jj = 0; jj < CONFIG_T::n_filt; jj++) {
@@ -121,11 +127,16 @@ void mult_buffer(hls::stream<typename data_T::value_type> data_window[CONFIG_T::
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void compute_output_encoded(const data_T &in_elem,
-                            hls::stream<typename data_T::value_type> data_window[CONFIG_T::kernel_size * CONFIG_T::n_chan],
-                            hls::stream<res_T> &res, res_T &res_pack, unsigned &outputs_ready,
-                            typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan * CONFIG_T::n_filt],
-                            typename CONFIG_T::bias_t biases[CONFIG_T::n_filt], ap_uint<CONFIG_T::kernel_size> *pixel_idx) {
+void compute_output_encoded(
+    const data_T &in_elem,
+    hls::stream<typename data_T::value_type> data_window[CONFIG_T::kernel_size * CONFIG_T::n_chan],
+    hls::stream<res_T> &res,
+    res_T &res_pack,
+    unsigned &outputs_ready,
+    typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt],
+    ap_uint<CONFIG_T::kernel_size> *pixel_idx
+) {
     #pragma HLS INLINE
 
 MultLoop:
@@ -151,8 +162,9 @@ void compute_output_encoded(const data_T &in_elem,
 //       Line Buffer Implementation (Phil's)
 // *************************************************
 template <class data_T, typename CONFIG_T>
-void kernel_shift_1d(const data_T &in_elem,
-                     typename data_T::value_type kernel_window[CONFIG_T::filt_width * CONFIG_T::n_chan]) {
+void kernel_shift_1d(
+    const data_T &in_elem, typename data_T::value_type kernel_window[CONFIG_T::filt_width * CONFIG_T::n_chan]
+) {
     #pragma HLS inline
 
     // Shift kernel_window by one step to the left (manual shift operation)
@@ -180,7 +192,8 @@ void kernel_shift_1d(const data_T &in_elem,
 template <class data_T, typename CONFIG_T>
 void kernel_shift_2d(
     typename data_T::value_type shift_buffer[CONFIG_T::filt_height][CONFIG_T::n_chan],
-    typename data_T::value_type kernel_window[CONFIG_T::filt_width * CONFIG_T::filt_height * CONFIG_T::n_chan]) {
+    typename data_T::value_type kernel_window[CONFIG_T::filt_width * CONFIG_T::filt_height * CONFIG_T::n_chan]
+) {
     #pragma HLS inline
 
     // Shift kernel_window by one step to the left (manual shift operation)
@@ -216,7 +229,8 @@ void shift_line_buffer(
     const data_T &in_elem,
     ap_shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[MAX(CONFIG_T::filt_height - 1, 1)]
                                                                              [CONFIG_T::n_chan],
-    typename data_T::value_type kernel_window[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan]) {
+    typename data_T::value_type kernel_window[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan]
+) {
 
     #pragma HLS PIPELINE
 
@@ -238,8 +252,9 @@ void shift_line_buffer(
     LineBufferShift:
         for (unsigned i_ih = 1; i_ih < CONFIG_T::filt_height; i_ih++) {
             #pragma HLS UNROLL
-            typename data_T::value_type pop_elem = line_buffer[i_ih - 1][i_ic].shift(
-                shift_buffer[CONFIG_T::filt_height - i_ih][i_ic]); // Shift the line buffer, return the popped pixel
+            typename data_T::value_type pop_elem =
+                line_buffer[i_ih - 1][i_ic].shift(shift_buffer[CONFIG_T::filt_height - i_ih][i_ic]
+                ); // Shift the line buffer, return the popped pixel
             shift_buffer[CONFIG_T::filt_height - i_ih - 1][i_ic] =
                 pop_elem; // Popped element placed back into shift_buffer, one row up.
         }
@@ -254,7 +269,8 @@ void compute_output_buffer_2d(
                                                                              [CONFIG_T::n_chan],
     hls::stream<res_T> &res_stream,
     typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     #pragma HLS INLINE OFF
 
     // Thresholds
@@ -285,8 +301,10 @@ void compute_output_buffer_2d(
 
         // Dense multiply
         // #pragma HLS INLINE recursive
-        CONFIG_T::mult_config::template kernel<typename data_T::value_type, typename res_T::value_type,
-                                               typename CONFIG_T::mult_config>::dense(kernel_data, res_out, weights, biases);
+        CONFIG_T::mult_config::
+            template kernel<typename data_T::value_type, typename res_T::value_type, typename CONFIG_T::mult_config>::dense(
+                kernel_data, res_out, weights, biases
+            );
 
     // Pack output
     CastLoop:
@@ -322,9 +340,11 @@ void compute_output_buffer_2d(
 // Conv 1D compute output
 template <class data_T, class res_T, typename CONFIG_T>
 void compute_output_buffer_1d(
-    const data_T &in_elem, hls::stream<res_T> &res_stream,
+    const data_T &in_elem,
+    hls::stream<res_T> &res_stream,
     typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     #pragma HLS INLINE OFF
 
     // Thresholds
@@ -351,8 +371,10 @@ void compute_output_buffer_1d(
 
         // Dense multiply
         // #pragma HLS INLINE recursive
-        CONFIG_T::mult_config::template kernel<typename data_T::value_type, typename res_T::value_type,
-                                               typename CONFIG_T::mult_config>::dense(kernel_data, res_out, weights, biases);
+        CONFIG_T::mult_config::
+            template kernel<typename data_T::value_type, typename res_T::value_type, typename CONFIG_T::mult_config>::dense(
+                kernel_data, res_out, weights, biases
+            );
 
     // Pack output
     CastLoop:
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_dense.h b/hls4ml/templates/vivado/nnet_utils/nnet_dense.h
index d6c7beb70..b95abc371 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_dense.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_dense.h
@@ -38,18 +38,24 @@ struct dense_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-           typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-           typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
     #pragma HLS INLINE
     CONFIG_T::template kernel<data_T, res_T, CONFIG_T>::dense(data, res, weights, biases);
 }
 
 template <class data_T, class res_T, typename CONFIG_T> class DenseLatency : public DenseKernel<data_T, res_T, CONFIG_T> {
   public:
-    static void dense(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                      typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-                      typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+    static void dense(
+        data_T data[CONFIG_T::n_in],
+        res_T res[CONFIG_T::n_out],
+        typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+        typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+    ) {
         #pragma HLS INLINE
         dense_latency<data_T, res_T, CONFIG_T>(data, res, weights, biases);
     }
@@ -58,9 +64,12 @@ template <class data_T, class res_T, typename CONFIG_T> class DenseLatency : pub
 template <class data_T, class res_T, typename CONFIG_T>
 class DenseResource_rf_leq_nin : public DenseKernel<data_T, res_T, CONFIG_T> {
   public:
-    static void dense(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                      typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-                      typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+    static void dense(
+        data_T data[CONFIG_T::n_in],
+        res_T res[CONFIG_T::n_out],
+        typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+        typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+    ) {
         #pragma HLS INLINE
         dense_resource_rf_leq_nin<data_T, res_T, CONFIG_T>(data, res, weights, biases);
     }
@@ -69,9 +78,12 @@ class DenseResource_rf_leq_nin : public DenseKernel<data_T, res_T, CONFIG_T> {
 template <class data_T, class res_T, typename CONFIG_T>
 class DenseResource_rf_gt_nin_rem0 : public DenseKernel<data_T, res_T, CONFIG_T> {
   public:
-    static void dense(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                      typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-                      typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+    static void dense(
+        data_T data[CONFIG_T::n_in],
+        res_T res[CONFIG_T::n_out],
+        typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+        typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+    ) {
         #pragma HLS INLINE
         dense_resource_rf_gt_nin_rem0<data_T, res_T, CONFIG_T>(data, res, weights, biases);
     }
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_dense_compressed.h b/hls4ml/templates/vivado/nnet_utils/nnet_dense_compressed.h
index 029b74803..5431432d8 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_dense_compressed.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_dense_compressed.h
@@ -9,8 +9,9 @@
 namespace nnet {
 
 template <typename CONFIG_T>
-void fill_mult(typename CONFIG_T::index_t index, typename CONFIG_T::accum_t mult[CONFIG_T::n_out],
-               typename CONFIG_T::accum_t weight) {
+void fill_mult(
+    typename CONFIG_T::index_t index, typename CONFIG_T::accum_t mult[CONFIG_T::n_out], typename CONFIG_T::accum_t weight
+) {
     for (unsigned k = 0; k < CONFIG_T::n_out; k++) {
         #pragma HLS UNROLL
         if (k == index)
@@ -19,9 +20,12 @@ void fill_mult(typename CONFIG_T::index_t index, typename CONFIG_T::accum_t mult
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_compressed(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                      typename CONFIG_T::weight_t weights[CONFIG_T::n_nonzeros],
-                      typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense_compressed(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_nonzeros],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
 
     const int multiplier_limit = DIV_ROUNDUP(CONFIG_T::n_nonzeros, CONFIG_T::reuse_factor);
 
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_dense_latency.h b/hls4ml/templates/vivado/nnet_utils/nnet_dense_latency.h
index 02802c45a..475d62f34 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_dense_latency.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_dense_latency.h
@@ -10,9 +10,12 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_latency(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                   typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-                   typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense_latency(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
     data_T cache;
     typename CONFIG_T::accum_t mult[CONFIG_T::n_in * CONFIG_T::n_out];
     typename CONFIG_T::accum_t acc[CONFIG_T::n_out];
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_dense_resource.h b/hls4ml/templates/vivado/nnet_utils/nnet_dense_resource.h
index 333a0e75f..1dd510fde 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_dense_resource.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_dense_resource.h
@@ -10,9 +10,12 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_resource_rf_leq_nin(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                               typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-                               typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense_resource_rf_leq_nin(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
 
     const int rufactor = CONFIG_T::reuse_factor;
     const int multfactor = MIN(CONFIG_T::n_in, CONFIG_T::reuse_factor);
@@ -56,7 +59,8 @@ void dense_resource_rf_leq_nin(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::
             #pragma HLS UNROLL
 
             acc[out_index] += static_cast<typename CONFIG_T::accum_t>(
-                CONFIG_T::template product<data_T, typename CONFIG_T::weight_t>::product(data[in_index], weights[w_index]));
+                CONFIG_T::template product<data_T, typename CONFIG_T::weight_t>::product(data[in_index], weights[w_index])
+            );
 
             // Increment w_index
             w_index += rufactor;
@@ -84,9 +88,12 @@ void dense_resource_rf_leq_nin(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_resource_rf_gt_nin_rem0(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                                   typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-                                   typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense_resource_rf_gt_nin_rem0(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
 
     const int rufactor = MIN(CONFIG_T::reuse_factor, CONFIG_T::n_in * CONFIG_T::n_out);
     const int multfactor = MIN(CONFIG_T::n_in, CONFIG_T::reuse_factor);
@@ -142,7 +149,8 @@ void dense_resource_rf_gt_nin_rem0(data_T data[CONFIG_T::n_in], res_T res[CONFIG
         for (int im = 0; im < block_factor; im++) {
             #pragma HLS UNROLL
             acc[out_index] += static_cast<typename CONFIG_T::accum_t>(
-                CONFIG_T::template product<data_T, typename CONFIG_T::weight_t>::product(data[in_index], weights[w_index]));
+                CONFIG_T::template product<data_T, typename CONFIG_T::weight_t>::product(data[in_index], weights[w_index])
+            );
 
             w_index += rufactor;
             if (w_index >= CONFIG_T::n_in * CONFIG_T::n_out)
@@ -166,9 +174,12 @@ void dense_resource_rf_gt_nin_rem0(data_T data[CONFIG_T::n_in], res_T res[CONFIG
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_resource_rf_gt_nin(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                              typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-                              typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense_resource_rf_gt_nin(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
 
     const int rufactor = CONFIG_T::reuse_factor;
     const int multfactor = MIN(CONFIG_T::n_in, CONFIG_T::reuse_factor);
@@ -252,9 +263,12 @@ void dense_resource_rf_gt_nin(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_resource(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-                    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense_resource(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
 
     #pragma HLS INLINE recursive
 
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_dense_stream.h b/hls4ml/templates/vivado/nnet_utils/nnet_dense_stream.h
index 3e3183480..ccae91f57 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_dense_stream.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_dense_stream.h
@@ -10,9 +10,12 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense_wrapper(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                   typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-                   typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense_wrapper(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_out],
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
     #pragma HLS INLINE recursive
     if (CONFIG_T::strategy == nnet::latency) {
         #pragma HLS PIPELINE II=CONFIG_T::reuse_factor
@@ -21,9 +24,12 @@ void dense_wrapper(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void dense(hls::stream<data_T> &data_stream, hls::stream<res_T> &res_stream,
-           typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-           typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+void dense(
+    hls::stream<data_T> &data_stream,
+    hls::stream<res_T> &res_stream,
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+) {
     typename data_T::value_type data[CONFIG_T::n_in];
     #pragma HLS ARRAY_PARTITION variable=data complete
 
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_embed.h b/hls4ml/templates/vivado/nnet_utils/nnet_embed.h
index dfc77afaf..a12040d3a 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_embed.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_embed.h
@@ -21,8 +21,11 @@ struct embed_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void embedding(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_in * CONFIG_T::n_out],
-               typename CONFIG_T::embeddings_t embeddings[CONFIG_T::vocab_size * CONFIG_T::n_out]) {
+void embedding(
+    data_T data[CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_in * CONFIG_T::n_out],
+    typename CONFIG_T::embeddings_t embeddings[CONFIG_T::vocab_size * CONFIG_T::n_out]
+) {
 
     #pragma HLS PIPELINE II=CONFIG_T::reuse_factor
     // This can save a few cycles, but it will create a large multiplexer due to
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_embed_stream.h b/hls4ml/templates/vivado/nnet_utils/nnet_embed_stream.h
index 79ae9bc10..1a27cea10 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_embed_stream.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_embed_stream.h
@@ -8,8 +8,11 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void embedding(hls::stream<data_T> &data, hls::stream<res_T> &res,
-               typename CONFIG_T::embeddings_t embeddings[CONFIG_T::vocab_size * CONFIG_T::n_out]) {
+void embedding(
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
+    typename CONFIG_T::embeddings_t embeddings[CONFIG_T::vocab_size * CONFIG_T::n_out]
+) {
     data_T in_data = data.read();
 
 InputSequence:
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_function_stubs.h b/hls4ml/templates/vivado/nnet_utils/nnet_function_stubs.h
index 1316bbe77..6d69d4407 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_function_stubs.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_function_stubs.h
@@ -11,28 +11,34 @@ namespace nnet {
 
 template <class data_T, typename CONFIG_T> class FillConv1DBuffer {
   public:
-    static void fill_buffer(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                            data_T buffer[CONFIG_T::n_pixels][CONFIG_T::filt_width * CONFIG_T::n_chan],
-                            const unsigned partition) {
+    static void fill_buffer(
+        data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+        data_T buffer[CONFIG_T::n_pixels][CONFIG_T::filt_width * CONFIG_T::n_chan],
+        const unsigned partition
+    ) {
         // To be implemented in subclasses
     }
 };
 
 template <class data_T, typename CONFIG_T> class FillConv2DBuffer {
   public:
-    static void
-    fill_buffer(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
-                data_T buffer[CONFIG_T::n_pixels][CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan],
-                const unsigned partition) {
+    static void fill_buffer(
+        data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
+        data_T buffer[CONFIG_T::n_pixels][CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan],
+        const unsigned partition
+    ) {
         // To be implemented in subclasses
     }
 };
 
 template <class data_T, class res_T, typename CONFIG_T> class DenseKernel {
   public:
-    static void dense(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],
-                      typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
-                      typename CONFIG_T::bias_t biases[CONFIG_T::n_out]) {
+    static void dense(
+        data_T data[CONFIG_T::n_in],
+        res_T res[CONFIG_T::n_out],
+        typename CONFIG_T::weight_t weights[CONFIG_T::n_in * CONFIG_T::n_out],
+        typename CONFIG_T::bias_t biases[CONFIG_T::n_out]
+    ) {
         // To be implemented in subclasses
     }
 };
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_garnet.h b/hls4ml/templates/vivado/nnet_utils/nnet_garnet.h
index 1fcd55459..9506b379b 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_garnet.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_garnet.h
@@ -90,15 +90,15 @@ template <class CONFIG_T> typename CONFIG_T::edge_weight_t compute_edge_weight(t
 }
 
 template <class dividend_T, class exponent_T>
-inline typename std::enable_if<std::is_class<dividend_T>::value, dividend_T>::type normalize_log2(dividend_T dividend,
-                                                                                                  exponent_T exponent) {
+inline typename std::enable_if<std::is_class<dividend_T>::value, dividend_T>::type
+normalize_log2(dividend_T dividend, exponent_T exponent) {
     #pragma HLS INLINE
     return dividend >> exponent;
 }
 
 template <class dividend_T, class exponent_T>
-inline typename std::enable_if<not std::is_class<dividend_T>::value, dividend_T>::type normalize_log2(dividend_T dividend,
-                                                                                                      exponent_T exponent) {
+inline typename std::enable_if<not std::is_class<dividend_T>::value, dividend_T>::type
+normalize_log2(dividend_T dividend, exponent_T exponent) {
     #pragma HLS INLINE
     return dividend / std::pow(2., exponent);
 }
@@ -298,8 +298,8 @@ template <class CONFIG_T, class res_T> struct SingleVertexResSetter {
 };
 
 template <class CONFIG_T, class data_getter_T, class arrays_local_T, class arrays_T>
-inline void compute_weights_aggregates(data_getter_T const &data_getter, unsigned iv, arrays_local_T &arrays_local,
-                                       arrays_T &arrays) {
+inline void
+compute_weights_aggregates(data_getter_T const &data_getter, unsigned iv, arrays_local_T &arrays_local, arrays_T &arrays) {
     #pragma HLS INLINE
 
 Aggregators:
@@ -354,8 +354,9 @@ inline typename CONFIG_T::aggr_t compute_output_base_core(arrays_T const &arrays
 }
 
 template <class CONFIG_T, class arrays_T>
-inline void compute_output_base(arrays_T const &arrays,
-                                typename CONFIG_T::aggr_t output_base[CONFIG_T::n_out_features * CONFIG_T::n_aggregators]) {
+inline void compute_output_base(
+    arrays_T const &arrays, typename CONFIG_T::aggr_t output_base[CONFIG_T::n_out_features * CONFIG_T::n_aggregators]
+) {
     #pragma HLS INLINE
     #pragma HLS UNROLL region
 
@@ -371,10 +372,12 @@ inline void compute_output_base(arrays_T const &arrays,
 }
 
 template <class CONFIG_T, class arrays_T, class res_setter_T>
-inline void
-compute_vertex_output(arrays_T const &arrays, unsigned iv,
-                      typename CONFIG_T::aggr_t const output_base[CONFIG_T::n_out_features * CONFIG_T::n_aggregators],
-                      res_setter_T &res_setter) {
+inline void compute_vertex_output(
+    arrays_T const &arrays,
+    unsigned iv,
+    typename CONFIG_T::aggr_t const output_base[CONFIG_T::n_out_features * CONFIG_T::n_aggregators],
+    res_setter_T &res_setter
+) {
     #pragma HLS INLINE
 
     typename arrays_T::edge_weight_t edge_weights[CONFIG_T::n_aggregators];
@@ -467,8 +470,9 @@ void distribute(nvtx_T const nvtx, arrays_T const &arrays, res_T res[CONFIG_T::n
 }
 
 template <class CONFIG_T, class output_biases_T, class arrays_T, class res_T>
-void set_output(output_biases_T const &output_transform_biases, arrays_T const &arrays,
-                res_T res[CONFIG_T::n_out_features]) {
+void set_output(
+    output_biases_T const &output_transform_biases, arrays_T const &arrays, res_T res[CONFIG_T::n_out_features]
+) {
     #pragma HLS PIPELINE
 
 OutFeatures:
@@ -533,8 +537,13 @@ void distribute_aggregate(nvtx_T const nvtx, prev_arrays_T const &prev_arrays, c
     current_arrays.set_means_normalized(nvtx, means_accum);
 }
 
-template <class prev_layer_t, class current_layer_t, class last_layer_t, class nvtx_T, class prev_arrays_T,
-          class last_arrays_T>
+template <
+    class prev_layer_t,
+    class current_layer_t,
+    class last_layer_t,
+    class nvtx_T,
+    class prev_arrays_T,
+    class last_arrays_T>
 inline typename std::enable_if<std::is_same<current_layer_t, last_layer_t>::value>::type
 sublayer(nvtx_T const nvtx, prev_arrays_T const &prev_arrays, last_arrays_T &last_arrays) {
     #pragma HLS INLINE
@@ -542,8 +551,13 @@ sublayer(nvtx_T const nvtx, prev_arrays_T const &prev_arrays, last_arrays_T &las
     distribute_aggregate<prev_layer_t, current_layer_t>(nvtx, prev_arrays, last_arrays);
 }
 
-template <class prev_layer_t, class current_layer_t, class last_layer_t, class nvtx_T, class prev_arrays_T,
-          class last_arrays_T>
+template <
+    class prev_layer_t,
+    class current_layer_t,
+    class last_layer_t,
+    class nvtx_T,
+    class prev_arrays_T,
+    class last_arrays_T>
 inline typename std::enable_if<not std::is_same<current_layer_t, last_layer_t>::value>::type
 sublayer(nvtx_T const nvtx, prev_arrays_T const &prev_arrays, last_arrays_T &last_arrays) {
     #pragma HLS INLINE
@@ -601,9 +615,11 @@ struct garnet_config {
 
 // vertices -> vertices
 template <class data_T, class nvtx_T, class res_T, typename CONFIG_T>
-typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::no_collapse>::type
-garnet(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features], nvtx_T const nvtx[1],
-       res_T res[CONFIG_T::n_vertices * CONFIG_T::n_out_features]) {
+typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::no_collapse>::type garnet(
+    data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features],
+    nvtx_T const nvtx[1],
+    res_T res[CONFIG_T::n_vertices * CONFIG_T::n_out_features]
+) {
     #pragma HLS DATAFLOW
 
     garnet_utils::WeightsAndMeans<CONFIG_T> arrays;
@@ -615,9 +631,11 @@ garnet(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features], nvtx_T
 
 // vertices -> out features
 template <class data_T, class nvtx_T, class res_T, class CONFIG_T>
-typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::collapse_mean>::type
-garnet(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features], nvtx_T const nvtx[1],
-       res_T res[CONFIG_T::n_out_features]) {
+typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::collapse_mean>::type garnet(
+    data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features],
+    nvtx_T const nvtx[1],
+    res_T res[CONFIG_T::n_out_features]
+) {
     #pragma HLS DATAFLOW
 
     garnet_utils::Means<CONFIG_T> arrays;
@@ -631,9 +649,11 @@ garnet(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features], nvtx_T
 
 // vertices -> vertices
 template <class data_T, class nvtx_T, class res_T, class CONFIG_T>
-typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::no_collapse>::type
-garnet_stack(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features], nvtx_T const nvtx[1],
-             res_T res[CONFIG_T::n_vertices * CONFIG_T::n_out_features]) {
+typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::no_collapse>::type garnet_stack(
+    data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features],
+    nvtx_T const nvtx[1],
+    res_T res[CONFIG_T::n_vertices * CONFIG_T::n_out_features]
+) {
     #pragma HLS DATAFLOW
 
     typedef typename CONFIG_T::template sublayer_t<0> first_layer_t;
@@ -645,17 +665,20 @@ garnet_stack(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features],
 
     garnet_utils::aggregate<first_layer_t>(data, nvtx[0], arrays_first);
 
-    garnet_utils::sublayer<first_layer_t, typename first_layer_t::next_layer_t, last_layer_t>(nvtx[0], arrays_first,
-                                                                                              arrays_last);
+    garnet_utils::sublayer<first_layer_t, typename first_layer_t::next_layer_t, last_layer_t>(
+        nvtx[0], arrays_first, arrays_last
+    );
 
     garnet_utils::distribute<last_layer_t>(nvtx[0], arrays_last, res);
 }
 
 // vertices -> out features
 template <class data_T, class nvtx_T, class res_T, class CONFIG_T>
-typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::collapse_mean>::type
-garnet_stack(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features], nvtx_T const nvtx[1],
-             res_T res[CONFIG_T::n_out_features]) {
+typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::collapse_mean>::type garnet_stack(
+    data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features],
+    nvtx_T const nvtx[1],
+    res_T res[CONFIG_T::n_out_features]
+) {
     #pragma HLS DATAFLOW
 
     typedef typename CONFIG_T::template sublayer_t<0> first_layer_t;
@@ -667,8 +690,9 @@ garnet_stack(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features],
 
     garnet_utils::aggregate<first_layer_t>(data, nvtx[0], arrays_first);
 
-    garnet_utils::sublayer<first_layer_t, typename first_layer_t::next_layer_t, last_layer_t>(nvtx[0], arrays_first,
-                                                                                              arrays_last);
+    garnet_utils::sublayer<first_layer_t, typename first_layer_t::next_layer_t, last_layer_t>(
+        nvtx[0], arrays_first, arrays_last
+    );
 
     garnet_utils::OutputBiasNormalizer<last_layer_t, nvtx_T> normalize_bias(nvtx[0]);
 
@@ -677,9 +701,11 @@ garnet_stack(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features],
 
 /* Reference (dumb) implementation returning (Vertices, Features) */
 template <class data_T, class nvtx_T, class res_T, typename CONFIG_T>
-typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::no_collapse>::type
-garnet_ref(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features], nvtx_T const nvtx[1],
-           res_T res[CONFIG_T::n_vertices * CONFIG_T::n_out_features]) {
+typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::no_collapse>::type garnet_ref(
+    data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features],
+    nvtx_T const nvtx[1],
+    res_T res[CONFIG_T::n_vertices * CONFIG_T::n_out_features]
+) {
     typename CONFIG_T::edge_weight_t edge_weights[CONFIG_T::n_vertices * CONFIG_T::n_aggregators];
     typename CONFIG_T::aggr_t propagated_features[CONFIG_T::n_vertices * CONFIG_T::n_propagate];
 
@@ -781,9 +807,11 @@ garnet_ref(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features], nv
 
 /* Reference (dumb) implementation returning (Features) - output averaged over vertices already */
 template <class data_T, class nvtx_T, class res_T, typename CONFIG_T>
-typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::collapse_mean>::type
-garnet_ref(data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features], nvtx_T const nvtx[1],
-           res_T res[CONFIG_T::n_out_features]) {
+typename std::enable_if<CONFIG_T::output_collapse == CONFIG_T::collapse_mean>::type garnet_ref(
+    data_T const data[CONFIG_T::n_vertices * CONFIG_T::n_in_features],
+    nvtx_T const nvtx[1],
+    res_T res[CONFIG_T::n_out_features]
+) {
     typename CONFIG_T::aggr_t vertex_res[CONFIG_T::n_vertices * CONFIG_T::n_out_features];
 
     garnet_ref<CONFIG_T>(data, nvtx, vertex_res);
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_image.h b/hls4ml/templates/vivado/nnet_utils/nnet_image.h
index eeb454815..cc3c37203 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_image.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_image.h
@@ -16,8 +16,10 @@ struct resize_config {
 };
 
 template <class data_T, typename CONFIG_T>
-void resize_nearest(data_T image[CONFIG_T::height * CONFIG_T::width * CONFIG_T::n_chan],
-                    data_T resized[CONFIG_T::new_height * CONFIG_T::new_width * CONFIG_T::n_chan]) {
+void resize_nearest(
+    data_T image[CONFIG_T::height * CONFIG_T::width * CONFIG_T::n_chan],
+    data_T resized[CONFIG_T::new_height * CONFIG_T::new_width * CONFIG_T::n_chan]
+) {
     int y_ratio = (int)((CONFIG_T::height << 16) / CONFIG_T::new_height) + 1;
     int x_ratio = (int)((CONFIG_T::width << 16) / CONFIG_T::new_width) + 1;
     int x2, y2;
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_math.h b/hls4ml/templates/vivado/nnet_utils/nnet_math.h
index c021d8eb5..e993431ad 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_math.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_math.h
@@ -92,8 +92,9 @@ template <class T> void sincos_lut(const T &input, T output[2]) {
         if ((luTdex1 % (1 << (AP_MAX(T::width - T::iwidth - 12, 0)))) > (1 << (AP_MAX(T::width - T::iwidth - 13, 0)))) {
             luTdex = luTdex + 1;
         }
-        typedef ap_ufixed<AP_MAX((AP_MAX(T::width - T::iwidth - 3, 1) + T::width - T::iwidth - 12), 1),
-                          AP_MAX(T::width - T::iwidth - 3, 1)>
+        typedef ap_ufixed<
+            AP_MAX((AP_MAX(T::width - T::iwidth - 3, 1) + T::width - T::iwidth - 12), 1),
+            AP_MAX(T::width - T::iwidth - 3, 1)>
             datatype;
         datatype x = (datatype)luTdex1;
         x = x >> AP_MAX(T::width - T::iwidth - 12, 0);
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_merge.h b/hls4ml/templates/vivado/nnet_utils/nnet_merge.h
index 979c44782..80c2b72c0 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_merge.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_merge.h
@@ -113,8 +113,11 @@ void dot1d(input1_T data1[CONFIG_T::n_in], input2_T data2[CONFIG_T::n_in], res_T
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate1d(input1_T data1[CONFIG_T::n_elem1_0], input2_T data2[CONFIG_T::n_elem2_0],
-                   res_T res[CONFIG_T::n_elem1_0 + CONFIG_T::n_elem2_0]) {
+void concatenate1d(
+    input1_T data1[CONFIG_T::n_elem1_0],
+    input2_T data2[CONFIG_T::n_elem2_0],
+    res_T res[CONFIG_T::n_elem1_0 + CONFIG_T::n_elem2_0]
+) {
     #pragma HLS PIPELINE
 
     for (int ii = 0; ii < CONFIG_T::n_elem1_0; ii++) {
@@ -126,9 +129,11 @@ void concatenate1d(input1_T data1[CONFIG_T::n_elem1_0], input2_T data2[CONFIG_T:
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate2d_0(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
-                     input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1],
-                     res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 + CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1]) {
+void concatenate2d_0(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1],
+    res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 + CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1]
+) {
     #pragma HLS PIPELINE
 
     for (int ii = 0; ii < CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1; ii++) {
@@ -140,9 +145,11 @@ void concatenate2d_0(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate2d_1(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
-                     input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1],
-                     res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 + CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1]) {
+void concatenate2d_1(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1],
+    res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 + CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1]
+) {
     #pragma HLS PIPELINE
 
     for (int ii = 0; ii < CONFIG_T::n_elem1_0; ii++) {
@@ -157,9 +164,11 @@ void concatenate2d_1(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate2d(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
-                   input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1],
-                   res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 + CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1]) {
+void concatenate2d(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1],
+    res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 + CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1]
+) {
     #pragma HLS INLINE
 
     if (CONFIG_T::axis == 2 || CONFIG_T::axis == -1) {
@@ -170,10 +179,13 @@ void concatenate2d(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1],
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate3d_0(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
-                     input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
-                     res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
-                               CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]) {
+void concatenate3d_0(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
+    res_T
+        res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
+            CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]
+) {
     #pragma HLS PIPELINE
 
     for (int ii = 0; ii < CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2; ii++) {
@@ -185,10 +197,13 @@ void concatenate3d_0(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 *
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate3d_1(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
-                     input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
-                     res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
-                               CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]) {
+void concatenate3d_1(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
+    res_T
+        res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
+            CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]
+) {
     #pragma HLS PIPELINE
 
     for (int ii = 0; ii < CONFIG_T::n_elem1_0; ii++) {
@@ -212,10 +227,13 @@ void concatenate3d_1(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 *
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate3d_2(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
-                     input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
-                     res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
-                               CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]) {
+void concatenate3d_2(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
+    res_T
+        res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
+            CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]
+) {
     #pragma HLS PIPELINE
 
     for (int ii = 0; ii < CONFIG_T::n_elem1_0; ii++) {
@@ -237,10 +255,13 @@ void concatenate3d_2(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 *
 }
 
 template <class input1_T, class input2_T, class res_T, typename CONFIG_T>
-void concatenate3d(input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
-                   input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
-                   res_T res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
-                             CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]) {
+void concatenate3d(
+    input1_T data1[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2],
+    input2_T data2[CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2],
+    res_T
+        res[CONFIG_T::n_elem1_0 * CONFIG_T::n_elem1_1 * CONFIG_T::n_elem1_2 +
+            CONFIG_T::n_elem2_0 * CONFIG_T::n_elem2_1 * CONFIG_T::n_elem2_2]
+) {
     #pragma HLS INLINE
 
     if (CONFIG_T::axis == 3 || CONFIG_T::axis == -1) {
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_mult.h b/hls4ml/templates/vivado/nnet_utils/nnet_mult.h
index 00d1c6d12..07bbcd545 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_mult.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_mult.h
@@ -92,16 +92,17 @@ template <class x_T, class w_T> class weight_exponential : public Product {
 } // namespace product
 
 template <class data_T, class res_T, typename CONFIG_T>
-inline typename std::enable_if<std::is_same<data_T, ap_uint<1>>::value &&
-                                   std::is_same<typename CONFIG_T::weight_t, ap_uint<1>>::value,
-                               ap_int<nnet::ceillog2(CONFIG_T::n_in) + 2>>::type
+inline typename std::enable_if<
+    std::is_same<data_T, ap_uint<1>>::value && std::is_same<typename CONFIG_T::weight_t, ap_uint<1>>::value,
+    ap_int<nnet::ceillog2(CONFIG_T::n_in) + 2>>::type
 cast(typename CONFIG_T::accum_t x) {
     return (ap_int<nnet::ceillog2(CONFIG_T::n_in) + 2>)(x - CONFIG_T::n_in / 2) * 2;
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
 inline typename std::enable_if<
-    std::is_same<data_T, ap_uint<1>>::value && !std::is_same<typename CONFIG_T::weight_t, ap_uint<1>>::value, res_T>::type
+    std::is_same<data_T, ap_uint<1>>::value && !std::is_same<typename CONFIG_T::weight_t, ap_uint<1>>::value,
+    res_T>::type
 cast(typename CONFIG_T::accum_t x) {
     return (res_T)x;
 }
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_padding.h b/hls4ml/templates/vivado/nnet_utils/nnet_padding.h
index e48a2fb47..a356ee8c7 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_padding.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_padding.h
@@ -68,8 +68,10 @@ struct padding2d_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void zeropad2d_cf(data_T data[CONFIG_T::n_chan * CONFIG_T::in_height * CONFIG_T::in_width],
-                  data_T res[CONFIG_T::n_chan * CONFIG_T::out_height * CONFIG_T::out_width]) {
+void zeropad2d_cf(
+    data_T data[CONFIG_T::n_chan * CONFIG_T::in_height * CONFIG_T::in_width],
+    data_T res[CONFIG_T::n_chan * CONFIG_T::out_height * CONFIG_T::out_width]
+) {
     #pragma HLS PIPELINE
 
     for (int k = 0; k < CONFIG_T::n_chan; k++) {
@@ -101,8 +103,10 @@ void zeropad2d_cf(data_T data[CONFIG_T::n_chan * CONFIG_T::in_height * CONFIG_T:
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void zeropad2d_cl(data_T data[CONFIG_T::n_chan * CONFIG_T::in_height * CONFIG_T::in_width],
-                  res_T res[CONFIG_T::n_chan * CONFIG_T::out_height * CONFIG_T::out_width]) {
+void zeropad2d_cl(
+    data_T data[CONFIG_T::n_chan * CONFIG_T::in_height * CONFIG_T::in_width],
+    res_T res[CONFIG_T::n_chan * CONFIG_T::out_height * CONFIG_T::out_width]
+) {
     #pragma HLS PIPELINE
 
     for (int i = 0; i < CONFIG_T::pad_top; i++) {
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_pooling.h b/hls4ml/templates/vivado/nnet_utils/nnet_pooling.h
index bb9f0b3f0..ff042ef84 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_pooling.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_pooling.h
@@ -167,8 +167,10 @@ template <typename CONFIG_T> constexpr int pool_op_limit() {
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pooling2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt],
-                  res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt]) {
+void pooling2d_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt],
+    res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt]
+) {
     #pragma HLS PIPELINE II=CONFIG_T::reuse_factor
 
     // TODO partition the arrays according to the reuse factor
@@ -214,16 +216,21 @@ void pooling2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_
 
                 res[(ii / CONFIG_T::stride_height) * CONFIG_T::out_width * CONFIG_T::n_filt +
                     (jj / CONFIG_T::stride_width) * CONFIG_T::n_filt + ff] =
-                    pool_op<data_T, CONFIG_T::pool_height * CONFIG_T::pool_width, CONFIG_T::pool_op,
-                            typename CONFIG_T::accum_t>(pool, patch_size);
+                    pool_op<
+                        data_T,
+                        CONFIG_T::pool_height * CONFIG_T::pool_width,
+                        CONFIG_T::pool_op,
+                        typename CONFIG_T::accum_t>(pool, patch_size);
             }
         }
     }
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pooling2d_cf(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt],
-                  res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt]) {
+void pooling2d_cf(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt],
+    res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt]
+) {
     #pragma HLS PIPELINE II=CONFIG_T::reuse_factor
 
     // TODO partition the arrays according to the reuse factor
@@ -255,9 +262,9 @@ void pooling2d_cf(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_
                             if (CONFIG_T::count_pad)
                                 img_overlap++;
                         } else {
-                            pool[kk * CONFIG_T::stride_width + ll] =
-                                data[(ii + kk - CONFIG_T::pad_top) * CONFIG_T::in_width +
-                                     ff * CONFIG_T::in_width * CONFIG_T::in_height + ll + jj - CONFIG_T::pad_left];
+                            pool[kk * CONFIG_T::stride_width + ll] = data
+                                [(ii + kk - CONFIG_T::pad_top) * CONFIG_T::in_width +
+                                 ff * CONFIG_T::in_width * CONFIG_T::in_height + ll + jj - CONFIG_T::pad_left];
                             img_overlap++;
                         }
                     }
@@ -267,8 +274,11 @@ void pooling2d_cf(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_
                 // not overlapping padding region
                 res[(ii / CONFIG_T::stride_height) * CONFIG_T::out_width + (jj / CONFIG_T::stride_width) +
                     ff * CONFIG_T::out_height * CONFIG_T::out_width] =
-                    pool_op<data_T, CONFIG_T::pool_height * CONFIG_T::pool_width, CONFIG_T::pool_op,
-                            typename CONFIG_T::accum_t>(pool);
+                    pool_op<
+                        data_T,
+                        CONFIG_T::pool_height * CONFIG_T::pool_width,
+                        CONFIG_T::pool_op,
+                        typename CONFIG_T::accum_t>(pool);
                 // If the pool op is Average, the zero-padding needs to be removed from the results
                 if (CONFIG_T::pool_op == Average) {
                     data_T rescale =
@@ -282,8 +292,9 @@ void pooling2d_cf(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void global_pooling2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt],
-                         res_T res[CONFIG_T::n_filt]) {
+void global_pooling2d_cl(
+    data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_filt], res_T res[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
     assert(CONFIG_T::pad_top == 0 && CONFIG_T::pad_bottom == 0);
     assert(CONFIG_T::pool_width == CONFIG_T::stride_width);
@@ -304,7 +315,8 @@ void global_pooling2d_cl(data_T data[CONFIG_T::in_height * CONFIG_T::in_width *
         }
 
         res[filt] = static_cast<res_T>(
-            pool_op<data_T, CONFIG_T::in_height * CONFIG_T::in_width, CONFIG_T::pool_op, typename CONFIG_T::accum_t>(pool));
+            pool_op<data_T, CONFIG_T::in_height * CONFIG_T::in_width, CONFIG_T::pool_op, typename CONFIG_T::accum_t>(pool)
+        );
     }
 }
 
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_pooling_stream.h b/hls4ml/templates/vivado/nnet_utils/nnet_pooling_stream.h
index 13d5979a1..01bec16e0 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_pooling_stream.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_pooling_stream.h
@@ -34,9 +34,14 @@ template <unsigned TABLE_SIZE, unsigned POOL_SIZE> void init_pool_table(unsigned
 
 template <class data_T, class res_T, typename CONFIG_T>
 void compute_pool_encoded_2d(
-    const unsigned h_idx, const unsigned w_idx, const data_T &in_elem,
+    const unsigned h_idx,
+    const unsigned w_idx,
+    const data_T &in_elem,
     hls::stream<typename data_T::value_type> data_window[CONFIG_T::pool_height * CONFIG_T::pool_width * CONFIG_T::n_filt],
-    hls::stream<res_T> &res, res_T &res_pack, unsigned &outputs_ready) {
+    hls::stream<res_T> &res,
+    res_T &res_pack,
+    unsigned &outputs_ready
+) {
     // Nearest H without unused pixels on the right
     constexpr unsigned nH =
         ((CONFIG_T::in_height - CONFIG_T::pool_height) / CONFIG_T::stride_height) * CONFIG_T::stride_height +
@@ -92,7 +97,8 @@ void compute_pool_encoded_2d(
         for (unsigned c = 0; c < CONFIG_T::n_filt; c++) {
             if (filt_mask > 0)
                 data_window[c * CONFIG_T::pool_height * CONFIG_T::pool_width + filt_mask.to_uint() - 1].write(
-                    in_elem[p * CONFIG_T::n_filt + c]);
+                    in_elem[p * CONFIG_T::n_filt + c]
+                );
         }
 
         if (filt_mask == CONFIG_T::pool_height * CONFIG_T::pool_width) {
@@ -106,11 +112,13 @@ void compute_pool_encoded_2d(
                     1) { // Saves resources if we don't pack output, compiler will remove the else branch
                     res_pack[c] =
                         reduce_pool<typename CONFIG_T::accum_t, CONFIG_T::pool_height * CONFIG_T::pool_width, CONFIG_T>(
-                            pool_window);
+                            pool_window
+                        );
                 } else {
                     res_pack[outputs_ready * CONFIG_T::n_filt + c] =
                         reduce_pool<typename CONFIG_T::accum_t, CONFIG_T::pool_height * CONFIG_T::pool_width, CONFIG_T>(
-                            pool_window);
+                            pool_window
+                        );
                 }
             }
             if (res_T::size / CONFIG_T::n_filt ==
@@ -153,8 +161,9 @@ void pooling2d_encoded_cl(hls::stream<data_T> &data, hls::stream<res_T> &res) {
             if (res_T::size / CONFIG_T::n_filt == 1) {
                 #pragma HLS PIPELINE II=pack_factor
             }
-            compute_pool_encoded_2d<data_T, res_T, CONFIG_T>(i_ih, i_iw, data.read(), data_window, res, res_pack,
-                                                             outputs_ready);
+            compute_pool_encoded_2d<data_T, res_T, CONFIG_T>(
+                i_ih, i_iw, data.read(), data_window, res, res_pack, outputs_ready
+            );
         }
     }
 }
@@ -163,10 +172,12 @@ void pooling2d_encoded_cl(hls::stream<data_T> &data, hls::stream<res_T> &res) {
 //       Line Buffer Implementation (Phil's)
 // *************************************************
 template <class data_T, class res_T, typename CONFIG_T>
-void compute_pool_buffer_2d(const data_T &in_elem,
-                            ap_shift_reg<typename data_T::value_type, CONFIG_T::in_width>
-                                line_buffer[MAX(CONFIG_T::pool_height - 1, 1)][CONFIG_T::n_filt],
-                            hls::stream<res_T> &res) {
+void compute_pool_buffer_2d(
+    const data_T &in_elem,
+    ap_shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[MAX(CONFIG_T::pool_height - 1, 1)]
+                                                                             [CONFIG_T::n_filt],
+    hls::stream<res_T> &res
+) {
     #pragma HLS INLINE
     const static int lShiftX = CONFIG_T::pool_width - 1;
     const static int lShiftY = CONFIG_T::pool_height - 1;
@@ -267,9 +278,14 @@ void pooling2d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res) {
 // *************************************************
 
 template <class data_T, class res_T, typename CONFIG_T>
-void compute_pool_encoded_1d(const unsigned w_idx, const data_T &in_elem,
-                             hls::stream<typename data_T::value_type> data_window[CONFIG_T::pool_width * CONFIG_T::n_filt],
-                             hls::stream<res_T> &res, res_T &res_pack, unsigned &outputs_ready) {
+void compute_pool_encoded_1d(
+    const unsigned w_idx,
+    const data_T &in_elem,
+    hls::stream<typename data_T::value_type> data_window[CONFIG_T::pool_width * CONFIG_T::n_filt],
+    hls::stream<res_T> &res,
+    res_T &res_pack,
+    unsigned &outputs_ready
+) {
     // Nearest W without unused pixels on the right
     constexpr unsigned nW =
         ((CONFIG_T::n_in - CONFIG_T::pool_width) / CONFIG_T::stride_width) * CONFIG_T::stride_width + CONFIG_T::pool_width;
@@ -485,7 +501,8 @@ void compute_global_pool(const data_T &in_elem, typename CONFIG_T::accum_t data_
             data_pack[p] = in_elem[p * CONFIG_T::n_filt + c];
         }
         data_window[c] = reduce_global_pool<typename CONFIG_T::accum_t, data_T::size / CONFIG_T::n_filt, CONFIG_T>(
-            data_window[c], data_pack);
+            data_window[c], data_pack
+        );
     }
 }
 
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_recurrent.h b/hls4ml/templates/vivado/nnet_utils/nnet_recurrent.h
index d3b96ba5f..f8c1d68d6 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_recurrent.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_recurrent.h
@@ -45,11 +45,16 @@ struct lstm_config {
 //  Originall had a version allows for the state in each layer to be saved, moved this to above (this requires are LARGE
 //  dense network at the end)
 template <class data_T, class res_T, typename CONFIG_T>
-void lstm(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG_T::n_state],
-          res_T s_newstate[CONFIG_T::n_state], typename CONFIG_T::weight_t param[CONFIG_T::n_state * 4 * CONFIG_T::n_in],
-          typename CONFIG_T::weight_t param_r[CONFIG_T::n_state * 4 * CONFIG_T::n_state],
-          typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 4],
-          typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 4]) {
+void lstm(
+    bool reset_state,
+    data_T data[CONFIG_T::n_in],
+    res_T h_newstate[CONFIG_T::n_state],
+    res_T s_newstate[CONFIG_T::n_state],
+    typename CONFIG_T::weight_t param[CONFIG_T::n_state * 4 * CONFIG_T::n_in],
+    typename CONFIG_T::weight_t param_r[CONFIG_T::n_state * 4 * CONFIG_T::n_state],
+    typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 4],
+    typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 4]
+) {
     // Initialize the state variable -- will maintain state between function calls
 
     typename CONFIG_T::accum_t tmpres[CONFIG_T::n_state * 4];
@@ -87,11 +92,13 @@ void lstm(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG
     }
 
     CONFIG_T::template activation_recr<data_T, typename CONFIG_T::weight_t, typename CONFIG_T::ACT_CONFIG_LSTM>::activation(
-        inputacc_ifo, tmpres_ifo);
+        inputacc_ifo, tmpres_ifo
+    );
 
     // Now for the confusion matrix
     CONFIG_T::template activation<data_T, typename CONFIG_T::weight_t, typename CONFIG_T::ACT_CONFIG_T>::activation(
-        inputacc_c, tmpres_c);
+        inputacc_c, tmpres_c
+    );
 
     // Operation: s=g*i+sold*f (update state with buffer to avoid timing issues)
     for (int iacc = 0; iacc < (CONFIG_T::n_state); iacc++) {
@@ -100,7 +107,8 @@ void lstm(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG
     }
     // Operation: h=act(s)*o
     CONFIG_T::template activation<data_T, typename CONFIG_T::weight_t, typename CONFIG_T::ACT_CONFIG_T>::activation(
-        s_newstate, s_actstate);
+        s_newstate, s_actstate
+    );
 
     for (int iacc = 0; iacc < CONFIG_T::n_state; iacc++) {
         #pragma HLS UNROLL
@@ -109,12 +117,16 @@ void lstm(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void lstm_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG_T::n_state],
-                 res_T s_newstate[CONFIG_T::n_state],
-                 typename CONFIG_T::weight_t param[CONFIG_T::n_state * 4 * CONFIG_T::n_in],
-                 typename CONFIG_T::weight_t param_r[CONFIG_T::n_state * 4 * CONFIG_T::n_state],
-                 typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 4],
-                 typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 4]) {
+void lstm_static(
+    bool reset_state,
+    data_T data[CONFIG_T::n_in],
+    res_T h_newstate[CONFIG_T::n_state],
+    res_T s_newstate[CONFIG_T::n_state],
+    typename CONFIG_T::weight_t param[CONFIG_T::n_state * 4 * CONFIG_T::n_in],
+    typename CONFIG_T::weight_t param_r[CONFIG_T::n_state * 4 * CONFIG_T::n_state],
+    typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 4],
+    typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 4]
+) {
     static res_T h_state[CONFIG_T::n_state];
     static res_T s_state[CONFIG_T::n_state];
     // Initialize the state variable -- will maintain state between function calls
@@ -147,8 +159,9 @@ void lstm_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate
     }
 
     nnet::dense<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config1>(data, tmpres, param, param_b);
-    nnet::dense<res_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config2>(h_state, tmpres_state, param_r,
-                                                                                    param_br);
+    nnet::dense<res_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config2>(
+        h_state, tmpres_state, param_r, param_br
+    );
 
     for (int iacc = 0; iacc < (3 * CONFIG_T::n_state); iacc++) {
         #pragma HLS UNROLL
@@ -164,11 +177,13 @@ void lstm_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate
     }
 
     CONFIG_T::template activation_recr<data_T, typename CONFIG_T::weight_t, typename CONFIG_T::ACT_CONFIG_LSTM>::activation(
-        inputacc_ifo, tmpres_ifo);
+        inputacc_ifo, tmpres_ifo
+    );
 
     // Now for the confusion matrix
     CONFIG_T::template activation<data_T, typename CONFIG_T::weight_t, typename CONFIG_T::ACT_CONFIG_T>::activation(
-        inputacc_c, tmpres_c);
+        inputacc_c, tmpres_c
+    );
 
     // Operation: s=g*i+sold*f (update state with buffer to avoid timing issues)
     for (int iacc = 0; iacc < (CONFIG_T::n_state); iacc++) {
@@ -178,7 +193,8 @@ void lstm_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate
     }
     // Operation: h=act(s)*o
     CONFIG_T::template activation<data_T, typename CONFIG_T::weight_t, typename CONFIG_T::ACT_CONFIG_T>::activation(
-        s_state, s_actstate);
+        s_state, s_actstate
+    );
 
     for (int iacc = 0; iacc < CONFIG_T::n_state; iacc++) {
         #pragma HLS UNROLL
@@ -188,11 +204,14 @@ void lstm_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void lstm_stack(data_T data[CONFIG_T::n_sequence * CONFIG_T::n_in], res_T res[CONFIG_T::n_sequence_out * CONFIG_T::n_state],
-                typename CONFIG_T::weight_t param[CONFIG_T::n_state * 4 * CONFIG_T::n_in],
-                typename CONFIG_T::weight_t param_r[CONFIG_T::n_state * 4 * CONFIG_T::n_state],
-                typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 4],
-                typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 4]) {
+void lstm_stack(
+    data_T data[CONFIG_T::n_sequence * CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_sequence_out * CONFIG_T::n_state],
+    typename CONFIG_T::weight_t param[CONFIG_T::n_state * 4 * CONFIG_T::n_in],
+    typename CONFIG_T::weight_t param_r[CONFIG_T::n_state * 4 * CONFIG_T::n_state],
+    typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 4],
+    typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 4]
+) {
 
     res_T h_newstate[CONFIG_T::n_state];
     res_T s_newstate[CONFIG_T::n_state];
@@ -213,11 +232,13 @@ void lstm_stack(data_T data[CONFIG_T::n_sequence * CONFIG_T::n_in], res_T res[CO
             data_in[j] = data[j + iloop * CONFIG_T::n_in];
         }
         if (CONFIG_T::use_static)
-            nnet::lstm_static<data_T, res_T, CONFIG_T>(reset_state, data_in, h_newstate, s_newstate, param, param_r, param_b,
-                                                       param_br);
+            nnet::lstm_static<data_T, res_T, CONFIG_T>(
+                reset_state, data_in, h_newstate, s_newstate, param, param_r, param_b, param_br
+            );
         else
-            nnet::lstm<data_T, res_T, CONFIG_T>(reset_state, data_in, h_newstate, s_newstate, param, param_r, param_b,
-                                                param_br);
+            nnet::lstm<data_T, res_T, CONFIG_T>(
+                reset_state, data_in, h_newstate, s_newstate, param, param_r, param_b, param_br
+            );
         if (CONFIG_T::n_sequence_out > 1)
             for (int i = CONFIG_T::n_state * iloop, j = 0; i < (CONFIG_T::n_state * (iloop + 1)); i++, j++) {
                 #pragma HLS UNROLL
@@ -233,11 +254,14 @@ void lstm_stack(data_T data[CONFIG_T::n_sequence * CONFIG_T::n_in], res_T res[CO
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void lstm_stack(hls::stream<data_T> &data_stream, hls::stream<res_T> &res_stream,
-                typename CONFIG_T::weight_t param[CONFIG_T::n_state * 4 * CONFIG_T::n_in],
-                typename CONFIG_T::weight_t param_r[CONFIG_T::n_state * 4 * CONFIG_T::n_state],
-                typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 4],
-                typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 4]) {
+void lstm_stack(
+    hls::stream<data_T> &data_stream,
+    hls::stream<res_T> &res_stream,
+    typename CONFIG_T::weight_t param[CONFIG_T::n_state * 4 * CONFIG_T::n_in],
+    typename CONFIG_T::weight_t param_r[CONFIG_T::n_state * 4 * CONFIG_T::n_state],
+    typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 4],
+    typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 4]
+) {
 
     typename res_T::value_type h_newstate[CONFIG_T::n_state];
     typename res_T::value_type s_newstate[CONFIG_T::n_state];
@@ -266,10 +290,12 @@ void lstm_stack(hls::stream<data_T> &data_stream, hls::stream<res_T> &res_stream
         }
         if (CONFIG_T::use_static)
             nnet::lstm_static<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(
-                reset_state, data_in, h_newstate, s_newstate, param, param_r, param_b, param_br);
+                reset_state, data_in, h_newstate, s_newstate, param, param_r, param_b, param_br
+            );
         else
             nnet::lstm<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(
-                reset_state, data_in, h_newstate, s_newstate, param, param_r, param_b, param_br);
+                reset_state, data_in, h_newstate, s_newstate, param, param_r, param_b, param_br
+            );
         if (CONFIG_T::n_sequence_out > 1) {
             res_T res_pack;
             PRAGMA_DATA_PACK(res_pack)
@@ -324,12 +350,16 @@ struct gru_config {
 };
 
 template <class data_T, class res_T, typename CONFIG_T>
-void gru(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG_T::n_state],
-         typename CONFIG_T::weight_t param[CONFIG_T::n_state * 3 * CONFIG_T::n_in], // TODO - Check the layout of the param
-                                                                                    // weights - refer page in copy!!
-         typename CONFIG_T::weight_t param_zr[CONFIG_T::n_state * 3 * CONFIG_T::n_state],
-         typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 3],
-         typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 3]) {
+void gru(
+    bool reset_state,
+    data_T data[CONFIG_T::n_in],
+    res_T h_newstate[CONFIG_T::n_state],
+    typename CONFIG_T::weight_t param[CONFIG_T::n_state * 3 * CONFIG_T::n_in], // TODO - Check the layout of the param
+                                                                               // weights - refer page in copy!!
+    typename CONFIG_T::weight_t param_zr[CONFIG_T::n_state * 3 * CONFIG_T::n_state],
+    typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 3],
+    typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 3]
+) {
     // Initialize the state variable -- will maintain state between function calls
     typename CONFIG_T::accum_t tmpres[CONFIG_T::n_state * 3];
     typename CONFIG_T::accum_t tmpres_state_zr[CONFIG_T::n_state * 3];
@@ -349,8 +379,9 @@ void gru(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG_
     #pragma HLS ARRAY_PARTITION variable=inputacc_h      complete
 
     nnet::dense<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config1>(data, tmpres, param, param_b);
-    nnet::dense<res_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config2>(h_newstate, tmpres_state_zr, param_zr,
-                                                                                    param_br);
+    nnet::dense<res_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config2>(
+        h_newstate, tmpres_state_zr, param_zr, param_br
+    );
 
     // Adding the individual vectors from the multiplication of tmpres = Wx*x(t); tmpres_state_zr = Wh*h(t-1); tmpres
     // initialized with biases -- DONE
@@ -361,8 +392,10 @@ void gru(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG_
     }
 
     // Activation function Sub layer -- START
-    CONFIG_T::template activation_recr<typename CONFIG_T::accum_t, typename CONFIG_T::weight_t,
-                                       typename CONFIG_T::ACT_CONFIG_GRU>::activation(inputacc_zr, tmpres_zr);
+    CONFIG_T::template activation_recr<
+        typename CONFIG_T::accum_t,
+        typename CONFIG_T::weight_t,
+        typename CONFIG_T::ACT_CONFIG_GRU>::activation(inputacc_zr, tmpres_zr);
 
     // Activation function Sub layer -- END
 
@@ -383,26 +416,31 @@ void gru(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG_
     }
 
     // Now run the activation on this guy
-    CONFIG_T::template activation<typename CONFIG_T::accum_t, typename CONFIG_T::weight_t,
-                                  typename CONFIG_T::ACT_CONFIG_T>::activation(inputacc_h, tmpres_h);
+    CONFIG_T::template activation<typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, typename CONFIG_T::ACT_CONFIG_T>::
+        activation(inputacc_h, tmpres_h);
 
     // Mix the stat with the previous state
     for (int iacc = 0; iacc < (CONFIG_T::n_state); iacc++) {
         #pragma HLS UNROLL
         if (CONFIG_T::pytorch_order)
-            h_newstate[iacc] = (res_T)(tmpres_h[iacc] * (1 - tmpres_zr[iacc + (CONFIG_T::n_state)]) +
-                                       h_newstate[iacc] * tmpres_zr[iacc + (CONFIG_T::n_state)]);
+            h_newstate[iacc] = (res_T
+            )(tmpres_h[iacc] * (1 - tmpres_zr[iacc + (CONFIG_T::n_state)]) +
+              h_newstate[iacc] * tmpres_zr[iacc + (CONFIG_T::n_state)]);
         else
             h_newstate[iacc] = (res_T)(tmpres_h[iacc] * (1 - tmpres_zr[iacc]) + h_newstate[iacc] * tmpres_zr[iacc]);
     }
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void gru_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[CONFIG_T::n_state],
-                typename CONFIG_T::weight_t param[CONFIG_T::n_state * 3 * CONFIG_T::n_in],
-                typename CONFIG_T::weight_t param_zr[CONFIG_T::n_state * 3 * CONFIG_T::n_state],
-                typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 3],
-                typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 3]) {
+void gru_static(
+    bool reset_state,
+    data_T data[CONFIG_T::n_in],
+    res_T h_newstate[CONFIG_T::n_state],
+    typename CONFIG_T::weight_t param[CONFIG_T::n_state * 3 * CONFIG_T::n_in],
+    typename CONFIG_T::weight_t param_zr[CONFIG_T::n_state * 3 * CONFIG_T::n_state],
+    typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 3],
+    typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 3]
+) {
     // Initialize the state variable -- will maintain state between function calls
 
     static res_T h_state[CONFIG_T::n_state];
@@ -432,8 +470,9 @@ void gru_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[
     }
 
     nnet::dense<data_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config1>(data, tmpres, param, param_b);
-    nnet::dense<res_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config2>(h_state, tmpres_state_zr, param_zr,
-                                                                                    param_br);
+    nnet::dense<res_T, typename CONFIG_T::accum_t, typename CONFIG_T::mult_config2>(
+        h_state, tmpres_state_zr, param_zr, param_br
+    );
 
     // Adding the individual vectors from the multiplication of tmpres = Wx*x(t); tmpres_state_zr = Wh*h(t-1); tmpres
     // initialized with biases -- DONE
@@ -444,8 +483,10 @@ void gru_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[
     }
 
     // Activation function Sub layer -- START
-    CONFIG_T::template activation_recr<typename CONFIG_T::accum_t, typename CONFIG_T::weight_t,
-                                       typename CONFIG_T::ACT_CONFIG_GRU>::activation(inputacc_zr, tmpres_zr);
+    CONFIG_T::template activation_recr<
+        typename CONFIG_T::accum_t,
+        typename CONFIG_T::weight_t,
+        typename CONFIG_T::ACT_CONFIG_GRU>::activation(inputacc_zr, tmpres_zr);
 
     // Activation function Sub layer -- END
 
@@ -466,15 +507,16 @@ void gru_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[
     }
 
     // Now run the activation on this guy
-    CONFIG_T::template activation<typename CONFIG_T::accum_t, typename CONFIG_T::weight_t,
-                                  typename CONFIG_T::ACT_CONFIG_T>::activation(inputacc_h, tmpres_h);
+    CONFIG_T::template activation<typename CONFIG_T::accum_t, typename CONFIG_T::weight_t, typename CONFIG_T::ACT_CONFIG_T>::
+        activation(inputacc_h, tmpres_h);
 
     // Mix the stat with the previous state
     for (int iacc = 0; iacc < (CONFIG_T::n_state); iacc++) {
         #pragma HLS UNROLL
         if (CONFIG_T::pytorch_order)
-            h_state[iacc] = (res_T)(tmpres_h[iacc] * (1 - tmpres_zr[iacc + (CONFIG_T::n_state)]) +
-                                    h_state[iacc] * tmpres_zr[iacc + (CONFIG_T::n_state)]);
+            h_state[iacc] = (res_T
+            )(tmpres_h[iacc] * (1 - tmpres_zr[iacc + (CONFIG_T::n_state)]) +
+              h_state[iacc] * tmpres_zr[iacc + (CONFIG_T::n_state)]);
         else
             h_state[iacc] = (res_T)(tmpres_h[iacc] * (1 - tmpres_zr[iacc]) + h_state[iacc] * tmpres_zr[iacc]);
         h_newstate[iacc] = h_state[iacc];
@@ -482,11 +524,14 @@ void gru_static(bool reset_state, data_T data[CONFIG_T::n_in], res_T h_newstate[
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void gru_stack(data_T data[CONFIG_T::n_sequence * CONFIG_T::n_in], res_T res[CONFIG_T::n_sequence_out * CONFIG_T::n_state],
-               typename CONFIG_T::weight_t param[CONFIG_T::n_state * 3 * CONFIG_T::n_in],
-               typename CONFIG_T::weight_t param_zr[CONFIG_T::n_state * 3 * CONFIG_T::n_state],
-               typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 3],
-               typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 3]) {
+void gru_stack(
+    data_T data[CONFIG_T::n_sequence * CONFIG_T::n_in],
+    res_T res[CONFIG_T::n_sequence_out * CONFIG_T::n_state],
+    typename CONFIG_T::weight_t param[CONFIG_T::n_state * 3 * CONFIG_T::n_in],
+    typename CONFIG_T::weight_t param_zr[CONFIG_T::n_state * 3 * CONFIG_T::n_state],
+    typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 3],
+    typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 3]
+) {
 
     res_T h_state[CONFIG_T::n_state];
     data_T data_in[CONFIG_T::n_in];
@@ -523,11 +568,14 @@ void gru_stack(data_T data[CONFIG_T::n_sequence * CONFIG_T::n_in], res_T res[CON
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void gru_stack(hls::stream<data_T> &data_stream, hls::stream<res_T> &res_stream,
-               typename CONFIG_T::weight_t param[CONFIG_T::n_state * 3 * CONFIG_T::n_in],
-               typename CONFIG_T::weight_t param_zr[CONFIG_T::n_state * 3 * CONFIG_T::n_state],
-               typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 3],
-               typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 3]) {
+void gru_stack(
+    hls::stream<data_T> &data_stream,
+    hls::stream<res_T> &res_stream,
+    typename CONFIG_T::weight_t param[CONFIG_T::n_state * 3 * CONFIG_T::n_in],
+    typename CONFIG_T::weight_t param_zr[CONFIG_T::n_state * 3 * CONFIG_T::n_state],
+    typename CONFIG_T::bias_t param_b[CONFIG_T::n_state * 3],
+    typename CONFIG_T::bias_t param_br[CONFIG_T::n_state * 3]
+) {
 
     typename res_T::value_type h_newstate[CONFIG_T::n_state];
     #pragma HLS ARRAY_PARTITION variable=h_newstate complete
@@ -552,10 +600,12 @@ void gru_stack(hls::stream<data_T> &data_stream, hls::stream<res_T> &res_stream,
         }
         if (CONFIG_T::use_static)
             nnet::gru_static<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(
-                reset_state, data_in, h_newstate, param, param_zr, param_b, param_br);
+                reset_state, data_in, h_newstate, param, param_zr, param_b, param_br
+            );
         else
-            nnet::gru<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(reset_state, data_in, h_newstate,
-                                                                                         param, param_zr, param_b, param_br);
+            nnet::gru<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(
+                reset_state, data_in, h_newstate, param, param_zr, param_b, param_br
+            );
         if (CONFIG_T::n_sequence_out > 1) {
             res_T res_pack;
             PRAGMA_DATA_PACK(res_pack)
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_sepconv1d.h b/hls4ml/templates/vivado/nnet_utils/nnet_sepconv1d.h
index d804af260..8c13166fa 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_sepconv1d.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_sepconv1d.h
@@ -10,10 +10,12 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void depthwise_conv_1d_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                          res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                          typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan],
-                          typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+void depthwise_conv_1d_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     #pragma HLS INLINE recursive
     if (CONFIG_T::strategy == nnet::latency) {
         depthwise_conv_1d_latency_cl<data_T, res_T, CONFIG_T>(data, res, weights, biases);
@@ -23,22 +25,26 @@ void depthwise_conv_1d_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
 }
 
 template <class data_T, class dw_res_T, class res_T, typename CONFIG_T>
-void separable_conv_1d_cl(data_T data[CONFIG_T::depthwise_config::in_width * CONFIG_T::depthwise_config::n_chan],
-                          res_T res[CONFIG_T::pointwise_config::out_width * CONFIG_T::pointwise_config::n_filt],
-                          typename CONFIG_T::depthwise_config::weight_t
-                              depthwise_weights[CONFIG_T::depthwise_config::filt_width * CONFIG_T::depthwise_config::n_chan],
-                          typename CONFIG_T::pointwise_config::weight_t
-                              pointwise_weights[CONFIG_T::pointwise_config::n_chan * CONFIG_T::pointwise_config::n_filt],
-                          typename CONFIG_T::depthwise_config::bias_t depthwise_biases[CONFIG_T::depthwise_config::n_chan],
-                          typename CONFIG_T::pointwise_config::bias_t pointwise_biases[CONFIG_T::pointwise_config::n_filt]) {
+void separable_conv_1d_cl(
+    data_T data[CONFIG_T::depthwise_config::in_width * CONFIG_T::depthwise_config::n_chan],
+    res_T res[CONFIG_T::pointwise_config::out_width * CONFIG_T::pointwise_config::n_filt],
+    typename CONFIG_T::depthwise_config::weight_t
+        depthwise_weights[CONFIG_T::depthwise_config::filt_width * CONFIG_T::depthwise_config::n_chan],
+    typename CONFIG_T::pointwise_config::weight_t
+        pointwise_weights[CONFIG_T::pointwise_config::n_chan * CONFIG_T::pointwise_config::n_filt],
+    typename CONFIG_T::depthwise_config::bias_t depthwise_biases[CONFIG_T::depthwise_config::n_chan],
+    typename CONFIG_T::pointwise_config::bias_t pointwise_biases[CONFIG_T::pointwise_config::n_filt]
+) {
     #pragma HLS INLINE recursive
 
     dw_res_T depthwise_res[CONFIG_T::depthwise_config::out_width * CONFIG_T::depthwise_config::n_filt];
 
-    depthwise_conv_1d_cl<data_T, dw_res_T, typename CONFIG_T::depthwise_config>(data, depthwise_res, depthwise_weights,
-                                                                                depthwise_biases);
-    pointwise_conv_1d_cl<dw_res_T, res_T, typename CONFIG_T::pointwise_config>(depthwise_res, res, pointwise_weights,
-                                                                               pointwise_biases);
+    depthwise_conv_1d_cl<data_T, dw_res_T, typename CONFIG_T::depthwise_config>(
+        data, depthwise_res, depthwise_weights, depthwise_biases
+    );
+    pointwise_conv_1d_cl<dw_res_T, res_T, typename CONFIG_T::pointwise_config>(
+        depthwise_res, res, pointwise_weights, pointwise_biases
+    );
 }
 
 } // namespace nnet
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_sepconv1d_latency.h b/hls4ml/templates/vivado/nnet_utils/nnet_sepconv1d_latency.h
index beacbbe4e..4a915c728 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_sepconv1d_latency.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_sepconv1d_latency.h
@@ -8,10 +8,12 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void depthwise_conv_1d_latency_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
-                                  res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
-                                  typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_filt],
-                                  typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void depthwise_conv_1d_latency_cl(
+    data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::out_width * CONFIG_T::n_filt],
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
 
     constexpr unsigned mult_n_in = CONFIG_T::filt_width * CONFIG_T::n_chan;
     constexpr unsigned mult_n_acc = CONFIG_T::filt_width;
@@ -53,7 +55,8 @@ void depthwise_conv_1d_latency_cl(data_T data[CONFIG_T::in_width * CONFIG_T::n_c
                 cache = data_buf[i_pxl][i_in];
                 mult[i_in] =
                     CONFIG_T::mult_config::template product<data_T, typename CONFIG_T::mult_config::weight_t>::product(
-                        cache, weights[i_in]);
+                        cache, weights[i_in]
+                    );
             }
 
         // Initialize accumulator with input biases
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_sepconv1d_stream.h b/hls4ml/templates/vivado/nnet_utils/nnet_sepconv1d_stream.h
index ca3143d01..3200282f9 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_sepconv1d_stream.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_sepconv1d_stream.h
@@ -9,9 +9,12 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void depthwise_conv_1d_encoded_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
-                                  typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan],
-                                  typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+void depthwise_conv_1d_encoded_cl(
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     assert(CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
 
     hls::stream<typename data_T::value_type> data_window[CONFIG_T::filt_width * CONFIG_T::n_chan];
@@ -36,15 +39,19 @@ void depthwise_conv_1d_encoded_cl(hls::stream<data_T> &data, hls::stream<res_T>
             #pragma HLS PIPELINE II=CONFIG_T::reuse_factor
         }
         compute_scaled_indices_1d<data_T, CONFIG_T>(i_iw, pixel_idx);
-        compute_depthwise_output_encoded<data_T, res_T, CONFIG_T>(data.read(), data_window, res, res_pack, outputs_ready,
-                                                                  weights, biases, pixel_idx);
+        compute_depthwise_output_encoded<data_T, res_T, CONFIG_T>(
+            data.read(), data_window, res, res_pack, outputs_ready, weights, biases, pixel_idx
+        );
     }
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void depthwise_conv_1d_buffer_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
-                                 typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan],
-                                 typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+void depthwise_conv_1d_buffer_cl(
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     assert(CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
 
 ReadInputWidth:
@@ -58,9 +65,12 @@ void depthwise_conv_1d_buffer_cl(hls::stream<data_T> &data, hls::stream<res_T> &
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void depthwise_conv_1d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
-                          typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan],
-                          typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+void depthwise_conv_1d_cl(
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::filt_width * CONFIG_T::n_chan],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
 
     assert((CONFIG_T::n_filt == CONFIG_T::n_chan) && "only a depth multiplier of 1 is currently supported");
 
@@ -76,9 +86,12 @@ void depthwise_conv_1d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_1d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
-                          typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                          typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_1d_cl(
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
     assert(CONFIG_T::filt_width == 1);
 
@@ -99,23 +112,28 @@ void pointwise_conv_1d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
 }
 
 template <class data_T, class dw_res_T, class res_T, typename CONFIG_T>
-void separable_conv_1d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
-                          typename CONFIG_T::depthwise_config::weight_t
-                              depthwise_weights[CONFIG_T::depthwise_config::filt_width * CONFIG_T::depthwise_config::n_chan],
-                          typename CONFIG_T::pointwise_config::weight_t
-                              pointwise_weights[CONFIG_T::pointwise_config::n_chan * CONFIG_T::pointwise_config::n_filt],
-                          typename CONFIG_T::depthwise_config::bias_t depthwise_biases[CONFIG_T::depthwise_config::n_chan],
-                          typename CONFIG_T::pointwise_config::bias_t pointwise_biases[CONFIG_T::pointwise_config::n_filt]) {
+void separable_conv_1d_cl(
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
+    typename CONFIG_T::depthwise_config::weight_t
+        depthwise_weights[CONFIG_T::depthwise_config::filt_width * CONFIG_T::depthwise_config::n_chan],
+    typename CONFIG_T::pointwise_config::weight_t
+        pointwise_weights[CONFIG_T::pointwise_config::n_chan * CONFIG_T::pointwise_config::n_filt],
+    typename CONFIG_T::depthwise_config::bias_t depthwise_biases[CONFIG_T::depthwise_config::n_chan],
+    typename CONFIG_T::pointwise_config::bias_t pointwise_biases[CONFIG_T::pointwise_config::n_filt]
+) {
     #pragma HLS DATAFLOW
 
     hls::stream<dw_res_T> depthwise_res;
     unsigned res_depth = CONFIG_T::depthwise_config::out_width;
     #pragma HLS STREAM variable=depthwise_res depth=res_depth
 
-    depthwise_conv_1d_cl<data_T, dw_res_T, typename CONFIG_T::depthwise_config>(data, depthwise_res, depthwise_weights,
-                                                                                depthwise_biases);
-    pointwise_conv_1d_cl<dw_res_T, res_T, typename CONFIG_T::pointwise_config>(depthwise_res, res, pointwise_weights,
-                                                                               pointwise_biases);
+    depthwise_conv_1d_cl<data_T, dw_res_T, typename CONFIG_T::depthwise_config>(
+        data, depthwise_res, depthwise_weights, depthwise_biases
+    );
+    pointwise_conv_1d_cl<dw_res_T, res_T, typename CONFIG_T::pointwise_config>(
+        depthwise_res, res, pointwise_weights, pointwise_biases
+    );
 }
 
 } // namespace nnet
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_sepconv2d.h b/hls4ml/templates/vivado/nnet_utils/nnet_sepconv2d.h
index 9ec638375..67336b886 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_sepconv2d.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_sepconv2d.h
@@ -14,7 +14,8 @@ void depthwise_conv_2d_cl(
     data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
     res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     #pragma HLS INLINE recursive
     if (CONFIG_T::strategy == nnet::latency) {
         depthwise_conv_2d_latency_cl<data_T, res_T, CONFIG_T>(data, res, weights, biases);
@@ -24,26 +25,32 @@ void depthwise_conv_2d_cl(
 }
 
 template <class data_T, class dw_res_T, class res_T, typename CONFIG_T>
-void separable_conv_2d_cl(data_T data[CONFIG_T::depthwise_config::in_height * CONFIG_T::depthwise_config::in_width *
-                                      CONFIG_T::depthwise_config::n_chan],
-                          res_T res[CONFIG_T::pointwise_config::out_height * CONFIG_T::pointwise_config::out_width *
-                                    CONFIG_T::pointwise_config::n_filt],
-                          typename CONFIG_T::depthwise_config::weight_t
-                              depthwise_weights[CONFIG_T::depthwise_config::filt_height *
-                                                CONFIG_T::depthwise_config::filt_width * CONFIG_T::depthwise_config::n_chan],
-                          typename CONFIG_T::pointwise_config::weight_t
-                              pointwise_weights[CONFIG_T::pointwise_config::n_chan * CONFIG_T::pointwise_config::n_filt],
-                          typename CONFIG_T::depthwise_config::bias_t depthwise_biases[CONFIG_T::depthwise_config::n_chan],
-                          typename CONFIG_T::pointwise_config::bias_t pointwise_biases[CONFIG_T::pointwise_config::n_filt]) {
+void separable_conv_2d_cl(
+    data_T data
+        [CONFIG_T::depthwise_config::in_height * CONFIG_T::depthwise_config::in_width * CONFIG_T::depthwise_config::n_chan],
+    res_T
+        res[CONFIG_T::pointwise_config::out_height * CONFIG_T::pointwise_config::out_width *
+            CONFIG_T::pointwise_config::n_filt],
+    typename CONFIG_T::depthwise_config::weight_t depthwise_weights
+        [CONFIG_T::depthwise_config::filt_height * CONFIG_T::depthwise_config::filt_width *
+         CONFIG_T::depthwise_config::n_chan],
+    typename CONFIG_T::pointwise_config::weight_t
+        pointwise_weights[CONFIG_T::pointwise_config::n_chan * CONFIG_T::pointwise_config::n_filt],
+    typename CONFIG_T::depthwise_config::bias_t depthwise_biases[CONFIG_T::depthwise_config::n_chan],
+    typename CONFIG_T::pointwise_config::bias_t pointwise_biases[CONFIG_T::pointwise_config::n_filt]
+) {
     #pragma HLS INLINE recursive
 
-    dw_res_T depthwise_res[CONFIG_T::depthwise_config::out_height * CONFIG_T::depthwise_config::out_width *
-                           CONFIG_T::depthwise_config::n_filt];
+    dw_res_T depthwise_res
+        [CONFIG_T::depthwise_config::out_height * CONFIG_T::depthwise_config::out_width *
+         CONFIG_T::depthwise_config::n_filt];
 
-    depthwise_conv_2d_cl<data_T, dw_res_T, typename CONFIG_T::depthwise_config>(data, depthwise_res, depthwise_weights,
-                                                                                depthwise_biases);
-    pointwise_conv_2d_cl<dw_res_T, res_T, typename CONFIG_T::pointwise_config>(depthwise_res, res, pointwise_weights,
-                                                                               pointwise_biases);
+    depthwise_conv_2d_cl<data_T, dw_res_T, typename CONFIG_T::depthwise_config>(
+        data, depthwise_res, depthwise_weights, depthwise_biases
+    );
+    pointwise_conv_2d_cl<dw_res_T, res_T, typename CONFIG_T::pointwise_config>(
+        depthwise_res, res, pointwise_weights, pointwise_biases
+    );
 }
 
 } // namespace nnet
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_sepconv2d_latency.h b/hls4ml/templates/vivado/nnet_utils/nnet_sepconv2d_latency.h
index d8adedc7e..73ceae201 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_sepconv2d_latency.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_sepconv2d_latency.h
@@ -12,7 +12,8 @@ void depthwise_conv_2d_latency_cl(
     data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],
     res_T res[CONFIG_T::out_height * CONFIG_T::out_width * CONFIG_T::n_filt],
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_filt],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
 
     constexpr unsigned mult_n_in = CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan;
     constexpr unsigned mult_n_acc = CONFIG_T::filt_height * CONFIG_T::filt_width;
@@ -54,7 +55,8 @@ void depthwise_conv_2d_latency_cl(
                 cache = data_buf[i_pxl][i_in];
                 mult[i_in] =
                     CONFIG_T::mult_config::template product<data_T, typename CONFIG_T::mult_config::weight_t>::product(
-                        cache, weights[i_in]);
+                        cache, weights[i_in]
+                    );
             }
 
         // Initialize accumulator with input biases
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_sepconv2d_stream.h b/hls4ml/templates/vivado/nnet_utils/nnet_sepconv2d_stream.h
index 7f4dd866c..3bcfa511e 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_sepconv2d_stream.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_sepconv2d_stream.h
@@ -11,9 +11,11 @@ namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
 void depthwise_conv_2d_encoded_cl(
-    hls::stream<data_T> &data, hls::stream<res_T> &res,
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     assert(CONFIG_T::pad_top == 0 && CONFIG_T::pad_bottom == 0 && CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
     assert(CONFIG_T::filt_height == CONFIG_T::filt_width);
 
@@ -41,8 +43,9 @@ void depthwise_conv_2d_encoded_cl(
                 #pragma HLS PIPELINE II=CONFIG_T::reuse_factor
             }
             compute_scaled_indices_2d<data_T, CONFIG_T>(i_ih, i_iw, pixel_idx);
-            compute_depthwise_output_encoded<data_T, res_T, CONFIG_T>(data.read(), data_window, res, res_pack, outputs_ready,
-                                                                      weights, biases, pixel_idx);
+            compute_depthwise_output_encoded<data_T, res_T, CONFIG_T>(
+                data.read(), data_window, res, res_pack, outputs_ready, weights, biases, pixel_idx
+            );
         }
     }
 }
@@ -50,9 +53,11 @@ void depthwise_conv_2d_encoded_cl(
 // Line Buffer Implementation (Phil's)
 template <class data_T, class res_T, typename CONFIG_T>
 void depthwise_conv_2d_buffer_cl(
-    hls::stream<data_T> &data, hls::stream<res_T> &res,
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     assert(CONFIG_T::pad_top == 0 && CONFIG_T::pad_bottom == 0 && CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
 
     static ap_shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[CONFIG_T::filt_height - 1]
@@ -78,9 +83,11 @@ void depthwise_conv_2d_buffer_cl(
 
 template <class data_T, class res_T, typename CONFIG_T>
 void depthwise_conv_2d_cl(
-    hls::stream<data_T> &data, hls::stream<res_T> &res,
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
     typename CONFIG_T::weight_t weights[CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
 
     assert((CONFIG_T::n_filt == CONFIG_T::n_chan) && "only a depth multiplier of 1 is currently supported");
 
@@ -96,9 +103,12 @@ void depthwise_conv_2d_cl(
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_conv_2d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
-                          typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                          typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_conv_2d_cl(
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     assert(CONFIG_T::pad_top == 0 && CONFIG_T::pad_bottom == 0 && CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
     assert(CONFIG_T::filt_height == 1 && CONFIG_T::filt_width == 1);
 
@@ -122,24 +132,29 @@ void pointwise_conv_2d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
 }
 
 template <class data_T, class dw_res_T, class res_T, typename CONFIG_T>
-void separable_conv_2d_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
-                          typename CONFIG_T::depthwise_config::weight_t
-                              depthwise_weights[CONFIG_T::depthwise_config::filt_height *
-                                                CONFIG_T::depthwise_config::filt_width * CONFIG_T::depthwise_config::n_chan],
-                          typename CONFIG_T::pointwise_config::weight_t
-                              pointwise_weights[CONFIG_T::pointwise_config::n_chan * CONFIG_T::pointwise_config::n_filt],
-                          typename CONFIG_T::depthwise_config::bias_t depthwise_biases[CONFIG_T::depthwise_config::n_chan],
-                          typename CONFIG_T::pointwise_config::bias_t pointwise_biases[CONFIG_T::pointwise_config::n_filt]) {
+void separable_conv_2d_cl(
+    hls::stream<data_T> &data,
+    hls::stream<res_T> &res,
+    typename CONFIG_T::depthwise_config::weight_t depthwise_weights
+        [CONFIG_T::depthwise_config::filt_height * CONFIG_T::depthwise_config::filt_width *
+         CONFIG_T::depthwise_config::n_chan],
+    typename CONFIG_T::pointwise_config::weight_t
+        pointwise_weights[CONFIG_T::pointwise_config::n_chan * CONFIG_T::pointwise_config::n_filt],
+    typename CONFIG_T::depthwise_config::bias_t depthwise_biases[CONFIG_T::depthwise_config::n_chan],
+    typename CONFIG_T::pointwise_config::bias_t pointwise_biases[CONFIG_T::pointwise_config::n_filt]
+) {
     #pragma HLS DATAFLOW
 
     hls::stream<dw_res_T> depthwise_res;
     unsigned res_depth = CONFIG_T::depthwise_config::out_height * CONFIG_T::depthwise_config::out_width;
     #pragma HLS STREAM variable=depthwise_res depth=res_depth
 
-    depthwise_conv_2d_cl<data_T, dw_res_T, typename CONFIG_T::depthwise_config>(data, depthwise_res, depthwise_weights,
-                                                                                depthwise_biases);
-    pointwise_conv_2d_cl<dw_res_T, res_T, typename CONFIG_T::pointwise_config>(depthwise_res, res, pointwise_weights,
-                                                                               pointwise_biases);
+    depthwise_conv_2d_cl<data_T, dw_res_T, typename CONFIG_T::depthwise_config>(
+        data, depthwise_res, depthwise_weights, depthwise_biases
+    );
+    pointwise_conv_2d_cl<dw_res_T, res_T, typename CONFIG_T::pointwise_config>(
+        depthwise_res, res, pointwise_weights, pointwise_biases
+    );
 }
 
 } // namespace nnet
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_sepconv_stream.h b/hls4ml/templates/vivado/nnet_utils/nnet_sepconv_stream.h
index 9c16de190..37d7a1ec8 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_sepconv_stream.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_sepconv_stream.h
@@ -8,9 +8,12 @@
 namespace nnet {
 
 template <class data_T, class res_T, typename CONFIG_T>
-void depthwise_product(data_T data[CONFIG_T::kernel_size * CONFIG_T::n_chan], res_T res[CONFIG_T::n_chan],
-                       typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan],
-                       typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+void depthwise_product(
+    data_T data[CONFIG_T::kernel_size * CONFIG_T::n_chan],
+    res_T res[CONFIG_T::n_chan],
+    typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     #pragma HLS INLINE
 
     typename CONFIG_T::accum_t mult[CONFIG_T::kernel_size * CONFIG_T::n_chan];
@@ -30,7 +33,8 @@ void depthwise_product(data_T data[CONFIG_T::kernel_size * CONFIG_T::n_chan], re
     for (int ii = 0; ii < CONFIG_T::kernel_size * CONFIG_T::n_chan; ii++) {
         #pragma HLS UNROLL
         mult[ii] = CONFIG_T::mult_config::template product<data_T, typename CONFIG_T::mult_config::weight_t>::product(
-            data[ii], weights[ii]);
+            data[ii], weights[ii]
+        );
     }
 
 // Initialize accumulator with input biases
@@ -59,10 +63,14 @@ void depthwise_product(data_T data[CONFIG_T::kernel_size * CONFIG_T::n_chan], re
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void depthwise_mult_buffer(hls::stream<typename data_T::value_type> data_window[CONFIG_T::kernel_size * CONFIG_T::n_chan],
-                           res_T &res_pack, hls::stream<res_T> &res_stream, unsigned &outputs_ready,
-                           typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan],
-                           typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+void depthwise_mult_buffer(
+    hls::stream<typename data_T::value_type> data_window[CONFIG_T::kernel_size * CONFIG_T::n_chan],
+    res_T &res_pack,
+    hls::stream<res_T> &res_stream,
+    unsigned &outputs_ready,
+    typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     #pragma HLS INLINE
 
     typename data_T::value_type data[CONFIG_T::kernel_size * CONFIG_T::n_chan];
@@ -107,10 +115,15 @@ void depthwise_mult_buffer(hls::stream<typename data_T::value_type> data_window[
 
 template <class data_T, class res_T, typename CONFIG_T>
 void compute_depthwise_output_encoded(
-    const data_T &in_elem, hls::stream<typename data_T::value_type> data_window[CONFIG_T::kernel_size * CONFIG_T::n_chan],
-    hls::stream<res_T> &res, res_T &res_pack, unsigned &outputs_ready,
+    const data_T &in_elem,
+    hls::stream<typename data_T::value_type> data_window[CONFIG_T::kernel_size * CONFIG_T::n_chan],
+    hls::stream<res_T> &res,
+    res_T &res_pack,
+    unsigned &outputs_ready,
     typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan],
-    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan], ap_uint<CONFIG_T::kernel_size> *pixel_idx) {
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan],
+    ap_uint<CONFIG_T::kernel_size> *pixel_idx
+) {
     #pragma HLS INLINE
 
 MultLoop:
@@ -133,9 +146,12 @@ void compute_depthwise_output_encoded(
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void pointwise_mult_buffer(const data_T &data_pack, hls::stream<res_T> &res_stream,
-                           typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
-                           typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
+void pointwise_mult_buffer(
+    const data_T &data_pack,
+    hls::stream<res_T> &res_stream,
+    typename CONFIG_T::weight_t weights[CONFIG_T::n_chan * CONFIG_T::n_filt],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]
+) {
     #pragma HLS INLINE
 
     typename data_T::value_type data[CONFIG_T::n_chan];
@@ -156,10 +172,12 @@ void pointwise_mult_buffer(const data_T &data_pack, hls::stream<res_T> &res_stre
     #pragma HLS INLINE recursive
     if (CONFIG_T::strategy == nnet::latency) {
         dense_latency<typename data_T::value_type, typename res_T::value_type, typename CONFIG_T::mult_config>(
-            data, res, weights, biases);
+            data, res, weights, biases
+        );
     } else {
         dense_resource<typename data_T::value_type, typename res_T::value_type, typename CONFIG_T::mult_config>(
-            data, res, weights, biases);
+            data, res, weights, biases
+        );
     }
 
 CastLoop:
@@ -173,9 +191,12 @@ void pointwise_mult_buffer(const data_T &data_pack, hls::stream<res_T> &res_stre
 
 // Line Buffer Implementation (Phil's)
 template <class data_T, class res_T, typename CONFIG_T>
-void compute_depthwise_output_buffer_1d(const data_T &in_elem, hls::stream<res_T> &res_stream,
-                                        typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan],
-                                        typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+void compute_depthwise_output_buffer_1d(
+    const data_T &in_elem,
+    hls::stream<res_T> &res_stream,
+    typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     #pragma HLS INLINE
 
     // Thresholds
@@ -202,8 +223,9 @@ void compute_depthwise_output_buffer_1d(const data_T &in_elem, hls::stream<res_T
         // Dense multiply
         #pragma HLS INLINE recursive
         if (CONFIG_T::strategy == nnet::latency) {
-            depthwise_product<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(kernel_data, res_out,
-                                                                                                 weights, biases);
+            depthwise_product<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(
+                kernel_data, res_out, weights, biases
+            );
         } else {
             assert("Resource strategy for DepthwiseConv1D is not supported." && false);
         }
@@ -231,12 +253,14 @@ void compute_depthwise_output_buffer_1d(const data_T &in_elem, hls::stream<res_T
 }
 
 template <class data_T, class res_T, typename CONFIG_T>
-void compute_depthwise_output_buffer_2d(const data_T &in_elem,
-                                        ap_shift_reg<typename data_T::value_type, CONFIG_T::in_width>
-                                            line_buffer[MAX(CONFIG_T::filt_height - 1, 1)][CONFIG_T::n_chan],
-                                        hls::stream<res_T> &res_stream,
-                                        typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan],
-                                        typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]) {
+void compute_depthwise_output_buffer_2d(
+    const data_T &in_elem,
+    ap_shift_reg<typename data_T::value_type, CONFIG_T::in_width> line_buffer[MAX(CONFIG_T::filt_height - 1, 1)]
+                                                                             [CONFIG_T::n_chan],
+    hls::stream<res_T> &res_stream,
+    typename CONFIG_T::weight_t weights[CONFIG_T::kernel_size * CONFIG_T::n_chan],
+    typename CONFIG_T::bias_t biases[CONFIG_T::n_chan]
+) {
     #pragma HLS INLINE
 
     // Thresholds
@@ -267,8 +291,9 @@ void compute_depthwise_output_buffer_2d(const data_T &in_elem,
         // Dense multiply
         #pragma HLS INLINE recursive
         if (CONFIG_T::strategy == nnet::latency) {
-            depthwise_product<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(kernel_data, res_out,
-                                                                                                 weights, biases);
+            depthwise_product<typename data_T::value_type, typename res_T::value_type, CONFIG_T>(
+                kernel_data, res_out, weights, biases
+            );
         } else {
             assert("Resource strategy for DepthwiseConv2D is not supported." && false);
         }
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_stream.h b/hls4ml/templates/vivado/nnet_utils/nnet_stream.h
index 900db16c3..c4570659c 100644
--- a/hls4ml/templates/vivado/nnet_utils/nnet_stream.h
+++ b/hls4ml/templates/vivado/nnet_utils/nnet_stream.h
@@ -153,8 +153,9 @@ void broadcast_stream_1x1xC(hls::stream<data_T> &data, hls::stream<res_T> &res)
 
 template <class data_T, class res_T, typename CONFIG_T>
 void broadcast_stream_HxWx1(hls::stream<data_T> &data, hls::stream<res_T> &res) {
-    assert(CONFIG_T::in_chan == 1 && CONFIG_T::in_height == CONFIG_T::out_height &&
-           CONFIG_T::in_width == CONFIG_T::out_width);
+    assert(
+        CONFIG_T::in_chan == 1 && CONFIG_T::in_height == CONFIG_T::out_height && CONFIG_T::in_width == CONFIG_T::out_width
+    );
 BroadcastLoop:
     for (int i = 0; i < CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::in_chan / data_T::size; i++) {
         #pragma HLS PIPELINE
@@ -173,8 +174,7 @@ template <class data_T, class res_T, typename CONFIG_T>
 void broadcast_stream(hls::stream<data_T> &data, hls::stream<res_T> &res) {
     if (CONFIG_T::in_height == 1 && CONFIG_T::in_width == 1 && CONFIG_T::in_chan == CONFIG_T::out_chan) {
         broadcast_stream_1x1xC<data_T, res_T, CONFIG_T>(data, res);
-    } else if (CONFIG_T::in_chan == 1 && CONFIG_T::in_height == CONFIG_T::out_height &&
-               CONFIG_T::in_width == CONFIG_T::out_width) {
+    } else if (CONFIG_T::in_chan == 1 && CONFIG_T::in_height == CONFIG_T::out_height && CONFIG_T::in_width == CONFIG_T::out_width) {
         broadcast_stream_HxWx1<data_T, res_T, CONFIG_T>(data, res);
     }
 }