diff --git a/src/build/source_templates/compress.template b/src/build/source_templates/compress.template
index 32008e9..09a5df4 100644
--- a/src/build/source_templates/compress.template
+++ b/src/build/source_templates/compress.template
@@ -31,7 +31,6 @@
       main:
       while (true) {
 
-        // find a match
         int forwardOff = sOff;
 
         int ref;
@@ -51,15 +50,12 @@
           ${type}Utils.writeShort(hashTable, h, sOff - srcOff);
         } while (!LZ4${utils}.readIntEquals(src, ref, sOff));
 
-        // catch up
         final int excess = LZ4${utils}.commonBytesBackward(src, ref, sOff, srcOff, anchor);
         sOff -= excess;
         ref -= excess;
 
-        // sequence == refsequence
         final int runLen = sOff - anchor;
 
-        // encode literal length
         int tokenOff = dOff++;
 
         if (dOff + runLen + (2 + 1 + LAST_LITERALS) + (runLen >>> 8) > destEnd) {
@@ -73,16 +69,13 @@
           ${utils}.writeByte(dest, tokenOff, runLen << ML_BITS);
         }
 
-        // copy literals
         LZ4${utils}.wildArraycopy(src, anchor, dest, dOff, runLen);
         dOff += runLen;
 
         while (true) {
-          // encode offset
           ${utils}.writeShortLE(dest, dOff, (short) (sOff - ref));
           dOff += 2;
 
-          // count nb matches
           sOff += MIN_MATCH;
           ref += MIN_MATCH;
           final int matchLen = LZ4${utils}.commonBytes(src, ref, sOff, srcLimit);
@@ -91,7 +84,6 @@
           }
           sOff += matchLen;
 
-          // encode match len
           if (matchLen >= ML_MASK) {
             ${utils}.writeByte(dest, tokenOff, ${utils}.readByte(dest, tokenOff) | ML_MASK);
             dOff = LZ4${utils}.writeLen(matchLen - ML_MASK, dest, dOff);
@@ -99,16 +91,13 @@
             ${utils}.writeByte(dest, tokenOff, ${utils}.readByte(dest, tokenOff) | matchLen);
           }
 
-          // test end of chunk
           if (sOff > mflimit) {
             anchor = sOff;
             break main;
           }
 
-          // fill table
           ${type}Utils.writeShort(hashTable, hash64k(${utils}.readInt(src, sOff - 2)), sOff - 2 - srcOff);
 
-          // test next position
           final int h = hash64k(${utils}.readInt(src, sOff));
           ref = srcOff + ${type}Utils.readShort(hashTable, h);
           ${type}Utils.writeShort(hashTable, h, sOff - srcOff);
@@ -121,7 +110,6 @@
           ${utils}.writeByte(dest, tokenOff, 0);
         }
 
-        // prepare next loop
         anchor = sOff++;
       }
     }
@@ -160,7 +148,6 @@
     main:
     while (true) {
 
-      // find a match
       int forwardOff = sOff;
 
       int ref;
@@ -187,10 +174,8 @@
       sOff -= excess;
       ref -= excess;
 
-      // sequence == refsequence
       final int runLen = sOff - anchor;
 
-      // encode literal length
       int tokenOff = dOff++;
 
       if (dOff + runLen + (2 + 1 + LAST_LITERALS) + (runLen >>> 8) > destEnd) {
@@ -204,16 +189,13 @@
         ${utils}.writeByte(dest, tokenOff, runLen << ML_BITS);
       }
 
-      // copy literals
       LZ4${utils}.wildArraycopy(src, anchor, dest, dOff, runLen);
       dOff += runLen;
 
       while (true) {
-        // encode offset
         ${utils}.writeShortLE(dest, dOff, back);
         dOff += 2;
 
-        // count nb matches
         sOff += MIN_MATCH;
         final int matchLen = LZ4${utils}.commonBytes(src, ref + MIN_MATCH, sOff, srcLimit);
         if (dOff + (1 + LAST_LITERALS) + (matchLen >>> 8) > destEnd) {
@@ -221,7 +203,6 @@
         }
         sOff += matchLen;
 
-        // encode match len
         if (matchLen >= ML_MASK) {
           ${utils}.writeByte(dest, tokenOff, ${utils}.readByte(dest, tokenOff) | ML_MASK);
           dOff = LZ4${utils}.writeLen(matchLen - ML_MASK, dest, dOff);
@@ -229,16 +210,13 @@
           ${utils}.writeByte(dest, tokenOff, ${utils}.readByte(dest, tokenOff) | matchLen);
         }
 
-        // test end of chunk
         if (sOff > mflimit) {
           anchor = sOff;
           break main;
         }
 
-        // fill table
         ${type}Utils.writeInt(hashTable, hash(${utils}.readInt(src, sOff - 2)), sOff - 2);
 
-        // test next position
         final int h = hash(${utils}.readInt(src, sOff));
         ref = ${type}Utils.readInt(hashTable, h);
         ${type}Utils.writeInt(hashTable, h, sOff);
@@ -252,7 +230,6 @@
         ${utils}.writeByte(dest, tokenOff, 0);
       }
 
-      // prepare next loop
       anchor = sOff++;
     }
 
diff --git a/src/build/source_templates/compress_hc.template b/src/build/source_templates/compress_hc.template
index 7179db3..7976ad1 100644
--- a/src/build/source_templates/compress_hc.template
+++ b/src/build/source_templates/compress_hc.template
@@ -47,7 +47,6 @@
         continue;
       }
 
-      // saved, in case we would skip too much
       copyTo(match1, match0);
 
       search2:
@@ -55,20 +54,19 @@
         assert match1.start >= anchor;
         if (match1.end() >= mfLimit
             || !ht.insertAndFindWiderMatch(src, match1.end() - 2, match1.start + 1, matchLimit, match1.len, match2)) {
-          // no better match
           dOff = LZ4${utils}.encodeSequence(src, anchor, match1.start, match1.ref, match1.len, dest, dOff, destEnd);
           anchor = sOff = match1.end();
           continue main;
         }
 
         if (match0.start < match1.start) {
-          if (match2.start < match1.start + match0.len) { // empirical
+          if (match2.start < match1.start + match0.len) {
             copyTo(match0, match1);
           }
         }
         assert match2.start > match1.start;
 
-        if (match2.start - match1.start < 3) { // First Match too small : removed
+        if (match2.start - match1.start < 3) {
           copyTo(match2, match1);
           continue search2;
         }
@@ -91,21 +89,18 @@
 
           if (match2.start + match2.len >= mfLimit
               || !ht.insertAndFindWiderMatch(src, match2.end() - 3, match2.start, matchLimit, match2.len, match3)) {
-            // no better match -> 2 sequences to encode
             if (match2.start < match1.end()) {
               match1.len = match2.start - match1.start;
             }
-            // encode seq 1
             dOff = LZ4${utils}.encodeSequence(src, anchor, match1.start, match1.ref, match1.len, dest, dOff, destEnd);
             anchor = sOff = match1.end();
-            // encode seq 2
             dOff = LZ4${utils}.encodeSequence(src, anchor, match2.start, match2.ref, match2.len, dest, dOff, destEnd);
             anchor = sOff = match2.end();
             continue main;
           }
 
-          if (match3.start < match1.end() + 3) { // Not enough space for match 2 : remove it
-            if (match3.start >= match1.end()) { // // can write Seq1 immediately ==> Seq2 is removed, so Seq3 becomes Seq1
+          if (match3.start < match1.end() + 3) {
+            if (match3.start >= match1.end()) {
               if (match2.start < match1.end()) {
                 final int correction = match1.end() - match2.start;
                 match2.fix(correction);
@@ -127,7 +122,6 @@
             continue search3;
           }
 
-          // OK, now we have 3 ascending matches; let's write at least the first one
           if (match2.start < match1.end()) {
             if (match2.start - match1.start < ML_MASK) {
               if (match1.len > OPTIMAL_ML) {
diff --git a/src/build/source_templates/decompress.template b/src/build/source_templates/decompress.template
index f1c2890..1e2aa23 100644
--- a/src/build/source_templates/decompress.template
+++ b/src/build/source_templates/decompress.template
@@ -55,7 +55,6 @@
       final int token = ${utils}.readByte(src, sOff) & 0xFF;
       ++sOff;
 
-      // literals
       int literalLen = token >>> ML_BITS;
       if (literalLen == RUN_MASK) {
         byte len = (byte) 0xFF;
@@ -81,7 +80,7 @@
           LZ4${utils}.safeArraycopy(src, sOff, dest, dOff, literalLen);
           sOff += literalLen;
           dOff = literalCopyEnd;
-          break; // EOF
+          break;
         }
       }
 
@@ -89,7 +88,6 @@
       sOff += literalLen;
       dOff = literalCopyEnd;
 
-      // matchs
       final int matchDec = ${utils}.readShortLE(src, sOff);
       sOff += 2;
       int matchOff = dOff - matchDec;
diff --git a/src/build/source_templates/hashtable.template b/src/build/source_templates/hashtable.template
index 174f8e8..91935f5 100644
--- a/src/build/source_templates/hashtable.template
+++ b/src/build/source_templates/hashtable.template
@@ -92,8 +92,8 @@
 
       int ref = hashPointer(buf, off);
 
-      if (ref >= off - 4 && ref <= off && ref >= base) { // potential repetition
-        if (LZ4${utils}.readIntEquals(buf, ref, off)) { // confirmed
+      if (ref >= off - 4 && ref <= off && ref >= base) {
+        if (LZ4${utils}.readIntEquals(buf, ref, off)) {
           delta = off - ref;
           repl = match.len = MIN_MATCH + LZ4${utils}.commonBytes(buf, ref + MIN_MATCH, off + MIN_MATCH, matchLimit);
           match.ref = ref;
@@ -119,7 +119,7 @@
         int ptr = off;
         final int end = off + repl - (MIN_MATCH - 1);
         while (ptr < end - delta) {
-          chainTable[ptr & MASK] = (short) delta; // pre load
+          chainTable[ptr & MASK] = (short) delta;
           ++ptr;
         }
         do {
diff --git a/src/build/source_templates/xxhash32_streaming.template b/src/build/source_templates/xxhash32_streaming.template
index 6166758..9fa55e8 100644
--- a/src/build/source_templates/xxhash32_streaming.template
+++ b/src/build/source_templates/xxhash32_streaming.template
@@ -66,7 +66,7 @@ final class StreamingXXHash32Java${type} extends AbstractStreamingXXHash32Java {
 
     totalLen += len;
 
-    if (memSize + len < 16) { // fill in tmp buffer
+    if (memSize + len < 16) {
       System.arraycopy(buf, off, memory, memSize, len);
       memSize += len;
       return;
@@ -74,7 +74,7 @@ final class StreamingXXHash32Java${type} extends AbstractStreamingXXHash32Java {
 
     final int end = off + len;
 
-    if (memSize > 0) { // data left from previous update
+    if (memSize > 0) {
       System.arraycopy(buf, off, memory, memSize, 16 - memSize);
 
       v1 += readIntLE(memory, 0) * PRIME2;
diff --git a/src/build/source_templates/xxhash64_streaming.template b/src/build/source_templates/xxhash64_streaming.template
index 2789ae0..e781746 100644
--- a/src/build/source_templates/xxhash64_streaming.template
+++ b/src/build/source_templates/xxhash64_streaming.template
@@ -90,7 +90,7 @@ final class StreamingXXHash64Java${type} extends AbstractStreamingXXHash64Java {
 
     totalLen += len;
 
-    if (memSize + len < 32) { // fill in tmp buffer
+    if (memSize + len < 32) {
       System.arraycopy(buf, off, memory, memSize, len);
       memSize += len;
       return;
@@ -98,7 +98,7 @@ final class StreamingXXHash64Java${type} extends AbstractStreamingXXHash64Java {
 
     final int end = off + len;
 
-    if (memSize > 0) { // data left from previous update
+    if (memSize > 0) {
       System.arraycopy(buf, off, memory, memSize, 32 - memSize);
 
       v1 += readLongLE(memory, 0) * PRIME64_2;