diff --git a/contrib/halog/fgets2-64.c b/contrib/halog/fgets2-64.c
index 7556a31..1be6f22 100644
--- a/contrib/halog/fgets2-64.c
+++ b/contrib/halog/fgets2-64.c
@@ -58,7 +58,7 @@
 #define FGETS2_BUFSIZE		(256*1024)
 const char *fgets2(FILE *stream)
 {
-	static char buffer[FGETS2_BUFSIZE + 9]; // +9 to have zeroes past the end
+	static char buffer[FGETS2_BUFSIZE + 68];
 	static char *end = buffer;
 	static char *line = buffer;
 
@@ -73,7 +73,7 @@
 		 * time.
 		 */
 
-		if (next <= (end-12)) {
+		if (next <= end) {
 			/* max 3 bytes tested here */
 			while ((((unsigned long)next) & 3) && *next != '\n')
 				next++;
@@ -115,8 +115,8 @@
 		if (!has_zero(*(unsigned int *)next ^ 0x0A0A0A0AU))
 			next += 4;
 
-		/* we finish if needed. Note that next might be slightly higher
-		 * than end here because we might have gone past it above.
+		/* We finish if needed : if <next> is below <end>, it means we
+		 * found an LF in one of the 4 following bytes.
 		 */
 		while (next < end) {
 			if (*next == '\n') {
@@ -131,7 +131,8 @@
 
 		/* we found an incomplete line. First, let's move the
 		 * remaining part of the buffer to the beginning, then
-		 * try to complete the buffer with a new read.
+		 * try to complete the buffer with a new read. We can't
+		 * rely on <next> anymore because it went past <end>.
 		 */
 		if (line > buffer) {
 			if (end != line)
@@ -156,6 +157,7 @@
 		}
 
 		end += ret;
+		*end = '\n'; /* make parser stop ASAP */
 		/* search for '\n' again */
 	}
 }
