diff --git a/src/f32-conv-hwc/3x3s2p1c3x4-neonfma-2x2.c b/src/f32-conv-hwc/3x3s2p1c3x4-neonfma-2x2.c
index 298beec..9a62d7e 100644
--- a/src/f32-conv-hwc/3x3s2p1c3x4-neonfma-2x2.c
+++ b/src/f32-conv-hwc/3x3s2p1c3x4-neonfma-2x2.c
@@ -622,7 +622,7 @@
               vst1_f32((float*) ((uintptr_t) o0_tmp + output_width_stride), vo0x1_lo);
               vo0x1_lo = vget_high_f32(vo0x1);
             }
-      
+
             vst1_f32(o1_tmp, vo1x0_lo); o1_tmp += 2;
             vo1x0_lo = vget_high_f32(vo1x0);
             vst1_f32(o0_tmp, vo0x0_lo); o0_tmp += 2;
diff --git a/src/im2col.c b/src/im2col.c
index 22f5dd3..73b041f 100644
--- a/src/im2col.c
+++ b/src/im2col.c
@@ -35,7 +35,7 @@
           for (size_t kernel_x = 0; kernel_x < kernel_width; kernel_x++) {
             const size_t input_x = output_x * subsampling_width + kernel_x * dilation_width - input_padding_left;
             if (input_x < output_width) {
-              memcpy(output, 
+              memcpy(output,
                 (const void*) ((uintptr_t) input + (input_y * input_width + input_x) * input_pixel_stride_in_bytes),
                 group_input_channels_in_bytes);
             } else {
diff --git a/src/math/exp-avx2-p5.c b/src/math/exp-avx2-p5.c
index c3d21c9..683b10f 100644
--- a/src/math/exp-avx2-p5.c
+++ b/src/math/exp-avx2-p5.c
@@ -42,7 +42,7 @@
     const __m256 vx = _mm256_loadu_ps(input);
 
     // Compute reduced argument n := round(x / log(2)).
-    // We do it by adding a large number (magic bias), which cause rounding of result to an integer, then subtracing the 
+    // We do it by adding a large number (magic bias), which cause rounding of result to an integer, then subtracing the
     // large number back. The first addition is combined with multiplication by log2e into a single FMA instruction.
     // The trick with adding large number is valid only within certain bounds (|x| <= 2**22), but thats ok, because
     // inputs outside of [-103.97207, 88.72283] underflow or overflow expf(x) anyway. We fixup the result for such
diff --git a/src/math/exp-avx2-perm-p3.c b/src/math/exp-avx2-perm-p3.c
index 2ee2c60..7984765 100644
--- a/src/math/exp-avx2-perm-p3.c
+++ b/src/math/exp-avx2-perm-p3.c
@@ -43,7 +43,7 @@
     const __m256 vx = _mm256_loadu_ps(input);
 
     // Compute reduced argument n := round(x * 8 / log(2)).
-    // We do it by adding a large number (magic bias), which cause rounding of result to an integer, then subtracing the 
+    // We do it by adding a large number (magic bias), which cause rounding of result to an integer, then subtracing the
     // large number back. The first addition is combined with multiplication by log2e into a single FMA instruction.
     // The trick with adding large number is valid only within certain bounds (|x| <= 2**22), but thats ok, because
     // inputs outside of [-103.97207, 88.72283] underflow or overflow expf(x) anyway. We fixup the result for such
diff --git a/src/math/exp-avx2-perm-p4.c b/src/math/exp-avx2-perm-p4.c
index c53d607..2f69868 100644
--- a/src/math/exp-avx2-perm-p4.c
+++ b/src/math/exp-avx2-perm-p4.c
@@ -46,7 +46,7 @@
     const __m256 vx = _mm256_loadu_ps(input);
 
     // Compute reduced argument n := round(x * 8 / log(2)).
-    // We do it by adding a large number (magic bias), which cause rounding of result to an integer, then subtracing the 
+    // We do it by adding a large number (magic bias), which cause rounding of result to an integer, then subtracing the
     // large number back. The first addition is combined with multiplication by log2e into a single FMA instruction.
     // The trick with adding large number is valid only within certain bounds (|x| <= 2**22), but thats ok, because
     // inputs outside of [-103.97207, 88.72283] underflow or overflow expf(x) anyway. We fixup the result for such
diff --git a/src/math/exp-avx512f-p5.c b/src/math/exp-avx512f-p5.c
index 9b2faac..4b2c083 100644
--- a/src/math/exp-avx512f-p5.c
+++ b/src/math/exp-avx512f-p5.c
@@ -42,7 +42,7 @@
     const __m512 vx = _mm512_loadu_ps(input);
 
     // Compute reduced argument n := round(x / log(2)).
-    // We do it by adding a large number (magic bias), which cause rounding of result to an integer, then subtracing the 
+    // We do it by adding a large number (magic bias), which cause rounding of result to an integer, then subtracing the
     // large number back. The first addition is combined with multiplication by log2e into a single FMA instruction.
     // The trick with adding large number is valid only within certain bounds (|x| <= 2**22), but thats ok, because
     // inputs outside of [-103.97207, 88.72283] underflow or overflow expf(x) anyway. We fixup the result for such
diff --git a/src/math/exp-avx512f-perm-p3.c b/src/math/exp-avx512f-perm-p3.c
index c014392..ff82d1b 100644
--- a/src/math/exp-avx512f-perm-p3.c
+++ b/src/math/exp-avx512f-perm-p3.c
@@ -45,7 +45,7 @@
     const __m512 vx = _mm512_loadu_ps(input);
 
     // Compute reduced argument n := round(x * 16 / log(2)).
-    // We do it by adding a large number (magic bias), which cause rounding of result to an integer, then subtracing the 
+    // We do it by adding a large number (magic bias), which cause rounding of result to an integer, then subtracing the
     // large number back. The first addition is combined with multiplication by log2e into a single FMA instruction.
     // The trick with adding large number is valid only within certain bounds (|x| <= 2**22), but thats ok, because
     // inputs outside of [-103.97207, 88.72283] underflow or overflow expf(x) anyway. We fixup the result for such
diff --git a/src/math/expminus-avx2-p5.c b/src/math/expminus-avx2-p5.c
index 8c05304..5d4fe4e 100644
--- a/src/math/expminus-avx2-p5.c
+++ b/src/math/expminus-avx2-p5.c
@@ -35,7 +35,7 @@
     const __m256 vx = _mm256_loadu_ps(input);
 
     // Compute reduced argument n := round(x / log(2)).
-    // We do it by adding a large number (magic bias), which cause rounding of result to an integer, then subtracing the 
+    // We do it by adding a large number (magic bias), which cause rounding of result to an integer, then subtracing the
     // large number back. The first addition is combined with multiplication by log2e into a single FMA instruction.
     // The trick with adding large number is valid only within certain bounds (|x| <= 2**22), but thats ok, because
     // inputs outside of [-103.97207, 0.0] underflow expf(x) anyway. We fixup the result for such inputs at the very end
diff --git a/src/q8-gemm/2x4c8-sse2.c b/src/q8-gemm/2x4c8-sse2.c
index 8551ad6..55e962b 100644
--- a/src/q8-gemm/2x4c8-sse2.c
+++ b/src/q8-gemm/2x4c8-sse2.c
@@ -149,7 +149,7 @@
     const __m128i vq31prod1x0123 = _mm_shuffle_epi32(vq31prod1x0213, _MM_SHUFFLE(3, 1, 2, 0));
 
     const __m128i vremainder_mask = _mm_load_si128((const __m128i*) params->sse2.remainder_mask);
-    
+
     const __m128i vrem0x0123 =
       _mm_add_epi32(_mm_and_si128(vq31prod0x0123, vremainder_mask), _mm_cmpgt_epi32(_mm_setzero_si128(), vq31prod0x0123));
     const __m128i vrem1x0123 =
@@ -158,9 +158,9 @@
     const __m128i vremainder_threshold = _mm_load_si128((const __m128i*) params->sse2.remainder_threshold);
     const __m128i vshift = _mm_load_si128((const __m128i*) params->sse2.shift);
 
-    vacc0x0123 = 
+    vacc0x0123 =
       _mm_sub_epi32(_mm_sra_epi32(vq31prod0x0123, vshift), _mm_cmpgt_epi32(vrem0x0123, vremainder_threshold));
-    vacc1x0123 = 
+    vacc1x0123 =
       _mm_sub_epi32(_mm_sra_epi32(vq31prod1x0123, vshift), _mm_cmpgt_epi32(vrem1x0123, vremainder_threshold));
 
     const __m128i voutput_zero_point = _mm_load_si128((const __m128i*) params->sse2.output_zero_point);
diff --git a/src/u8-maxpool/9p8q-neon.c b/src/u8-maxpool/9p8q-neon.c
index 28c19ea..9deaf24 100644
--- a/src/u8-maxpool/9p8q-neon.c
+++ b/src/u8-maxpool/9p8q-neon.c
@@ -129,7 +129,7 @@
         }
       }
     }
-    
+
     for (ptrdiff_t m = (ptrdiff_t) ks - 9; m > 0; m -= 8) {
       const uint8_t* i0 = *input++;
       const uint8_t* i1 = *input++;
diff --git a/src/u8-maxpool/9p8q-scalar.c b/src/u8-maxpool/9p8q-scalar.c
index 198dce7..e442f75 100644
--- a/src/u8-maxpool/9p8q-scalar.c
+++ b/src/u8-maxpool/9p8q-scalar.c
@@ -89,7 +89,7 @@
         *o++ = vout;
       } while (--k != 0);
     }
-    
+
     for (ptrdiff_t m = (ptrdiff_t) ks - 9; m > 0; m -= 8) {
       const uint8_t* i0 = *input++;
       const uint8_t* i1 = *input++;
diff --git a/src/u8-maxpool/9p8q-sse2.c b/src/u8-maxpool/9p8q-sse2.c
index 1805a69..8903457 100644
--- a/src/u8-maxpool/9p8q-sse2.c
+++ b/src/u8-maxpool/9p8q-sse2.c
@@ -133,7 +133,7 @@
         }
       }
     }
-    
+
     for (ptrdiff_t m = (ptrdiff_t) ks - 9; m > 0; m -= 8) {
       const uint8_t* i0 = *input++;
       const uint8_t* i1 = *input++;