From 31e6685c72ad20889794abea2edb6ffc2464251a Mon Sep 17 00:00:00 2001
From: Drew Smirnoff <drew@floatpane.com>
Date: Mon, 23 Mar 2026 12:43:22 +0400
Subject: [PATCH] refactor: remove commits from C files (#372)

Co-authored-by: Lea <lea@floatpane.com>
---
 clib/base64wrap.h      |    4 -
 clib/entity.c          |   28 -
 clib/entity.h          |   31 +-
 clib/htmlconv.h        |   26 +-
 clib/imgconv.h         |   18 +-
 clib/md4c-html.c       |   88 +-
 clib/md4c-html.h       |   49 +-
 clib/md4c.c            | 1025 ++++----------------
 clib/md4c.h            |  299 +-----
 clib/stb_image.h       | 2079 +++++++++-------------------------------
 clib/stb_image_write.h |  470 ++-------
 11 files changed, 789 insertions(+), 3328 deletions(-)

diff --git a/clib/base64wrap.h b/clib/base64wrap.h
index 2479a170ea0beb9f2002e056ada8c8306d059022..944430b4a7ea37e8b39cdb110ef4281dad771ae2 100644
--- a/clib/base64wrap.h
+++ b/clib/base64wrap.h
@@ -3,10 +3,6 @@
 
 #include <stddef.h>
 
-// wrap_base64 wraps base64-encoded data at 76 characters per line with \r\n
-// separators, as required by MIME (RFC 2045). The caller must free the returned
-// pointer with free().
-// Returns NULL if allocation fails.
 char* wrap_base64(const char* data, size_t len, size_t* out_len);
 
 #endif
diff --git a/clib/entity.c b/clib/entity.c
index 777706647c3aec70325f7e2ead158d7063bb271f..628ed45f227c6b70ae18a926f5ce1df83edae5ec 100644
--- a/clib/entity.c
+++ b/clib/entity.c
@@ -1,33 +1,6 @@
-/*
- * MD4C: Markdown parser for C
- * (http://github.com/mity/md4c)
- *
- * Copyright (c) 2016-2024 Martin Mitáš
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-
 #include "entity.h"
 #include <string.h>
 
-
-/* Generated by scripts/build_enity_map.py. */
 static const ENTITY ENTITY_MAP[] = {
     { "&AElig;", { 198, 0 } },
     { "&AMP;", { 38, 0 } },
@@ -2156,7 +2129,6 @@ static const ENTITY ENTITY_MAP[] = {
     { "&zwnj;", { 8204, 0 } }
 };
 
-
 typedef struct ENTITY_KEY_tag ENTITY_KEY;
 struct ENTITY_KEY_tag {
     const char* name;
diff --git a/clib/entity.h b/clib/entity.h
index b5d3868b4a6d3a5c857aa3b78223183d68ab0c39..41beb0affa4458ec3a1880f496640aeb38b4311d 100644
--- a/clib/entity.h
+++ b/clib/entity.h
@@ -1,36 +1,8 @@
-/*
- * MD4C: Markdown parser for C
- * (http://github.com/mity/md4c)
- *
- * Copyright (c) 2016-2024 Martin Mitáš
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-
 #ifndef MD4C_ENTITY_H
 #define MD4C_ENTITY_H
 
 #include <stdlib.h>
 
-
-/* Most entities are formed by single Unicode codepoint, few by two codepoints.
- * Single-codepoint entities have codepoints[1] set to zero. */
 typedef struct ENTITY_tag ENTITY;
 struct ENTITY_tag {
     const char* name;
@@ -39,5 +11,4 @@ struct ENTITY_tag {
 
 const ENTITY* entity_lookup(const char* name, size_t name_size);
 
-
-#endif  /* MD4C_ENTITY_H */
+#endif
diff --git a/clib/htmlconv.h b/clib/htmlconv.h
index e6e6eb6afc171b93ac515e8baaec9a8248b929fa..7d9c1fd8510d42ed756030ad47f4cd3c09fbeada 100644
--- a/clib/htmlconv.h
+++ b/clib/htmlconv.h
@@ -3,25 +3,22 @@
 
 #include <stddef.h>
 
-// Element types found during HTML parsing.
 enum {
-    HELEM_TEXT       = 0,  // Plain text segment
-    HELEM_H1         = 1,  // <h1> text
-    HELEM_H2         = 2,  // <h2> text
-    HELEM_LINK       = 3,  // <a href="...">text</a>
-    HELEM_IMAGE      = 4,  // <img src="..." alt="...">
-    HELEM_BLOCKQUOTE = 5,  // <blockquote> content (with optional cite/prev)
+    HELEM_TEXT       = 0,
+    HELEM_H1         = 1,
+    HELEM_H2         = 2,
+    HELEM_LINK       = 3,
+    HELEM_IMAGE      = 4,
+    HELEM_BLOCKQUOTE = 5,
 };
 
-// HTMLElement represents a parsed element from the HTML document.
 typedef struct {
     int type;
-    char* text;     // Text content (h1/h2 text, link text, blockquote content)
-    char* attr1;    // href for links, src for images, cite for blockquotes
-    char* attr2;    // alt for images, prev_text for blockquotes (On...wrote:)
+    char* text;
+    char* attr1;
+    char* attr2;
 } HTMLElement;
 
-// HTMLConvertResult holds the output of html_to_elements.
 typedef struct {
     HTMLElement* elements;
     int count;
@@ -29,13 +26,8 @@ typedef struct {
     int ok;
 } HTMLConvertResult;
 
-// html_to_elements parses an HTML string and returns an array of structured
-// elements. The caller processes these elements to apply terminal styling.
-// style/script content is stripped. Block elements get proper spacing.
-// Returns a result with ok=1 on success. Caller must free with free_html_result.
 HTMLConvertResult html_to_elements(const char* html, size_t len);
 
-// free_html_result frees all memory in an HTMLConvertResult.
 void free_html_result(HTMLConvertResult* r);
 
 #endif
diff --git a/clib/imgconv.h b/clib/imgconv.h
index 2c72254ebf2d17cfceec676c08888ab55499ab65..bcc1e4adb32525490b6343240d0ce2f5856c331d 100644
--- a/clib/imgconv.h
+++ b/clib/imgconv.h
@@ -3,26 +3,18 @@
 
 #include <stddef.h>
 
-// ImageResult holds the output of decode_to_png.
 typedef struct {
-    unsigned char* png_data; // PNG-encoded bytes (caller must free)
-    size_t png_len;          // Length of png_data
-    int width;               // Image width in pixels
-    int height;              // Image height in pixels
-    int ok;                  // 1 on success, 0 on failure
+    unsigned char* png_data;
+    size_t png_len;
+    int width;
+    int height;
+    int ok;
 } ImageResult;
 
-// decode_to_png takes raw image bytes (JPEG, PNG, BMP, GIF, etc.),
-// decodes them, and re-encodes as PNG. Supports any format that
-// stb_image can decode.
 ImageResult decode_to_png(const unsigned char* data, size_t len);
 
-// free_image_result frees the PNG data inside an ImageResult.
 void free_image_result(ImageResult* r);
 
-// image_dimensions returns only the width and height of an image without
-// fully decoding pixel data. Faster than decode_to_png when you only need
-// dimensions. Returns 1 on success, 0 on failure.
 int image_dimensions(const unsigned char* data, size_t len, int* width, int* height);
 
 #endif
diff --git a/clib/md4c-html.c b/clib/md4c-html.c
index 5229de541389567f97426df5946998140b2f6f9f..46bb9faf411d5d0fcfb64a550a787e8712be868f 100644
--- a/clib/md4c-html.c
+++ b/clib/md4c-html.c
@@ -1,37 +1,11 @@
-/*
- * MD4C: Markdown parser for C
- * (http://github.com/mity/md4c)
- *
- * Copyright (c) 2016-2024 Martin Mitáš
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-
 #include <stdio.h>
 #include <string.h>
 
 #include "md4c-html.h"
 #include "entity.h"
 
-
 #if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 199409L
-    /* C89/90 or old compilers in general may not understand "inline". */
+
     #if defined __GNUC__
         #define inline __inline__
     #elif defined _MSC_VER
@@ -45,8 +19,6 @@
     #define snprintf _snprintf
 #endif
 
-
-
 typedef struct MD_HTML_tag MD_HTML;
 struct MD_HTML_tag {
     void (*process_output)(const MD_CHAR*, MD_SIZE, void*);
@@ -59,40 +31,30 @@ struct MD_HTML_tag {
 #define NEED_HTML_ESC_FLAG   0x1
 #define NEED_URL_ESC_FLAG    0x2
 
-
-/*****************************************
- ***  HTML rendering helper functions  ***
- *****************************************/
-
 #define ISDIGIT(ch)     ('0' <= (ch) && (ch) <= '9')
 #define ISLOWER(ch)     ('a' <= (ch) && (ch) <= 'z')
 #define ISUPPER(ch)     ('A' <= (ch) && (ch) <= 'Z')
 #define ISALNUM(ch)     (ISLOWER(ch) || ISUPPER(ch) || ISDIGIT(ch))
 
-
 static inline void
 render_verbatim(MD_HTML* r, const MD_CHAR* text, MD_SIZE size)
 {
     r->process_output(text, size, r->userdata);
 }
 
-/* Keep this as a macro. Most compiler should then be smart enough to replace
- * the strlen() call with a compile-time constant if the string is a C literal. */
 #define RENDER_VERBATIM(r, verbatim)                                    \
         render_verbatim((r), (verbatim), (MD_SIZE) (strlen(verbatim)))
 
-
 static void
 render_html_escaped(MD_HTML* r, const MD_CHAR* data, MD_SIZE size)
 {
     MD_OFFSET beg = 0;
     MD_OFFSET off = 0;
 
-    /* Some characters need to be escaped in normal HTML text. */
     #define NEED_HTML_ESC(ch)   (r->escape_map[(unsigned char)(ch)] & NEED_HTML_ESC_FLAG)
 
     while(1) {
-        /* Optimization: Use some loop unrolling. */
+
         while(off + 3 < size  &&  !NEED_HTML_ESC(data[off+0])  &&  !NEED_HTML_ESC(data[off+1])
                               &&  !NEED_HTML_ESC(data[off+2])  &&  !NEED_HTML_ESC(data[off+3]))
             off += 4;
@@ -124,7 +86,6 @@ render_url_escaped(MD_HTML* r, const MD_CHAR* data, MD_SIZE size)
     MD_OFFSET beg = 0;
     MD_OFFSET off = 0;
 
-    /* Some characters need to be escaped in URL attributes. */
     #define NEED_URL_ESC(ch)    (r->escape_map[(unsigned char)(ch)] & NEED_URL_ESC_FLAG)
 
     while(1) {
@@ -200,8 +161,6 @@ render_utf8_codepoint(MD_HTML* r, unsigned codepoint,
         fn_append(r, utf8_replacement_char, 3);
 }
 
-/* Translate entity to its UTF-8 equivalent, or output the verbatim one
- * if such entity is unknown (or if the translation is disabled). */
 static void
 render_entity(MD_HTML* r, const MD_CHAR* text, MD_SIZE size,
               void (*fn_append)(MD_HTML*, const MD_CHAR*, MD_SIZE))
@@ -211,17 +170,16 @@ render_entity(MD_HTML* r, const MD_CHAR* text, MD_SIZE size,
         return;
     }
 
-    /* We assume UTF-8 output is what is desired. */
     if(size > 3 && text[1] == '#') {
         unsigned codepoint = 0;
 
         if(text[2] == 'x' || text[2] == 'X') {
-            /* Hexadecimal entity (e.g. "&#x1234abcd;")). */
+
             MD_SIZE i;
             for(i = 3; i < size-1; i++)
                 codepoint = 16 * codepoint + hex_val(text[i]);
         } else {
-            /* Decimal entity (e.g. "&1234;") */
+
             MD_SIZE i;
             for(i = 2; i < size-1; i++)
                 codepoint = 10 * codepoint + (text[i] - '0');
@@ -230,7 +188,7 @@ render_entity(MD_HTML* r, const MD_CHAR* text, MD_SIZE size,
         render_utf8_codepoint(r, codepoint, fn_append);
         return;
     } else {
-        /* Named entity (e.g. "&nbsp;"). */
+
         const ENTITY* ent;
 
         ent = entity_lookup(text, size);
@@ -265,7 +223,6 @@ render_attribute(MD_HTML* r, const MD_ATTRIBUTE* attr,
     }
 }
 
-
 static void
 render_open_ol_block(MD_HTML* r, const MD_BLOCK_OL_DETAIL* det)
 {
@@ -299,7 +256,6 @@ render_open_code_block(MD_HTML* r, const MD_BLOCK_CODE_DETAIL* det)
 {
     RENDER_VERBATIM(r, "<pre><code");
 
-    /* If known, output the HTML 5 attribute class="language-LANGNAME". */
     if(det->lang.text != NULL) {
         RENDER_VERBATIM(r, " class=\"language-");
         render_attribute(r, &det->lang, render_html_escaped);
@@ -366,11 +322,6 @@ render_open_wikilink_span(MD_HTML* r, const MD_SPAN_WIKILINK_DETAIL* det)
     RENDER_VERBATIM(r, "\">");
 }
 
-
-/**************************************
- ***  HTML renderer implementation  ***
- **************************************/
-
 static int
 enter_block_callback(MD_BLOCKTYPE type, void* detail, void* userdata)
 {
@@ -378,7 +329,7 @@ enter_block_callback(MD_BLOCKTYPE type, void* detail, void* userdata)
     MD_HTML* r = (MD_HTML*) userdata;
 
     switch(type) {
-        case MD_BLOCK_DOC:      /* noop */ break;
+        case MD_BLOCK_DOC:       break;
         case MD_BLOCK_QUOTE:    RENDER_VERBATIM(r, "<blockquote>\n"); break;
         case MD_BLOCK_UL:       RENDER_VERBATIM(r, "<ul>\n"); break;
         case MD_BLOCK_OL:       render_open_ol_block(r, (const MD_BLOCK_OL_DETAIL*)detail); break;
@@ -386,7 +337,7 @@ enter_block_callback(MD_BLOCKTYPE type, void* detail, void* userdata)
         case MD_BLOCK_HR:       RENDER_VERBATIM(r, (r->flags & MD_HTML_FLAG_XHTML) ? "<hr />\n" : "<hr>\n"); break;
         case MD_BLOCK_H:        RENDER_VERBATIM(r, head[((MD_BLOCK_H_DETAIL*)detail)->level - 1]); break;
         case MD_BLOCK_CODE:     render_open_code_block(r, (const MD_BLOCK_CODE_DETAIL*) detail); break;
-        case MD_BLOCK_HTML:     /* noop */ break;
+        case MD_BLOCK_HTML:      break;
         case MD_BLOCK_P:        RENDER_VERBATIM(r, "<p>"); break;
         case MD_BLOCK_TABLE:    RENDER_VERBATIM(r, "<table>\n"); break;
         case MD_BLOCK_THEAD:    RENDER_VERBATIM(r, "<thead>\n"); break;
@@ -406,15 +357,15 @@ leave_block_callback(MD_BLOCKTYPE type, void* detail, void* userdata)
     MD_HTML* r = (MD_HTML*) userdata;
 
     switch(type) {
-        case MD_BLOCK_DOC:      /*noop*/ break;
+        case MD_BLOCK_DOC:       break;
         case MD_BLOCK_QUOTE:    RENDER_VERBATIM(r, "</blockquote>\n"); break;
         case MD_BLOCK_UL:       RENDER_VERBATIM(r, "</ul>\n"); break;
         case MD_BLOCK_OL:       RENDER_VERBATIM(r, "</ol>\n"); break;
         case MD_BLOCK_LI:       RENDER_VERBATIM(r, "</li>\n"); break;
-        case MD_BLOCK_HR:       /*noop*/ break;
+        case MD_BLOCK_HR:        break;
         case MD_BLOCK_H:        RENDER_VERBATIM(r, head[((MD_BLOCK_H_DETAIL*)detail)->level - 1]); break;
         case MD_BLOCK_CODE:     RENDER_VERBATIM(r, "</code></pre>\n"); break;
-        case MD_BLOCK_HTML:     /* noop */ break;
+        case MD_BLOCK_HTML:      break;
         case MD_BLOCK_P:        RENDER_VERBATIM(r, "</p>\n"); break;
         case MD_BLOCK_TABLE:    RENDER_VERBATIM(r, "</table>\n"); break;
         case MD_BLOCK_THEAD:    RENDER_VERBATIM(r, "</thead>\n"); break;
@@ -433,20 +384,6 @@ enter_span_callback(MD_SPANTYPE type, void* detail, void* userdata)
     MD_HTML* r = (MD_HTML*) userdata;
     int inside_img = (r->image_nesting_level > 0);
 
-    /* We are inside a Markdown image label. Markdown allows to use any emphasis
-     * and other rich contents in that context similarly as in any link label.
-     *
-     * However, unlike in the case of links (where that contents becomescontents
-     * of the <a>...</a> tag), in the case of images the contents is supposed to
-     * fall into the attribute alt: <img alt="...">.
-     *
-     * In that context we naturally cannot output nested HTML tags. So lets
-     * suppress them and only output the plain text (i.e. what falls into text()
-     * callback).
-     *
-     * CommonMark specification declares this a recommended practice for HTML
-     * output.
-     */
     if(type == MD_SPAN_IMG)
         r->image_nesting_level++;
     if(inside_img)
@@ -486,7 +423,7 @@ leave_span_callback(MD_SPANTYPE type, void* detail, void* userdata)
         case MD_SPAN_IMG:               render_close_img_span(r, (MD_SPAN_IMG_DETAIL*) detail); break;
         case MD_SPAN_CODE:              RENDER_VERBATIM(r, "</code>"); break;
         case MD_SPAN_DEL:               RENDER_VERBATIM(r, "</del>"); break;
-        case MD_SPAN_LATEXMATH:         /*fall through*/
+        case MD_SPAN_LATEXMATH:
         case MD_SPAN_LATEXMATH_DISPLAY: RENDER_VERBATIM(r, "</x-equation>"); break;
         case MD_SPAN_WIKILINK:          RENDER_VERBATIM(r, "</x-wikilink>"); break;
     }
@@ -542,7 +479,6 @@ md_html(const MD_CHAR* input, MD_SIZE input_size,
         NULL
     };
 
-    /* Build map of characters which need escaping. */
     for(i = 0; i < 256; i++) {
         unsigned char ch = (unsigned char) i;
 
@@ -553,7 +489,6 @@ md_html(const MD_CHAR* input, MD_SIZE input_size,
             render.escape_map[i] |= NEED_URL_ESC_FLAG;
     }
 
-    /* Consider skipping UTF-8 byte order mark (BOM). */
     if(renderer_flags & MD_HTML_FLAG_SKIP_UTF8_BOM  &&  sizeof(MD_CHAR) == 1) {
         static const MD_CHAR bom[3] = { (char)0xef, (char)0xbb, (char)0xbf };
         if(input_size >= sizeof(bom)  &&  memcmp(input, bom, sizeof(bom)) == 0) {
@@ -564,4 +499,3 @@ md_html(const MD_CHAR* input, MD_SIZE input_size,
 
     return md_parse(input, input_size, &parser, (void*) &render);
 }
-
diff --git a/clib/md4c-html.h b/clib/md4c-html.h
index 324211da2ad913d867eb484de86813bd9de99545..1872fc73274219b39825c69c8e7a5d08f9d458bc 100644
--- a/clib/md4c-html.h
+++ b/clib/md4c-html.h
@@ -1,28 +1,3 @@
-/*
- * MD4C: Markdown parser for C
- * (http://github.com/mity/md4c)
- *
- * Copyright (c) 2016-2024 Martin Mitáš
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-
 #ifndef MD4C_HTML_H
 #define MD4C_HTML_H
 
@@ -32,37 +7,17 @@
     extern "C" {
 #endif
 
-
-/* If set, debug output from md_parse() is sent to stderr. */
 #define MD_HTML_FLAG_DEBUG                  0x0001
 #define MD_HTML_FLAG_VERBATIM_ENTITIES      0x0002
 #define MD_HTML_FLAG_SKIP_UTF8_BOM          0x0004
 #define MD_HTML_FLAG_XHTML                  0x0008
 
-
-/* Render Markdown into HTML.
- *
- * Note only contents of <body> tag is generated. Caller must generate
- * HTML header/footer manually before/after calling md_html().
- *
- * Params input and input_size specify the Markdown input.
- * Callback process_output() gets called with chunks of HTML output.
- * (Typical implementation may just output the bytes to a file or append to
- * some buffer).
- * Param userdata is just propagated back to process_output() callback.
- * Param parser_flags are flags from md4c.h propagated to md_parse().
- * Param render_flags is bitmask of MD_HTML_FLAG_xxxx.
- *
- * Returns -1 on error (if md_parse() fails.)
- * Returns 0 on success.
- */
 int md_html(const MD_CHAR* input, MD_SIZE input_size,
             void (*process_output)(const MD_CHAR*, MD_SIZE, void*),
             void* userdata, unsigned parser_flags, unsigned renderer_flags);
 
-
 #ifdef __cplusplus
-    }  /* extern "C" { */
+    }
 #endif
 
-#endif  /* MD4C_HTML_H */
+#endif
diff --git a/clib/md4c.c b/clib/md4c.c
index e3f5cf9d026d481ebb09b41ef39eaad79ae6de9d..50ecbf6abd5c61624f33de0fc5c6b380d8568b28 100644
--- a/clib/md4c.c
+++ b/clib/md4c.c
@@ -1,28 +1,3 @@
-/*
- * MD4C: Markdown parser for C
- * (http://github.com/mity/md4c)
- *
- * Copyright (c) 2016-2024 Martin Mitáš
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-
 #include "md4c.h"
 
 #include <limits.h>
@@ -31,13 +6,8 @@
 #include <stdlib.h>
 #include <string.h>
 
-
-/*****************************
- ***  Miscellaneous Stuff  ***
- *****************************/
-
 #if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 199409L
-    /* C89/90 or old compilers in general may not understand "inline". */
+
     #if defined __GNUC__
         #define inline __inline__
     #elif defined _MSC_VER
@@ -47,12 +17,10 @@
     #endif
 #endif
 
-/* Make the UTF-8 support the default. */
 #if !defined MD4C_USE_ASCII && !defined MD4C_USE_UTF8 && !defined MD4C_USE_UTF16
     #define MD4C_USE_UTF8
 #endif
 
-/* Magic for making wide literals with MD4C_USE_UTF16. */
 #ifdef _T
     #undef _T
 #endif
@@ -62,7 +30,6 @@
     #define _T(x)           x
 #endif
 
-/* Misc. macros. */
 #define SIZEOF_ARRAY(a)     (sizeof(a) / sizeof(a[0]))
 
 #define STRINGIZE_(x)       #x
@@ -106,7 +73,6 @@
     #endif
 #endif
 
-/* For falling through case labels in switch statements. */
 #if defined __clang__ && __clang_major__ >= 12
     #define MD_FALLTHROUGH()        __attribute__((fallthrough))
 #elif defined __GNUC__ && __GNUC__ >= 7
@@ -115,31 +81,12 @@
     #define MD_FALLTHROUGH()        ((void)0)
 #endif
 
-/* Suppress "unused parameter" warnings. */
 #define MD_UNUSED(x)                ((void)x)
 
-
-/******************************
- ***  Some internal limits  ***
- ******************************/
-
-/* We limit code span marks to lower than 32 backticks. This solves the
- * pathologic case of too many openers, each of different length: Their
- * resolving would be then O(n^2). */
 #define CODESPAN_MARK_MAXLEN    32
 
-/* We limit column count of tables to prevent quadratic explosion of output
- * from pathological input of a table thousands of columns and thousands
- * of rows where rows are requested with as little as single character
- * per-line, relying on us to "helpfully" fill all the missing "<td></td>". */
 #define TABLE_MAXCOLCOUNT       128
 
-
-/************************
- ***  Internal Types  ***
- ************************/
-
-/* These are omnipresent so lets save some typing. */
 #define CHAR    MD_CHAR
 #define SZ      MD_SIZE
 #define OFF     MD_OFFSET
@@ -152,33 +99,24 @@ typedef struct MD_BLOCK_tag MD_BLOCK;
 typedef struct MD_CONTAINER_tag MD_CONTAINER;
 typedef struct MD_REF_DEF_tag MD_REF_DEF;
 
-
-/* During analyzes of inline marks, we need to manage stacks of unresolved
- * openers of the given type.
- * The stack connects the marks via MD_MARK::next;
- */
 typedef struct MD_MARKSTACK_tag MD_MARKSTACK;
 struct MD_MARKSTACK_tag {
-    int top;        /* -1 if empty. */
+    int top;
 };
 
-/* Context propagated through all the parsing. */
 typedef struct MD_CTX_tag MD_CTX;
 struct MD_CTX_tag {
-    /* Immutable stuff (parameters of md_parse()). */
+
     const CHAR* text;
     SZ size;
     MD_PARSER parser;
     void* userdata;
 
-    /* When this is true, it allows some optimizations. */
     int doc_ends_with_newline;
 
-    /* Helper temporary growing buffer. */
     CHAR* buffer;
     unsigned alloc_buffer;
 
-    /* Reference definitions. */
     MD_REF_DEF* ref_defs;
     int n_ref_defs;
     int alloc_ref_defs;
@@ -186,10 +124,6 @@ struct MD_CTX_tag {
     int ref_def_hashtable_size;
     SZ max_ref_def_output;
 
-    /* Stack of inline/span markers.
-     * This is only used for parsing a single block contents but by storing it
-     * here we may reuse the stack for subsequent blocks; i.e. we have fewer
-     * (re)allocations. */
     MD_MARK* marks;
     int n_marks;
     int alloc_marks;
@@ -200,18 +134,17 @@ struct MD_CTX_tag {
     char mark_char_map[256];
 #endif
 
-    /* For resolving of inline spans. */
     MD_MARKSTACK opener_stacks[16];
-#define ASTERISK_OPENERS_oo_mod3_0      (ctx->opener_stacks[0])     /* Opener-only */
+#define ASTERISK_OPENERS_oo_mod3_0      (ctx->opener_stacks[0])
 #define ASTERISK_OPENERS_oo_mod3_1      (ctx->opener_stacks[1])
 #define ASTERISK_OPENERS_oo_mod3_2      (ctx->opener_stacks[2])
-#define ASTERISK_OPENERS_oc_mod3_0      (ctx->opener_stacks[3])     /* Both opener and closer candidate */
+#define ASTERISK_OPENERS_oc_mod3_0      (ctx->opener_stacks[3])
 #define ASTERISK_OPENERS_oc_mod3_1      (ctx->opener_stacks[4])
 #define ASTERISK_OPENERS_oc_mod3_2      (ctx->opener_stacks[5])
-#define UNDERSCORE_OPENERS_oo_mod3_0    (ctx->opener_stacks[6])     /* Opener-only */
+#define UNDERSCORE_OPENERS_oo_mod3_0    (ctx->opener_stacks[6])
 #define UNDERSCORE_OPENERS_oo_mod3_1    (ctx->opener_stacks[7])
 #define UNDERSCORE_OPENERS_oo_mod3_2    (ctx->opener_stacks[8])
-#define UNDERSCORE_OPENERS_oc_mod3_0    (ctx->opener_stacks[9])     /* Both opener and closer candidate */
+#define UNDERSCORE_OPENERS_oc_mod3_0    (ctx->opener_stacks[9])
 #define UNDERSCORE_OPENERS_oc_mod3_1    (ctx->opener_stacks[10])
 #define UNDERSCORE_OPENERS_oc_mod3_2    (ctx->opener_stacks[11])
 #define TILDE_OPENERS_1                 (ctx->opener_stacks[12])
@@ -219,49 +152,33 @@ struct MD_CTX_tag {
 #define BRACKET_OPENERS                 (ctx->opener_stacks[14])
 #define DOLLAR_OPENERS                  (ctx->opener_stacks[15])
 
-    /* Stack of dummies which need to call free() for pointers stored in them.
-     * These are constructed during inline parsing and freed after all the block
-     * is processed (i.e. all callbacks referring those strings are called). */
     MD_MARKSTACK ptr_stack;
 
-    /* For resolving table rows. */
     int n_table_cell_boundaries;
     int table_cell_boundaries_head;
     int table_cell_boundaries_tail;
 
-    /* For resolving links. */
     int unresolved_link_head;
     int unresolved_link_tail;
 
-    /* For resolving raw HTML. */
     OFF html_comment_horizon;
     OFF html_proc_instr_horizon;
     OFF html_decl_horizon;
     OFF html_cdata_horizon;
 
-    /* For block analysis.
-     * Notes:
-     *   -- It holds MD_BLOCK as well as MD_LINE structures. After each
-     *      MD_BLOCK, its (multiple) MD_LINE(s) follow.
-     *   -- For MD_BLOCK_HTML and MD_BLOCK_CODE, MD_VERBATIMLINE(s) are used
-     *      instead of MD_LINE(s).
-     */
     void* block_bytes;
     MD_BLOCK* current_block;
     int n_block_bytes;
     int alloc_block_bytes;
 
-    /* For container block analysis. */
     MD_CONTAINER* containers;
     int n_containers;
     int alloc_containers;
 
-    /* Minimal indentation to call the block "indented code block". */
     unsigned code_indent_offset;
 
-    /* Contextual info for line analysis. */
-    SZ code_fence_length;   /* For checking closing fence length. */
-    int html_block_type;    /* For checking closing raw HTML condition. */
+    SZ code_fence_length;
+    int html_block_type;
     int last_line_has_list_loosening_effect;
     int last_list_item_starts_with_two_blank_lines;
 };
@@ -288,7 +205,7 @@ struct MD_LINE_ANALYSIS_tag {
     int enforce_new_block;
     OFF beg;
     OFF end;
-    unsigned indent;        /* Indentation level. */
+    unsigned indent;
 };
 
 typedef struct MD_LINE_tag MD_LINE;
@@ -304,17 +221,9 @@ struct MD_VERBATIMLINE_tag {
     OFF indent;
 };
 
-
-/*****************
- ***  Helpers  ***
- *****************/
-
-/* Character accessors. */
 #define CH(off)                 (ctx->text[(off)])
 #define STR(off)                (ctx->text + (off))
 
-/* Character classification.
- * Note we assume ASCII compatibility of code points < 128 here. */
 #define ISIN_(ch, ch_min, ch_max)       ((ch_min) <= (unsigned)(ch) && (unsigned)(ch) <= (ch_max))
 #define ISANYOF_(ch, palette)           ((ch) != _T('\0')  &&  md_strchr((palette), (ch)) != NULL)
 #define ISANYOF2_(ch, ch1, ch2)         ((ch) == (ch1) || (ch) == (ch2))
@@ -348,15 +257,12 @@ struct MD_VERBATIMLINE_tag {
 #define ISXDIGIT(off)                   ISXDIGIT_(CH(off))
 #define ISALNUM(off)                    ISALNUM_(CH(off))
 
-
 #if defined MD4C_USE_UTF16
     #define md_strchr wcschr
 #else
     #define md_strchr strchr
 #endif
 
-
-/* Case insensitive check of string equality. */
 static inline int
 md_ascii_case_eq(const CHAR* s1, const CHAR* s2, SZ n)
 {
@@ -411,7 +317,6 @@ md_text_with_null_replacement(MD_CTX* ctx, MD_TEXTTYPE type, const CHAR* str, SZ
     }
 }
 
-
 #define MD_CHECK(func)                                                      \
     do {                                                                    \
         ret = (func);                                                       \
@@ -419,7 +324,6 @@ md_text_with_null_replacement(MD_CTX* ctx, MD_TEXTTYPE type, const CHAR* str, SZ
             goto abort;                                                     \
     } while(0)
 
-
 #define MD_TEMP_BUFFER(sz)                                                  \
     do {                                                                    \
         if(sz > ctx->alloc_buffer) {                                        \
@@ -438,7 +342,6 @@ md_text_with_null_replacement(MD_CTX* ctx, MD_TEXTTYPE type, const CHAR* str, SZ
         }                                                                   \
     } while(0)
 
-
 #define MD_ENTER_BLOCK(type, arg)                                           \
     do {                                                                    \
         ret = ctx->parser.enter_block((type), (arg), ctx->userdata);        \
@@ -497,9 +400,6 @@ md_text_with_null_replacement(MD_CTX* ctx, MD_TEXTTYPE type, const CHAR* str, SZ
         }                                                                   \
     } while(0)
 
-
-/* If the offset falls into a gap between line, we return the following
- * line. */
 static const MD_LINE*
 md_lookup_line(OFF off, const MD_LINE* lines, MD_SIZE n_lines, MD_SIZE* p_line_index)
 {
@@ -532,25 +432,14 @@ md_lookup_line(OFF off, const MD_LINE* lines, MD_SIZE n_lines, MD_SIZE* p_line_i
     return NULL;
 }
 
-
-/*************************
- ***  Unicode Support  ***
- *************************/
-
 typedef struct MD_UNICODE_FOLD_INFO_tag MD_UNICODE_FOLD_INFO;
 struct MD_UNICODE_FOLD_INFO_tag {
     unsigned codepoints[3];
     unsigned n_codepoints;
 };
 
-
 #if defined MD4C_USE_UTF16 || defined MD4C_USE_UTF8
-    /* Binary search over sorted "map" of codepoints. Consecutive sequences
-     * of codepoints may be encoded in the map by just using the
-     * (MIN_CODEPOINT | 0x40000000) and (MAX_CODEPOINT | 0x80000000).
-     *
-     * Returns index of the found record in the map (in the case of ranges,
-     * the minimal value is used); or -1 on failure. */
+
     static int
     md_unicode_bsearch__(unsigned codepoint, const unsigned* map, size_t map_size)
     {
@@ -560,7 +449,7 @@ struct MD_UNICODE_FOLD_INFO_tag {
         beg = 0;
         end = (int) map_size-1;
         while(beg <= end) {
-            /* Pivot may be a range, not just a single value. */
+
             pivot_beg = pivot_end = (beg + end) / 2;
             if(map[pivot_end] & 0x40000000)
                 pivot_end++;
@@ -583,16 +472,13 @@ struct MD_UNICODE_FOLD_INFO_tag {
     {
 #define R(cp_min, cp_max)   ((cp_min) | 0x40000000), ((cp_max) | 0x80000000)
 #define S(cp)               (cp)
-        /* Unicode "Zs" category.
-         * (generated by scripts/build_whitespace_map.py) */
+
         static const unsigned WHITESPACE_MAP[] = {
             S(0x0020), S(0x00a0), S(0x1680), R(0x2000,0x200a), S(0x202f), S(0x205f), S(0x3000)
         };
 #undef R
 #undef S
 
-        /* The ASCII ones are the most frequently used ones, also CommonMark
-         * specification requests few more in this range. */
         if(codepoint <= 0x7f)
             return ISWHITESPACE_(codepoint);
 
@@ -604,8 +490,7 @@ struct MD_UNICODE_FOLD_INFO_tag {
     {
 #define R(cp_min, cp_max)   ((cp_min) | 0x40000000), ((cp_max) | 0x80000000)
 #define S(cp)               (cp)
-        /* Unicode general "P" and "S" categories.
-         * (generated by scripts/build_punct_map.py) */
+
         static const unsigned PUNCT_MAP[] = {
             R(0x0021,0x002f), R(0x003a,0x0040), R(0x005b,0x0060), R(0x007b,0x007e), R(0x00a1,0x00a9),
             R(0x00ab,0x00ac), R(0x00ae,0x00b1), S(0x00b4), R(0x00b6,0x00b8), S(0x00bb), S(0x00bf), S(0x00d7),
@@ -669,8 +554,6 @@ struct MD_UNICODE_FOLD_INFO_tag {
 #undef R
 #undef S
 
-        /* The ASCII ones are the most frequently used ones, also CommonMark
-         * specification requests few more in this range. */
         if(codepoint <= 0x7f)
             return ISPUNCT_(codepoint);
 
@@ -682,8 +565,7 @@ struct MD_UNICODE_FOLD_INFO_tag {
     {
 #define R(cp_min, cp_max)   ((cp_min) | 0x40000000), ((cp_max) | 0x80000000)
 #define S(cp)               (cp)
-        /* Unicode "Pc", "Pd", "Pe", "Pf", "Pi", "Po", "Ps" categories.
-         * (generated by scripts/build_folding_map.py) */
+
         static const unsigned FOLD_MAP_1[] = {
             R(0x0041,0x005a), S(0x00b5), R(0x00c0,0x00d6), R(0x00d8,0x00de), R(0x0100,0x012e), R(0x0132,0x0136),
             R(0x0139,0x0147), R(0x014a,0x0176), S(0x0178), R(0x0179,0x017d), S(0x017f), S(0x0181), S(0x0182),
@@ -782,7 +664,6 @@ struct MD_UNICODE_FOLD_INFO_tag {
 
         int i;
 
-        /* Fast path for ASCII characters. */
         if(codepoint <= 0x7f) {
             info->codepoints[0] = codepoint;
             if(ISUPPER_(codepoint))
@@ -791,13 +672,12 @@ struct MD_UNICODE_FOLD_INFO_tag {
             return;
         }
 
-        /* Try to locate the codepoint in any of the maps. */
         for(i = 0; i < (int) SIZEOF_ARRAY(FOLD_MAP_LIST); i++) {
             int index;
 
             index = md_unicode_bsearch__(codepoint, FOLD_MAP_LIST[i].map, FOLD_MAP_LIST[i].map_size);
             if(index >= 0) {
-                /* Found the mapping. */
+
                 unsigned n_codepoints = FOLD_MAP_LIST[i].n_codepoints;
                 const unsigned* map = FOLD_MAP_LIST[i].map;
                 const unsigned* codepoints = FOLD_MAP_LIST[i].data + (index * n_codepoints);
@@ -806,13 +686,12 @@ struct MD_UNICODE_FOLD_INFO_tag {
                 info->n_codepoints = n_codepoints;
 
                 if(FOLD_MAP_LIST[i].map[index] != codepoint) {
-                    /* The found mapping maps whole range of codepoints,
-                     * i.e. we have to offset info->codepoints[0] accordingly. */
+
                     if((map[index] & 0x00ffffff)+1 == codepoints[0]) {
-                        /* Alternating type of the range. */
+
                         info->codepoints[0] = codepoint + ((codepoint & 0x1) == (map[index] & 0x1) ? 1 : 0);
                     } else {
-                        /* Range to range kind of mapping. */
+
                         info->codepoints[0] += (codepoint - (map[index] & 0x00ffffff));
                     }
                 }
@@ -821,13 +700,11 @@ struct MD_UNICODE_FOLD_INFO_tag {
             }
         }
 
-        /* No mapping found. Map the codepoint to itself. */
         info->codepoints[0] = codepoint;
         info->n_codepoints = 1;
     }
 #endif
 
-
 #if defined MD4C_USE_UTF16
     #define IS_UTF16_SURROGATE_HI(word)     (((WORD)(word) & 0xfc00) == 0xd800)
     #define IS_UTF16_SURROGATE_LO(word)     (((WORD)(word) & 0xfc00) == 0xdc00)
@@ -858,7 +735,6 @@ struct MD_UNICODE_FOLD_INFO_tag {
         return CH(off);
     }
 
-    /* No whitespace uses surrogates, so no decoding needed here. */
     #define ISUNICODEWHITESPACE_(codepoint) md_is_unicode_whitespace__(codepoint)
     #define ISUNICODEWHITESPACE(off)        md_is_unicode_whitespace__(CH(off))
     #define ISUNICODEWHITESPACEBEFORE(off)  md_is_unicode_whitespace__(CH((off)-1))
@@ -977,18 +853,6 @@ struct MD_UNICODE_FOLD_INFO_tag {
     }
 #endif
 
-
-/*************************************
- ***  Helper string manipulations  ***
- *************************************/
-
-/* Fill buffer with copy of the string between 'beg' and 'end' but replace any
- * line breaks with given replacement character.
- *
- * NOTE: Caller is responsible to make sure the buffer is large enough.
- * (Given the output is always shorter than input, (end - beg) is good idea
- * what the caller should allocate.)
- */
 static void
 md_merge_lines(MD_CTX* ctx, OFF beg, OFF end, const MD_LINE* lines, MD_SIZE n_lines,
                CHAR line_break_replacement_char, CHAR* buffer, SZ* p_size)
@@ -1024,8 +888,6 @@ md_merge_lines(MD_CTX* ctx, OFF beg, OFF end, const MD_LINE* lines, MD_SIZE n_li
     }
 }
 
-/* Wrapper of md_merge_lines() which allocates new buffer for the output string.
- */
 static int
 md_merge_lines_alloc(MD_CTX* ctx, OFF beg, OFF end, const MD_LINE* lines, MD_SIZE n_lines,
                     CHAR line_break_replacement_char, CHAR** p_str, SZ* p_size)
@@ -1061,18 +923,6 @@ md_skip_unicode_whitespace(const CHAR* label, OFF off, SZ size)
     return off;
 }
 
-
-/******************************
- ***  Recognizing raw HTML  ***
- ******************************/
-
-/* md_is_html_tag() may be called when processing inlines (inline raw HTML)
- * or when breaking document to blocks (checking for start of HTML block type 7).
- *
- * When breaking document to blocks, we do not yet know line boundaries, but
- * in that case the whole tag has to live on a single line. We distinguish this
- * by n_lines == 0.
- */
 static int
 md_is_html_tag(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg, OFF max_end, OFF* p_end)
 {
@@ -1087,39 +937,26 @@ md_is_html_tag(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg, OFF
         return FALSE;
     off++;
 
-    /* For parsing attributes, we need a little state automaton below.
-     * State -1: no attributes are allowed.
-     * State 0: attribute could follow after some whitespace.
-     * State 1: after a whitespace (attribute name may follow).
-     * State 2: after attribute name ('=' MAY follow).
-     * State 3: after '=' (value specification MUST follow).
-     * State 41: in middle of unquoted attribute value.
-     * State 42: in middle of single-quoted attribute value.
-     * State 43: in middle of double-quoted attribute value.
-     */
     attr_state = 0;
 
     if(CH(off) == _T('/')) {
-        /* Closer tag "</ ... >". No attributes may be present. */
+
         attr_state = -1;
         off++;
     }
 
-    /* Tag name */
     if(off >= line_end  ||  !ISALPHA(off))
         return FALSE;
     off++;
     while(off < line_end  &&  (ISALNUM(off)  ||  CH(off) == _T('-')))
         off++;
 
-    /* (Optional) attributes (if not closer), (optional) '/' (if not closer)
-     * and final '>'. */
     while(1) {
         while(off < line_end  &&  !ISNEWLINE(off)) {
             if(attr_state > 40) {
                 if(attr_state == 41 && (ISBLANK(off) || ISANYOF(off, _T("\"'=<>`")))) {
                     attr_state = 0;
-                    off--;  /* Put the char back for re-inspection in the new state. */
+                    off--;
                 } else if(attr_state == 42 && CH(off) == _T('\'')) {
                     attr_state = 0;
                 } else if(attr_state == 43 && CH(off) == _T('"')) {
@@ -1131,24 +968,24 @@ md_is_html_tag(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg, OFF
                     attr_state = 1;
                 off++;
             } else if(attr_state <= 2 && CH(off) == _T('>')) {
-                /* End. */
+
                 goto done;
             } else if(attr_state <= 2 && CH(off) == _T('/') && off+1 < line_end && CH(off+1) == _T('>')) {
-                /* End with digraph '/>' */
+
                 off++;
                 goto done;
             } else if((attr_state == 1 || attr_state == 2) && (ISALPHA(off) || CH(off) == _T('_') || CH(off) == _T(':'))) {
                 off++;
-                /* Attribute name */
+
                 while(off < line_end && (ISALNUM(off) || ISANYOF(off, _T("_.:-"))))
                     off++;
                 attr_state = 2;
             } else if(attr_state == 2 && CH(off) == _T('=')) {
-                /* Attribute assignment sign */
+
                 off++;
                 attr_state = 3;
             } else if(attr_state == 3) {
-                /* Expecting start of attribute value. */
+
                 if(CH(off) == _T('"'))
                     attr_state = 43;
                 else if(CH(off) == _T('\''))
@@ -1159,13 +996,11 @@ md_is_html_tag(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg, OFF
                     return FALSE;
                 off++;
             } else {
-                /* Anything unexpected. */
+
                 return FALSE;
             }
         }
 
-        /* We have to be on a single line. See definition of start condition
-         * of HTML block, type 7. */
         if(n_lines == 0)
             return FALSE;
 
@@ -1201,15 +1036,14 @@ md_scan_for_html_closer(MD_CTX* ctx, const MD_CHAR* str, MD_SIZE len,
     MD_SIZE line_index = 0;
 
     if(off < *p_scan_horizon  &&  *p_scan_horizon >= max_end - len) {
-        /* We have already scanned the range up to the max_end so we know
-         * there is nothing to see. */
+
         return FALSE;
     }
 
     while(TRUE) {
         while(off + len <= lines[line_index].end  &&  off + len <= max_end) {
             if(md_ascii_eq(STR(off), str, len)) {
-                /* Success. */
+
                 *p_end = off + len;
                 return TRUE;
             }
@@ -1218,7 +1052,7 @@ md_scan_for_html_closer(MD_CTX* ctx, const MD_CHAR* str, MD_SIZE len,
 
         line_index++;
         if(off >= max_end  ||  line_index >= n_lines) {
-            /* Failure. */
+
             *p_scan_horizon = off;
             return FALSE;
         }
@@ -1239,10 +1073,8 @@ md_is_html_comment(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg,
     if(CH(off+1) != _T('!')  ||  CH(off+2) != _T('-')  ||  CH(off+3) != _T('-'))
         return FALSE;
 
-    /* Skip only "<!" so that we accept also "<!-->" or "<!--->" */
     off += 2;
 
-    /* Scan for ordinary comment closer "-->". */
     return md_scan_for_html_closer(ctx, _T("-->"), 3,
                 lines, n_lines, off, max_end, p_end, &ctx->html_comment_horizon);
 }
@@ -1273,7 +1105,6 @@ md_is_html_declaration(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF b
         return FALSE;
     off += 2;
 
-    /* Declaration name. */
     if(off >= lines[0].end  ||  !ISALPHA(off))
         return FALSE;
     off++;
@@ -1313,11 +1144,6 @@ md_is_html_any(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg, OFF
             md_is_html_cdata(ctx, lines, n_lines, beg, max_end, p_end));
 }
 
-
-/****************************
- ***  Recognizing Entity  ***
- ****************************/
-
 static int
 md_is_hex_entity_contents(MD_CTX* ctx, const CHAR* text, OFF beg, OFF max_end, OFF* p_end)
 {
@@ -1404,11 +1230,6 @@ md_is_entity(MD_CTX* ctx, OFF beg, OFF max_end, OFF* p_end)
     return md_is_entity_str(ctx, ctx->text, beg, max_end, p_end);
 }
 
-
-/******************************
- ***  Attribute Management  ***
- ******************************/
-
 typedef struct MD_ATTRIBUTE_BUILD_tag MD_ATTRIBUTE_BUILD;
 struct MD_ATTRIBUTE_BUILD_tag {
     CHAR* text;
@@ -1420,7 +1241,6 @@ struct MD_ATTRIBUTE_BUILD_tag {
     OFF trivial_offsets[2];
 };
 
-
 #define MD_BUILD_ATTR_NO_ESCAPES    0x0001
 
 static int
@@ -1440,7 +1260,7 @@ md_build_attr_append_substr(MD_CTX* ctx, MD_ATTRIBUTE_BUILD* build,
             MD_LOG("realloc() failed.");
             return -1;
         }
-        /* Note +1 to reserve space for final offset (== raw_size). */
+
         new_substr_offsets = (OFF*) realloc(build->substr_offsets,
                                     (build->substr_alloc+1) * sizeof(OFF));
         if(new_substr_offsets == NULL) {
@@ -1481,8 +1301,6 @@ md_build_attribute(MD_CTX* ctx, const CHAR* raw_text, SZ raw_size,
 
     memset(build, 0, sizeof(MD_ATTRIBUTE_BUILD));
 
-    /* If there is no backslash and no ampersand, build trivial attribute
-     * without any malloc(). */
     is_trivial = TRUE;
     for(raw_off = 0; raw_off < raw_size; raw_off++) {
         if(ISANYOF3_(raw_text[raw_off], _T('\\'), _T('&'), _T('\0'))) {
@@ -1556,11 +1374,6 @@ abort:
     return -1;
 }
 
-
-/*********************************************
- ***  Dictionary of Reference Definitions  ***
- *********************************************/
-
 #define MD_FNV1A_BASE       2166136261U
 #define MD_FNV1A_PRIME      16777619U
 
@@ -1579,7 +1392,6 @@ md_fnv1a(unsigned base, const void* data, size_t n)
     return hash;
 }
 
-
 struct MD_REF_DEF_tag {
     CHAR* label;
     CHAR* title;
@@ -1592,10 +1404,6 @@ struct MD_REF_DEF_tag {
     unsigned char title_needs_free : 1;
 };
 
-/* Label equivalence is quite complicated with regards to whitespace and case
- * folding. This complicates computing a hash of it as well as direct comparison
- * of two labels. */
-
 static unsigned
 md_link_label_hash(const CHAR* label, SZ size)
 {
@@ -1635,18 +1443,17 @@ md_link_label_cmp_load_fold_info(const CHAR* label, OFF off, SZ size,
     SZ char_size;
 
     if(off >= size) {
-        /* Treat end of a link label as a whitespace. */
+
         goto whitespace;
     }
 
     codepoint = md_decode_unicode(label, off, size, &char_size);
     off += char_size;
     if(ISUNICODEWHITESPACE_(codepoint)) {
-        /* Treat all whitespace as equivalent */
+
         goto whitespace;
     }
 
-    /* Get real folding info. */
     md_get_unicode_fold_info(codepoint, fold_info);
     return off;
 
@@ -1672,7 +1479,7 @@ md_link_label_cmp(const CHAR* a_label, SZ a_size, const CHAR* b_label, SZ b_size
     while(a_off < a_size || a_fi_off < a_fi.n_codepoints ||
           b_off < b_size || b_fi_off < b_fi.n_codepoints)
     {
-        /* If needed, load fold info for next char. */
+
         if(a_fi_off >= a_fi.n_codepoints) {
             a_fi_off = 0;
             a_off = md_link_label_cmp_load_fold_info(a_label, a_off, a_size, &a_fi);
@@ -1697,7 +1504,7 @@ typedef struct MD_REF_DEF_LIST_tag MD_REF_DEF_LIST;
 struct MD_REF_DEF_LIST_tag {
     int n_ref_defs;
     int alloc_ref_defs;
-    MD_REF_DEF* ref_defs[];  /* Valid items always  point into ctx->ref_defs[] */
+    MD_REF_DEF* ref_defs[];
 };
 
 static int
@@ -1721,7 +1528,6 @@ md_ref_def_cmp_for_sort(const void* a, const void* b)
 
     cmp = md_ref_def_cmp(a, b);
 
-    /* Ensure stability of the sorting. */
     if(cmp == 0) {
         const MD_REF_DEF* a_ref = *(const MD_REF_DEF**)a;
         const MD_REF_DEF* b_ref = *(const MD_REF_DEF**)b;
@@ -1753,12 +1559,6 @@ md_build_ref_def_hashtable(MD_CTX* ctx)
     }
     memset(ctx->ref_def_hashtable, 0, ctx->ref_def_hashtable_size * sizeof(void*));
 
-    /* Each member of ctx->ref_def_hashtable[] can be:
-     *  -- NULL,
-     *  -- pointer to the MD_REF_DEF in ctx->ref_defs[], or
-     *  -- pointer to a MD_REF_DEF_LIST, which holds multiple pointers to
-     *     such MD_REF_DEFs.
-     */
     for(i = 0; i < ctx->n_ref_defs; i++) {
         MD_REF_DEF* def = &ctx->ref_defs[i];
         void* bucket;
@@ -1768,23 +1568,20 @@ md_build_ref_def_hashtable(MD_CTX* ctx)
         bucket = ctx->ref_def_hashtable[def->hash % ctx->ref_def_hashtable_size];
 
         if(bucket == NULL) {
-            /* The bucket is empty. Make it just point to the def. */
+
             ctx->ref_def_hashtable[def->hash % ctx->ref_def_hashtable_size] = def;
             continue;
         }
 
         if(ctx->ref_defs <= (MD_REF_DEF*) bucket  &&  (MD_REF_DEF*) bucket < ctx->ref_defs + ctx->n_ref_defs) {
-            /* The bucket already contains one ref. def. Lets see whether it
-             * is the same label (ref. def. duplicate) or different one
-             * (hash conflict). */
+
             MD_REF_DEF* old_def = (MD_REF_DEF*) bucket;
 
             if(md_link_label_cmp(def->label, def->label_size, old_def->label, old_def->label_size) == 0) {
-                /* Duplicate label: Ignore this ref. def. */
+
                 continue;
             }
 
-            /* Make the bucket complex, i.e. able to hold more ref. defs. */
             list = (MD_REF_DEF_LIST*) malloc(sizeof(MD_REF_DEF_LIST) + 2 * sizeof(MD_REF_DEF*));
             if(list == NULL) {
                 MD_LOG("malloc() failed.");
@@ -1798,12 +1595,6 @@ md_build_ref_def_hashtable(MD_CTX* ctx)
             continue;
         }
 
-        /* Append the def to the complex bucket list.
-         *
-         * Note in this case we ignore potential duplicates to avoid expensive
-         * iterating over the complex bucket. Below, we revisit all the complex
-         * buckets and handle it more cheaply after the complex bucket contents
-         * is sorted. */
         list = (MD_REF_DEF_LIST*) bucket;
         if(list->n_ref_defs >= list->alloc_ref_defs) {
             int alloc_ref_defs = list->alloc_ref_defs + list->alloc_ref_defs / 2;
@@ -1822,7 +1613,6 @@ md_build_ref_def_hashtable(MD_CTX* ctx)
         list->n_ref_defs++;
     }
 
-    /* Sort the complex buckets so we can use bsearch() with them. */
     for(i = 0; i < ctx->ref_def_hashtable_size; i++) {
         void* bucket = ctx->ref_def_hashtable[i];
         MD_REF_DEF_LIST* list;
@@ -1835,10 +1625,6 @@ md_build_ref_def_hashtable(MD_CTX* ctx)
         list = (MD_REF_DEF_LIST*) bucket;
         qsort(list->ref_defs, list->n_ref_defs, sizeof(MD_REF_DEF*), md_ref_def_cmp_for_sort);
 
-        /* Disable all duplicates in the complex bucket by forcing all such
-         * records to point to the 1st such ref. def. I.e. no matter which
-         * record is found during the lookup, it will always point to the right
-         * ref. def. in ctx->ref_defs[]. */
         for(j = 1; j < list->n_ref_defs; j++) {
             if(md_ref_def_cmp(&list->ref_defs[j-1], &list->ref_defs[j]) == 0)
                 list->ref_defs[j] = list->ref_defs[j-1];
@@ -1910,15 +1696,6 @@ md_lookup_ref_def(MD_CTX* ctx, const CHAR* label, SZ label_size)
     }
 }
 
-
-/***************************
- ***  Recognizing Links  ***
- ***************************/
-
-/* Note this code is partially shared between processing inlines and blocks
- * as reference definitions and links share some helper parser functions.
- */
-
 typedef struct MD_LINK_ATTR_tag MD_LINK_ATTR;
 struct MD_LINK_ATTR_tag {
     OFF dest_beg;
@@ -1929,7 +1706,6 @@ struct MD_LINK_ATTR_tag {
     int title_needs_free;
 };
 
-
 static int
 md_is_link_label(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg,
                  OFF* p_end, MD_SIZE* p_beg_line_index, MD_SIZE* p_end_line_index,
@@ -1962,14 +1738,14 @@ md_is_link_label(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg,
                 return FALSE;
             } else if(CH(off) == _T(']')) {
                 if(contents_beg < contents_end) {
-                    /* Success. */
+
                     *p_contents_beg = contents_beg;
                     *p_contents_end = contents_end;
                     *p_end = off+1;
                     *p_end_line_index = line_index;
                     return TRUE;
                 } else {
-                    /* Link label must have some non-whitespace contents. */
+
                     return FALSE;
                 }
             } else {
@@ -2024,7 +1800,7 @@ md_is_link_destination_A(MD_CTX* ctx, OFF beg, OFF max_end, OFF* p_end,
             return FALSE;
 
         if(CH(off) == _T('>')) {
-            /* Success. */
+
             *p_contents_beg = beg+1;
             *p_contents_end = off;
             *p_end = off+1;
@@ -2053,9 +1829,6 @@ md_is_link_destination_B(MD_CTX* ctx, OFF beg, OFF max_end, OFF* p_end,
         if(ISWHITESPACE(off) || ISCNTRL(off))
             break;
 
-        /* Link destination may include balanced pairs of unescaped '(' ')'.
-         * Note we limit the maximal nesting level by 32 to protect us from
-         * https://github.com/jgm/cmark/issues/214 */
         if(CH(off) == _T('(')) {
             parenthesis_level++;
             if(parenthesis_level > 32)
@@ -2072,7 +1845,6 @@ md_is_link_destination_B(MD_CTX* ctx, OFF beg, OFF max_end, OFF* p_end,
     if(parenthesis_level != 0  ||  off == beg)
         return FALSE;
 
-    /* Success. */
     *p_contents_beg = beg;
     *p_contents_end = off;
     *p_end = off;
@@ -2098,7 +1870,6 @@ md_is_link_title(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg,
     CHAR closer_char;
     MD_SIZE line_index = 0;
 
-    /* White space with up to one line break. */
     while(off < lines[line_index].end  &&  ISWHITESPACE(off))
         off++;
     if(off >= lines[line_index].end) {
@@ -2112,7 +1883,6 @@ md_is_link_title(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg,
 
     *p_beg_line_index = line_index;
 
-    /* First char determines how to detect end of it. */
     switch(CH(off)) {
         case _T('"'):   closer_char = _T('"'); break;
         case _T('\''):  closer_char = _T('\''); break;
@@ -2130,13 +1900,13 @@ md_is_link_title(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg,
             if(CH(off) == _T('\\')  &&  off+1 < ctx->size  &&  (ISPUNCT(off+1) || ISNEWLINE(off+1))) {
                 off++;
             } else if(CH(off) == closer_char) {
-                /* Success. */
+
                 *p_contents_end = off;
                 *p_end = off+1;
                 *p_end_line_index = line_index;
                 return TRUE;
             } else if(closer_char == _T(')')  &&  CH(off) == _T('(')) {
-                /* ()-style title cannot contain (unescaped '(')) */
+
                 return FALSE;
             }
 
@@ -2149,14 +1919,6 @@ md_is_link_title(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg,
     return FALSE;
 }
 
-/* Returns 0 if it is not a reference definition.
- *
- * Returns N > 0 if it is a reference definition. N then corresponds to the
- * number of lines forming it). In this case the definition is stored for
- * resolving any links referring to it.
- *
- * Returns -1 in case of an error (out of memory).
- */
 static int
 md_is_link_reference_definition(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
 {
@@ -2176,19 +1938,16 @@ md_is_link_reference_definition(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lin
     MD_REF_DEF* def = NULL;
     int ret = 0;
 
-    /* Link label. */
     if(!md_is_link_label(ctx, lines, n_lines, lines[0].beg,
                 &off, &label_contents_line_index, &line_index,
                 &label_contents_beg, &label_contents_end))
         return FALSE;
     label_is_multiline = (label_contents_line_index != line_index);
 
-    /* Colon. */
     if(off >= lines[line_index].end  ||  CH(off) != _T(':'))
         return FALSE;
     off++;
 
-    /* Optional white space with up to one line break. */
     while(off < lines[line_index].end  &&  ISWHITESPACE(off))
         off++;
     if(off >= lines[line_index].end) {
@@ -2198,13 +1957,10 @@ md_is_link_reference_definition(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lin
         off = lines[line_index].beg;
     }
 
-    /* Link destination. */
     if(!md_is_link_destination(ctx, off, lines[line_index].end,
                 &off, &dest_contents_beg, &dest_contents_end))
         return FALSE;
 
-    /* (Optional) title. Note we interpret it as an title only if nothing
-     * more follows on its last line. */
     if(md_is_link_title(ctx, lines + line_index, n_lines - line_index, off,
                 &off, &title_contents_line_index, &tmp_line_index,
                 &title_contents_beg, &title_contents_end)
@@ -2214,18 +1970,16 @@ md_is_link_reference_definition(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lin
         title_contents_line_index += line_index;
         line_index += tmp_line_index;
     } else {
-        /* Not a title. */
+
         title_is_multiline = FALSE;
         title_contents_beg = off;
         title_contents_end = off;
         title_contents_line_index = 0;
     }
 
-    /* Nothing more can follow on the last line. */
     if(off < lines[line_index].end)
         return FALSE;
 
-    /* So, it _is_ a reference definition. Remember it. */
     if(ctx->n_ref_defs >= ctx->alloc_ref_defs) {
         MD_REF_DEF* new_defs;
 
@@ -2266,12 +2020,11 @@ md_is_link_reference_definition(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lin
     def->dest_beg = dest_contents_beg;
     def->dest_end = dest_contents_end;
 
-    /* Success. */
     ctx->n_ref_defs++;
     return line_index + 1;
 
 abort:
-    /* Failure. */
+
     if(def != NULL  &&  def->label_needs_free)
         free(def->label);
     if(def != NULL  &&  def->title_needs_free)
@@ -2299,7 +2052,6 @@ md_is_link_reference(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines,
     beg += (CH(beg) == _T('!') ? 2 : 1);
     end--;
 
-    /* Find lines corresponding to the beg and end positions. */
     beg_line = md_lookup_line(beg, lines, n_lines, NULL);
     is_multiline = (end > beg_line->end);
 
@@ -2324,7 +2076,7 @@ md_is_link_reference(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines,
         free(label);
 
     if(def != NULL) {
-        /* See https://github.com/mity/md4c/issues/238 */
+
         MD_SIZE output_size_estimation = def->label_size + def->title_size + def->dest_end - def->dest_beg;
         if(output_size_estimation < ctx->max_ref_def_output) {
             ctx->max_ref_def_output -= output_size_estimation;
@@ -2357,7 +2109,6 @@ md_is_inline_link_spec(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines,
     MD_ASSERT(CH(off) == _T('('));
     off++;
 
-    /* Optional white space with up to one line break. */
     while(off < lines[line_index].end  &&  ISWHITESPACE(off))
         off++;
     if(off >= lines[line_index].end  &&  (off >= ctx->size  ||  ISNEWLINE(off))) {
@@ -2367,7 +2118,6 @@ md_is_inline_link_spec(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines,
         off = lines[line_index].beg;
     }
 
-    /* Link destination may be omitted, but only when not also having a title. */
     if(off < ctx->size  &&  CH(off) == _T(')')) {
         attr->dest_beg = off;
         attr->dest_end = off;
@@ -2379,12 +2129,10 @@ md_is_inline_link_spec(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines,
         return TRUE;
     }
 
-    /* Link destination. */
     if(!md_is_link_destination(ctx, off, lines[line_index].end,
                         &off, &attr->dest_beg, &attr->dest_end))
         return FALSE;
 
-    /* (Optional) title. */
     if(md_is_link_title(ctx, lines + line_index, n_lines - line_index, off,
                 &off, &title_contents_line_index, &tmp_line_index,
                 &title_contents_beg, &title_contents_end))
@@ -2393,14 +2141,13 @@ md_is_inline_link_spec(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines,
         title_contents_line_index += line_index;
         line_index += tmp_line_index;
     } else {
-        /* Not a title. */
+
         title_is_multiline = FALSE;
         title_contents_beg = off;
         title_contents_end = off;
         title_contents_line_index = 0;
     }
 
-    /* Optional whitespace followed with final ')'. */
     while(off < lines[line_index].end  &&  ISWHITESPACE(off))
         off++;
     if(off >= lines[line_index].end) {
@@ -2452,106 +2199,31 @@ md_free_ref_defs(MD_CTX* ctx)
     free(ctx->ref_defs);
 }
 
-
-/******************************************
- ***  Processing Inlines (a.k.a Spans)  ***
- ******************************************/
-
-/* We process inlines in few phases:
- *
- * (1) We go through the block text and collect all significant characters
- *     which may start/end a span or some other significant position into
- *     ctx->marks[]. Core of this is what md_collect_marks() does.
- *
- *     We also do some very brief preliminary context-less analysis, whether
- *     it might be opener or closer (e.g. of an emphasis span).
- *
- *     This speeds the other steps as we do not need to re-iterate over all
- *     characters anymore.
- *
- * (2) We analyze each potential mark types, in order by their precedence.
- *
- *     In each md_analyze_XXX() function, we re-iterate list of the marks,
- *     skipping already resolved regions (in preceding precedences) and try to
- *     resolve them.
- *
- * (2.1) For trivial marks, which are single (e.g. HTML entity), we just mark
- *       them as resolved.
- *
- * (2.2) For range-type marks, we analyze whether the mark could be closer
- *       and, if yes, whether there is some preceding opener it could satisfy.
- *
- *       If not we check whether it could be really an opener and if yes, we
- *       remember it so subsequent closers may resolve it.
- *
- * (3) Finally, when all marks were analyzed, we render the block contents
- *     by calling MD_RENDERER::text() callback, interrupting by ::enter_span()
- *     or ::close_span() whenever we reach a resolved mark.
- */
-
-
-/* The mark structure.
- *
- * '\\': Maybe escape sequence.
- * '\0': NULL char.
- *  '*': Maybe (strong) emphasis start/end.
- *  '_': Maybe (strong) emphasis start/end.
- *  '~': Maybe strikethrough start/end (needs MD_FLAG_STRIKETHROUGH).
- *  '`': Maybe code span start/end.
- *  '&': Maybe start of entity.
- *  ';': Maybe end of entity.
- *  '<': Maybe start of raw HTML or autolink.
- *  '>': Maybe end of raw HTML or autolink.
- *  '[': Maybe start of link label or link text.
- *  '!': Equivalent of '[' for image.
- *  ']': Maybe end of link label or link text.
- *  '@': Maybe permissive e-mail auto-link (needs MD_FLAG_PERMISSIVEEMAILAUTOLINKS).
- *  ':': Maybe permissive URL auto-link (needs MD_FLAG_PERMISSIVEURLAUTOLINKS).
- *  '.': Maybe permissive WWW auto-link (needs MD_FLAG_PERMISSIVEWWWAUTOLINKS).
- *  'D': Dummy mark, it reserves a space for splitting a previous mark
- *       (e.g. emphasis) or to make more space for storing some special data
- *       related to the preceding mark (e.g. link).
- *
- * Note that not all instances of these chars in the text imply creation of the
- * structure. Only those which have (or may have, after we see more context)
- * the special meaning.
- *
- * (Keep this struct as small as possible to fit as much of them into CPU
- * cache line.)
- */
 struct MD_MARK_tag {
     OFF beg;
     OFF end;
 
-    /* For unresolved openers, 'next' may be used to form a stack of
-     * unresolved open openers.
-     *
-     * When resolved with MD_MARK_OPENER/CLOSER flag, next/prev is index of the
-     * respective closer/opener.
-     */
     int prev;
     int next;
     CHAR ch;
     unsigned char flags;
 };
 
-/* Mark flags (these apply to ALL mark types). */
-#define MD_MARK_POTENTIAL_OPENER            0x01  /* Maybe opener. */
-#define MD_MARK_POTENTIAL_CLOSER            0x02  /* Maybe closer. */
-#define MD_MARK_OPENER                      0x04  /* Definitely opener. */
-#define MD_MARK_CLOSER                      0x08  /* Definitely closer. */
-#define MD_MARK_RESOLVED                    0x10  /* Resolved in any definite way. */
+#define MD_MARK_POTENTIAL_OPENER            0x01
+#define MD_MARK_POTENTIAL_CLOSER            0x02
+#define MD_MARK_OPENER                      0x04
+#define MD_MARK_CLOSER                      0x08
+#define MD_MARK_RESOLVED                    0x10
 
-/* Mark flags specific for various mark types (so they can share bits). */
-#define MD_MARK_EMPH_OC                     0x20  /* Opener/closer mixed candidate. Helper for the "rule of 3". */
+#define MD_MARK_EMPH_OC                     0x20
 #define MD_MARK_EMPH_MOD3_0                 0x40
 #define MD_MARK_EMPH_MOD3_1                 0x80
 #define MD_MARK_EMPH_MOD3_2                 (0x40 | 0x80)
 #define MD_MARK_EMPH_MOD3_MASK              (0x40 | 0x80)
-#define MD_MARK_AUTOLINK                    0x20  /* Distinguisher for '<', '>'. */
+#define MD_MARK_AUTOLINK                    0x20
 #define MD_MARK_AUTOLINK_MISSING_MAILTO     0x40
-#define MD_MARK_VALIDPERMISSIVEAUTOLINK     0x20  /* For permissive autolinks. */
-#define MD_MARK_HASNESTEDBRACKETS           0x20  /* For '[' to rule out invalid link labels early */
+#define MD_MARK_VALIDPERMISSIVEAUTOLINK     0x20
+#define MD_MARK_HASNESTEDBRACKETS           0x20
 
 static MD_MARKSTACK*
 md_emph_stack(MD_CTX* ctx, MD_CHAR ch, unsigned flags)
@@ -2636,7 +2308,6 @@ md_add_mark(MD_CTX* ctx)
             mark->flags = (flags_);                                     \
         } while(0)
 
-
 static inline void
 md_mark_stack_push(MD_CTX* ctx, MD_MARKSTACK* stack, int mark_index)
 {
@@ -2653,16 +2324,12 @@ md_mark_stack_pop(MD_CTX* ctx, MD_MARKSTACK* stack)
     return top;
 }
 
-/* Sometimes, we need to store a pointer into the mark. It is quite rare
- * so we do not bother to make MD_MARK use union, and it can only happen
- * for dummy marks. */
 static inline void
 md_mark_store_ptr(MD_CTX* ctx, int mark_index, void* ptr)
 {
     MD_MARK* mark = &ctx->marks[mark_index];
     MD_ASSERT(mark->ch == 'D');
 
-    /* Check only members beg and end are misused for this. */
     MD_ASSERT(sizeof(void*) <= 2 * sizeof(OFF));
     memcpy(mark, &ptr, sizeof(void*));
 }
@@ -2683,7 +2350,6 @@ md_resolve_range(MD_CTX* ctx, int opener_index, int closer_index)
     MD_MARK* opener = &ctx->marks[opener_index];
     MD_MARK* closer = &ctx->marks[closer_index];
 
-    /* Interconnect opener and closer and mark both as resolved. */
     opener->next = closer_index;
     closer->prev = opener_index;
 
@@ -2691,23 +2357,9 @@ md_resolve_range(MD_CTX* ctx, int opener_index, int closer_index)
     closer->flags |= MD_MARK_CLOSER | MD_MARK_RESOLVED;
 }
 
-
 #define MD_ROLLBACK_CROSSING    0
 #define MD_ROLLBACK_ALL         1
 
-/* In the range ctx->marks[opener_index] ... [closer_index], undo some or all
- * resolvings accordingly to these rules:
- *
- * (1) All stacks of openers are cut so that any pending potential openers
- *     are discarded from future consideration.
- *
- * (2) If 'how' is MD_ROLLBACK_ALL, then ALL resolved marks inside the range
- *     are thrown away and turned into dummy marks ('D').
- *
- * WARNING: Do not call for arbitrary range of opener and closer.
- * This must form (potentially) valid range not crossing nesting boundaries
- * of already resolved ranges.
- */
 static void
 md_rollback(MD_CTX* ctx, int opener_index, int closer_index, int how)
 {
@@ -2799,15 +2451,12 @@ md_is_code_span(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg,
     has_space_after_opener = (opener_end < line_end && CH(opener_end) == _T(' '));
     has_eol_after_opener = (opener_end == line_end);
 
-    /* The caller needs to know end of the opening mark even if we fail. */
     opener->end = opener_end;
 
     mark_len = opener_end - opener_beg;
     if(mark_len > CODESPAN_MARK_MAXLEN)
         return FALSE;
 
-    /* Check whether we already know there is no closer of this length.
-     * If so, re-scan does no sense. This fixes issue #59. */
     if(last_potential_closers[mark_len-1] >= lines[n_lines-1].end  ||
        (*p_reached_paragraph_end  &&  last_potential_closers[mark_len-1] < opener_end))
         return FALSE;
@@ -2815,7 +2464,6 @@ md_is_code_span(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg,
     closer_beg = opener_end;
     closer_end = opener_end;
 
-    /* Find closer mark. */
     while(TRUE) {
         while(closer_beg < line_end  &&  CH(closer_beg) != _T('`')) {
             if(CH(closer_beg) != _T(' '))
@@ -2827,19 +2475,16 @@ md_is_code_span(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg,
             closer_end++;
 
         if(closer_end - closer_beg == mark_len) {
-            /* Success. */
+
             has_space_before_closer = (closer_beg > lines[line_index].beg && CH(closer_beg-1) == _T(' '));
             has_eol_before_closer = (closer_beg == lines[line_index].beg);
             break;
         }
 
         if(closer_end - closer_beg > 0) {
-            /* We have found a back-tick which is not part of the closer. */
+
             has_only_space = FALSE;
 
-            /* But if we eventually fail, remember it as a potential closer
-             * of its own length for future attempts. This mitigates needs for
-             * rescans. */
             if(closer_end - closer_beg < CODESPAN_MARK_MAXLEN) {
                 if(closer_beg > last_potential_closers[closer_end - closer_beg - 1])
                     last_potential_closers[closer_end - closer_beg - 1] = closer_beg;
@@ -2849,11 +2494,11 @@ md_is_code_span(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg,
         if(closer_end >= line_end) {
             line_index++;
             if(line_index >= n_lines) {
-                /* Reached end of the paragraph and still nothing. */
+
                 *p_reached_paragraph_end = TRUE;
                 return FALSE;
             }
-            /* Try on the next line. */
+
             line_end = lines[line_index].end;
             closer_beg = lines[line_index].beg;
         } else {
@@ -2861,9 +2506,6 @@ md_is_code_span(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg,
         }
     }
 
-    /* If there is a space or a new line both after and before the opener
-     * (and if the code span is not made of spaces only), consume one initial
-     * and one trailing space as part of the marks. */
     if(!has_only_space  &&
        (has_space_after_opener || has_eol_after_opener)  &&
        (has_space_before_closer || has_eol_before_closer))
@@ -2876,9 +2518,9 @@ md_is_code_span(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg,
         if(has_space_before_closer)
             closer_beg--;
         else {
-            /* Go back to the end of prev line */
+
             closer_beg = lines[line_index-1].end;
-            /* But restore any trailing whitespace */
+
             while(closer_beg < ctx->size  &&  ISBLANK(closer_beg))
                 closer_beg++;
         }
@@ -2902,7 +2544,6 @@ md_is_autolink_uri(MD_CTX* ctx, OFF beg, OFF max_end, OFF* p_end)
 
     MD_ASSERT(CH(beg) == _T('<'));
 
-    /* Check for scheme. */
     if(off >= max_end  ||  !ISASCII(off))
         return FALSE;
     off++;
@@ -2918,7 +2559,6 @@ md_is_autolink_uri(MD_CTX* ctx, OFF beg, OFF max_end, OFF* p_end)
         off++;
     }
 
-    /* Check the path after the scheme. */
     while(off < max_end  &&  CH(off) != _T('>')) {
         if(ISWHITESPACE(off) || ISCNTRL(off) || CH(off) == _T('<'))
             return FALSE;
@@ -2941,25 +2581,15 @@ md_is_autolink_email(MD_CTX* ctx, OFF beg, OFF max_end, OFF* p_end)
 
     MD_ASSERT(CH(beg) == _T('<'));
 
-    /* The code should correspond to this regexp:
-            /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+
-            @[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?
-            (?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
-     */
-
-    /* Username (before '@'). */
     while(off < max_end  &&  (ISALNUM(off) || ISANYOF(off, _T(".!#$%&'*+/=?^_`{|}~-"))))
         off++;
     if(off <= beg+1)
         return FALSE;
 
-    /* '@' */
     if(off >= max_end  ||  CH(off) != _T('@'))
         return FALSE;
     off++;
 
-    /* Labels delimited with '.'; each label is sequence of 1 - 63 alnum
-     * characters or '-', but '-' is not allowed as first or last char. */
     label_len = 0;
     while(off < max_end) {
         if(ISALNUM(off))
@@ -3017,15 +2647,14 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
             CHAR ch;
 
 #ifdef MD4C_USE_UTF16
-    /* For UTF-16, mark_char_map[] covers only ASCII. */
+
     #define IS_MARK_CHAR(off)   ((CH(off) < SIZEOF_ARRAY(ctx->mark_char_map))  &&  \
                                 (ctx->mark_char_map[(unsigned char) CH(off)]))
 #else
-    /* For 8-bit encodings, mark_char_map[] covers all 256 elements. */
+
     #define IS_MARK_CHAR(off)   (ctx->mark_char_map[(unsigned char) CH(off)])
 #endif
 
-            /* Optimization: Use some loop unrolling. */
             while(off + 3 < line->end  &&  !IS_MARK_CHAR(off+0)  &&  !IS_MARK_CHAR(off+1)
                                        &&  !IS_MARK_CHAR(off+2)  &&  !IS_MARK_CHAR(off+3))
                 off += 4;
@@ -3037,22 +2666,18 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
 
             ch = CH(off);
 
-            /* A backslash escape.
-             * It can go beyond line->end as it may involve escaped new
-             * line to form a hard break. */
             if(ch == _T('\\')  &&  off+1 < ctx->size  &&  (ISPUNCT(off+1) || ISNEWLINE(off+1))) {
-                /* Hard-break cannot be on the last line of the block. */
+
                 if(!ISNEWLINE(off+1)  ||  line_index+1 < n_lines)
                     ADD_MARK(ch, off, off+2, MD_MARK_RESOLVED);
                 off += 2;
                 continue;
             }
 
-            /* A potential (string) emphasis start/end. */
             if(ch == _T('*')  ||  ch == _T('_')) {
                 OFF tmp = off+1;
-                int left_level;     /* What precedes: 0 = whitespace; 1 = punctuation; 2 = other char. */
-                int right_level;    /* What follows: 0 = whitespace; 1 = punctuation; 2 = other char. */
+                int left_level;
+                int right_level;
 
                 while(tmp < line->end  &&  CH(tmp) == ch)
                     tmp++;
@@ -3071,7 +2696,6 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
                 else
                     right_level = 2;
 
-                /* Intra-word underscore doesn't have special meaning. */
                 if(ch == _T('_')  &&  left_level == 2  &&  right_level == 2) {
                     left_level = 0;
                     right_level = 0;
@@ -3087,10 +2711,6 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
                     if(flags == (MD_MARK_POTENTIAL_OPENER | MD_MARK_POTENTIAL_CLOSER))
                         flags |= MD_MARK_EMPH_OC;
 
-                    /* For "the rule of three" we need to remember the original
-                     * size of the mark (modulo three), before we potentially
-                     * split the mark when being later resolved partially by some
-                     * shorter closer. */
                     switch((tmp - off) % 3) {
                         case 0: flags |= MD_MARK_EMPH_MOD3_0; break;
                         case 1: flags |= MD_MARK_EMPH_MOD3_1; break;
@@ -3099,10 +2719,6 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
 
                     ADD_MARK(ch, off, tmp, flags);
 
-                    /* During resolving, multiple asterisks may have to be
-                     * split into independent span start/ends. Consider e.g.
-                     * "**foo* bar*". Therefore we push also some empty dummy
-                     * marks to have enough space for that. */
                     off++;
                     while(off < tmp) {
                         ADD_MARK('D', off, off, 0);
@@ -3115,7 +2731,6 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
                 continue;
             }
 
-            /* A potential code span start/end. */
             if(ch == _T('`')) {
                 MD_MARK opener;
                 MD_MARK closer;
@@ -3130,7 +2745,6 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
                     md_resolve_range(ctx, ctx->n_marks-2, ctx->n_marks-1);
                     off = closer.end;
 
-                    /* Advance the current line accordingly. */
                     if(off > line->end)
                         line = md_lookup_line(off, lines, n_lines, &line_index);
                     continue;
@@ -3140,16 +2754,14 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
                 continue;
             }
 
-            /* A potential entity start. */
             if(ch == _T('&')) {
                 ADD_MARK(ch, off, off+1, MD_MARK_POTENTIAL_OPENER);
                 off++;
                 continue;
             }
 
-            /* A potential entity end. */
             if(ch == _T(';')) {
-                /* We surely cannot be entity unless the previous mark is '&'. */
+
                 if(ctx->n_marks > 0  &&  ctx->marks[ctx->n_marks-1].ch == _T('&'))
                     ADD_MARK(ch, off, off+1, MD_MARK_POTENTIAL_CLOSER);
 
@@ -3157,7 +2769,6 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
                 continue;
             }
 
-            /* A potential autolink or raw HTML start/end. */
             if(ch == _T('<')) {
                 int is_autolink;
                 OFF autolink_end;
@@ -3167,9 +2778,6 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
                     int is_html;
                     OFF html_end;
 
-                    /* Given the nature of the raw HTML, we have to recognize
-                     * it here. Doing so later in md_analyze_lt_gt() could
-                     * open can of worms of quadratic complexity. */
                     is_html = md_is_html_any(ctx, line, n_lines - line_index, off,
                                     lines[n_lines-1].end, &html_end);
                     if(is_html) {
@@ -3179,7 +2787,6 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
                         ctx->marks[ctx->n_marks-1].prev = ctx->n_marks-2;
                         off = html_end;
 
-                        /* Advance the current line accordingly. */
                         if(off > line->end)
                             line = md_lookup_line(off, lines, n_lines, &line_index);
                         continue;
@@ -3205,13 +2812,11 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
                 continue;
             }
 
-            /* A potential link or its part. */
             if(ch == _T('[')  ||  (ch == _T('!') && off+1 < line->end && CH(off+1) == _T('['))) {
                 OFF tmp = (ch == _T('[') ? off+1 : off+2);
                 ADD_MARK(ch, off, tmp, MD_MARK_POTENTIAL_OPENER);
                 off = tmp;
-                /* Two dummies to make enough place for data we need if it is
-                 * a link. */
+
                 ADD_MARK('D', off, off, 0);
                 ADD_MARK('D', off, off, 0);
                 continue;
@@ -3222,13 +2827,12 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
                 continue;
             }
 
-            /* A potential permissive e-mail autolink. */
             if(ch == _T('@')) {
                 if(line->beg + 1 <= off  &&  ISALNUM(off-1)  &&
                     off + 3 < line->end  &&  ISALNUM(off+1))
                 {
                     ADD_MARK(ch, off, off+1, MD_MARK_POTENTIAL_OPENER);
-                    /* Push a dummy as a reserve for a closer. */
+
                     ADD_MARK('D', line->beg, line->end, 0);
                 }
 
@@ -3236,7 +2840,6 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
                 continue;
             }
 
-            /* A potential permissive URL autolink. */
             if(ch == _T(':')) {
                 static struct {
                     const CHAR* scheme;
@@ -3244,7 +2847,7 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
                     const CHAR* suffix;
                     SZ suffix_size;
                 } scheme_map[] = {
-                    /* In the order from the most frequently used, arguably. */
+
                     { _T("http"), 4,    _T("//"), 2 },
                     { _T("https"), 5,   _T("//"), 2 },
                     { _T("ftp"), 3,     _T("//"), 2 }
@@ -3261,7 +2864,7 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
                         off + 1 + suffix_size < line->end  &&  md_ascii_eq(STR(off+1), suffix, suffix_size))
                     {
                         ADD_MARK(ch, off-scheme_size, off+1+suffix_size, MD_MARK_POTENTIAL_OPENER);
-                        /* Push a dummy as a reserve for a closer. */
+
                         ADD_MARK('D', line->beg, line->end, 0);
                         off += 1 + suffix_size;
                         break;
@@ -3272,13 +2875,12 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
                 continue;
             }
 
-            /* A potential permissive WWW autolink. */
             if(ch == _T('.')) {
                 if(line->beg + 3 <= off  &&  md_ascii_eq(STR(off-3), _T("www"), 3)  &&
                    (off-3 == line->beg || ISUNICODEWHITESPACEBEFORE(off-3) || ISUNICODEPUNCTBEFORE(off-3)))
                 {
                     ADD_MARK(ch, off-3, off+1, MD_MARK_POTENTIAL_OPENER);
-                    /* Push a dummy as a reserve for a closer. */
+
                     ADD_MARK('D', line->beg, line->end, 0);
                     off++;
                     continue;
@@ -3288,14 +2890,12 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
                 continue;
             }
 
-            /* A potential table cell boundary or wiki link label delimiter. */
             if((table_mode || ctx->parser.flags & MD_FLAG_WIKILINKS) && ch == _T('|')) {
                 ADD_MARK(ch, off, off+1, 0);
                 off++;
                 continue;
             }
 
-            /* A potential strikethrough/equation start/end. */
             if(ch == _T('$') || ch == _T('~')) {
                 OFF tmp = off+1;
 
@@ -3317,7 +2917,6 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
                 continue;
             }
 
-            /* Turn non-trivial whitespace into single space. */
             if(ISWHITESPACE_(ch)) {
                 OFF tmp = off+1;
 
@@ -3331,7 +2930,6 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
                 continue;
             }
 
-            /* NULL character. */
             if(ch == _T('\0')) {
                 ADD_MARK(ch, off, off+1, MD_MARK_RESOLVED);
                 off++;
@@ -3342,8 +2940,6 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m
         }
     }
 
-    /* Add a dummy mark at the end of the mark vector to simplify
-     * process_inlines(). */
     ADD_MARK(127, ctx->size, ctx->size, MD_MARK_RESOLVED);
 
 abort:
@@ -3353,18 +2949,6 @@ abort:
 static void
 md_analyze_bracket(MD_CTX* ctx, int mark_index)
 {
-    /* We cannot really resolve links here as for that we would need
-     * more context. E.g. a following pair of brackets (reference link),
-     * or enclosing pair of brackets (if the inner is the link, the outer
-     * one cannot be.)
-     *
-     * Therefore we here only construct a list of '[' ']' pairs ordered by
-     * position of the closer. This allows us to analyze what is or is not
-     * link in the right order, from inside to outside in case of nested
-     * brackets.
-     *
-     * The resolving itself is deferred to md_resolve_links().
-     */
 
     MD_MARK* mark = &ctx->marks[mark_index];
 
@@ -3380,13 +2964,9 @@ md_analyze_bracket(MD_CTX* ctx, int mark_index)
         int opener_index = md_mark_stack_pop(ctx, &BRACKET_OPENERS);
         MD_MARK* opener = &ctx->marks[opener_index];
 
-        /* Interconnect the opener and closer. */
         opener->next = mark_index;
         mark->prev = opener_index;
 
-        /* Add the pair into a list of potential links for md_resolve_links().
-         * Note we misuse opener->prev for this as opener->next points to its
-         * closer. */
         if(ctx->unresolved_link_tail >= 0)
             ctx->marks[ctx->unresolved_link_tail].prev = opener_index;
         else
@@ -3396,7 +2976,6 @@ md_analyze_bracket(MD_CTX* ctx, int mark_index)
     }
 }
 
-/* Forward declaration. */
 static void md_analyze_link_contents(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines,
                                      int mark_beg, int mark_end);
 
@@ -3427,13 +3006,6 @@ md_resolve_links(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
             next_closer = NULL;
         }
 
-        /* If nested ("[ [ ] ]"), we need to make sure that:
-         *   - The outer does not end inside of (...) belonging to the inner.
-         *   - The outer cannot be link if the inner is link (i.e. not image).
-         *
-         * (Note we here analyze from inner to outer as the marks are ordered
-         * by closer->beg.)
-         */
         if((opener->beg < last_link_beg  &&  closer->end < last_link_end)  ||
            (opener->beg < last_img_beg  &&  closer->end < last_img_end)  ||
            (opener->beg < last_link_end  &&  opener->ch == '['))
@@ -3442,16 +3014,13 @@ md_resolve_links(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
             continue;
         }
 
-        /* Recognize and resolve wiki links.
-         * Wiki-links maybe '[[destination]]' or '[[destination|label]]'.
-         */
         if ((ctx->parser.flags & MD_FLAG_WIKILINKS) &&
-            (opener->end - opener->beg == 1) &&         /* not image */
-            next_opener != NULL &&                      /* double '[' opener */
+            (opener->end - opener->beg == 1) &&
+            next_opener != NULL &&
             next_opener->ch == '[' &&
             (next_opener->beg == opener->beg - 1) &&
             (next_opener->end - next_opener->beg == 1) &&
-            next_closer != NULL &&                      /* double ']' closer */
+            next_closer != NULL &&
             next_closer->ch == ']' &&
             (next_closer->beg == closer->beg + 1) &&
             (next_closer->end - next_closer->beg == 1))
@@ -3462,9 +3031,6 @@ md_resolve_links(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
 
             is_link = TRUE;
 
-            /* We don't allow destination to be longer than 100 characters.
-             * Lets scan to see whether there is '|'. (If not then the whole
-             * wiki-link has to be below the 100 characters.) */
             delim_index = opener_index + 1;
             while(delim_index < closer_index) {
                 MD_MARK* m = &ctx->marks[delim_index];
@@ -3486,7 +3052,6 @@ md_resolve_links(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
             if(dest_end - dest_beg == 0 || dest_end - dest_beg > 100)
                 is_link = FALSE;
 
-            /* There may not be any new line in the destination. */
             if(is_link) {
                 OFF off;
                 for(off = dest_beg; off < dest_end; off++) {
@@ -3505,7 +3070,7 @@ md_resolve_links(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
                         delim->flags |= MD_MARK_RESOLVED;
                         opener->end = delim->beg;
                     } else {
-                        /* The pipe is just before the closer: [[foo|]] */
+
                         md_rollback(ctx, opener_index, closer_index, MD_ROLLBACK_ALL);
                         closer->beg = delim->beg;
                         delim = NULL;
@@ -3533,11 +3098,11 @@ md_resolve_links(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
 
         if(next_opener != NULL  &&  next_opener->beg == closer->end) {
             if(next_closer->beg > closer->end + 1) {
-                /* Might be full reference link. */
+
                 if(!(next_opener->flags & MD_MARK_HASNESTEDBRACKETS))
                     is_link = md_is_link_reference(ctx, lines, n_lines, next_opener->beg, next_closer->end, &attr);
             } else {
-                /* Might be shortcut reference link. */
+
                 if(!(opener->flags & MD_MARK_HASNESTEDBRACKETS))
                     is_link = md_is_link_reference(ctx, lines, n_lines, opener->beg, closer->end, &attr);
             }
@@ -3546,24 +3111,20 @@ md_resolve_links(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
                 return -1;
 
             if(is_link) {
-                /* Eat the 2nd "[...]". */
+
                 closer->end = next_closer->end;
 
-                /* Do not analyze the label as a standalone link in the next
-                 * iteration. */
                 next_index = ctx->marks[next_index].prev;
             }
         } else {
             if(closer->end < ctx->size  &&  CH(closer->end) == _T('(')) {
-                /* Might be inline link. */
+
                 OFF inline_link_end = UINT_MAX;
 
                 is_link = md_is_inline_link_spec(ctx, lines, n_lines, closer->end, &inline_link_end, &attr);
                 if(is_link < 0)
                     return -1;
 
-                /* Check the closing ')' is not inside an already resolved range
-                 * (i.e. a range with a higher priority), e.g. a code span. */
                 if(is_link) {
                     int i = closer_index + 1;
 
@@ -3574,7 +3135,7 @@ md_resolve_links(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
                             break;
                         if((mark->flags & (MD_MARK_OPENER | MD_MARK_RESOLVED)) == (MD_MARK_OPENER | MD_MARK_RESOLVED)) {
                             if(ctx->marks[mark->next].beg >= inline_link_end) {
-                                /* Cancel the link status. */
+
                                 if(attr.title_needs_free)
                                     free(attr.title);
                                 is_link = FALSE;
@@ -3589,13 +3150,13 @@ md_resolve_links(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
                 }
 
                 if(is_link) {
-                    /* Eat the "(...)" */
+
                     closer->end = inline_link_end;
                 }
             }
 
             if(!is_link) {
-                /* Might be collapsed reference link. */
+
                 if(!(opener->flags & MD_MARK_HASNESTEDBRACKETS))
                     is_link = md_is_link_reference(ctx, lines, n_lines, opener->beg, closer->end, &attr);
                 if(is_link < 0)
@@ -3604,19 +3165,17 @@ md_resolve_links(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
         }
 
         if(is_link) {
-            /* Resolve the brackets as a link. */
+
             opener->flags |= MD_MARK_OPENER | MD_MARK_RESOLVED;
             closer->flags |= MD_MARK_CLOSER | MD_MARK_RESOLVED;
 
-            /* If it is a link, we store the destination and title in the two
-             * dummy marks after the opener. */
             MD_ASSERT(ctx->marks[opener_index+1].ch == 'D');
             ctx->marks[opener_index+1].beg = attr.dest_beg;
             ctx->marks[opener_index+1].end = attr.dest_end;
 
             MD_ASSERT(ctx->marks[opener_index+2].ch == 'D');
             md_mark_store_ptr(ctx, opener_index+2, attr.title);
-            /* The title might or might not have been allocated for us. */
+
             if(attr.title_needs_free)
                 md_mark_stack_push(ctx, &ctx->ptr_stack, opener_index+2);
             ctx->marks[opener_index+2].prev = attr.title_size;
@@ -3631,9 +3190,6 @@ md_resolve_links(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
 
             md_analyze_link_contents(ctx, lines, n_lines, opener_index+1, closer_index);
 
-            /* If the link text is formed by nothing but permissive autolink,
-             * suppress the autolink.
-             * See https://github.com/mity/md4c/issues/152 for more info. */
             if(ctx->parser.flags & MD_FLAG_PERMISSIVEAUTOLINKS) {
                 MD_MARK* first_nested;
                 MD_MARK* last_nested;
@@ -3666,8 +3222,6 @@ md_resolve_links(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
     return 0;
 }
 
-/* Analyze whether the mark '&' starts a HTML entity.
- * If so, update its flags as well as flags of corresponding closer ';'. */
 static void
 md_analyze_entity(MD_CTX* ctx, int mark_index)
 {
@@ -3675,13 +3229,6 @@ md_analyze_entity(MD_CTX* ctx, int mark_index)
     MD_MARK* closer;
     OFF off;
 
-    /* Cannot be entity if there is no closer as the next mark.
-     * (Any other mark between would mean strange character which cannot be
-     * part of the entity.
-     *
-     * So we can do all the work on '&' and do not call this later for the
-     * closing mark ';'.
-     */
     if(mark_index + 1 >= ctx->n_marks)
         return;
     closer = &ctx->marks[mark_index+1];
@@ -3711,10 +3258,6 @@ md_analyze_table_cell_boundary(MD_CTX* ctx, int mark_index)
     ctx->n_table_cell_boundaries++;
 }
 
-/* Split a longer mark into two. The new mark takes the given count of
- * characters. May only be called if an adequate number of dummy 'D' marks
- * follows.
- */
 static int
 md_split_emph_mark(MD_CTX* ctx, int mark_index, SZ n)
 {
@@ -3737,7 +3280,6 @@ md_analyze_emph(MD_CTX* ctx, int mark_index)
 {
     MD_MARK* mark = &ctx->marks[mark_index];
 
-    /* If we can be a closer, try to resolve with the preceding opener. */
     if(mark->flags & MD_MARK_POTENTIAL_CLOSER) {
         MD_MARK* opener = NULL;
         int opener_index = 0;
@@ -3747,7 +3289,6 @@ md_analyze_emph(MD_CTX* ctx, int mark_index)
 
         n_opener_stacks = 0;
 
-        /* Apply the rule of 3 */
         opener_stacks[n_opener_stacks++] = md_emph_stack(ctx, mark->ch, MD_MARK_EMPH_MOD3_0 | MD_MARK_EMPH_OC);
         if((flags & MD_MARK_EMPH_MOD3_MASK) != MD_MARK_EMPH_MOD3_2)
             opener_stacks[n_opener_stacks++] = md_emph_stack(ctx, mark->ch, MD_MARK_EMPH_MOD3_1 | MD_MARK_EMPH_OC);
@@ -3759,7 +3300,6 @@ md_analyze_emph(MD_CTX* ctx, int mark_index)
         if(!(flags & MD_MARK_EMPH_OC)  ||  (flags & MD_MARK_EMPH_MOD3_MASK) != MD_MARK_EMPH_MOD3_1)
             opener_stacks[n_opener_stacks++] = md_emph_stack(ctx, mark->ch, MD_MARK_EMPH_MOD3_2);
 
-        /* Opener is the most recent mark from the allowed stacks. */
         for(i = 0; i < n_opener_stacks; i++) {
             if(opener_stacks[i]->top >= 0) {
                 int m_index = opener_stacks[i]->top;
@@ -3772,7 +3312,6 @@ md_analyze_emph(MD_CTX* ctx, int mark_index)
             }
         }
 
-        /* Resolve, if we have found matching opener. */
         if(opener != NULL) {
             SZ opener_size = opener->end - opener->beg;
             SZ closer_size = mark->end - mark->beg;
@@ -3785,7 +3324,6 @@ md_analyze_emph(MD_CTX* ctx, int mark_index)
                 md_split_emph_mark(ctx, mark_index, closer_size - opener_size);
             }
 
-            /* Above we were only peeking. */
             md_mark_stack_pop(ctx, stack);
 
             md_rollback(ctx, opener_index, mark_index, MD_ROLLBACK_CROSSING);
@@ -3794,7 +3332,6 @@ md_analyze_emph(MD_CTX* ctx, int mark_index)
         }
     }
 
-    /* If we could not resolve as closer, we may be yet be an opener. */
     if(mark->flags & MD_MARK_POTENTIAL_OPENER)
         md_mark_stack_push(ctx, md_emph_stack(ctx, mark->ch, mark->flags), mark_index);
 }
@@ -3805,10 +3342,6 @@ md_analyze_tilde(MD_CTX* ctx, int mark_index)
     MD_MARK* mark = &ctx->marks[mark_index];
     MD_MARKSTACK* stack = md_opener_stack(ctx, mark_index);
 
-    /* We attempt to be Github Flavored Markdown compatible here. GFM accepts
-     * only tildes sequences of length 1 and 2, and the length of the opener
-     * and closer has to match. */
-
     if((mark->flags & MD_MARK_POTENTIAL_CLOSER)  &&  stack->top >= 0) {
         int opener_index = stack->top;
 
@@ -3828,20 +3361,18 @@ md_analyze_dollar(MD_CTX* ctx, int mark_index)
     MD_MARK* mark = &ctx->marks[mark_index];
 
     if((mark->flags & MD_MARK_POTENTIAL_CLOSER)  &&  DOLLAR_OPENERS.top >= 0) {
-        /* If the potential closer has a non-matching number of $, discard */
+
         MD_MARK* opener = &ctx->marks[DOLLAR_OPENERS.top];
         int opener_index = DOLLAR_OPENERS.top;
         MD_MARK* closer = mark;
         int closer_index = mark_index;
 
         if(opener->end - opener->beg == closer->end - closer->beg) {
-            /* We are the matching closer */
+
             md_mark_stack_pop(ctx, &DOLLAR_OPENERS);
             md_rollback(ctx, opener_index, closer_index, MD_ROLLBACK_ALL);
             md_resolve_range(ctx, opener_index, closer_index);
 
-            /* Discard all pending openers: Latex math span do not allow
-             * nesting. */
             DOLLAR_OPENERS.top = -1;
             return;
         }
@@ -3905,16 +3436,16 @@ md_analyze_permissive_autolink(MD_CTX* ctx, int mark_index)
         int min_components;
         const MD_CHAR optional_end_char;
     } URL_MAP[] = {
-        { _T('\0'), _T('.'),  _T(".-_"),      2, _T('\0') },    /* host, mandatory */
-        { _T('/'),  _T('/'),  _T("/.-_"),     0, _T('/') },     /* path */
-        { _T('?'),  _T('&'),  _T("&.-+_=()"), 1, _T('\0') },    /* query */
-        { _T('#'),  _T('\0'), _T(".-+_") ,    1, _T('\0') }     /* fragment */
+        { _T('\0'), _T('.'),  _T(".-_"),      2, _T('\0') },
+        { _T('/'),  _T('/'),  _T("/.-_"),     0, _T('/') },
+        { _T('?'),  _T('&'),  _T("&.-+_=()"), 1, _T('\0') },
+        { _T('#'),  _T('\0'), _T(".-+_") ,    1, _T('\0') }
     };
 
     MD_MARK* opener = &ctx->marks[mark_index];
-    MD_MARK* closer = &ctx->marks[mark_index + 1];  /* The dummy. */
-    OFF line_beg = closer->beg;     /* md_collect_mark() set this for us */
-    OFF line_end = closer->end;     /* ditto */
+    MD_MARK* closer = &ctx->marks[mark_index + 1];
+    OFF line_beg = closer->beg;
+    OFF line_end = closer->end;
     OFF beg = opener->beg;
     OFF end = opener->end;
     MD_MARK* left_cursor = opener;
@@ -3928,7 +3459,6 @@ md_analyze_permissive_autolink(MD_CTX* ctx, int mark_index)
     if(opener->ch == '@') {
         MD_ASSERT(CH(opener->beg) == _T('@'));
 
-        /* Scan backwards for the user name (before '@'). */
         while(beg > line_beg) {
             if(ISALNUM(beg-1))
                 beg--;
@@ -3940,12 +3470,10 @@ md_analyze_permissive_autolink(MD_CTX* ctx, int mark_index)
             else
                 break;
         }
-        if(beg == opener->beg)      /* empty user name */
+        if(beg == opener->beg)
             return;
     }
 
-    /* Verify there's line boundary, whitespace, allowed punctuation or
-     * resolved emphasis mark just before the suspected autolink. */
     if(beg == line_beg  ||  ISUNICODEWHITESPACEBEFORE(beg)  ||  ISANYOF(beg-1, _T("({["))) {
         left_boundary_ok = TRUE;
     } else if(ISANYOF(beg-1, _T("*_~"))) {
@@ -3984,7 +3512,6 @@ md_analyze_permissive_autolink(MD_CTX* ctx, int mark_index)
                 if(CH(end) == URL_MAP[i].delim_char)
                     n_components++;
 
-                /* brackets have to be balanced. */
                 if(CH(end) == _T('(')) {
                     n_open_brackets++;
                 } else if(CH(end) == _T(')')) {
@@ -4006,12 +3533,10 @@ md_analyze_permissive_autolink(MD_CTX* ctx, int mark_index)
         if(n_components < URL_MAP[i].min_components  ||  n_open_brackets != 0)
             return;
 
-        if(opener->ch == '@')   /* E-mail autolinks wants only the host. */
+        if(opener->ch == '@')
             break;
     }
 
-    /* Verify there's line boundary, whitespace, allowed punctuation or
-     * resolved emphasis mark just after the suspected autolink. */
     if(end == line_end  ||  ISUNICODEWHITESPACE(end)  ||  ISANYOF(end, _T(")}].!?,;"))) {
         right_boundary_ok = TRUE;
     } else {
@@ -4024,7 +3549,6 @@ md_analyze_permissive_autolink(MD_CTX* ctx, int mark_index)
     if(!right_boundary_ok)
         return;
 
-    /* Success, we are an autolink. */
     opener->beg = beg;
     opener->end = beg;
     closer->beg = end;
@@ -4048,7 +3572,6 @@ md_analyze_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines,
     while(i < mark_end) {
         MD_MARK* mark = &ctx->marks[i];
 
-        /* Skip resolved spans. */
         if(mark->flags & MD_MARK_RESOLVED) {
             if((mark->flags & MD_MARK_OPENER)  &&
                !((flags & MD_ANALYZE_NOSKIP_EMPH) && ISANYOF_(mark->ch, "*_~")))
@@ -4061,31 +3584,28 @@ md_analyze_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines,
             continue;
         }
 
-        /* Skip marks we do not want to deal with. */
         if(!ISANYOF_(mark->ch, mark_chars)) {
             i++;
             continue;
         }
 
-        /* The resolving in previous step could have expanded a mark. */
         if(mark->beg < last_end) {
             i++;
             continue;
         }
 
-        /* Analyze the mark. */
         switch(mark->ch) {
-            case '[':   /* Pass through. */
-            case '!':   /* Pass through. */
+            case '[':
+            case '!':
             case ']':   md_analyze_bracket(ctx, i); break;
             case '&':   md_analyze_entity(ctx, i); break;
             case '|':   md_analyze_table_cell_boundary(ctx, i); break;
-            case '_':   /* Pass through. */
+            case '_':
             case '*':   md_analyze_emph(ctx, i); break;
             case '~':   md_analyze_tilde(ctx, i); break;
             case '$':   md_analyze_dollar(ctx, i); break;
-            case '.':   /* Pass through. */
-            case ':':   /* Pass through. */
+            case '.':
+            case ':':
             case '@':   md_analyze_permissive_autolink(ctx, i); break;
         }
 
@@ -4100,19 +3620,15 @@ md_analyze_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines,
     }
 }
 
-/* Analyze marks (build ctx->marks). */
 static int
 md_analyze_inlines(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_mode)
 {
     int ret;
 
-    /* Reset the previously collected stack of marks. */
     ctx->n_marks = 0;
 
-    /* Collect all marks. */
     MD_CHECK(md_collect_marks(ctx, lines, n_lines, table_mode));
 
-    /* (1) Links. */
     md_analyze_marks(ctx, lines, n_lines, 0, ctx->n_marks, _T("[]!"), 0);
     MD_CHECK(md_resolve_links(ctx, lines, n_lines));
     BRACKET_OPENERS.top = -1;
@@ -4120,14 +3636,13 @@ md_analyze_inlines(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table
     ctx->unresolved_link_tail = -1;
 
     if(table_mode) {
-        /* (2) Analyze table cell boundaries. */
+
         MD_ASSERT(n_lines == 1);
         ctx->n_table_cell_boundaries = 0;
         md_analyze_marks(ctx, lines, n_lines, 0, ctx->n_marks, _T("|"), 0);
         return ret;
     }
 
-    /* (3) Emphasis and strong emphasis; permissive autolinks. */
     md_analyze_link_contents(ctx, lines, n_lines, 0, ctx->n_marks);
 
 abort:
@@ -4144,9 +3659,7 @@ md_analyze_link_contents(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines,
     md_analyze_marks(ctx, lines, n_lines, mark_beg, mark_end, _T("*_~$"), 0);
 
     if((ctx->parser.flags & MD_FLAG_PERMISSIVEAUTOLINKS) != 0) {
-        /* These have to be processed last, as they may be greedy and expand
-         * from their original mark. Also their implementation must be careful
-         * not to cross any (previously) resolved marks when doing so. */
+
         md_analyze_marks(ctx, lines, n_lines, mark_beg, mark_end, _T("@:."), MD_ANALYZE_NOSKIP_EMPH);
     }
 
@@ -4164,8 +3677,6 @@ md_enter_leave_span_a(MD_CTX* ctx, int enter, MD_SPANTYPE type,
     MD_SPAN_A_DETAIL det;
     int ret = 0;
 
-    /* Note we here rely on fact that MD_SPAN_A_DETAIL and
-     * MD_SPAN_IMG_DETAIL are binary-compatible. */
     memset(&det, 0, sizeof(MD_SPAN_A_DETAIL));
     MD_CHECK(md_build_attribute(ctx, dest, dest_size,
                     (is_autolink ? MD_BUILD_ATTR_NO_ESCAPES : 0),
@@ -4203,8 +3714,6 @@ abort:
     return ret;
 }
 
-
-/* Render the output, accordingly to the analyzed ctx->marks. */
 static int
 md_process_inlines(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
 {
@@ -4218,10 +3727,6 @@ md_process_inlines(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
     int enforce_hardbreak = 0;
     int ret = 0;
 
-    /* Find first resolved mark. Note there is always at least one resolved
-     * mark,  the dummy last one after the end of the latest line we actually
-     * never really reach. This saves us of a lot of special checks and cases
-     * in this function. */
     mark = ctx->marks;
     while(!(mark->flags & MD_MARK_RESOLVED))
         mark++;
@@ -4229,28 +3734,27 @@ md_process_inlines(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
     text_type = MD_TEXT_NORMAL;
 
     while(1) {
-        /* Process the text up to the next mark or end-of-line. */
+
         tmp = (line->end < mark->beg ? line->end : mark->beg);
         if(tmp > off) {
             MD_TEXT(text_type, STR(off), tmp - off);
             off = tmp;
         }
 
-        /* If reached the mark, process it and move to next one. */
         if(off >= mark->beg) {
             switch(mark->ch) {
-                case '\\':      /* Backslash escape. */
+                case '\\':
                     if(ISNEWLINE(mark->beg+1))
                         enforce_hardbreak = 1;
                     else
                         MD_TEXT(text_type, STR(mark->beg+1), 1);
                     break;
 
-                case ' ':       /* Non-trivial space. */
+                case ' ':
                     MD_TEXT(text_type, _T(" "), 1);
                     break;
 
-                case '`':       /* Code span. */
+                case '`':
                     if(mark->flags & MD_MARK_OPENER) {
                         MD_ENTER_SPAN(MD_SPAN_CODE, NULL);
                         text_type = MD_TEXT_CODE;
@@ -4260,7 +3764,7 @@ md_process_inlines(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
                     }
                     break;
 
-                case '_':       /* Underline (or emphasis if we fall through). */
+                case '_':
                     if(ctx->parser.flags & MD_FLAG_UNDERLINE) {
                         if(mark->flags & MD_MARK_OPENER) {
                             while(off < mark->end) {
@@ -4277,7 +3781,7 @@ md_process_inlines(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
                     }
                     MD_FALLTHROUGH();
 
-                case '*':       /* Emphasis, strong emphasis. */
+                case '*':
                     if(mark->flags & MD_MARK_OPENER) {
                         if((mark->end - off) % 2) {
                             MD_ENTER_SPAN(MD_SPAN_EM, NULL);
@@ -4316,7 +3820,7 @@ md_process_inlines(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
                     }
                     break;
 
-                case '[':       /* Link, wiki link, image. */
+                case '[':
                 case '!':
                 case ']':
                 {
@@ -4355,7 +3859,6 @@ md_process_inlines(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
                                 md_mark_get_ptr(ctx, (int)(title_mark - ctx->marks)),
 								title_mark->prev));
 
-                    /* link/image closer may span multiple lines. */
                     if(mark->ch == ']') {
                         while(mark->end > line->end)
                             line++;
@@ -4365,33 +3868,27 @@ md_process_inlines(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
                 }
 
                 case '<':
-                case '>':       /* Autolink or raw HTML. */
+                case '>':
                     if(!(mark->flags & MD_MARK_AUTOLINK)) {
-                        /* Raw HTML. */
+
                         if(mark->flags & MD_MARK_OPENER)
                             text_type = MD_TEXT_HTML;
                         else
                             text_type = MD_TEXT_NORMAL;
                         break;
                     }
-                    /* Pass through, if auto-link. */
+
                     MD_FALLTHROUGH();
 
-                case '@':       /* Permissive e-mail autolink. */
-                case ':':       /* Permissive URL autolink. */
-                case '.':       /* Permissive WWW autolink. */
+                case '@':
+                case ':':
+                case '.':
                 {
                     MD_MARK* opener = ((mark->flags & MD_MARK_OPENER) ? mark : &ctx->marks[mark->prev]);
                     MD_MARK* closer = &ctx->marks[opener->next];
                     const CHAR* dest = STR(opener->end);
                     SZ dest_size = closer->beg - opener->end;
 
-                    /* For permissive auto-links we do not know closer mark
-                     * position at the time of md_collect_marks(), therefore
-                     * it can be out-of-order in ctx->marks[].
-                     *
-                     * With this flag, we make sure that we output the closer
-                     * only if we processed the opener. */
                     if(mark->flags & MD_MARK_OPENER)
                         closer->flags |= MD_MARK_VALIDPERMISSIVEAUTOLINK;
 
@@ -4413,7 +3910,7 @@ md_process_inlines(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
                     break;
                 }
 
-                case '&':       /* Entity. */
+                case '&':
                     MD_TEXT(MD_TEXT_ENTITY, STR(mark->beg), mark->end - mark->beg);
                     break;
 
@@ -4427,16 +3924,14 @@ md_process_inlines(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
 
             off = mark->end;
 
-            /* Move to next resolved mark. */
             prev_mark = mark;
             mark++;
             while(!(mark->flags & MD_MARK_RESOLVED)  ||  mark->beg < off)
                 mark++;
         }
 
-        /* If reached end of line, move to next one. */
         if(off >= line->end) {
-            /* If it is the last line, we are done. */
+
             if(off >= end)
                 break;
 
@@ -4445,20 +3940,16 @@ md_process_inlines(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
                 MD_ASSERT(ISANYOF2_(prev_mark->ch, '`', '$')  &&  (prev_mark->flags & MD_MARK_OPENER));
                 MD_ASSERT(ISANYOF2_(mark->ch, '`', '$')  &&  (mark->flags & MD_MARK_CLOSER));
 
-                /* Inside a code span, trailing line whitespace has to be
-                 * outputted. */
                 tmp = off;
                 while(off < ctx->size  &&  ISBLANK(off))
                     off++;
                 if(off > tmp)
                     MD_TEXT(text_type, STR(tmp), off-tmp);
 
-                /* and new lines are transformed into single spaces. */
                 if(off == line->end)
                     MD_TEXT(text_type, _T(" "), 1);
             } else if(text_type == MD_TEXT_HTML) {
-                /* Inside raw HTML, we output the new line verbatim, including
-                 * any trailing spaces. */
+
                 tmp = off;
                 while(tmp < end  &&  ISBLANK(tmp))
                     tmp++;
@@ -4466,7 +3957,7 @@ md_process_inlines(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
                     MD_TEXT(MD_TEXT_HTML, STR(off), tmp - off);
                 MD_TEXT(MD_TEXT_HTML, _T("\n"), 1);
             } else {
-                /* Output soft or hard line break. */
+
                 MD_TEXTTYPE break_type = MD_TEXT_SOFTBR;
 
                 if(text_type == MD_TEXT_NORMAL) {
@@ -4483,7 +3974,6 @@ md_process_inlines(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
                 MD_TEXT(break_type, _T("\n"), 1);
             }
 
-            /* Move to the next line. */
             line++;
             off = line->beg;
 
@@ -4495,11 +3985,6 @@ abort:
     return ret;
 }
 
-
-/***************************
- ***  Processing Tables  ***
- ***************************/
-
 static void
 md_analyze_table_alignment(MD_CTX* ctx, OFF beg, OFF end, MD_ALIGN* align, int n_align)
 {
@@ -4507,7 +3992,7 @@ md_analyze_table_alignment(MD_CTX* ctx, OFF beg, OFF end, MD_ALIGN* align, int n
     OFF off = beg;
 
     while(n_align > 0) {
-        int index = 0;  /* index into align_map[] */
+        int index = 0;
 
         while(CH(off) != _T('-'))
             off++;
@@ -4525,7 +4010,6 @@ md_analyze_table_alignment(MD_CTX* ctx, OFF beg, OFF end, MD_ALIGN* align, int n
 
 }
 
-/* Forward declaration. */
 static int md_process_normal_block_contents(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines);
 
 static int
@@ -4564,12 +4048,8 @@ md_process_table_row(MD_CTX* ctx, MD_BLOCKTYPE cell_type, OFF beg, OFF end,
     line.beg = beg;
     line.end = end;
 
-    /* Break the line into table cells by identifying pipe characters who
-     * form the cell boundary. */
     MD_CHECK(md_analyze_inlines(ctx, &line, 1, TRUE));
 
-    /* We have to remember the cell boundaries in local buffer because
-     * ctx->marks[] shall be reused during cell contents processing. */
     n = ctx->n_table_cell_boundaries + 2;
     pipe_offs = (OFF*) malloc(n * sizeof(OFF));
     if(pipe_offs == NULL) {
@@ -4585,15 +4065,13 @@ md_process_table_row(MD_CTX* ctx, MD_BLOCKTYPE cell_type, OFF beg, OFF end,
     }
     pipe_offs[j++] = end+1;
 
-    /* Process cells. */
     MD_ENTER_BLOCK(MD_BLOCK_TR, NULL);
     k = 0;
     for(i = 0; i < j-1  &&  k < col_count; i++) {
         if(pipe_offs[i] < pipe_offs[i+1]-1)
             MD_CHECK(md_process_table_cell(ctx, cell_type, align[k++], pipe_offs[i], pipe_offs[i+1]-1));
     }
-    /* Make sure we call enough table cells even if the current table contains
-     * too few of them. */
+
     while(k < col_count)
         MD_CHECK(md_process_table_cell(ctx, cell_type, align[k++], 0, 0));
     MD_LEAVE_BLOCK(MD_BLOCK_TR, NULL);
@@ -4614,8 +4092,6 @@ md_process_table_block_contents(MD_CTX* ctx, int col_count, const MD_LINE* lines
     MD_SIZE line_index;
     int ret = 0;
 
-    /* At least two lines have to be present: The column headers and the line
-     * with the underlines. */
     MD_ASSERT(n_lines >= 2);
 
     align = malloc(col_count * sizeof(MD_ALIGN));
@@ -4646,11 +4122,6 @@ abort:
     return ret;
 }
 
-
-/**************************
- ***  Processing Block  ***
- **************************/
-
 #define MD_BLOCK_CONTAINER_OPENER   0x01
 #define MD_BLOCK_CONTAINER_CLOSER   0x02
 #define MD_BLOCK_CONTAINER          (MD_BLOCK_CONTAINER_OPENER | MD_BLOCK_CONTAINER_CLOSER)
@@ -4661,17 +4132,8 @@ struct MD_BLOCK_tag {
     MD_BLOCKTYPE type  :  8;
     unsigned flags     :  8;
 
-    /* MD_BLOCK_H:      Header level (1 - 6)
-     * MD_BLOCK_CODE:   Non-zero if fenced, zero if indented.
-     * MD_BLOCK_LI:     Task mark character (0 if not task list item, 'x', 'X' or ' ').
-     * MD_BLOCK_TABLE:  Column count (as determined by the table underline).
-     */
     unsigned data      : 16;
 
-    /* Leaf blocks:     Count of lines (MD_LINE or MD_VERBATIMLINE) on the block.
-     * MD_BLOCK_LI:     Task mark offset in the input doc.
-     * MD_BLOCK_OL:     Start item number.
-     */
     MD_SIZE n_lines;
 };
 
@@ -4686,7 +4148,6 @@ struct MD_CONTAINER_tag {
     OFF task_mark_off;
 };
 
-
 static int
 md_process_normal_block_contents(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines)
 {
@@ -4697,7 +4158,7 @@ md_process_normal_block_contents(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_li
     MD_CHECK(md_process_inlines(ctx, lines, n_lines));
 
 abort:
-    /* Free any temporary memory blocks stored within some dummy marks. */
+
     for(i = ctx->ptr_stack.top; i >= 0; i = ctx->marks[i].next)
         free(md_mark_get_ptr(ctx, i));
     ctx->ptr_stack.top = -1;
@@ -4720,7 +4181,6 @@ md_process_verbatim_block_contents(MD_CTX* ctx, MD_TEXTTYPE text_type, const MD_
 
         MD_ASSERT(indent >= 0);
 
-        /* Output code indentation. */
         while(indent > (int) indent_chunk_size) {
             MD_TEXT(text_type, indent_chunk_str, indent_chunk_size);
             indent -= indent_chunk_size;
@@ -4728,10 +4188,8 @@ md_process_verbatim_block_contents(MD_CTX* ctx, MD_TEXTTYPE text_type, const MD_
         if(indent > 0)
             MD_TEXT(text_type, indent_chunk_str, indent);
 
-        /* Output the code line itself. */
         MD_TEXT_INSECURE(text_type, STR(line->beg), line->end - line->beg);
 
-        /* Enforce end-of-line. */
         MD_TEXT(text_type, _T("\n"), 1);
     }
 
@@ -4743,12 +4201,11 @@ static int
 md_process_code_block_contents(MD_CTX* ctx, int is_fenced, const MD_VERBATIMLINE* lines, MD_SIZE n_lines)
 {
     if(is_fenced) {
-        /* Skip the first line in case of fenced code: It is the fence.
-         * (Only the starting fence is present due to logic in md_analyze_line().) */
+
         lines++;
         n_lines--;
     } else {
-        /* Ignore blank lines at start/end of indented code block. */
+
         while(n_lines > 0  &&  lines[0].beg == lines[0].end) {
             lines++;
             n_lines--;
@@ -4775,21 +4232,17 @@ md_setup_fenced_code_detail(MD_CTX* ctx, const MD_BLOCK* block, MD_BLOCK_CODE_DE
     CHAR fence_ch = CH(fence_line->beg);
     int ret = 0;
 
-    /* Skip the fence itself. */
     while(beg < ctx->size  &&  CH(beg) == fence_ch)
         beg++;
-    /* Trim initial spaces. */
+
     while(beg < ctx->size  &&  CH(beg) == _T(' '))
         beg++;
 
-    /* Trim trailing spaces. */
     while(end > beg  &&  CH(end-1) == _T(' '))
         end--;
 
-    /* Build info string attribute. */
     MD_CHECK(md_build_attribute(ctx, STR(beg), end - beg, 0, &det->info, info_build));
 
-    /* Build info string attribute. */
     lang_end = beg;
     while(lang_end < end  &&  !ISWHITESPACE(lang_end))
         lang_end++;
@@ -4828,7 +4281,7 @@ md_process_leaf_block(MD_CTX* ctx, const MD_BLOCK* block)
             break;
 
         case MD_BLOCK_CODE:
-            /* For fenced code block, we may need to set the info string. */
+
             if(block->data != 0) {
                 memset(&det.code, 0, sizeof(MD_BLOCK_CODE_DETAIL));
                 clean_fence_code_detail = TRUE;
@@ -4843,17 +4296,16 @@ md_process_leaf_block(MD_CTX* ctx, const MD_BLOCK* block)
             break;
 
         default:
-            /* Noop. */
+
             break;
     }
 
     if(!is_in_tight_list  ||  block->type != MD_BLOCK_P)
         MD_ENTER_BLOCK(block->type, (void*) &det);
 
-    /* Process the block contents accordingly to is type. */
     switch(block->type) {
         case MD_BLOCK_HR:
-            /* noop */
+
             break;
 
         case MD_BLOCK_CODE:
@@ -4894,10 +4346,6 @@ md_process_all_blocks(MD_CTX* ctx)
     int byte_off = 0;
     int ret = 0;
 
-    /* ctx->containers now is not needed for detection of lists and list items
-     * so we reuse it for tracking what lists are loose or tight. We rely
-     * on the fact the vector is large enough to hold the deepest nesting
-     * level of lists. */
     ctx->n_containers = 0;
 
     while(byte_off < ctx->n_block_bytes) {
@@ -4927,7 +4375,7 @@ md_process_all_blocks(MD_CTX* ctx)
                 break;
 
             default:
-                /* noop */
+
                 break;
         }
 
@@ -4946,9 +4394,7 @@ md_process_all_blocks(MD_CTX* ctx)
                     ctx->containers[ctx->n_containers].is_loose = (block->flags & MD_BLOCK_LOOSE_LIST);
                     ctx->n_containers++;
                 } else if(block->type == MD_BLOCK_QUOTE) {
-                    /* This causes that any text in a block quote, even if
-                     * nested inside a tight list item, is wrapped with
-                     * <p>...</p>. */
+
                     ctx->containers[ctx->n_containers].is_loose = TRUE;
                     ctx->n_containers++;
                 }
@@ -4971,11 +4417,6 @@ abort:
     return ret;
 }
 
-
-/************************************
- ***  Grouping Lines into Blocks  ***
- ************************************/
-
 static void*
 md_push_block_bytes(MD_CTX* ctx, int n_bytes)
 {
@@ -4993,7 +4434,6 @@ md_push_block_bytes(MD_CTX* ctx, int n_bytes)
             return NULL;
         }
 
-        /* Fix the ->current_block after the reallocation. */
         if(ctx->current_block != NULL) {
             OFF off_current_block = (OFF) ((char*) ctx->current_block - (char*) ctx->block_bytes);
             ctx->current_block = (MD_BLOCK*) ((char*) new_block_bytes + off_current_block);
@@ -5057,12 +4497,6 @@ md_start_new_block(MD_CTX* ctx, const MD_LINE_ANALYSIS* line)
     return 0;
 }
 
-/* Eat from start of current (textual) block any reference definitions and
- * remember them so we can resolve any links referring to them.
- *
- * (Reference definitions can only be at start of it as they cannot break
- * a paragraph.)
- */
 static int
 md_consume_link_reference_definitions(MD_CTX* ctx)
 {
@@ -5070,35 +4504,29 @@ md_consume_link_reference_definitions(MD_CTX* ctx)
     MD_SIZE n_lines = ctx->current_block->n_lines;
     MD_SIZE n = 0;
 
-    /* Compute how many lines at the start of the block form one or more
-     * reference definitions. */
     while(n < n_lines) {
         int n_link_ref_lines;
 
         n_link_ref_lines = md_is_link_reference_definition(ctx,
                                     lines + n, n_lines - n);
-        /* Not a reference definition? */
+
         if(n_link_ref_lines == 0)
             break;
 
-        /* We fail if it is the ref. def. but it could not be stored due
-         * a memory allocation error. */
         if(n_link_ref_lines < 0)
             return -1;
 
         n += n_link_ref_lines;
     }
 
-    /* If there was at least one reference definition, we need to remove
-     * its lines from the block, or perhaps even the whole block. */
     if(n > 0) {
         if(n == n_lines) {
-            /* Remove complete block. */
+
             ctx->n_block_bytes -= n * sizeof(MD_LINE);
             ctx->n_block_bytes -= sizeof(MD_BLOCK);
             ctx->current_block = NULL;
         } else {
-            /* Remove just some initial lines from the block. */
+
             memmove(lines, lines + n, (n_lines - n) * sizeof(MD_LINE));
             ctx->current_block->n_lines -= n;
             ctx->n_block_bytes -= n * sizeof(MD_LINE);
@@ -5116,9 +4544,6 @@ md_end_current_block(MD_CTX* ctx)
     if(ctx->current_block == NULL)
         return ret;
 
-    /* Check whether there is a reference definition. (We do this here instead
-     * of in md_analyze_line() because reference definition can take multiple
-     * lines.) */
     if(ctx->current_block->type == MD_BLOCK_P  ||
        (ctx->current_block->type == MD_BLOCK_H  &&  (ctx->current_block->flags & MD_BLOCK_SETEXT_HEADER)))
     {
@@ -5134,18 +4559,16 @@ md_end_current_block(MD_CTX* ctx)
         MD_SIZE n_lines = ctx->current_block->n_lines;
 
         if(n_lines > 1) {
-            /* Get rid of the underline. */
+
             ctx->current_block->n_lines--;
             ctx->n_block_bytes -= sizeof(MD_LINE);
         } else {
-            /* Only the underline has left after eating the ref. defs.
-             * Keep the line as beginning of a new ordinary paragraph. */
+
             ctx->current_block->type = MD_BLOCK_P;
             return 0;
         }
     }
 
-    /* Mark we are not building any block anymore. */
     ctx->current_block = NULL;
 
 abort:
@@ -5204,12 +4627,6 @@ abort:
     return ret;
 }
 
-
-
-/***********************
- ***  Line Analysis  ***
- ***********************/
-
 static int
 md_is_hr_line(MD_CTX* ctx, OFF beg, OFF* p_end, OFF* p_killer)
 {
@@ -5227,7 +4644,6 @@ md_is_hr_line(MD_CTX* ctx, OFF beg, OFF* p_end, OFF* p_killer)
         return FALSE;
     }
 
-    /* Nothing else can be present on the line. */
     if(off < ctx->size  &&  !ISNEWLINE(off)) {
         *p_killer = off;
         return FALSE;
@@ -5270,11 +4686,9 @@ md_is_setext_underline(MD_CTX* ctx, OFF beg, OFF* p_end, unsigned* p_level)
     while(off < ctx->size  &&  CH(off) == CH(beg))
         off++;
 
-    /* Optionally, space(s) or tabs can follow. */
     while(off < ctx->size  &&  ISBLANK(off))
         off++;
 
-    /* But nothing more is allowed on the line. */
     if(off < ctx->size  &&  !ISNEWLINE(off))
         return FALSE;
 
@@ -5300,7 +4714,6 @@ md_is_table_underline(MD_CTX* ctx, OFF beg, OFF* p_end, unsigned* p_col_count)
     while(1) {
         int delimited = FALSE;
 
-        /* Cell underline ("-----", ":----", "----:" or ":----:") */
         if(off < ctx->size  &&  CH(off) == _T(':'))
             off++;
         if(off >= ctx->size  ||  CH(off) != _T('-'))
@@ -5316,7 +4729,6 @@ md_is_table_underline(MD_CTX* ctx, OFF beg, OFF* p_end, unsigned* p_col_count)
             return FALSE;
         }
 
-        /* Pipe delimiter (optional at the end of line). */
         while(off < ctx->size  &&  ISWHITESPACE(off))
             off++;
         if(off < ctx->size  &&  CH(off) == _T('|')) {
@@ -5327,7 +4739,6 @@ md_is_table_underline(MD_CTX* ctx, OFF beg, OFF* p_end, unsigned* p_col_count)
                 off++;
         }
 
-        /* Success, if we reach end of line. */
         if(off >= ctx->size  ||  ISNEWLINE(off))
             break;
 
@@ -5351,19 +4762,16 @@ md_is_opening_code_fence(MD_CTX* ctx, OFF beg, OFF* p_end)
     while(off < ctx->size && CH(off) == CH(beg))
         off++;
 
-    /* Fence must have at least three characters. */
     if(off - beg < 3)
         return FALSE;
 
     ctx->code_fence_length = off - beg;
 
-    /* Optionally, space(s) can follow. */
     while(off < ctx->size  &&  CH(off) == _T(' '))
         off++;
 
-    /* Optionally, an info string can follow. */
     while(off < ctx->size  &&  !ISNEWLINE(off)) {
-        /* Backtick-based fence must not contain '`' in the info string. */
+
         if(CH(beg) == _T('`')  &&  CH(off) == _T('`'))
             return FALSE;
         off++;
@@ -5379,33 +4787,25 @@ md_is_closing_code_fence(MD_CTX* ctx, CHAR ch, OFF beg, OFF* p_end)
     OFF off = beg;
     int ret = FALSE;
 
-    /* Closing fence must have at least the same length and use same char as
-     * opening one. */
     while(off < ctx->size  &&  CH(off) == ch)
         off++;
     if(off - beg < ctx->code_fence_length)
         goto out;
 
-    /* Optionally, space(s) can follow */
     while(off < ctx->size  &&  CH(off) == _T(' '))
         off++;
 
-    /* But nothing more is allowed on the line. */
     if(off < ctx->size  &&  !ISNEWLINE(off))
         goto out;
 
     ret = TRUE;
 
 out:
-    /* Note we set *p_end even on failure: If we are not closing fence, caller
-     * would eat the line anyway without any parsing. */
+
     *p_end = off;
     return ret;
 }
 
-
-/* Helper data for md_is_html_block_start_condition() and
- * md_is_html_block_end_condition() */
 typedef struct TAG_tag TAG;
 struct TAG_tag {
     const CHAR* name;
@@ -5444,14 +4844,10 @@ static const TAG xx[] = { Xend };
 #undef X
 #undef Xend
 
-/* Returns type of the raw HTML block, or FALSE if it is not HTML block.
- * (Refer to CommonMark specification for details about the types.)
- */
 static int
 md_is_html_block_start_condition(MD_CTX* ctx, OFF beg)
 {
-    /* Type 6 is started by a long list of allowed tags. We use two-level
-     * tree to speed-up the search. */
+
     static const TAG* map6[26] = {
         a6, b6, c6, d6, xx, f6, xx, h6, i6, xx, xx, l6, m6,
         n6, o6, p6, xx, xx, s6, t6, u6, xx, xx, xx, xx, xx
@@ -5459,7 +4855,6 @@ md_is_html_block_start_condition(MD_CTX* ctx, OFF beg)
     OFF off = beg + 1;
     int i;
 
-    /* Check for type 1: <script, <pre, or <style */
     for(i = 0; t1[i].name != NULL; i++) {
         if(off + t1[i].len <= ctx->size) {
             if(md_ascii_case_eq(STR(off), t1[i].name, t1[i].len))
@@ -5467,28 +4862,23 @@ md_is_html_block_start_condition(MD_CTX* ctx, OFF beg)
         }
     }
 
-    /* Check for type 2: <!-- */
     if(off + 3 < ctx->size  &&  CH(off) == _T('!')  &&  CH(off+1) == _T('-')  &&  CH(off+2) == _T('-'))
         return 2;
 
-    /* Check for type 3: <? */
     if(off < ctx->size  &&  CH(off) == _T('?'))
         return 3;
 
-    /* Check for type 4 or 5: <! */
     if(off < ctx->size  &&  CH(off) == _T('!')) {
-        /* Check for type 4: <! followed by uppercase letter. */
+
         if(off + 1 < ctx->size  &&  ISASCII(off+1))
             return 4;
 
-        /* Check for type 5: <![CDATA[ */
         if(off + 8 < ctx->size) {
             if(md_ascii_eq(STR(off), _T("![CDATA["), 8))
                 return 5;
         }
     }
 
-    /* Check for type 6: Many possible starting tags listed above. */
     if(off + 1 < ctx->size  &&  (ISALPHA(off) || (CH(off) == _T('/') && ISALPHA(off+1)))) {
         int slot;
         const TAG* tags;
@@ -5515,12 +4905,11 @@ md_is_html_block_start_condition(MD_CTX* ctx, OFF beg)
         }
     }
 
-    /* Check for type 7: any COMPLETE other opening or closing tag. */
     if(off + 1 < ctx->size) {
         OFF end;
 
         if(md_is_html_tag(ctx, NULL, 0, beg, ctx->size, &end)) {
-            /* Only optional whitespace and new line may follow. */
+
             while(end < ctx->size  &&  ISWHITESPACE(end))
                 end++;
             if(end >= ctx->size  ||  ISNEWLINE(end))
@@ -5531,8 +4920,6 @@ md_is_html_block_start_condition(MD_CTX* ctx, OFF beg)
     return FALSE;
 }
 
-/* Case sensitive check whether there is a substring 'what' between 'beg'
- * and end of line. */
 static int
 md_line_contains(MD_CTX* ctx, OFF beg, const CHAR* what, SZ what_len, OFF* p_end)
 {
@@ -5550,11 +4937,6 @@ md_line_contains(MD_CTX* ctx, OFF beg, const CHAR* what, SZ what_len, OFF* p_end
     return FALSE;
 }
 
-/* Returns type of HTML block end condition or FALSE if not an end condition.
- *
- * Note it fills p_end even when it is not end condition as the caller
- * does not need to analyze contents of a raw HTML block.
- */
 static int
 md_is_html_block_end_condition(MD_CTX* ctx, OFF beg, OFF* p_end)
 {
@@ -5595,10 +4977,10 @@ md_is_html_block_end_condition(MD_CTX* ctx, OFF beg, OFF* p_end)
         case 5:
             return (md_line_contains(ctx, beg, _T("]]>"), 3, p_end) ? 5 : FALSE);
 
-        case 6:     /* Pass through */
+        case 6:
         case 7:
             if(beg >= ctx->size  ||  ISNEWLINE(beg)) {
-                /* Blank line ends types 6 and 7. */
+
                 *p_end = beg;
                 return ctx->html_block_type;
             }
@@ -5610,11 +4992,10 @@ md_is_html_block_end_condition(MD_CTX* ctx, OFF beg, OFF* p_end)
     return FALSE;
 }
 
-
 static int
 md_is_container_compatible(const MD_CONTAINER* pivot, const MD_CONTAINER* container)
 {
-    /* Block quote has no "items" like lists. */
+
     if(container->ch == _T('>'))
         return FALSE;
 
@@ -5667,8 +5048,7 @@ md_enter_child_containers(MD_CTX* ctx, int n_children)
             case _T('-'):
             case _T('+'):
             case _T('*'):
-                /* Remember offset in ctx->block_bytes so we can revisit the
-                 * block if we detect it is a loose list. */
+
                 md_end_current_block(ctx);
                 c->block_byte_off = ctx->n_block_bytes;
 
@@ -5747,7 +5127,6 @@ md_is_container_mark(MD_CTX* ctx, unsigned indent, OFF beg, OFF* p_end, MD_CONTA
     if(off >= ctx->size  ||  indent >= ctx->code_indent_offset)
         return FALSE;
 
-    /* Check for block quote mark. */
     if(CH(off) == _T('>')) {
         off++;
         p_container->ch = _T('>');
@@ -5759,7 +5138,6 @@ md_is_container_mark(MD_CTX* ctx, unsigned indent, OFF beg, OFF* p_end, MD_CONTA
         return TRUE;
     }
 
-    /* Check for list item bullet mark. */
     if(ISANYOF(off, _T("-+*"))  &&  (off+1 >= ctx->size || ISBLANK(off+1) || ISNEWLINE(off+1))) {
         p_container->ch = CH(off);
         p_container->is_loose = FALSE;
@@ -5770,7 +5148,6 @@ md_is_container_mark(MD_CTX* ctx, unsigned indent, OFF beg, OFF* p_end, MD_CONTA
         return TRUE;
     }
 
-    /* Check for ordered list item marks. */
     max_end = off + 9;
     if(max_end > ctx->size)
         max_end = ctx->size;
@@ -5816,8 +5193,6 @@ md_line_indentation(MD_CTX* ctx, unsigned total_indent, OFF beg, OFF* p_end)
 
 static const MD_LINE_ANALYSIS md_dummy_blank_line = { MD_LINE_BLANK, 0, 0, 0, 0, 0 };
 
-/* Analyze type of the line and find some its properties. This serves as a
- * main input for determining type and boundaries of a block. */
 static int
 md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
                 const MD_LINE_ANALYSIS* pivot_line, MD_LINE_ANALYSIS* line)
@@ -5837,28 +5212,25 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
     line->beg = off;
     line->enforce_new_block = FALSE;
 
-    /* Given the indentation and block quote marks '>', determine how many of
-     * the current containers are our parents. */
     while(n_parents < ctx->n_containers) {
         MD_CONTAINER* c = &ctx->containers[n_parents];
 
         if(c->ch == _T('>')  &&  line->indent < ctx->code_indent_offset  &&
             off < ctx->size  &&  CH(off) == _T('>'))
         {
-            /* Block quote mark. */
+
             off++;
             total_indent++;
             line->indent = md_line_indentation(ctx, total_indent, off, &off);
             total_indent += line->indent;
 
-            /* The optional 1st space after '>' is part of the block quote mark. */
             if(line->indent > 0)
                 line->indent--;
 
             line->beg = off;
 
         } else if(c->ch != _T('>')  &&  line->indent >= c->contents_indent) {
-            /* List. */
+
             line->indent -= c->contents_indent;
         } else {
             break;
@@ -5868,8 +5240,7 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
     }
 
     if(off >= ctx->size  ||  ISNEWLINE(off)) {
-        /* Blank line does not need any real indentation to be nested inside
-         * a list. */
+
         if(n_brothers + n_children == 0) {
             while(n_parents < ctx->n_containers  &&  ctx->containers[n_parents].ch != _T('>'))
                 n_parents++;
@@ -5877,12 +5248,10 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
     }
 
     while(TRUE) {
-        /* Check whether we are fenced code continuation. */
+
         if(pivot_line->type == MD_LINE_FENCEDCODE) {
             line->beg = off;
 
-            /* We are another MD_LINE_FENCEDCODE unless we are closing fence
-             * which we transform into MD_LINE_BLANK. */
             if(line->indent < ctx->code_indent_offset) {
                 if(md_is_closing_code_fence(ctx, CH(pivot_line->beg), off, &off)) {
                     line->type = MD_LINE_BLANK;
@@ -5891,7 +5260,6 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
                 }
             }
 
-            /* Change indentation accordingly to the initial code fence. */
             if(n_parents == ctx->n_containers) {
                 if(line->indent > pivot_line->indent)
                     line->indent -= pivot_line->indent;
@@ -5903,11 +5271,9 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
             }
         }
 
-        /* Check whether we are HTML block continuation. */
         if(pivot_line->type == MD_LINE_HTML  &&  ctx->html_block_type > 0) {
             if(n_parents < ctx->n_containers) {
-                /* HTML block is implicitly ended if the enclosing container
-                 * block ends. */
+
                 ctx->html_block_type = 0;
             } else {
                 int html_block_type;
@@ -5916,10 +5282,8 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
                 if(html_block_type > 0) {
                     MD_ASSERT(html_block_type == ctx->html_block_type);
 
-                    /* Make sure this is the last line of the block. */
                     ctx->html_block_type = 0;
 
-                    /* Some end conditions serve as blank lines at the same time. */
                     if(html_block_type == 6 || html_block_type == 7) {
                         line->type = MD_LINE_BLANK;
                         line->indent = 0;
@@ -5933,7 +5297,6 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
             }
         }
 
-        /* Check for blank line. */
         if(off >= ctx->size  ||  ISNEWLINE(off)) {
             if(pivot_line->type == MD_LINE_INDENTEDCODE  &&  n_parents == ctx->n_containers) {
                 line->type = MD_LINE_INDENTEDCODE;
@@ -5949,17 +5312,7 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
                         ctx->containers[n_parents-1].ch != _T('>'));
 
     #if 1
-                /* See https://github.com/mity/md4c/issues/6
-                 *
-                 * This ugly checking tests we are in (yet empty) list item but
-                 * not its very first line (i.e. not the line with the list
-                 * item mark).
-                 *
-                 * If we are such a blank line, then any following non-blank
-                 * line which would be part of the list item actually has to
-                 * end the list because according to the specification, "a list
-                 * item can begin with at most one blank line."
-                 */
+
                 if(n_parents > 0  &&  ctx->containers[n_parents-1].ch != _T('>')  &&
                    n_brothers + n_children == 0  &&  ctx->current_block == NULL  &&
                    ctx->n_block_bytes > (int) sizeof(MD_BLOCK))
@@ -5973,10 +5326,7 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
             break;
         } else {
     #if 1
-            /* This is the 2nd half of the hack. If the flag is set (i.e. there
-             * was a 2nd blank line at the beginning of the list item) and if
-             * we would otherwise still belong to the list item, we enforce
-             * the end of the list. */
+
             if(ctx->last_list_item_starts_with_two_blank_lines) {
                 if(n_parents > 0  &&  n_parents == ctx->n_containers  &&
                    ctx->containers[n_parents-1].ch != _T('>')  &&
@@ -5999,7 +5349,6 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
             ctx->last_line_has_list_loosening_effect = FALSE;
         }
 
-        /* Check whether we are Setext underline. */
         if(line->indent < ctx->code_indent_offset  &&  pivot_line->type == MD_LINE_TEXT
             &&  off < ctx->size  &&  ISANYOF2(off, _T('='), _T('-'))
             &&  (n_parents == ctx->n_containers))
@@ -6013,7 +5362,6 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
             }
         }
 
-        /* Check for thematic break line. */
         if(line->indent < ctx->code_indent_offset
             &&  off < ctx->size  &&  off >= hr_killer
             &&  ISANYOF(off, _T("-_*")))
@@ -6024,8 +5372,6 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
             }
         }
 
-        /* Check for "brother" container. I.e. whether we are another list item
-         * in already started list. */
         if(n_parents < ctx->n_containers  &&  n_brothers + n_children == 0) {
             OFF tmp;
 
@@ -6041,7 +5387,6 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
                 total_indent += line->indent;
                 line->beg = off;
 
-                /* Some of the following whitespace actually still belongs to the mark. */
                 if(off >= ctx->size || ISNEWLINE(off)) {
                     container.contents_indent++;
                 } else if(line->indent <= ctx->code_indent_offset) {
@@ -6060,8 +5405,6 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
             }
         }
 
-        /* Check for indented code.
-         * Note indented code block cannot interrupt a paragraph. */
         if(line->indent >= ctx->code_indent_offset  &&  (pivot_line->type != MD_LINE_TEXT)) {
             line->type = MD_LINE_INDENTEDCODE;
             line->indent -= ctx->code_indent_offset;
@@ -6069,18 +5412,17 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
             break;
         }
 
-        /* Check for start of a new container block. */
         if(line->indent < ctx->code_indent_offset  &&
            md_is_container_mark(ctx, line->indent, off, &off, &container))
         {
             if(pivot_line->type == MD_LINE_TEXT  &&  n_parents == ctx->n_containers  &&
                         (off >= ctx->size || ISNEWLINE(off))  &&  container.ch != _T('>'))
             {
-                /* Noop. List mark followed by a blank line cannot interrupt a paragraph. */
+
             } else if(pivot_line->type == MD_LINE_TEXT  &&  n_parents == ctx->n_containers  &&
                         ISANYOF2_(container.ch, _T('.'), _T(')'))  &&  container.start != 1)
             {
-                /* Noop. Ordered list cannot interrupt a paragraph unless the start index is 1. */
+
             } else {
                 total_indent += container.contents_indent - container.mark_indent;
                 line->indent = md_line_indentation(ctx, total_indent, off, &off);
@@ -6089,7 +5431,6 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
                 line->beg = off;
                 line->data = container.ch;
 
-                /* Some of the following whitespace actually still belongs to the mark. */
                 if(off >= ctx->size || ISNEWLINE(off)) {
                     container.contents_indent++;
                 } else if(line->indent <= ctx->code_indent_offset) {
@@ -6112,13 +5453,11 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
             }
         }
 
-        /* Check whether we are table continuation. */
         if(pivot_line->type == MD_LINE_TABLE  &&  n_parents == ctx->n_containers) {
             line->type = MD_LINE_TABLE;
             break;
         }
 
-        /* Check for ATX header. */
         if(line->indent < ctx->code_indent_offset  &&
                 off < ctx->size  &&  CH(off) == _T('#'))
         {
@@ -6131,7 +5470,6 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
             }
         }
 
-        /* Check whether we are starting code fence. */
         if(line->indent < ctx->code_indent_offset  &&
                 off < ctx->size  &&  ISANYOF2(off, _T('`'), _T('~')))
         {
@@ -6143,20 +5481,18 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
             }
         }
 
-        /* Check for start of raw HTML block. */
         if(off < ctx->size  &&  CH(off) == _T('<')
             &&  !(ctx->parser.flags & MD_FLAG_NOHTMLBLOCKS))
         {
             ctx->html_block_type = md_is_html_block_start_condition(ctx, off);
 
-            /* HTML block type 7 cannot interrupt paragraph. */
             if(ctx->html_block_type == 7  &&  pivot_line->type == MD_LINE_TEXT)
                 ctx->html_block_type = 0;
 
             if(ctx->html_block_type > 0) {
-                /* The line itself also may immediately close the block. */
+
                 if(md_is_html_block_end_condition(ctx, off, &off) == ctx->html_block_type) {
-                    /* Make sure this is the last line of the block. */
+
                     ctx->html_block_type = 0;
                 }
 
@@ -6166,7 +5502,6 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
             }
         }
 
-        /* Check for table underline. */
         if((ctx->parser.flags & MD_FLAG_TABLES)  &&  pivot_line->type == MD_LINE_TEXT
             &&  off < ctx->size  &&  ISANYOF3(off, _T('|'), _T('-'), _T(':'))
             &&  n_parents == ctx->n_containers)
@@ -6182,14 +5517,12 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
             }
         }
 
-        /* By default, we are normal text line. */
         line->type = MD_LINE_TEXT;
         if(pivot_line->type == MD_LINE_TEXT  &&  n_brothers + n_children == 0) {
-            /* Lazy continuation. */
+
             n_parents = ctx->n_containers;
         }
 
-        /* Check for task mark. */
         if((ctx->parser.flags & MD_FLAG_TASKLISTS)  &&  n_brothers + n_children > 0  &&
            ISANYOF_(ctx->containers[ctx->n_containers-1].ch, _T("-+*.)")))
         {
@@ -6214,20 +5547,12 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
         break;
     }
 
-    /* Scan for end of the line.
-     *
-     * Note this is quite a bottleneck of the parsing as we here iterate almost
-     * over compete document.
-     */
 #if defined __linux__ && !defined MD4C_USE_UTF16
-    /* Recent glibc versions have superbly optimized strcspn(), even using
-     * vectorization if available. */
+
     if(ctx->doc_ends_with_newline  &&  off < ctx->size) {
         while(TRUE) {
             off += (OFF) strcspn(STR(off), "\r\n");
 
-            /* strcspn() can stop on zero terminator; but that can appear
-             * anywhere in the Markfown input... */
             if(CH(off) == _T('\0'))
                 off++;
             else
@@ -6236,7 +5561,7 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
     } else
 #endif
     {
-        /* Optimization: Use some loop unrolling. */
+
         while(off + 3 < ctx->size  &&  !ISNEWLINE(off+0)  &&  !ISNEWLINE(off+1)
                                    &&  !ISNEWLINE(off+2)  &&  !ISNEWLINE(off+3))
             off += 4;
@@ -6244,10 +5569,8 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
             off++;
     }
 
-    /* Set end of the line. */
     line->end = off;
 
-    /* But for ATX header, we should exclude the optional trailing mark. */
     if(line->type == MD_LINE_ATXHEADER) {
         OFF tmp = line->end;
         while(tmp > line->beg && ISBLANK(tmp-1))
@@ -6258,13 +5581,11 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
             line->end = tmp;
     }
 
-    /* Trim trailing spaces. */
     if(line->type != MD_LINE_INDENTEDCODE  &&  line->type != MD_LINE_FENCEDCODE  && line->type != MD_LINE_HTML) {
         while(line->end > line->beg && ISBLANK(line->end-1))
             line->end--;
     }
 
-    /* Eat also the new line. */
     if(off < ctx->size && CH(off) == _T('\r'))
         off++;
     if(off < ctx->size && CH(off) == _T('\n'))
@@ -6272,7 +5593,6 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
 
     *p_end = off;
 
-    /* If we belong to a list after seeing a blank line, the list is loose. */
     if(prev_line_has_list_loosening_effect  &&  line->type != MD_LINE_BLANK  &&  n_parents + n_brothers > 0) {
         MD_CONTAINER* c = &ctx->containers[n_parents + n_brothers - 1];
         if(c->ch != _T('>')) {
@@ -6281,11 +5601,9 @@ md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end,
         }
     }
 
-    /* Leave any containers we are not part of anymore. */
     if(n_children == 0  &&  n_parents + n_brothers < ctx->n_containers)
         MD_CHECK(md_leave_child_containers(ctx, n_parents + n_brothers));
 
-    /* Enter any container we found a mark for. */
     if(n_brothers > 0) {
         MD_ASSERT(n_brothers == 1);
         MD_CHECK(md_push_container_bytes(ctx, MD_BLOCK_LI,
@@ -6313,7 +5631,6 @@ md_process_line(MD_CTX* ctx, const MD_LINE_ANALYSIS** p_pivot_line, MD_LINE_ANAL
     const MD_LINE_ANALYSIS* pivot_line = *p_pivot_line;
     int ret = 0;
 
-    /* Blank line ends current leaf block. */
     if(line->type == MD_LINE_BLANK) {
         MD_CHECK(md_end_current_block(ctx));
         *p_pivot_line = &md_dummy_blank_line;
@@ -6323,11 +5640,9 @@ md_process_line(MD_CTX* ctx, const MD_LINE_ANALYSIS** p_pivot_line, MD_LINE_ANAL
     if(line->enforce_new_block)
         MD_CHECK(md_end_current_block(ctx));
 
-    /* Some line types form block on their own. */
     if(line->type == MD_LINE_HR || line->type == MD_LINE_ATXHEADER) {
         MD_CHECK(md_end_current_block(ctx));
 
-        /* Add our single-line block. */
         MD_CHECK(md_start_new_block(ctx, line));
         MD_CHECK(md_add_line_into_current_block(ctx, line));
         MD_CHECK(md_end_current_block(ctx));
@@ -6335,7 +5650,6 @@ md_process_line(MD_CTX* ctx, const MD_LINE_ANALYSIS** p_pivot_line, MD_LINE_ANAL
         return 0;
     }
 
-    /* MD_LINE_SETEXTUNDERLINE changes meaning of the current block and ends it. */
     if(line->type == MD_LINE_SETEXTUNDERLINE) {
         MD_ASSERT(ctx->current_block != NULL);
         ctx->current_block->type = MD_BLOCK_H;
@@ -6346,15 +5660,13 @@ md_process_line(MD_CTX* ctx, const MD_LINE_ANALYSIS** p_pivot_line, MD_LINE_ANAL
         if(ctx->current_block == NULL) {
             *p_pivot_line = &md_dummy_blank_line;
         } else {
-            /* This happens if we have consumed all the body as link ref. defs.
-             * and downgraded the underline into start of a new paragraph block. */
+
             line->type = MD_LINE_TEXT;
             *p_pivot_line = line;
         }
         return 0;
     }
 
-    /* MD_LINE_TABLEUNDERLINE changes meaning of the current block. */
     if(line->type == MD_LINE_TABLEUNDERLINE) {
         MD_ASSERT(ctx->current_block != NULL);
         MD_ASSERT(ctx->current_block->n_lines == 1);
@@ -6366,17 +5678,14 @@ md_process_line(MD_CTX* ctx, const MD_LINE_ANALYSIS** p_pivot_line, MD_LINE_ANAL
         return 0;
     }
 
-    /* The current block also ends if the line has different type. */
     if(line->type != pivot_line->type)
         MD_CHECK(md_end_current_block(ctx));
 
-    /* The current line may start a new block. */
     if(ctx->current_block == NULL) {
         MD_CHECK(md_start_new_block(ctx, line));
         *p_pivot_line = line;
     }
 
-    /* In all other cases the line is just a continuation of the current block. */
     MD_CHECK(md_add_line_into_current_block(ctx, line));
 
 abort:
@@ -6406,7 +5715,6 @@ md_process_doc(MD_CTX *ctx)
 
     MD_CHECK(md_build_ref_def_hashtable(ctx));
 
-    /* Process all blocks. */
     MD_CHECK(md_leave_child_containers(ctx, 0));
     MD_CHECK(md_process_all_blocks(ctx));
 
@@ -6415,7 +5723,7 @@ md_process_doc(MD_CTX *ctx)
 abort:
 
 #if 0
-    /* Output some memory consumption statistics. */
+
     {
         char buffer[256];
         sprintf(buffer, "Alloced %u bytes for block buffer.",
@@ -6439,11 +5747,6 @@ abort:
     return ret;
 }
 
-
-/********************
- ***  Public API  ***
- ********************/
-
 int
 md_parse(const MD_CHAR* text, MD_SIZE size, const MD_PARSER* parser, void* userdata)
 {
@@ -6457,7 +5760,6 @@ md_parse(const MD_CHAR* text, MD_SIZE size, const MD_PARSER* parser, void* userd
         return -1;
     }
 
-    /* Setup context structure. */
     memset(&ctx, 0, sizeof(MD_CTX));
     ctx.text = text;
     ctx.size = size;
@@ -6468,7 +5770,6 @@ md_parse(const MD_CHAR* text, MD_SIZE size, const MD_PARSER* parser, void* userd
     ctx.doc_ends_with_newline = (size > 0  &&  ISNEWLINE_(text[size-1]));
     ctx.max_ref_def_output = MIN(MIN(16 * (uint64_t)size, (uint64_t)(1024 * 1024)), (uint64_t)SZ_MAX);
 
-    /* Reset all mark stacks and lists. */
     for(i = 0; i < (int) SIZEOF_ARRAY(ctx.opener_stacks); i++)
         ctx.opener_stacks[i].top = -1;
     ctx.ptr_stack.top = -1;
@@ -6477,10 +5778,8 @@ md_parse(const MD_CHAR* text, MD_SIZE size, const MD_PARSER* parser, void* userd
     ctx.table_cell_boundaries_head = -1;
     ctx.table_cell_boundaries_tail = -1;
 
-    /* All the work. */
     ret = md_process_doc(&ctx);
 
-    /* Clean-up. */
     md_free_ref_defs(&ctx);
     md_free_ref_def_hashtable(&ctx);
     free(ctx.buffer);
diff --git a/clib/md4c.h b/clib/md4c.h
index 8d6be1cb4631528e7c387ca2e49ce42d1ef87477..ee4edb7f33fa8ecba16df2a6eaf22843be1eb1f3 100644
--- a/clib/md4c.h
+++ b/clib/md4c.h
@@ -1,28 +1,3 @@
-/*
- * MD4C: Markdown parser for C
- * (http://github.com/mity/md4c)
- *
- * Copyright (c) 2016-2024 Martin Mitáš
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-
 #ifndef MD4C_H
 #define MD4C_H
 
@@ -31,9 +6,7 @@
 #endif
 
 #if defined MD4C_USE_UTF16
-    /* Magic to support UTF-16. Note that in order to use it, you have to define
-     * the macro MD4C_USE_UTF16 both when building MD4C as well as when
-     * including this header in your code. */
+
     #ifdef _WIN32
         #include <windows.h>
         typedef WCHAR       MD_CHAR;
@@ -47,53 +20,28 @@
 typedef unsigned MD_SIZE;
 typedef unsigned MD_OFFSET;
 
-
-/* Block represents a part of document hierarchy structure like a paragraph
- * or list item.
- */
 typedef enum MD_BLOCKTYPE {
-    /* <body>...</body> */
+
     MD_BLOCK_DOC = 0,
 
-    /* <blockquote>...</blockquote> */
     MD_BLOCK_QUOTE,
 
-    /* <ul>...</ul>
-     * Detail: Structure MD_BLOCK_UL_DETAIL. */
     MD_BLOCK_UL,
 
-    /* <ol>...</ol>
-     * Detail: Structure MD_BLOCK_OL_DETAIL. */
     MD_BLOCK_OL,
 
-    /* <li>...</li>
-     * Detail: Structure MD_BLOCK_LI_DETAIL. */
     MD_BLOCK_LI,
 
-    /* <hr> */
     MD_BLOCK_HR,
 
-    /* <h1>...</h1> (for levels up to 6)
-     * Detail: Structure MD_BLOCK_H_DETAIL. */
     MD_BLOCK_H,
 
-    /* <pre><code>...</code></pre>
-     * Note the text lines within code blocks are terminated with '\n'
-     * instead of explicit MD_TEXT_BR. */
     MD_BLOCK_CODE,
 
-    /* Raw HTML block. This itself does not correspond to any particular HTML
-     * tag. The contents of it _is_ raw HTML source intended to be put
-     * in verbatim form to the HTML output. */
     MD_BLOCK_HTML,
 
-    /* <p>...</p> */
     MD_BLOCK_P,
 
-    /* <table>...</table> and its contents.
-     * Detail: Structure MD_BLOCK_TABLE_DETAIL (for MD_BLOCK_TABLE),
-     *         structure MD_BLOCK_TD_DETAIL (for MD_BLOCK_TH and MD_BLOCK_TD)
-     * Note all of these are used only if extension MD_FLAG_TABLES is enabled. */
     MD_BLOCK_TABLE,
     MD_BLOCK_THEAD,
     MD_BLOCK_TBODY,
@@ -102,132 +50,53 @@ typedef enum MD_BLOCKTYPE {
     MD_BLOCK_TD
 } MD_BLOCKTYPE;
 
-/* Span represents an in-line piece of a document which should be rendered with
- * the same font, color and other attributes. A sequence of spans forms a block
- * like paragraph or list item. */
 typedef enum MD_SPANTYPE {
-    /* <em>...</em> */
+
     MD_SPAN_EM,
 
-    /* <strong>...</strong> */
     MD_SPAN_STRONG,
 
-    /* <a href="xxx">...</a>
-     * Detail: Structure MD_SPAN_A_DETAIL. */
     MD_SPAN_A,
 
-    /* <img src="xxx">...</a>
-     * Detail: Structure MD_SPAN_IMG_DETAIL.
-     * Note: Image text can contain nested spans and even nested images.
-     * If rendered into ALT attribute of HTML <IMG> tag, it's responsibility
-     * of the parser to deal with it.
-     */
     MD_SPAN_IMG,
 
-    /* <code>...</code> */
     MD_SPAN_CODE,
 
-    /* <del>...</del>
-     * Note: Recognized only when MD_FLAG_STRIKETHROUGH is enabled.
-     */
     MD_SPAN_DEL,
 
-    /* For recognizing inline ($) and display ($$) equations
-     * Note: Recognized only when MD_FLAG_LATEXMATHSPANS is enabled.
-     */
     MD_SPAN_LATEXMATH,
     MD_SPAN_LATEXMATH_DISPLAY,
 
-    /* Wiki links
-     * Note: Recognized only when MD_FLAG_WIKILINKS is enabled.
-     */
     MD_SPAN_WIKILINK,
 
-    /* <u>...</u>
-     * Note: Recognized only when MD_FLAG_UNDERLINE is enabled. */
     MD_SPAN_U
 } MD_SPANTYPE;
 
-/* Text is the actual textual contents of span. */
 typedef enum MD_TEXTTYPE {
-    /* Normal text. */
+
     MD_TEXT_NORMAL = 0,
 
-    /* NULL character. CommonMark requires replacing NULL character with
-     * the replacement char U+FFFD, so this allows caller to do that easily. */
     MD_TEXT_NULLCHAR,
 
-    /* Line breaks.
-     * Note these are not sent from blocks with verbatim output (MD_BLOCK_CODE
-     * or MD_BLOCK_HTML). In such cases, '\n' is part of the text itself. */
-    MD_TEXT_BR,         /* <br> (hard break) */
-    MD_TEXT_SOFTBR,     /* '\n' in source text where it is not semantically meaningful (soft break) */
-
-    /* Entity.
-     * (a) Named entity, e.g. &nbsp; 
-     *     (Note MD4C does not have a list of known entities.
-     *     Anything matching the regexp /&[A-Za-z][A-Za-z0-9]{1,47};/ is
-     *     treated as a named entity.)
-     * (b) Numerical entity, e.g. &#1234;
-     * (c) Hexadecimal entity, e.g. &#x12AB;
-     *
-     * As MD4C is mostly encoding agnostic, application gets the verbatim
-     * entity text into the MD_PARSER::text_callback(). */
+    MD_TEXT_BR,
+    MD_TEXT_SOFTBR,
+
     MD_TEXT_ENTITY,
 
-    /* Text in a code block (inside MD_BLOCK_CODE) or inlined code (`code`).
-     * If it is inside MD_BLOCK_CODE, it includes spaces for indentation and
-     * '\n' for new lines. MD_TEXT_BR and MD_TEXT_SOFTBR are not sent for this
-     * kind of text. */
     MD_TEXT_CODE,
 
-    /* Text is a raw HTML. If it is contents of a raw HTML block (i.e. not
-     * an inline raw HTML), then MD_TEXT_BR and MD_TEXT_SOFTBR are not used.
-     * The text contains verbatim '\n' for the new lines. */
     MD_TEXT_HTML,
 
-    /* Text is inside an equation. This is processed the same way as inlined code
-     * spans (`code`). */
     MD_TEXT_LATEXMATH
 } MD_TEXTTYPE;
 
-
-/* Alignment enumeration. */
 typedef enum MD_ALIGN {
-    MD_ALIGN_DEFAULT = 0,   /* When unspecified. */
+    MD_ALIGN_DEFAULT = 0,
     MD_ALIGN_LEFT,
     MD_ALIGN_CENTER,
     MD_ALIGN_RIGHT
 } MD_ALIGN;
 
-
-/* String attribute.
- *
- * This wraps strings which are outside of a normal text flow and which are
- * propagated within various detailed structures, but which still may contain
- * string portions of different types like e.g. entities.
- *
- * So, for example, lets consider this image:
- *
- *     ![image alt text](http://example.org/image.png 'foo &quot; bar')
- *
- * The image alt text is propagated as a normal text via the MD_PARSER::text()
- * callback. However, the image title ('foo &quot; bar') is propagated as
- * MD_ATTRIBUTE in MD_SPAN_IMG_DETAIL::title.
- *
- * Then the attribute MD_SPAN_IMG_DETAIL::title shall provide the following:
- *  -- [0]: "foo "   (substr_types[0] == MD_TEXT_NORMAL; substr_offsets[0] == 0)
- *  -- [1]: "&quot;" (substr_types[1] == MD_TEXT_ENTITY; substr_offsets[1] == 4)
- *  -- [2]: " bar"   (substr_types[2] == MD_TEXT_NORMAL; substr_offsets[2] == 10)
- *  -- [3]: (n/a)    (n/a                              ; substr_offsets[3] == 14)
- *
- * Note that these invariants are always guaranteed:
- *  -- substr_offsets[0] == 0
- *  -- substr_offsets[LAST+1] == size
- *  -- Currently, only MD_TEXT_NORMAL, MD_TEXT_ENTITY, MD_TEXT_NULLCHAR
- *     substrings can appear. This could change only of the specification
- *     changes.
- */
 typedef struct MD_ATTRIBUTE {
     const MD_CHAR* text;
     MD_SIZE size;
@@ -235,173 +104,105 @@ typedef struct MD_ATTRIBUTE {
     const MD_OFFSET* substr_offsets;
 } MD_ATTRIBUTE;
 
-
-/* Detailed info for MD_BLOCK_UL. */
 typedef struct MD_BLOCK_UL_DETAIL {
-    int is_tight;           /* Non-zero if tight list, zero if loose. */
-    MD_CHAR mark;           /* Item bullet character in MarkDown source of the list, e.g. '-', '+', '*'. */
+    int is_tight;
+    MD_CHAR mark;
 } MD_BLOCK_UL_DETAIL;
 
-/* Detailed info for MD_BLOCK_OL. */
 typedef struct MD_BLOCK_OL_DETAIL {
-    unsigned start;         /* Start index of the ordered list. */
-    int is_tight;           /* Non-zero if tight list, zero if loose. */
-    MD_CHAR mark_delimiter; /* Character delimiting the item marks in MarkDown source, e.g. '.' or ')' */
+    unsigned start;
+    int is_tight;
+    MD_CHAR mark_delimiter;
 } MD_BLOCK_OL_DETAIL;
 
-/* Detailed info for MD_BLOCK_LI. */
 typedef struct MD_BLOCK_LI_DETAIL {
-    int is_task;            /* Can be non-zero only with MD_FLAG_TASKLISTS */
-    MD_CHAR task_mark;      /* If is_task, then one of 'x', 'X' or ' '. Undefined otherwise. */
-    MD_OFFSET task_mark_offset;  /* If is_task, then offset in the input of the char between '[' and ']'. */
+    int is_task;
+    MD_CHAR task_mark;
+    MD_OFFSET task_mark_offset;
 } MD_BLOCK_LI_DETAIL;
 
-/* Detailed info for MD_BLOCK_H. */
 typedef struct MD_BLOCK_H_DETAIL {
-    unsigned level;         /* Header level (1 - 6) */
+    unsigned level;
 } MD_BLOCK_H_DETAIL;
 
-/* Detailed info for MD_BLOCK_CODE. */
 typedef struct MD_BLOCK_CODE_DETAIL {
     MD_ATTRIBUTE info;
     MD_ATTRIBUTE lang;
-    MD_CHAR fence_char;     /* The character used for fenced code block; or zero for indented code block. */
+    MD_CHAR fence_char;
 } MD_BLOCK_CODE_DETAIL;
 
-/* Detailed info for MD_BLOCK_TABLE. */
 typedef struct MD_BLOCK_TABLE_DETAIL {
-    unsigned col_count;         /* Count of columns in the table. */
-    unsigned head_row_count;    /* Count of rows in the table header (currently always 1) */
-    unsigned body_row_count;    /* Count of rows in the table body */
+    unsigned col_count;
+    unsigned head_row_count;
+    unsigned body_row_count;
 } MD_BLOCK_TABLE_DETAIL;
 
-/* Detailed info for MD_BLOCK_TH and MD_BLOCK_TD. */
 typedef struct MD_BLOCK_TD_DETAIL {
     MD_ALIGN align;
 } MD_BLOCK_TD_DETAIL;
 
-/* Detailed info for MD_SPAN_A. */
 typedef struct MD_SPAN_A_DETAIL {
     MD_ATTRIBUTE href;
     MD_ATTRIBUTE title;
-    int is_autolink;            /* nonzero if this is an autolink */
+    int is_autolink;
 } MD_SPAN_A_DETAIL;
 
-/* Detailed info for MD_SPAN_IMG. */
 typedef struct MD_SPAN_IMG_DETAIL {
     MD_ATTRIBUTE src;
     MD_ATTRIBUTE title;
 } MD_SPAN_IMG_DETAIL;
 
-/* Detailed info for MD_SPAN_WIKILINK. */
 typedef struct MD_SPAN_WIKILINK {
     MD_ATTRIBUTE target;
 } MD_SPAN_WIKILINK_DETAIL;
 
-/* Flags specifying extensions/deviations from CommonMark specification.
- *
- * By default (when MD_PARSER::flags == 0), we follow CommonMark specification.
- * The following flags may allow some extensions or deviations from it.
- */
-#define MD_FLAG_COLLAPSEWHITESPACE          0x0001  /* In MD_TEXT_NORMAL, collapse non-trivial whitespace into single ' ' */
-#define MD_FLAG_PERMISSIVEATXHEADERS        0x0002  /* Do not require space in ATX headers ( ###header ) */
-#define MD_FLAG_PERMISSIVEURLAUTOLINKS      0x0004  /* Recognize URLs as autolinks even without '<', '>' */
-#define MD_FLAG_PERMISSIVEEMAILAUTOLINKS    0x0008  /* Recognize e-mails as autolinks even without '<', '>' and 'mailto:' */
-#define MD_FLAG_NOINDENTEDCODEBLOCKS        0x0010  /* Disable indented code blocks. (Only fenced code works.) */
-#define MD_FLAG_NOHTMLBLOCKS                0x0020  /* Disable raw HTML blocks. */
-#define MD_FLAG_NOHTMLSPANS                 0x0040  /* Disable raw HTML (inline). */
-#define MD_FLAG_TABLES                      0x0100  /* Enable tables extension. */
-#define MD_FLAG_STRIKETHROUGH               0x0200  /* Enable strikethrough extension. */
-#define MD_FLAG_PERMISSIVEWWWAUTOLINKS      0x0400  /* Enable WWW autolinks (even without any scheme prefix, if they begin with 'www.') */
-#define MD_FLAG_TASKLISTS                   0x0800  /* Enable task list extension. */
-#define MD_FLAG_LATEXMATHSPANS              0x1000  /* Enable $ and $$ containing LaTeX equations. */
-#define MD_FLAG_WIKILINKS                   0x2000  /* Enable wiki links extension. */
-#define MD_FLAG_UNDERLINE                   0x4000  /* Enable underline extension (and disables '_' for normal emphasis). */
-#define MD_FLAG_HARD_SOFT_BREAKS            0x8000  /* Force all soft breaks to act as hard breaks. */
+#define MD_FLAG_COLLAPSEWHITESPACE          0x0001
+#define MD_FLAG_PERMISSIVEATXHEADERS        0x0002
+#define MD_FLAG_PERMISSIVEURLAUTOLINKS      0x0004
+#define MD_FLAG_PERMISSIVEEMAILAUTOLINKS    0x0008
+#define MD_FLAG_NOINDENTEDCODEBLOCKS        0x0010
+#define MD_FLAG_NOHTMLBLOCKS                0x0020
+#define MD_FLAG_NOHTMLSPANS                 0x0040
+#define MD_FLAG_TABLES                      0x0100
+#define MD_FLAG_STRIKETHROUGH               0x0200
+#define MD_FLAG_PERMISSIVEWWWAUTOLINKS      0x0400
+#define MD_FLAG_TASKLISTS                   0x0800
+#define MD_FLAG_LATEXMATHSPANS              0x1000
+#define MD_FLAG_WIKILINKS                   0x2000
+#define MD_FLAG_UNDERLINE                   0x4000
+#define MD_FLAG_HARD_SOFT_BREAKS            0x8000
 
 #define MD_FLAG_PERMISSIVEAUTOLINKS         (MD_FLAG_PERMISSIVEEMAILAUTOLINKS | MD_FLAG_PERMISSIVEURLAUTOLINKS | MD_FLAG_PERMISSIVEWWWAUTOLINKS)
 #define MD_FLAG_NOHTML                      (MD_FLAG_NOHTMLBLOCKS | MD_FLAG_NOHTMLSPANS)
 
-/* Convenient sets of flags corresponding to well-known Markdown dialects.
- *
- * Note we may only support subset of features of the referred dialect.
- * The constant just enables those extensions which bring us as close as
- * possible given what features we implement.
- *
- * ABI compatibility note: Meaning of these can change in time as new
- * extensions, bringing the dialect closer to the original, are implemented.
- */
 #define MD_DIALECT_COMMONMARK               0
 #define MD_DIALECT_GITHUB                   (MD_FLAG_PERMISSIVEAUTOLINKS | MD_FLAG_TABLES | MD_FLAG_STRIKETHROUGH | MD_FLAG_TASKLISTS)
 
-/* Parser structure.
- */
 typedef struct MD_PARSER {
-    /* Reserved. Set to zero.
-     */
+
     unsigned abi_version;
 
-    /* Dialect options. Bitmask of MD_FLAG_xxxx values.
-     */
     unsigned flags;
 
-    /* Caller-provided rendering callbacks.
-     *
-     * For some block/span types, more detailed information is provided in a
-     * type-specific structure pointed by the argument 'detail'.
-     *
-     * The last argument of all callbacks, 'userdata', is just propagated from
-     * md_parse() and is available for any use by the application.
-     *
-     * Note any strings provided to the callbacks as their arguments or as
-     * members of any detail structure are generally not zero-terminated.
-     * Application has to take the respective size information into account.
-     *
-     * Any rendering callback may abort further parsing of the document by
-     * returning non-zero.
-     */
-    int (*enter_block)(MD_BLOCKTYPE /*type*/, void* /*detail*/, void* /*userdata*/);
-    int (*leave_block)(MD_BLOCKTYPE /*type*/, void* /*detail*/, void* /*userdata*/);
-
-    int (*enter_span)(MD_SPANTYPE /*type*/, void* /*detail*/, void* /*userdata*/);
-    int (*leave_span)(MD_SPANTYPE /*type*/, void* /*detail*/, void* /*userdata*/);
-
-    int (*text)(MD_TEXTTYPE /*type*/, const MD_CHAR* /*text*/, MD_SIZE /*size*/, void* /*userdata*/);
-
-    /* Debug callback. Optional (may be NULL).
-     *
-     * If provided and something goes wrong, this function gets called.
-     * This is intended for debugging and problem diagnosis for developers;
-     * it is not intended to provide any errors suitable for displaying to an
-     * end user.
-     */
-    void (*debug_log)(const char* /*msg*/, void* /*userdata*/);
-
-    /* Reserved. Set to NULL.
-     */
+    int (*enter_block)(MD_BLOCKTYPE , void* , void* );
+    int (*leave_block)(MD_BLOCKTYPE , void* , void* );
+
+    int (*enter_span)(MD_SPANTYPE , void* , void* );
+    int (*leave_span)(MD_SPANTYPE , void* , void* );
+
+    int (*text)(MD_TEXTTYPE , const MD_CHAR* , MD_SIZE , void* );
+
+    void (*debug_log)(const char* , void* );
+
     void (*syntax)(void);
 } MD_PARSER;
 
-
-/* For backward compatibility. Do not use in new code.
- */
 typedef MD_PARSER MD_RENDERER;
 
-
-/* Parse the Markdown document stored in the string 'text' of size 'size'.
- * The parser provides callbacks to be called during the parsing so the
- * caller can render the document on the screen or convert the Markdown
- * to another format.
- *
- * Zero is returned on success. If a runtime error occurs (e.g. a memory
- * fails), -1 is returned. If the processing is aborted due any callback
- * returning non-zero, the return value of the callback is returned.
- */
 int md_parse(const MD_CHAR* text, MD_SIZE size, const MD_PARSER* parser, void* userdata);
 
-
 #ifdef __cplusplus
-    }  /* extern "C" { */
+    }
 #endif
 
-#endif  /* MD4C_H */
+#endif
diff --git a/clib/stb_image.h b/clib/stb_image.h
index 9eedabedc45b3e6fd88fae6f14a160b4d53272ec..5da667f5d5e6b82eefa2d864a5d3961621a7c902 100644
--- a/clib/stb_image.h
+++ b/clib/stb_image.h
@@ -1,381 +1,15 @@
-/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb
-                                  no warranty implied; use at your own risk
-
-   Do this:
-      #define STB_IMAGE_IMPLEMENTATION
-   before you include this file in *one* C or C++ file to create the implementation.
-
-   // i.e. it should look like this:
-   #include ...
-   #include ...
-   #include ...
-   #define STB_IMAGE_IMPLEMENTATION
-   #include "stb_image.h"
-
-   You can #define STBI_ASSERT(x) before the #include to avoid using assert.h.
-   And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free
-
-
-   QUICK NOTES:
-      Primarily of interest to game developers and other people who can
-          avoid problematic images and only need the trivial interface
-
-      JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib)
-      PNG 1/2/4/8/16-bit-per-channel
-
-      TGA (not sure what subset, if a subset)
-      BMP non-1bpp, non-RLE
-      PSD (composited view only, no extra channels, 8/16 bit-per-channel)
-
-      GIF (*comp always reports as 4-channel)
-      HDR (radiance rgbE format)
-      PIC (Softimage PIC)
-      PNM (PPM and PGM binary only)
-
-      Animated GIF still needs a proper API, but here's one way to do it:
-          http://gist.github.com/urraka/685d9a6340b26b830d49
-
-      - decode from memory or through FILE (define STBI_NO_STDIO to remove code)
-      - decode from arbitrary I/O callbacks
-      - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON)
-
-   Full documentation under "DOCUMENTATION" below.
-
-
-LICENSE
-
-  See end of file for license information.
-
-RECENT REVISION HISTORY:
-
-      2.30  (2024-05-31) avoid erroneous gcc warning
-      2.29  (2023-05-xx) optimizations
-      2.28  (2023-01-29) many error fixes, security errors, just tons of stuff
-      2.27  (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes
-      2.26  (2020-07-13) many minor fixes
-      2.25  (2020-02-02) fix warnings
-      2.24  (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically
-      2.23  (2019-08-11) fix clang static analysis warning
-      2.22  (2019-03-04) gif fixes, fix warnings
-      2.21  (2019-02-25) fix typo in comment
-      2.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
-      2.19  (2018-02-11) fix warning
-      2.18  (2018-01-30) fix warnings
-      2.17  (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings
-      2.16  (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes
-      2.15  (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC
-      2.14  (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
-      2.13  (2016-12-04) experimental 16-bit API, only for PNG so far; fixes
-      2.12  (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
-      2.11  (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64
-                         RGB-format JPEG; remove white matting in PSD;
-                         allocate large structures on the stack;
-                         correct channel count for PNG & BMP
-      2.10  (2016-01-22) avoid warning introduced in 2.09
-      2.09  (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED
-
-   See end of file for full revision history.
-
-
- ============================    Contributors    =========================
-
- Image formats                          Extensions, features
-    Sean Barrett (jpeg, png, bmp)          Jetro Lauha (stbi_info)
-    Nicolas Schulz (hdr, psd)              Martin "SpartanJ" Golini (stbi_info)
-    Jonathan Dummer (tga)                  James "moose2000" Brown (iPhone PNG)
-    Jean-Marc Lienher (gif)                Ben "Disch" Wenger (io callbacks)
-    Tom Seddon (pic)                       Omar Cornut (1/2/4-bit PNG)
-    Thatcher Ulrich (psd)                  Nicolas Guillemot (vertical flip)
-    Ken Miller (pgm, ppm)                  Richard Mitton (16-bit PSD)
-    github:urraka (animated gif)           Junggon Kim (PNM comments)
-    Christopher Forseth (animated gif)     Daniel Gibson (16-bit TGA)
-                                           socks-the-fox (16-bit PNG)
-                                           Jeremy Sawicki (handle all ImageNet JPGs)
- Optimizations & bugfixes                  Mikhail Morozov (1-bit BMP)
-    Fabian "ryg" Giesen                    Anael Seghezzi (is-16-bit query)
-    Arseny Kapoulkine                      Simon Breuss (16-bit PNM)
-    John-Mark Allen
-    Carmelo J Fdez-Aguera
-
- Bug & warning fixes
-    Marc LeBlanc            David Woo          Guillaume George     Martins Mozeiko
-    Christpher Lloyd        Jerry Jansson      Joseph Thomson       Blazej Dariusz Roszkowski
-    Phil Jordan                                Dave Moore           Roy Eltham
-    Hayaki Saito            Nathan Reed        Won Chun
-    Luke Graham             Johan Duparc       Nick Verigakis       the Horde3D community
-    Thomas Ruf              Ronny Chevalier                         github:rlyeh
-    Janez Zemva             John Bartholomew   Michal Cichon        github:romigrou
-    Jonathan Blow           Ken Hamada         Tero Hanninen        github:svdijk
-    Eugene Golushkov        Laurent Gomila     Cort Stratton        github:snagar
-    Aruelien Pocheville     Sergio Gonzalez    Thibault Reuille     github:Zelex
-    Cass Everitt            Ryamond Barbiero                        github:grim210
-    Paul Du Bois            Engin Manap        Aldo Culquicondor    github:sammyhw
-    Philipp Wiesemann       Dale Weiler        Oriol Ferrer Mesia   github:phprus
-    Josh Tobin              Neil Bickford      Matthew Gregan       github:poppolopoppo
-    Julian Raschke          Gregory Mullen     Christian Floisand   github:darealshinji
-    Baldur Karlsson         Kevin Schmidt      JR Smith             github:Michaelangel007
-                            Brad Weinberger    Matvey Cherevko      github:mosra
-    Luca Sas                Alexander Veselov  Zack Middleton       [reserved]
-    Ryan C. Gordon          [reserved]                              [reserved]
-                     DO NOT ADD YOUR NAME HERE
-
-                     Jacko Dirks
-
-  To add your name to the credits, pick a random blank space in the middle and fill it.
-  80% of merge conflicts on stb PRs are due to people adding their name at the end
-  of the credits.
-*/
-
 #ifndef STBI_INCLUDE_STB_IMAGE_H
 #define STBI_INCLUDE_STB_IMAGE_H
 
-// DOCUMENTATION
-//
-// Limitations:
-//    - no 12-bit-per-channel JPEG
-//    - no JPEGs with arithmetic coding
-//    - GIF always returns *comp=4
-//
-// Basic usage (see HDR discussion below for HDR usage):
-//    int x,y,n;
-//    unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
-//    // ... process data if not NULL ...
-//    // ... x = width, y = height, n = # 8-bit components per pixel ...
-//    // ... replace '0' with '1'..'4' to force that many components per pixel
-//    // ... but 'n' will always be the number that it would have been if you said 0
-//    stbi_image_free(data);
-//
-// Standard parameters:
-//    int *x                 -- outputs image width in pixels
-//    int *y                 -- outputs image height in pixels
-//    int *channels_in_file  -- outputs # of image components in image file
-//    int desired_channels   -- if non-zero, # of image components requested in result
-//
-// The return value from an image loader is an 'unsigned char *' which points
-// to the pixel data, or NULL on an allocation failure or if the image is
-// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels,
-// with each pixel consisting of N interleaved 8-bit components; the first
-// pixel pointed to is top-left-most in the image. There is no padding between
-// image scanlines or between pixels, regardless of format. The number of
-// components N is 'desired_channels' if desired_channels is non-zero, or
-// *channels_in_file otherwise. If desired_channels is non-zero,
-// *channels_in_file has the number of components that _would_ have been
-// output otherwise. E.g. if you set desired_channels to 4, you will always
-// get RGBA output, but you can check *channels_in_file to see if it's trivially
-// opaque because e.g. there were only 3 channels in the source image.
-//
-// An output image with N components has the following components interleaved
-// in this order in each pixel:
-//
-//     N=#comp     components
-//       1           grey
-//       2           grey, alpha
-//       3           red, green, blue
-//       4           red, green, blue, alpha
-//
-// If image loading fails for any reason, the return value will be NULL,
-// and *x, *y, *channels_in_file will be unchanged. The function
-// stbi_failure_reason() can be queried for an extremely brief, end-user
-// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS
-// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
-// more user-friendly ones.
-//
-// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
-//
-// To query the width, height and component count of an image without having to
-// decode the full file, you can use the stbi_info family of functions:
-//
-//   int x,y,n,ok;
-//   ok = stbi_info(filename, &x, &y, &n);
-//   // returns ok=1 and sets x, y, n if image is a supported format,
-//   // 0 otherwise.
-//
-// Note that stb_image pervasively uses ints in its public API for sizes,
-// including sizes of memory buffers. This is now part of the API and thus
-// hard to change without causing breakage. As a result, the various image
-// loaders all have certain limits on image size; these differ somewhat
-// by format but generally boil down to either just under 2GB or just under
-// 1GB. When the decoded image would be larger than this, stb_image decoding
-// will fail.
-//
-// Additionally, stb_image will reject image files that have any of their
-// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS,
-// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit,
-// the only way to have an image with such dimensions load correctly
-// is for it to have a rather extreme aspect ratio. Either way, the
-// assumption here is that such larger images are likely to be malformed
-// or malicious. If you do need to load an image with individual dimensions
-// larger than that, and it still fits in the overall size limit, you can
-// #define STBI_MAX_DIMENSIONS on your own to be something larger.
-//
-// ===========================================================================
-//
-// UNICODE:
-//
-//   If compiling for Windows and you wish to use Unicode filenames, compile
-//   with
-//       #define STBI_WINDOWS_UTF8
-//   and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert
-//   Windows wchar_t filenames to utf8.
-//
-// ===========================================================================
-//
-// Philosophy
-//
-// stb libraries are designed with the following priorities:
-//
-//    1. easy to use
-//    2. easy to maintain
-//    3. good performance
-//
-// Sometimes I let "good performance" creep up in priority over "easy to maintain",
-// and for best performance I may provide less-easy-to-use APIs that give higher
-// performance, in addition to the easy-to-use ones. Nevertheless, it's important
-// to keep in mind that from the standpoint of you, a client of this library,
-// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all.
-//
-// Some secondary priorities arise directly from the first two, some of which
-// provide more explicit reasons why performance can't be emphasized.
-//
-//    - Portable ("ease of use")
-//    - Small source code footprint ("easy to maintain")
-//    - No dependencies ("ease of use")
-//
-// ===========================================================================
-//
-// I/O callbacks
-//
-// I/O callbacks allow you to read from arbitrary sources, like packaged
-// files or some other source. Data read from callbacks are processed
-// through a small internal buffer (currently 128 bytes) to try to reduce
-// overhead.
-//
-// The three functions you must define are "read" (reads some bytes of data),
-// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).
-//
-// ===========================================================================
-//
-// SIMD support
-//
-// The JPEG decoder will try to automatically use SIMD kernels on x86 when
-// supported by the compiler. For ARM Neon support, you must explicitly
-// request it.
-//
-// (The old do-it-yourself SIMD API is no longer supported in the current
-// code.)
-//
-// On x86, SSE2 will automatically be used when available based on a run-time
-// test; if not, the generic C versions are used as a fall-back. On ARM targets,
-// the typical path is to have separate builds for NEON and non-NEON devices
-// (at least this is true for iOS and Android). Therefore, the NEON support is
-// toggled by a build flag: define STBI_NEON to get NEON loops.
-//
-// If for some reason you do not want to use any of SIMD code, or if
-// you have issues compiling it, you can disable it entirely by
-// defining STBI_NO_SIMD.
-//
-// ===========================================================================
-//
-// HDR image support   (disable by defining STBI_NO_HDR)
-//
-// stb_image supports loading HDR images in general, and currently the Radiance
-// .HDR file format specifically. You can still load any file through the existing
-// interface; if you attempt to load an HDR file, it will be automatically remapped
-// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
-// both of these constants can be reconfigured through this interface:
-//
-//     stbi_hdr_to_ldr_gamma(2.2f);
-//     stbi_hdr_to_ldr_scale(1.0f);
-//
-// (note, do not use _inverse_ constants; stbi_image will invert them
-// appropriately).
-//
-// Additionally, there is a new, parallel interface for loading files as
-// (linear) floats to preserve the full dynamic range:
-//
-//    float *data = stbi_loadf(filename, &x, &y, &n, 0);
-//
-// If you load LDR images through this interface, those images will
-// be promoted to floating point values, run through the inverse of
-// constants corresponding to the above:
-//
-//     stbi_ldr_to_hdr_scale(1.0f);
-//     stbi_ldr_to_hdr_gamma(2.2f);
-//
-// Finally, given a filename (or an open file or memory block--see header
-// file for details) containing image data, you can query for the "most
-// appropriate" interface to use (that is, whether the image is HDR or
-// not), using:
-//
-//     stbi_is_hdr(char *filename);
-//
-// ===========================================================================
-//
-// iPhone PNG support:
-//
-// We optionally support converting iPhone-formatted PNGs (which store
-// premultiplied BGRA) back to RGB, even though they're internally encoded
-// differently. To enable this conversion, call
-// stbi_convert_iphone_png_to_rgb(1).
-//
-// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per
-// pixel to remove any premultiplied alpha *only* if the image file explicitly
-// says there's premultiplied data (currently only happens in iPhone images,
-// and only if iPhone convert-to-rgb processing is on).
-//
-// ===========================================================================
-//
-// ADDITIONAL CONFIGURATION
-//
-//  - You can suppress implementation of any of the decoders to reduce
-//    your code footprint by #defining one or more of the following
-//    symbols before creating the implementation.
-//
-//        STBI_NO_JPEG
-//        STBI_NO_PNG
-//        STBI_NO_BMP
-//        STBI_NO_PSD
-//        STBI_NO_TGA
-//        STBI_NO_GIF
-//        STBI_NO_HDR
-//        STBI_NO_PIC
-//        STBI_NO_PNM   (.ppm and .pgm)
-//
-//  - You can request *only* certain decoders and suppress all other ones
-//    (this will be more forward-compatible, as addition of new decoders
-//    doesn't require you to disable them explicitly):
-//
-//        STBI_ONLY_JPEG
-//        STBI_ONLY_PNG
-//        STBI_ONLY_BMP
-//        STBI_ONLY_PSD
-//        STBI_ONLY_TGA
-//        STBI_ONLY_GIF
-//        STBI_ONLY_HDR
-//        STBI_ONLY_PIC
-//        STBI_ONLY_PNM   (.ppm and .pgm)
-//
-//   - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still
-//     want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB
-//
-//  - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater
-//    than that size (in either width or height) without further processing.
-//    This is to let programs in the wild set an upper bound to prevent
-//    denial-of-service attacks on untrusted data, as one could generate a
-//    valid image of gigantic dimensions and force stb_image to allocate a
-//    huge block of memory and spend disproportionate time decoding it. By
-//    default this is set to (1 << 24), which is 16777216, but that's still
-//    very big.
-
 #ifndef STBI_NO_STDIO
 #include <stdio.h>
-#endif // STBI_NO_STDIO
+#endif
 
 #define STBI_VERSION 1
 
 enum
 {
-   STBI_default = 0, // only used for desired_channels
+   STBI_default = 0,
 
    STBI_grey       = 1,
    STBI_grey_alpha = 2,
@@ -399,34 +33,20 @@ extern "C" {
 #endif
 #endif
 
-//////////////////////////////////////////////////////////////////////////////
-//
-// PRIMARY API - works on images of any type
-//
-
-//
-// load image by filename, open file, or memory buffer
-//
-
 typedef struct
 {
-   int      (*read)  (void *user,char *data,int size);   // fill 'data' with 'size' bytes.  return number of bytes actually read
-   void     (*skip)  (void *user,int n);                 // skip the next 'n' bytes, or 'unget' the last -n bytes if negative
-   int      (*eof)   (void *user);                       // returns nonzero if we are at end of file/data
+   int      (*read)  (void *user,char *data,int size);
+   void     (*skip)  (void *user,int n);
+   int      (*eof)   (void *user);
 } stbi_io_callbacks;
 
-////////////////////////////////////
-//
-// 8-bits-per-channel interface
-//
-
 STBIDEF stbi_uc *stbi_load_from_memory   (stbi_uc           const *buffer, int len   , int *x, int *y, int *channels_in_file, int desired_channels);
 STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk  , void *user, int *x, int *y, int *channels_in_file, int desired_channels);
 
 #ifndef STBI_NO_STDIO
 STBIDEF stbi_uc *stbi_load            (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
 STBIDEF stbi_uc *stbi_load_from_file  (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
-// for stbi_load_from_file, file pointer is left pointing immediately after image
+
 #endif
 
 #ifndef STBI_NO_GIF
@@ -437,11 +57,6 @@ STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int *
 STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);
 #endif
 
-////////////////////////////////////
-//
-// 16-bits-per-channel interface
-//
-
 STBIDEF stbi_us *stbi_load_16_from_memory   (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
 STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels);
 
@@ -450,10 +65,6 @@ STBIDEF stbi_us *stbi_load_16          (char const *filename, int *x, int *y, in
 STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
 #endif
 
-////////////////////////////////////
-//
-// float-per-channel interface
-//
 #ifndef STBI_NO_LINEAR
    STBIDEF float *stbi_loadf_from_memory     (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
    STBIDEF float *stbi_loadf_from_callbacks  (stbi_io_callbacks const *clbk, void *user, int *x, int *y,  int *channels_in_file, int desired_channels);
@@ -467,30 +78,24 @@ STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_i
 #ifndef STBI_NO_HDR
    STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma);
    STBIDEF void   stbi_hdr_to_ldr_scale(float scale);
-#endif // STBI_NO_HDR
+#endif
 
 #ifndef STBI_NO_LINEAR
    STBIDEF void   stbi_ldr_to_hdr_gamma(float gamma);
    STBIDEF void   stbi_ldr_to_hdr_scale(float scale);
-#endif // STBI_NO_LINEAR
+#endif
 
-// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR
 STBIDEF int    stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);
 STBIDEF int    stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
 #ifndef STBI_NO_STDIO
 STBIDEF int      stbi_is_hdr          (char const *filename);
 STBIDEF int      stbi_is_hdr_from_file(FILE *f);
-#endif // STBI_NO_STDIO
-
+#endif
 
-// get a VERY brief reason for failure
-// on most compilers (and ALL modern mainstream compilers) this is threadsafe
 STBIDEF const char *stbi_failure_reason  (void);
 
-// free the loaded image -- this is just free()
 STBIDEF void     stbi_image_free      (void *retval_from_stbi_load);
 
-// get image dimensions & components without fully decoding
 STBIDEF int      stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
 STBIDEF int      stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);
 STBIDEF int      stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len);
@@ -503,29 +108,16 @@ STBIDEF int      stbi_is_16_bit          (char const *filename);
 STBIDEF int      stbi_is_16_bit_from_file(FILE *f);
 #endif
 
-
-
-// for image formats that explicitly notate that they have premultiplied alpha,
-// we just return the colors as stored in the file. set this flag to force
-// unpremultiplication. results are undefined if the unpremultiply overflow.
 STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);
 
-// indicate whether we should process iphone images back to canonical format,
-// or just pass them through "as-is"
 STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);
 
-// flip the image vertically, so the first pixel in the output array is the bottom left
 STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip);
 
-// as above, but only applies to images loaded on the thread that calls the function
-// this function is only available if your compiler supports thread-local variables;
-// calling it will fail to link if your compiler doesn't
 STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply);
 STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert);
 STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip);
 
-// ZLIB client - used by PNG, available for other purposes
-
 STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
 STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header);
 STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
@@ -534,15 +126,11 @@ STBIDEF int   stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuff
 STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
 STBIDEF int   stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
 
-
 #ifdef __cplusplus
 }
 #endif
 
-//
-//
-////   end header file   /////////////////////////////////////////////////////
-#endif // STBI_INCLUDE_STB_IMAGE_H
+#endif
 
 #ifdef STB_IMAGE_IMPLEMENTATION
 
@@ -583,15 +171,14 @@ STBIDEF int   stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const ch
 #define STBI_NO_ZLIB
 #endif
 
-
 #include <stdarg.h>
-#include <stddef.h> // ptrdiff_t on osx
+#include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 #include <limits.h>
 
 #if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
-#include <math.h>  // ldexp, pow
+#include <math.h>
 #endif
 
 #ifndef STBI_NO_STDIO
@@ -609,7 +196,6 @@ STBIDEF int   stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const ch
 #define STBI_EXTERN extern
 #endif
 
-
 #ifndef _MSC_VER
    #ifdef __cplusplus
    #define stbi_inline inline
@@ -651,7 +237,6 @@ typedef uint32_t stbi__uint32;
 typedef int32_t  stbi__int32;
 #endif
 
-// should produce compiler error if size is wrong
 typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
 
 #ifdef _MSC_VER
@@ -671,9 +256,9 @@ typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
 #endif
 
 #if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))
-// ok
+
 #elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED)
-// ok
+
 #else
 #error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)."
 #endif
@@ -688,7 +273,6 @@ typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
 #define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)
 #endif
 
-// x86/x64 detection
 #if defined(__x86_64__) || defined(_M_X64)
 #define STBI__X64_TARGET
 #elif defined(__i386) || defined(_M_IX86)
@@ -696,28 +280,12 @@ typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
 #endif
 
 #if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)
-// gcc doesn't support sse2 intrinsics unless you compile with -msse2,
-// which in turn means it gets to use SSE2 everywhere. This is unfortunate,
-// but previous attempts to provide the SSE2 functions with runtime
-// detection caused numerous issues. The way architecture extensions are
-// exposed in GCC/Clang is, sadly, not really suited for one-file libs.
-// New behavior: if compiled with -msse2, we use SSE2 without any
-// detection; if not, we don't use it at all.
+
 #define STBI_NO_SIMD
 #endif
 
 #if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)
-// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET
-//
-// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the
-// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant.
-// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not
-// simultaneously enabling "-mstackrealign".
-//
-// See https://github.com/nothings/stb/issues/81 for more information.
-//
-// So default to no SSE2 on 32-bit MinGW. If you've read this far and added
-// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2.
+
 #define STBI_NO_SIMD
 #endif
 
@@ -727,8 +295,8 @@ typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
 
 #ifdef _MSC_VER
 
-#if _MSC_VER >= 1400  // not VC6
-#include <intrin.h> // __cpuid
+#if _MSC_VER >= 1400
+#include <intrin.h>
 static int stbi__cpuid3(void)
 {
    int info[4];
@@ -758,15 +326,13 @@ static int stbi__sse2_available(void)
 }
 #endif
 
-#else // assume GCC-style if not VC++
+#else
 #define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
 
 #if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
 static int stbi__sse2_available(void)
 {
-   // If we're even attempting to compile this on GCC/Clang, that means
-   // -msse2 is on, which means the compiler is allowed to use SSE2
-   // instructions at will, and so are we.
+
    return 1;
 }
 #endif
@@ -774,7 +340,6 @@ static int stbi__sse2_available(void)
 #endif
 #endif
 
-// ARM NEON
 #if defined(STBI_NO_SIMD) && defined(STBI_NEON)
 #undef STBI_NEON
 #endif
@@ -796,12 +361,6 @@ static int stbi__sse2_available(void)
 #define STBI_MAX_DIMENSIONS (1 << 24)
 #endif
 
-///////////////////////////////////////////////
-//
-//  stbi__context struct and start_xxx functions
-
-// stbi__context structure is our basic context used by all images, so it
-// contains all the IO context, plus some basic image information
 typedef struct
 {
    stbi__uint32 img_x, img_y;
@@ -819,10 +378,8 @@ typedef struct
    stbi_uc *img_buffer_original, *img_buffer_original_end;
 } stbi__context;
 
-
 static void stbi__refill_buffer(stbi__context *s);
 
-// initialize a memory-decode context
 static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)
 {
    s->io.read = NULL;
@@ -832,7 +389,6 @@ static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)
    s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len;
 }
 
-// initialize a callback-based context
 static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)
 {
    s->io = *c;
@@ -856,9 +412,9 @@ static void stbi__stdio_skip(void *user, int n)
 {
    int ch;
    fseek((FILE*) user, n, SEEK_CUR);
-   ch = fgetc((FILE*) user);  /* have to read a byte to reset feof()'s flag */
+   ch = fgetc((FILE*) user);
    if (ch != EOF) {
-      ungetc(ch, (FILE *) user);  /* push byte back onto stream if valid. */
+      ungetc(ch, (FILE *) user);
    }
 }
 
@@ -879,15 +435,11 @@ static void stbi__start_file(stbi__context *s, FILE *f)
    stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f);
 }
 
-//static void stop_file(stbi__context *s) { }
-
-#endif // !STBI_NO_STDIO
+#endif
 
 static void stbi__rewind(stbi__context *s)
 {
-   // conceptually rewind SHOULD rewind to the beginning of the stream,
-   // but we just rewind to the beginning of the initial buffer, because
-   // we only use it after doing 'test', which only ever looks at at most 92 bytes
+
    s->img_buffer = s->img_buffer_original;
    s->img_buffer_end = s->img_buffer_original_end;
 }
@@ -987,54 +539,35 @@ static void *stbi__malloc(size_t size)
     return STBI_MALLOC(size);
 }
 
-// stb_image uses ints pervasively, including for offset calculations.
-// therefore the largest decoded image size we can support with the
-// current code, even on 64-bit targets, is INT_MAX. this is not a
-// significant limitation for the intended use case.
-//
-// we do, however, need to make sure our size calculations don't
-// overflow. hence a few helper functions for size calculations that
-// multiply integers together, making sure that they're non-negative
-// and no overflow occurs.
-
-// return 1 if the sum is valid, 0 on overflow.
-// negative terms are considered invalid.
 static int stbi__addsizes_valid(int a, int b)
 {
    if (b < 0) return 0;
-   // now 0 <= b <= INT_MAX, hence also
-   // 0 <= INT_MAX - b <= INTMAX.
-   // And "a + b <= INT_MAX" (which might overflow) is the
-   // same as a <= INT_MAX - b (no overflow)
+
    return a <= INT_MAX - b;
 }
 
-// returns 1 if the product is valid, 0 on overflow.
-// negative factors are considered invalid.
 static int stbi__mul2sizes_valid(int a, int b)
 {
    if (a < 0 || b < 0) return 0;
-   if (b == 0) return 1; // mul-by-0 is always safe
-   // portable way to check for no overflows in a*b
+   if (b == 0) return 1;
+
    return a <= INT_MAX/b;
 }
 
 #if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
-// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow
+
 static int stbi__mad2sizes_valid(int a, int b, int add)
 {
    return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add);
 }
 #endif
 
-// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow
 static int stbi__mad3sizes_valid(int a, int b, int c, int add)
 {
    return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
       stbi__addsizes_valid(a*b*c, add);
 }
 
-// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow
 #if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)
 static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)
 {
@@ -1044,7 +577,7 @@ static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)
 #endif
 
 #if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
-// mallocs with size overflow checking
+
 static void *stbi__malloc_mad2(int a, int b, int add)
 {
    if (!stbi__mad2sizes_valid(a, b, add)) return NULL;
@@ -1066,27 +599,21 @@ static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)
 }
 #endif
 
-// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow.
 static int stbi__addints_valid(int a, int b)
 {
-   if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow
-   if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0.
+   if ((a >= 0) != (b >= 0)) return 1;
+   if (a < 0 && b < 0) return a >= INT_MIN - b;
    return a <= INT_MAX - b;
 }
 
-// returns 1 if the product of two ints fits in a signed short, 0 on overflow.
 static int stbi__mul2shorts_valid(int a, int b)
 {
-   if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow
-   if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid
-   if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN
+   if (b == 0 || b == -1) return 1;
+   if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b;
+   if (b < 0) return a <= SHRT_MIN / b;
    return a >= SHRT_MIN / b;
 }
 
-// stbi__err - error
-// stbi__errpf - error returning pointer to float
-// stbi__errpuc - error returning pointer to unsigned char
-
 #ifdef STBI_NO_FAILURE_STRINGS
    #define stbi__err(x,y)  0
 #elif defined(STBI_FAILURE_USERMSG)
@@ -1132,17 +659,15 @@ STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_fli
 #define stbi__vertically_flip_on_load  (stbi__vertically_flip_on_load_set       \
                                          ? stbi__vertically_flip_on_load_local  \
                                          : stbi__vertically_flip_on_load_global)
-#endif // STBI_THREAD_LOCAL
+#endif
 
 static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
 {
-   memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields
-   ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed
-   ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order
+   memset(ri, 0, sizeof(*ri));
+   ri->bits_per_channel = 8;
+   ri->channel_order = STBI_ORDER_RGB;
    ri->num_channels = 0;
 
-   // test the formats with a very explicit header first (at least a FOURCC
-   // or distinctive magic number first)
    #ifndef STBI_NO_PNG
    if (stbi__png_test(s))  return stbi__png_load(s,x,y,comp,req_comp, ri);
    #endif
@@ -1161,9 +686,6 @@ static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int re
    if (stbi__pic_test(s))  return stbi__pic_load(s,x,y,comp,req_comp, ri);
    #endif
 
-   // then the formats that can end up attempting to load with just 1 or 2
-   // bytes matching expectations; these are prone to false positives, so
-   // try them later
    #ifndef STBI_NO_JPEG
    if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri);
    #endif
@@ -1179,7 +701,7 @@ static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int re
    #endif
 
    #ifndef STBI_NO_TGA
-   // test tga last because it's a crappy test!
+
    if (stbi__tga_test(s))
       return stbi__tga_load(s,x,y,comp,req_comp, ri);
    #endif
@@ -1197,7 +719,7 @@ static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int chan
    if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory");
 
    for (i = 0; i < img_len; ++i)
-      reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling
+      reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF);
 
    STBI_FREE(orig);
    return reduced;
@@ -1213,7 +735,7 @@ static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int chan
    if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
 
    for (i = 0; i < img_len; ++i)
-      enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff
+      enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]);
 
    STBI_FREE(orig);
    return enlarged;
@@ -1229,7 +751,7 @@ static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)
    for (row = 0; row < (h>>1); row++) {
       stbi_uc *row0 = bytes + row*bytes_per_row;
       stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row;
-      // swap row0 with row1
+
       size_t bytes_left = bytes_per_row;
       while (bytes_left) {
          size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp);
@@ -1265,7 +787,6 @@ static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x,
    if (result == NULL)
       return NULL;
 
-   // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
    STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
 
    if (ri.bits_per_channel != 8) {
@@ -1273,8 +794,6 @@ static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x,
       ri.bits_per_channel = 8;
    }
 
-   // @TODO: move stbi__convert_format to here
-
    if (stbi__vertically_flip_on_load) {
       int channels = req_comp ? req_comp : *comp;
       stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc));
@@ -1291,7 +810,6 @@ static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x,
    if (result == NULL)
       return NULL;
 
-   // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
    STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
 
    if (ri.bits_per_channel != 16) {
@@ -1299,9 +817,6 @@ static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x,
       ri.bits_per_channel = 16;
    }
 
-   // @TODO: move stbi__convert_format16 to here
-   // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision
-
    if (stbi__vertically_flip_on_load) {
       int channels = req_comp ? req_comp : *comp;
       stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16));
@@ -1330,7 +845,7 @@ STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int
 #if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
 STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)
 {
-	return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);
+	return WideCharToMultiByte(65001 , 0, input, -1, buffer, (int) bufferlen, NULL, NULL);
 }
 #endif
 
@@ -1340,10 +855,10 @@ static FILE *stbi__fopen(char const *filename, char const *mode)
 #if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
    wchar_t wMode[64];
    wchar_t wFilename[1024];
-	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename)))
+	if (0 == MultiByteToWideChar(65001 , 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename)))
       return 0;
 
-	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode)))
+	if (0 == MultiByteToWideChar(65001 , 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode)))
       return 0;
 
 #if defined(_MSC_VER) && _MSC_VER >= 1400
@@ -1362,7 +877,6 @@ static FILE *stbi__fopen(char const *filename, char const *mode)
    return f;
 }
 
-
 STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
 {
    FILE *f = stbi__fopen(filename, "rb");
@@ -1380,7 +894,7 @@ STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req
    stbi__start_file(&s,f);
    result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
    if (result) {
-      // need to 'unget' all the characters in the IO buffer
+
       fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
    }
    return result;
@@ -1393,7 +907,7 @@ STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp,
    stbi__start_file(&s,f);
    result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);
    if (result) {
-      // need to 'unget' all the characters in the IO buffer
+
       fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
    }
    return result;
@@ -1409,8 +923,7 @@ STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, i
    return result;
 }
 
-
-#endif //!STBI_NO_STDIO
+#endif
 
 STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)
 {
@@ -1506,13 +1019,9 @@ STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_
    stbi__start_file(&s,f);
    return stbi__loadf_main(&s,x,y,comp,req_comp);
 }
-#endif // !STBI_NO_STDIO
-
-#endif // !STBI_NO_LINEAR
+#endif
 
-// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is
-// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always
-// reports false!
+#endif
 
 STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
 {
@@ -1554,7 +1063,7 @@ STBIDEF int stbi_is_hdr_from_file(FILE *f)
    return 0;
    #endif
 }
-#endif // !STBI_NO_STDIO
+#endif
 
 STBIDEF int      stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)
 {
@@ -1581,12 +1090,6 @@ static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;
 STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }
 STBIDEF void   stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }
 
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// Common code used by all image loaders
-//
-
 enum
 {
    STBI__SCAN_load=0,
@@ -1599,8 +1102,7 @@ static void stbi__refill_buffer(stbi__context *s)
    int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
    s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original);
    if (n == 0) {
-      // at end of file, treat same as if from memory, but need to handle case
-      // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file
+
       s->read_from_callbacks = 0;
       s->img_buffer = s->buffer_start;
       s->img_buffer_end = s->buffer_start+1;
@@ -1623,14 +1125,13 @@ stbi_inline static stbi_uc stbi__get8(stbi__context *s)
 }
 
 #if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
-// nothing
+
 #else
 stbi_inline static int stbi__at_eof(stbi__context *s)
 {
    if (s->io.read) {
       if (!(s->io.eof)(s->io_user_data)) return 0;
-      // if feof() is true, check if buffer = end
-      // special case: we've only got the special 0 character at the end
+
       if (s->read_from_callbacks == 0) return 1;
    }
 
@@ -1639,11 +1140,11 @@ stbi_inline static int stbi__at_eof(stbi__context *s)
 #endif
 
 #if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC)
-// nothing
+
 #else
 static void stbi__skip(stbi__context *s, int n)
 {
-   if (n == 0) return;  // already there!
+   if (n == 0) return;
    if (n < 0) {
       s->img_buffer = s->img_buffer_end;
       return;
@@ -1661,7 +1162,7 @@ static void stbi__skip(stbi__context *s, int n)
 #endif
 
 #if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM)
-// nothing
+
 #else
 static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
 {
@@ -1689,7 +1190,7 @@ static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
 #endif
 
 #if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
-// nothing
+
 #else
 static int stbi__get16be(stbi__context *s)
 {
@@ -1699,7 +1200,7 @@ static int stbi__get16be(stbi__context *s)
 #endif
 
 #if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
-// nothing
+
 #else
 static stbi__uint32 stbi__get32be(stbi__context *s)
 {
@@ -1709,7 +1210,7 @@ static stbi__uint32 stbi__get32be(stbi__context *s)
 #endif
 
 #if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)
-// nothing
+
 #else
 static int stbi__get16le(stbi__context *s)
 {
@@ -1727,21 +1228,11 @@ static stbi__uint32 stbi__get32le(stbi__context *s)
 }
 #endif
 
-#define STBI__BYTECAST(x)  ((stbi_uc) ((x) & 255))  // truncate int to byte without warnings
+#define STBI__BYTECAST(x)  ((stbi_uc) ((x) & 255))
 
 #if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
-// nothing
+
 #else
-//////////////////////////////////////////////////////////////////////////////
-//
-//  generic converter from built-in img_n to req_comp
-//    individual types do this automatically as much as possible (e.g. jpeg
-//    does all cases internally since it needs to colorspace convert anyway,
-//    and it never has alpha, so very few cases ). png can automatically
-//    interleave an alpha=255 channel, but falls back to this for other cases
-//
-//  assume data buffer is malloced, so malloc a new one and free that one
-//  only failure mode is malloc failing
 
 static stbi_uc stbi__compute_y(int r, int g, int b)
 {
@@ -1750,7 +1241,7 @@ static stbi_uc stbi__compute_y(int r, int g, int b)
 #endif
 
 #if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
-// nothing
+
 #else
 static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
 {
@@ -1772,8 +1263,7 @@ static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int r
 
       #define STBI__COMBO(a,b)  ((a)*8+(b))
       #define STBI__CASE(a,b)   case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
-      // convert source image with img_n components to one with req_comp components;
-      // avoid switch per pixel, so use switch per scanline and massive macros
+
       switch (STBI__COMBO(img_n, req_comp)) {
          STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255;                                     } break;
          STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                  } break;
@@ -1798,7 +1288,7 @@ static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int r
 #endif
 
 #if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
-// nothing
+
 #else
 static stbi__uint16 stbi__compute_y_16(int r, int g, int b)
 {
@@ -1807,7 +1297,7 @@ static stbi__uint16 stbi__compute_y_16(int r, int g, int b)
 #endif
 
 #if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
-// nothing
+
 #else
 static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)
 {
@@ -1829,8 +1319,7 @@ static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int r
 
       #define STBI__COMBO(a,b)  ((a)*8+(b))
       #define STBI__CASE(a,b)   case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
-      // convert source image with img_n components to one with req_comp components;
-      // avoid switch per pixel, so use switch per scanline and massive macros
+
       switch (STBI__COMBO(img_n, req_comp)) {
          STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff;                                     } break;
          STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                     } break;
@@ -1862,7 +1351,7 @@ static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
    if (!data) return NULL;
    output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0);
    if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); }
-   // compute number of non-alpha components
+
    if (comp & 1) n = comp; else n = comp-1;
    for (i=0; i < x*y; ++i) {
       for (k=0; k < n; ++k) {
@@ -1888,7 +1377,7 @@ static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp)
    if (!data) return NULL;
    output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0);
    if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); }
-   // compute number of non-alpha components
+
    if (comp & 1) n = comp; else n = comp-1;
    for (i=0; i < x*y; ++i) {
       for (k=0; k < n; ++k) {
@@ -1909,41 +1398,19 @@ static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp)
 }
 #endif
 
-//////////////////////////////////////////////////////////////////////////////
-//
-//  "baseline" JPEG/JFIF decoder
-//
-//    simple implementation
-//      - doesn't support delayed output of y-dimension
-//      - simple interface (only one output format: 8-bit interleaved RGB)
-//      - doesn't try to recover corrupt jpegs
-//      - doesn't allow partial loading, loading multiple at once
-//      - still fast on x86 (copying globals into locals doesn't help x86)
-//      - allocates lots of intermediate memory (full size of all components)
-//        - non-interleaved case requires this anyway
-//        - allows good upsampling (see next)
-//    high-quality
-//      - upsampled channels are bilinearly interpolated, even across blocks
-//      - quality integer IDCT derived from IJG's 'slow'
-//    performance
-//      - fast huffman; reasonable integer IDCT
-//      - some SIMD kernels for common paths on targets with SSE2/NEON
-//      - uses a lot of intermediate memory, could cache poorly
-
 #ifndef STBI_NO_JPEG
 
-// huffman decoding acceleration
-#define FAST_BITS   9  // larger handles more cases; smaller stomps less cache
+#define FAST_BITS   9
 
 typedef struct
 {
    stbi_uc  fast[1 << FAST_BITS];
-   // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
+
    stbi__uint16 code[256];
    stbi_uc  values[256];
    stbi_uc  size[257];
    unsigned int maxcode[18];
-   int    delta[17];   // old 'firstsymbol' - old 'firstcode'
+   int    delta[17];
 } stbi__huffman;
 
 typedef struct
@@ -1954,12 +1421,10 @@ typedef struct
    stbi__uint16 dequant[4][64];
    stbi__int16 fast_ac[4][1 << FAST_BITS];
 
-// sizes for components, interleaved MCUs
    int img_h_max, img_v_max;
    int img_mcu_x, img_mcu_y;
    int img_mcu_w, img_mcu_h;
 
-// definition of jpeg image component
    struct
    {
       int id;
@@ -1972,14 +1437,14 @@ typedef struct
       stbi_uc *data;
       void *raw_data, *raw_coeff;
       stbi_uc *linebuf;
-      short   *coeff;   // progressive only
-      int      coeff_w, coeff_h; // number of 8x8 coefficient blocks
+      short   *coeff;
+      int      coeff_w, coeff_h;
    } img_comp[4];
 
-   stbi__uint32   code_buffer; // jpeg entropy-coded buffer
-   int            code_bits;   // number of valid bits
-   unsigned char  marker;      // marker seen while filling entropy buffer
-   int            nomore;      // flag if we saw a marker so must stop
+   stbi__uint32   code_buffer;
+   int            code_bits;
+   unsigned char  marker;
+   int            nomore;
 
    int            progressive;
    int            spec_start;
@@ -1988,13 +1453,12 @@ typedef struct
    int            succ_low;
    int            eob_run;
    int            jfif;
-   int            app14_color_transform; // Adobe APP14 tag
+   int            app14_color_transform;
    int            rgb;
 
    int scan_n, order[4];
    int restart_interval, todo;
 
-// kernels
    void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]);
    void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step);
    stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs);
@@ -2004,7 +1468,7 @@ static int stbi__build_huffman(stbi__huffman *h, int *count)
 {
    int i,j,k=0;
    unsigned int code;
-   // build size list for each symbol (from JPEG spec)
+
    for (i=0; i < 16; ++i) {
       for (j=0; j < count[i]; ++j) {
          h->size[k++] = (stbi_uc) (i+1);
@@ -2013,24 +1477,22 @@ static int stbi__build_huffman(stbi__huffman *h, int *count)
    }
    h->size[k] = 0;
 
-   // compute actual symbols (from jpeg spec)
    code = 0;
    k = 0;
    for(j=1; j <= 16; ++j) {
-      // compute delta to add to code to compute symbol id
+
       h->delta[j] = k - code;
       if (h->size[k] == j) {
          while (h->size[k] == j)
             h->code[k++] = (stbi__uint16) (code++);
          if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG");
       }
-      // compute largest code + 1 for this size, preshifted as needed later
+
       h->maxcode[j] = code << (16-j);
       code <<= 1;
    }
    h->maxcode[j] = 0xffffffff;
 
-   // build non-spec acceleration table; 255 is flag for not-accelerated
    memset(h->fast, 255, 1 << FAST_BITS);
    for (i=0; i < k; ++i) {
       int s = h->size[i];
@@ -2045,8 +1507,6 @@ static int stbi__build_huffman(stbi__huffman *h, int *count)
    return 1;
 }
 
-// build a table that decodes both magnitude and value of small ACs in
-// one go.
 static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)
 {
    int i;
@@ -2060,11 +1520,11 @@ static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)
          int len = h->size[fast];
 
          if (magbits && len + magbits <= FAST_BITS) {
-            // magnitude code followed by receive_extend code
+
             int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);
             int m = 1 << (magbits - 1);
             if (k < m) k += (~0U << magbits) + 1;
-            // if the result is small enough, we can fit it in fast_ac table
+
             if (k >= -128 && k <= 127)
                fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits));
          }
@@ -2078,7 +1538,7 @@ static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
       unsigned int b = j->nomore ? 0 : stbi__get8(j->s);
       if (b == 0xff) {
          int c = stbi__get8(j->s);
-         while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes
+         while (c == 0xff) c = stbi__get8(j->s);
          if (c != 0) {
             j->marker = (unsigned char) c;
             j->nomore = 1;
@@ -2090,10 +1550,8 @@ static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
    } while (j->code_bits <= 24);
 }
 
-// (1 << n) - 1
 static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
 
-// decode a jpeg huffman value from the bitstream
 stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
 {
    unsigned int temp;
@@ -2101,8 +1559,6 @@ stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
 
    if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
 
-   // look at the top FAST_BITS and determine what symbol ID it is,
-   // if the code is <= FAST_BITS
    c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
    k = h->fast[c];
    if (k < 255) {
@@ -2114,18 +1570,12 @@ stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
       return h->values[k];
    }
 
-   // naive test is to shift the code_buffer down so k bits are
-   // valid, then test against maxcode. To speed this up, we've
-   // preshifted maxcode left so that it has (16-k) 0s at the
-   // end; in other words, regardless of the number of bits, it
-   // wants to be compared against something shifted to have 16;
-   // that way we don't need to shift inside the loop.
    temp = j->code_buffer >> 16;
    for (k=FAST_BITS+1 ; ; ++k)
       if (temp < h->maxcode[k])
          break;
    if (k == 17) {
-      // error! code not found
+
       j->code_bits -= 16;
       return -1;
    }
@@ -2133,31 +1583,26 @@ stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
    if (k > j->code_bits)
       return -1;
 
-   // convert the huffman code to the symbol id
    c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];
-   if(c < 0 || c >= 256) // symbol id out of bounds!
+   if(c < 0 || c >= 256)
        return -1;
    STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);
 
-   // convert the id to a symbol
    j->code_bits -= k;
    j->code_buffer <<= k;
    return h->values[c];
 }
 
-// bias[n] = (-1<<n) + 1
 static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};
 
-// combined JPEG 'receive' and JPEG 'extend', since baseline
-// always extends everything it receives.
 stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
 {
    unsigned int k;
    int sgn;
    if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
-   if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing
+   if (j->code_bits < n) return 0;
 
-   sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative)
+   sgn = j->code_buffer >> 31;
    k = stbi_lrot(j->code_buffer, n);
    j->code_buffer = k & ~stbi__bmask[n];
    k &= stbi__bmask[n];
@@ -2165,12 +1610,11 @@ stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
    return k + (stbi__jbias[n] & (sgn - 1));
 }
 
-// get some unsigned bits
 stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)
 {
    unsigned int k;
    if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
-   if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing
+   if (j->code_bits < n) return 0;
    k = stbi_lrot(j->code_buffer, n);
    j->code_buffer = k & ~stbi__bmask[n];
    k &= stbi__bmask[n];
@@ -2182,15 +1626,13 @@ stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)
 {
    unsigned int k;
    if (j->code_bits < 1) stbi__grow_buffer_unsafe(j);
-   if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing
+   if (j->code_bits < 1) return 0;
    k = j->code_buffer;
    j->code_buffer <<= 1;
    --j->code_bits;
    return k & 0x80000000;
 }
 
-// given a value that's at position X in the zigzag stream,
-// where does it appear in the 8x8 matrix coded as row-major?
 static const stbi_uc stbi__jpeg_dezigzag[64+15] =
 {
     0,  1,  8, 16,  9,  2,  3, 10,
@@ -2201,12 +1643,11 @@ static const stbi_uc stbi__jpeg_dezigzag[64+15] =
    29, 22, 15, 23, 30, 37, 44, 51,
    58, 59, 52, 45, 38, 31, 39, 46,
    53, 60, 61, 54, 47, 55, 62, 63,
-   // let corrupt input sample past end
+
    63, 63, 63, 63, 63, 63, 63, 63,
    63, 63, 63, 63, 63, 63, 63
 };
 
-// decode one 64-entry block--
 static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)
 {
    int diff,dc,k;
@@ -2216,7 +1657,6 @@ static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman
    t = stbi__jpeg_huff_decode(j, hdc);
    if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG");
 
-   // 0 all the ac values now so we can do it 32-bits at a time
    memset(data,0,64*sizeof(data[0]));
 
    diff = t ? stbi__extend_receive(j, t) : 0;
@@ -2226,7 +1666,6 @@ static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman
    if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
    data[0] = (short) (dc * dequant[0]);
 
-   // decode AC components, see JPEG spec
    k = 1;
    do {
       unsigned int zig;
@@ -2234,13 +1673,13 @@ static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman
       if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
       c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
       r = fac[c];
-      if (r) { // fast-AC path
-         k += (r >> 4) & 15; // run
-         s = r & 15; // combined length
+      if (r) {
+         k += (r >> 4) & 15;
+         s = r & 15;
          if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");
          j->code_buffer <<= s;
          j->code_bits -= s;
-         // decode into unzigzag'd location
+
          zig = stbi__jpeg_dezigzag[k++];
          data[zig] = (short) ((r >> 8) * dequant[zig]);
       } else {
@@ -2249,11 +1688,11 @@ static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman
          s = rs & 15;
          r = rs >> 4;
          if (s == 0) {
-            if (rs != 0xf0) break; // end block
+            if (rs != 0xf0) break;
             k += 16;
          } else {
             k += r;
-            // decode into unzigzag'd location
+
             zig = stbi__jpeg_dezigzag[k++];
             data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]);
          }
@@ -2271,8 +1710,8 @@ static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__
    if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
 
    if (j->succ_high == 0) {
-      // first scan for DC coefficient, must be first
-      memset(data,0,64*sizeof(data[0])); // 0 all the ac values now
+
+      memset(data,0,64*sizeof(data[0]));
       t = stbi__jpeg_huff_decode(j, hdc);
       if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
       diff = t ? stbi__extend_receive(j, t) : 0;
@@ -2283,15 +1722,13 @@ static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__
       if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
       data[0] = (short) (dc * (1 << j->succ_low));
    } else {
-      // refinement scan for DC coefficient
+
       if (stbi__jpeg_get_bit(j))
          data[0] += (short) (1 << j->succ_low);
    }
    return 1;
 }
 
-// @OPTIMIZE: store non-zigzagged during the decode passes,
-// and only de-zigzag when dequantizing
 static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac)
 {
    int k;
@@ -2312,9 +1749,9 @@ static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__
          if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
          c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
          r = fac[c];
-         if (r) { // fast-AC path
-            k += (r >> 4) & 15; // run
-            s = r & 15; // combined length
+         if (r) {
+            k += (r >> 4) & 15;
+            s = r & 15;
             if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");
             j->code_buffer <<= s;
             j->code_bits -= s;
@@ -2342,7 +1779,6 @@ static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__
          }
       } while (k <= j->spec_end);
    } else {
-      // refinement scan for these AC coefficients
 
       short bit = (short) (1 << j->succ_low);
 
@@ -2363,7 +1799,7 @@ static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__
          k = j->spec_start;
          do {
             int r,s;
-            int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh
+            int rs = stbi__jpeg_huff_decode(j, hac);
             if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
             s = rs & 15;
             r = rs >> 4;
@@ -2372,22 +1808,19 @@ static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__
                   j->eob_run = (1 << r) - 1;
                   if (r)
                      j->eob_run += stbi__jpeg_get_bits(j, r);
-                  r = 64; // force end of block
+                  r = 64;
                } else {
-                  // r=15 s=0 should write 16 0s, so we just do
-                  // a run of 15 0s and then write s (which is 0),
-                  // so we don't have to do anything special here
+
                }
             } else {
                if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG");
-               // sign bit
+
                if (stbi__jpeg_get_bit(j))
                   s = bit;
                else
                   s = -bit;
             }
 
-            // advance by r
             while (k <= j->spec_end) {
                short *p = &data[stbi__jpeg_dezigzag[k++]];
                if (*p != 0) {
@@ -2412,10 +1845,9 @@ static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__
    return 1;
 }
 
-// take a -128..127 value and stbi__clamp it and convert to 0..255
 stbi_inline static stbi_uc stbi__clamp(int x)
 {
-   // trick to use a single test to catch both cases
+
    if ((unsigned int) x > 255) {
       if (x < 0) return 0;
       if (x > 255) return 255;
@@ -2426,7 +1858,6 @@ stbi_inline static stbi_uc stbi__clamp(int x)
 #define stbi__f2f(x)  ((int) (((x) * 4096 + 0.5)))
 #define stbi__fsh(x)  ((x) * 4096)
 
-// derived from jidctint -- DCT_ISLOW
 #define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \
    int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \
    p2 = s2;                                    \
@@ -2470,21 +1901,16 @@ static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])
    stbi_uc *o;
    short *d = data;
 
-   // columns
    for (i=0; i < 8; ++i,++d, ++v) {
-      // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
+
       if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0
            && d[40]==0 && d[48]==0 && d[56]==0) {
-         //    no shortcut                 0     seconds
-         //    (1|2|3|4|5|6|7)==0          0     seconds
-         //    all separate               -0.047 seconds
-         //    1 && 2|3 && 4|5 && 6|7:    -0.047 seconds
+
          int dcterm = d[0]*4;
          v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
       } else {
          STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56])
-         // constants scaled things up by 1<<12; let's bring them back
-         // down, but keep 2 extra bits of precision
+
          x0 += 512; x1 += 512; x2 += 512; x3 += 512;
          v[ 0] = (x0+t3) >> 10;
          v[56] = (x0-t3) >> 10;
@@ -2498,20 +1924,14 @@ static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])
    }
 
    for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {
-      // no fast case since the first 1D IDCT spread components out
+
       STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])
-      // constants scaled things up by 1<<12, plus we had 1<<2 from first
-      // loop, plus horizontal and vertical each scale by sqrt(8) so together
-      // we've got an extra 1<<3, so 1<<17 total we need to remove.
-      // so we want to round that, which means adding 0.5 * 1<<17,
-      // aka 65536. Also, we'll end up with -128 to 127 that we want
-      // to encode as 0..255 by adding 128, so we'll add that before the shift
+
       x0 += 65536 + (128<<17);
       x1 += 65536 + (128<<17);
       x2 += 65536 + (128<<17);
       x3 += 65536 + (128<<17);
-      // tried computing the shifts into temps, or'ing the temps to see
-      // if any were out of range, but that was slower
+
       o[0] = stbi__clamp((x0+t3) >> 17);
       o[7] = stbi__clamp((x0-t3) >> 17);
       o[1] = stbi__clamp((x1+t2) >> 17);
@@ -2524,20 +1944,15 @@ static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])
 }
 
 #ifdef STBI_SSE2
-// sse2 integer IDCT. not the fastest possible implementation but it
-// produces bit-identical results to the generic C version so it's
-// fully "transparent".
+
 static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
 {
-   // This is constructed to match our regular (generic) integer IDCT exactly.
+
    __m128i row0, row1, row2, row3, row4, row5, row6, row7;
    __m128i tmp;
 
-   // dot product constant: even elems=x, odd elems=y
    #define dct_const(x,y)  _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))
 
-   // out(0) = c0[even]*x + c0[odd]*y   (c0, x, y 16-bit, out 32-bit)
-   // out(1) = c1[even]*x + c1[odd]*y
    #define dct_rot(out0,out1, x,y,c0,c1) \
       __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \
       __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \
@@ -2546,22 +1961,18 @@ static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
       __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \
       __m128i out1##_h = _mm_madd_epi16(c0##hi, c1)
 
-   // out = in << 12  (in 16-bit, out 32-bit)
    #define dct_widen(out, in) \
       __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \
       __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)
 
-   // wide add
    #define dct_wadd(out, a, b) \
       __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \
       __m128i out##_h = _mm_add_epi32(a##_h, b##_h)
 
-   // wide sub
    #define dct_wsub(out, a, b) \
       __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \
       __m128i out##_h = _mm_sub_epi32(a##_h, b##_h)
 
-   // butterfly a/b, add bias, then shift by "s" and pack
    #define dct_bfly32o(out0, out1, a,b,bias,s) \
       { \
          __m128i abiased_l = _mm_add_epi32(a##_l, bias); \
@@ -2572,13 +1983,11 @@ static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
          out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \
       }
 
-   // 8-bit interleave step (for transposes)
    #define dct_interleave8(a, b) \
       tmp = a; \
       a = _mm_unpacklo_epi8(a, b); \
       b = _mm_unpackhi_epi8(tmp, b)
 
-   // 16-bit interleave step (for transposes)
    #define dct_interleave16(a, b) \
       tmp = a; \
       a = _mm_unpacklo_epi16(a, b); \
@@ -2586,7 +1995,7 @@ static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
 
    #define dct_pass(bias,shift) \
       { \
-         /* even part */ \
+          \
          dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \
          __m128i sum04 = _mm_add_epi16(row0, row4); \
          __m128i dif04 = _mm_sub_epi16(row0, row4); \
@@ -2596,7 +2005,7 @@ static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
          dct_wsub(x3, t0e, t3e); \
          dct_wadd(x1, t1e, t2e); \
          dct_wsub(x2, t1e, t2e); \
-         /* odd part */ \
+          \
          dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \
          dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \
          __m128i sum17 = _mm_add_epi16(row1, row7); \
@@ -2621,11 +2030,9 @@ static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
    __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f));
    __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f));
 
-   // rounding biases in column/row passes, see stbi__idct_block for explanation.
    __m128i bias_0 = _mm_set1_epi32(512);
    __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17));
 
-   // load
    row0 = _mm_load_si128((const __m128i *) (data + 0*8));
    row1 = _mm_load_si128((const __m128i *) (data + 1*8));
    row2 = _mm_load_si128((const __m128i *) (data + 2*8));
@@ -2635,52 +2042,44 @@ static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
    row6 = _mm_load_si128((const __m128i *) (data + 6*8));
    row7 = _mm_load_si128((const __m128i *) (data + 7*8));
 
-   // column pass
    dct_pass(bias_0, 10);
 
    {
-      // 16bit 8x8 transpose pass 1
+
       dct_interleave16(row0, row4);
       dct_interleave16(row1, row5);
       dct_interleave16(row2, row6);
       dct_interleave16(row3, row7);
 
-      // transpose pass 2
       dct_interleave16(row0, row2);
       dct_interleave16(row1, row3);
       dct_interleave16(row4, row6);
       dct_interleave16(row5, row7);
 
-      // transpose pass 3
       dct_interleave16(row0, row1);
       dct_interleave16(row2, row3);
       dct_interleave16(row4, row5);
       dct_interleave16(row6, row7);
    }
 
-   // row pass
    dct_pass(bias_1, 17);
 
    {
-      // pack
-      __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7
+
+      __m128i p0 = _mm_packus_epi16(row0, row1);
       __m128i p1 = _mm_packus_epi16(row2, row3);
       __m128i p2 = _mm_packus_epi16(row4, row5);
       __m128i p3 = _mm_packus_epi16(row6, row7);
 
-      // 8bit 8x8 transpose pass 1
-      dct_interleave8(p0, p2); // a0e0a1e1...
-      dct_interleave8(p1, p3); // c0g0c1g1...
+      dct_interleave8(p0, p2);
+      dct_interleave8(p1, p3);
 
-      // transpose pass 2
-      dct_interleave8(p0, p1); // a0c0e0g0...
-      dct_interleave8(p2, p3); // b0d0f0h0...
+      dct_interleave8(p0, p1);
+      dct_interleave8(p2, p3);
 
-      // transpose pass 3
-      dct_interleave8(p0, p2); // a0b0c0d0...
-      dct_interleave8(p1, p3); // a4b4c4d4...
+      dct_interleave8(p0, p2);
+      dct_interleave8(p1, p3);
 
-      // store
       _mm_storel_epi64((__m128i *) out, p0); out += out_stride;
       _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride;
       _mm_storel_epi64((__m128i *) out, p2); out += out_stride;
@@ -2702,12 +2101,10 @@ static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
 #undef dct_pass
 }
 
-#endif // STBI_SSE2
+#endif
 
 #ifdef STBI_NEON
 
-// NEON integer IDCT. should produce bit-identical
-// results to the generic C version.
 static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
 {
    int16x8_t row0, row1, row2, row3, row4, row5, row6, row7;
@@ -2737,17 +2134,14 @@ static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
    int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \
    int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)
 
-// wide add
 #define dct_wadd(out, a, b) \
    int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \
    int32x4_t out##_h = vaddq_s32(a##_h, b##_h)
 
-// wide sub
 #define dct_wsub(out, a, b) \
    int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \
    int32x4_t out##_h = vsubq_s32(a##_h, b##_h)
 
-// butterfly a/b, then shift using "shiftop" by "s" and pack
 #define dct_bfly32o(out0,out1, a,b,shiftop,s) \
    { \
       dct_wadd(sum, a, b); \
@@ -2758,7 +2152,7 @@ static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
 
 #define dct_pass(shiftop, shift) \
    { \
-      /* even part */ \
+       \
       int16x8_t sum26 = vaddq_s16(row2, row6); \
       dct_long_mul(p1e, sum26, rot0_0); \
       dct_long_mac(t2e, p1e, row6, rot0_1); \
@@ -2771,7 +2165,7 @@ static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
       dct_wsub(x3, t0e, t3e); \
       dct_wadd(x1, t1e, t2e); \
       dct_wsub(x2, t1e, t2e); \
-      /* odd part */ \
+       \
       int16x8_t sum15 = vaddq_s16(row1, row5); \
       int16x8_t sum17 = vaddq_s16(row1, row7); \
       int16x8_t sum35 = vaddq_s16(row3, row5); \
@@ -2796,7 +2190,6 @@ static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
       dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \
    }
 
-   // load
    row0 = vld1q_s16(data + 0*8);
    row1 = vld1q_s16(data + 1*8);
    row2 = vld1q_s16(data + 2*8);
@@ -2806,34 +2199,27 @@ static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
    row6 = vld1q_s16(data + 6*8);
    row7 = vld1q_s16(data + 7*8);
 
-   // add DC bias
    row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0));
 
-   // column pass
    dct_pass(vrshrn_n_s32, 10);
 
-   // 16bit 8x8 transpose
    {
-// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively.
-// whether compilers actually get this is another story, sadly.
+
 #define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }
 #define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); }
 #define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); }
 
-      // pass 1
-      dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6
+      dct_trn16(row0, row1);
       dct_trn16(row2, row3);
       dct_trn16(row4, row5);
       dct_trn16(row6, row7);
 
-      // pass 2
-      dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4
+      dct_trn32(row0, row2);
       dct_trn32(row1, row3);
       dct_trn32(row4, row6);
       dct_trn32(row5, row7);
 
-      // pass 3
-      dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0
+      dct_trn64(row0, row4);
       dct_trn64(row1, row5);
       dct_trn64(row2, row6);
       dct_trn64(row3, row7);
@@ -2843,14 +2229,10 @@ static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
 #undef dct_trn64
    }
 
-   // row pass
-   // vrshrn_n_s32 only supports shifts up to 16, we need
-   // 17. so do a non-rounding shift of 16 first then follow
-   // up with a rounding shift by 1.
    dct_pass(vshrn_n_s32, 16);
 
    {
-      // pack and round
+
       uint8x8_t p0 = vqrshrun_n_s16(row0, 1);
       uint8x8_t p1 = vqrshrun_n_s16(row1, 1);
       uint8x8_t p2 = vqrshrun_n_s16(row2, 1);
@@ -2860,33 +2242,25 @@ static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
       uint8x8_t p6 = vqrshrun_n_s16(row6, 1);
       uint8x8_t p7 = vqrshrun_n_s16(row7, 1);
 
-      // again, these can translate into one instruction, but often don't.
 #define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }
 #define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); }
 #define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); }
 
-      // sadly can't use interleaved stores here since we only write
-      // 8 bytes to each scan line!
-
-      // 8x8 8-bit transpose pass 1
       dct_trn8_8(p0, p1);
       dct_trn8_8(p2, p3);
       dct_trn8_8(p4, p5);
       dct_trn8_8(p6, p7);
 
-      // pass 2
       dct_trn8_16(p0, p2);
       dct_trn8_16(p1, p3);
       dct_trn8_16(p4, p6);
       dct_trn8_16(p5, p7);
 
-      // pass 3
       dct_trn8_32(p0, p4);
       dct_trn8_32(p1, p5);
       dct_trn8_32(p2, p6);
       dct_trn8_32(p3, p7);
 
-      // store
       vst1_u8(out, p0); out += out_stride;
       vst1_u8(out, p1); out += out_stride;
       vst1_u8(out, p2); out += out_stride;
@@ -2910,12 +2284,10 @@ static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
 #undef dct_pass
 }
 
-#endif // STBI_NEON
+#endif
 
 #define STBI__MARKER_none  0xff
-// if there's a pending marker from the entropy stream, return that
-// otherwise, fetch from the stream and get a marker. if there's no
-// marker, return 0xff, which is never a valid marker value
+
 static stbi_uc stbi__get_marker(stbi__jpeg *j)
 {
    stbi_uc x;
@@ -2923,16 +2295,12 @@ static stbi_uc stbi__get_marker(stbi__jpeg *j)
    x = stbi__get8(j->s);
    if (x != 0xff) return STBI__MARKER_none;
    while (x == 0xff)
-      x = stbi__get8(j->s); // consume repeated 0xff fill bytes
+      x = stbi__get8(j->s);
    return x;
 }
 
-// in each scan, we'll have scan_n components, and the order
-// of the components is specified by order[]
 #define STBI__RESTART(x)     ((x) >= 0xd0 && (x) <= 0xd7)
 
-// after a restart interval, stbi__jpeg_reset the entropy decoder and
-// the dc prediction
 static void stbi__jpeg_reset(stbi__jpeg *j)
 {
    j->code_bits = 0;
@@ -2942,8 +2310,7 @@ static void stbi__jpeg_reset(stbi__jpeg *j)
    j->marker = STBI__MARKER_none;
    j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
    j->eob_run = 0;
-   // no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
-   // since we don't even allow 1<<30 pixels
+
 }
 
 static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
@@ -2954,10 +2321,7 @@ static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
          int i,j;
          STBI_SIMD_ALIGN(short, data[64]);
          int n = z->order[0];
-         // non-interleaved data, we just need to process one block at a time,
-         // in trivial scanline order
-         // number of blocks to do just depends on how many actual "pixels" this
-         // component has, independent of interleaved MCU blocking and such
+
          int w = (z->img_comp[n].x+7) >> 3;
          int h = (z->img_comp[n].y+7) >> 3;
          for (j=0; j < h; ++j) {
@@ -2965,27 +2329,25 @@ static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
                int ha = z->img_comp[n].ha;
                if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;
                z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
-               // every data block is an MCU, so countdown the restart interval
+
                if (--z->todo <= 0) {
                   if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
-                  // if it's NOT a restart, then just bail, so we get corrupt data
-                  // rather than no data
+
                   if (!STBI__RESTART(z->marker)) return 1;
                   stbi__jpeg_reset(z);
                }
             }
          }
          return 1;
-      } else { // interleaved
+      } else {
          int i,j,k,x,y;
          STBI_SIMD_ALIGN(short, data[64]);
          for (j=0; j < z->img_mcu_y; ++j) {
             for (i=0; i < z->img_mcu_x; ++i) {
-               // scan an interleaved mcu... process scan_n components in order
+
                for (k=0; k < z->scan_n; ++k) {
                   int n = z->order[k];
-                  // scan out an mcu's worth of this component; that's just determined
-                  // by the basic H and V specified for the component
+
                   for (y=0; y < z->img_comp[n].v; ++y) {
                      for (x=0; x < z->img_comp[n].h; ++x) {
                         int x2 = (i*z->img_comp[n].h + x)*8;
@@ -2996,8 +2358,7 @@ static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
                      }
                   }
                }
-               // after all interleaved components, that's an interleaved MCU,
-               // so now count down the restart interval
+
                if (--z->todo <= 0) {
                   if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
                   if (!STBI__RESTART(z->marker)) return 1;
@@ -3011,10 +2372,7 @@ static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
       if (z->scan_n == 1) {
          int i,j;
          int n = z->order[0];
-         // non-interleaved data, we just need to process one block at a time,
-         // in trivial scanline order
-         // number of blocks to do just depends on how many actual "pixels" this
-         // component has, independent of interleaved MCU blocking and such
+
          int w = (z->img_comp[n].x+7) >> 3;
          int h = (z->img_comp[n].y+7) >> 3;
          for (j=0; j < h; ++j) {
@@ -3028,7 +2386,7 @@ static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
                   if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha]))
                      return 0;
                }
-               // every data block is an MCU, so countdown the restart interval
+
                if (--z->todo <= 0) {
                   if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
                   if (!STBI__RESTART(z->marker)) return 1;
@@ -3037,15 +2395,14 @@ static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
             }
          }
          return 1;
-      } else { // interleaved
+      } else {
          int i,j,k,x,y;
          for (j=0; j < z->img_mcu_y; ++j) {
             for (i=0; i < z->img_mcu_x; ++i) {
-               // scan an interleaved mcu... process scan_n components in order
+
                for (k=0; k < z->scan_n; ++k) {
                   int n = z->order[k];
-                  // scan out an mcu's worth of this component; that's just determined
-                  // by the basic H and V specified for the component
+
                   for (y=0; y < z->img_comp[n].v; ++y) {
                      for (x=0; x < z->img_comp[n].h; ++x) {
                         int x2 = (i*z->img_comp[n].h + x);
@@ -3056,8 +2413,7 @@ static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
                      }
                   }
                }
-               // after all interleaved components, that's an interleaved MCU,
-               // so now count down the restart interval
+
                if (--z->todo <= 0) {
                   if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
                   if (!STBI__RESTART(z->marker)) return 1;
@@ -3080,7 +2436,7 @@ static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)
 static void stbi__jpeg_finish(stbi__jpeg *z)
 {
    if (z->progressive) {
-      // dequantize and idct the data
+
       int i,j,n;
       for (n=0; n < z->s->img_n; ++n) {
          int w = (z->img_comp[n].x+7) >> 3;
@@ -3100,15 +2456,15 @@ static int stbi__process_marker(stbi__jpeg *z, int m)
 {
    int L;
    switch (m) {
-      case STBI__MARKER_none: // no marker found
+      case STBI__MARKER_none:
          return stbi__err("expected marker","Corrupt JPEG");
 
-      case 0xDD: // DRI - specify restart interval
+      case 0xDD:
          if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG");
          z->restart_interval = stbi__get16be(z->s);
          return 1;
 
-      case 0xDB: // DQT - define quantization table
+      case 0xDB:
          L = stbi__get16be(z->s)-2;
          while (L > 0) {
             int q = stbi__get8(z->s);
@@ -3123,7 +2479,7 @@ static int stbi__process_marker(stbi__jpeg *z, int m)
          }
          return L==0;
 
-      case 0xC4: // DHT - define huffman table
+      case 0xC4:
          L = stbi__get16be(z->s)-2;
          while (L > 0) {
             stbi_uc *v;
@@ -3136,7 +2492,7 @@ static int stbi__process_marker(stbi__jpeg *z, int m)
                sizes[i] = stbi__get8(z->s);
                n += sizes[i];
             }
-            if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values!
+            if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG");
             L -= 17;
             if (tc == 0) {
                if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0;
@@ -3154,7 +2510,6 @@ static int stbi__process_marker(stbi__jpeg *z, int m)
          return L==0;
    }
 
-   // check for comment block or APP blocks
    if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
       L = stbi__get16be(z->s);
       if (L < 2) {
@@ -3165,7 +2520,7 @@ static int stbi__process_marker(stbi__jpeg *z, int m)
       }
       L -= 2;
 
-      if (m == 0xE0 && L >= 5) { // JFIF APP0 segment
+      if (m == 0xE0 && L >= 5) {
          static const unsigned char tag[5] = {'J','F','I','F','\0'};
          int ok = 1;
          int i;
@@ -3175,7 +2530,7 @@ static int stbi__process_marker(stbi__jpeg *z, int m)
          L -= 5;
          if (ok)
             z->jfif = 1;
-      } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment
+      } else if (m == 0xEE && L >= 12) {
          static const unsigned char tag[6] = {'A','d','o','b','e','\0'};
          int ok = 1;
          int i;
@@ -3184,10 +2539,10 @@ static int stbi__process_marker(stbi__jpeg *z, int m)
                ok = 0;
          L -= 6;
          if (ok) {
-            stbi__get8(z->s); // version
-            stbi__get16be(z->s); // flags0
-            stbi__get16be(z->s); // flags1
-            z->app14_color_transform = stbi__get8(z->s); // color transform
+            stbi__get8(z->s);
+            stbi__get16be(z->s);
+            stbi__get16be(z->s);
+            z->app14_color_transform = stbi__get8(z->s);
             L -= 6;
          }
       }
@@ -3199,7 +2554,6 @@ static int stbi__process_marker(stbi__jpeg *z, int m)
    return stbi__err("unknown marker","Corrupt JPEG");
 }
 
-// after we see SOS
 static int stbi__process_scan_header(stbi__jpeg *z)
 {
    int i;
@@ -3213,7 +2567,7 @@ static int stbi__process_scan_header(stbi__jpeg *z)
       for (which = 0; which < z->s->img_n; ++which)
          if (z->img_comp[which].id == id)
             break;
-      if (which == z->s->img_n) return 0; // no match
+      if (which == z->s->img_n) return 0;
       z->img_comp[which].hd = q >> 4;   if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG");
       z->img_comp[which].ha = q & 15;   if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG");
       z->order[i] = which;
@@ -3222,7 +2576,7 @@ static int stbi__process_scan_header(stbi__jpeg *z)
    {
       int aa;
       z->spec_start = stbi__get8(z->s);
-      z->spec_end   = stbi__get8(z->s); // should be 63, but might be 0
+      z->spec_end   = stbi__get8(z->s);
       aa = stbi__get8(z->s);
       z->succ_high = (aa >> 4);
       z->succ_low  = (aa & 15);
@@ -3265,10 +2619,10 @@ static int stbi__process_frame_header(stbi__jpeg *z, int scan)
 {
    stbi__context *s = z->s;
    int Lf,p,i,q, h_max=1,v_max=1,c;
-   Lf = stbi__get16be(s);         if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG
-   p  = stbi__get8(s);            if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
-   s->img_y = stbi__get16be(s);   if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
-   s->img_x = stbi__get16be(s);   if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires
+   Lf = stbi__get16be(s);         if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG");
+   p  = stbi__get8(s);            if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only");
+   s->img_y = stbi__get16be(s);   if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height");
+   s->img_x = stbi__get16be(s);   if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG");
    if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
    if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
    c = stbi__get8(s);
@@ -3302,33 +2656,24 @@ static int stbi__process_frame_header(stbi__jpeg *z, int scan)
       if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;
    }
 
-   // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios
-   // and I've never seen a non-corrupted JPEG file actually use them
    for (i=0; i < s->img_n; ++i) {
       if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG");
       if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG");
    }
 
-   // compute interleaved mcu info
    z->img_h_max = h_max;
    z->img_v_max = v_max;
    z->img_mcu_w = h_max * 8;
    z->img_mcu_h = v_max * 8;
-   // these sizes can't be more than 17 bits
+
    z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;
    z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;
 
    for (i=0; i < s->img_n; ++i) {
-      // number of effective pixels (e.g. for non-interleaved MCU)
+
       z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;
       z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;
-      // to simplify generation, we'll allocate enough memory to decode
-      // the bogus oversized data from using interleaved MCUs and their
-      // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't
-      // discard the extra data until colorspace conversion
-      //
-      // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier)
-      // so these muls can't overflow with 32-bit ints (which we require)
+
       z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;
       z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;
       z->img_comp[i].coeff = 0;
@@ -3337,10 +2682,10 @@ static int stbi__process_frame_header(stbi__jpeg *z, int scan)
       z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15);
       if (z->img_comp[i].raw_data == NULL)
          return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
-      // align blocks for idct using mmx/sse
+
       z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
       if (z->progressive) {
-         // w2, h2 are multiples of 8 (see above)
+
          z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8;
          z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8;
          z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15);
@@ -3353,7 +2698,6 @@ static int stbi__process_frame_header(stbi__jpeg *z, int scan)
    return 1;
 }
 
-// use comparisons since in some cases we handle more than one case (e.g. SOF)
 #define stbi__DNL(x)         ((x) == 0xdc)
 #define stbi__SOI(x)         ((x) == 0xd8)
 #define stbi__EOI(x)         ((x) == 0xd9)
@@ -3366,8 +2710,8 @@ static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
 {
    int m;
    z->jfif = 0;
-   z->app14_color_transform = -1; // valid values are 0,1,2
-   z->marker = STBI__MARKER_none; // initialize cached marker to empty
+   z->app14_color_transform = -1;
+   z->marker = STBI__MARKER_none;
    m = stbi__get_marker(z);
    if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG");
    if (scan == STBI__SCAN_type) return 1;
@@ -3376,7 +2720,7 @@ static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
       if (!stbi__process_marker(z,m)) return 0;
       m = stbi__get_marker(z);
       while (m == STBI__MARKER_none) {
-         // some files have extra padding after their blocks, so ok, we'll scan
+
          if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG");
          m = stbi__get_marker(z);
       }
@@ -3388,27 +2732,22 @@ static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
 
 static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j)
 {
-   // some JPEGs have junk at end, skip over it but if we find what looks
-   // like a valid marker, resume there
+
    while (!stbi__at_eof(j->s)) {
       stbi_uc x = stbi__get8(j->s);
-      while (x == 0xff) { // might be a marker
+      while (x == 0xff) {
          if (stbi__at_eof(j->s)) return STBI__MARKER_none;
          x = stbi__get8(j->s);
          if (x != 0x00 && x != 0xff) {
-            // not a stuffed zero or lead-in to another marker, looks
-            // like an actual marker, return it
+
             return x;
          }
-         // stuffed zero has x=0 now which ends the loop, meaning we go
-         // back to regular scan loop.
-         // repeated 0xff keeps trying to read the next byte of the marker.
+
       }
    }
    return STBI__MARKER_none;
 }
 
-// decode image to YCbCr format
 static int stbi__decode_jpeg_image(stbi__jpeg *j)
 {
    int m;
@@ -3425,7 +2764,7 @@ static int stbi__decode_jpeg_image(stbi__jpeg *j)
          if (!stbi__parse_entropy_coded_data(j)) return 0;
          if (j->marker == STBI__MARKER_none ) {
          j->marker = stbi__skip_jpeg_junk_at_end(j);
-            // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0
+
          }
          m = stbi__get_marker(j);
          if (STBI__RESTART(m))
@@ -3446,8 +2785,6 @@ static int stbi__decode_jpeg_image(stbi__jpeg *j)
    return 1;
 }
 
-// static jfif-centered resampling (across block boundaries)
-
 typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,
                                     int w, int hs);
 
@@ -3464,7 +2801,7 @@ static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far,
 
 static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
 {
-   // need to generate two samples vertically for every one in input
+
    int i;
    STBI_NOTUSED(hs);
    for (i=0; i < w; ++i)
@@ -3474,12 +2811,12 @@ static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *
 
 static stbi_uc*  stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
 {
-   // need to generate two samples horizontally for every one in input
+
    int i;
    stbi_uc *input = in_near;
 
    if (w == 1) {
-      // if only one sample, can't do any interpolation
+
       out[0] = out[1] = input[0];
       return out;
    }
@@ -3504,7 +2841,7 @@ static stbi_uc*  stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc
 
 static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
 {
-   // need to generate 2x2 samples for every one in input
+
    int i,t0,t1;
    if (w == 1) {
       out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
@@ -3529,7 +2866,7 @@ static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc
 #if defined(STBI_SSE2) || defined(STBI_NEON)
 static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
 {
-   // need to generate 2x2 samples for every one in input
+
    int i=0,t0,t1;
 
    if (w == 1) {
@@ -3538,13 +2875,10 @@ static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stb
    }
 
    t1 = 3*in_near[0] + in_far[0];
-   // process groups of 8 pixels for as long as we can.
-   // note we can't handle the last pixel in a row in this loop
-   // because we need to handle the filter boundary conditions.
+
    for (; i < ((w-1) & ~7); i += 8) {
 #if defined(STBI_SSE2)
-      // load and perform the vertical filtering pass
-      // this uses 3*x + y = 4*x + (y - x)
+
       __m128i zero  = _mm_setzero_si128();
       __m128i farb  = _mm_loadl_epi64((__m128i *) (in_far + i));
       __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i));
@@ -3552,22 +2886,13 @@ static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stb
       __m128i nearw = _mm_unpacklo_epi8(nearb, zero);
       __m128i diff  = _mm_sub_epi16(farw, nearw);
       __m128i nears = _mm_slli_epi16(nearw, 2);
-      __m128i curr  = _mm_add_epi16(nears, diff); // current row
+      __m128i curr  = _mm_add_epi16(nears, diff);
 
-      // horizontal filter works the same based on shifted vers of current
-      // row. "prev" is current row shifted right by 1 pixel; we need to
-      // insert the previous pixel value (from t1).
-      // "next" is current row shifted left by 1 pixel, with first pixel
-      // of next block of 8 pixels added in.
       __m128i prv0 = _mm_slli_si128(curr, 2);
       __m128i nxt0 = _mm_srli_si128(curr, 2);
       __m128i prev = _mm_insert_epi16(prv0, t1, 0);
       __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7);
 
-      // horizontal filter, polyphase implementation since it's convenient:
-      // even pixels = 3*cur + prev = cur*4 + (prev - cur)
-      // odd  pixels = 3*cur + next = cur*4 + (next - cur)
-      // note the shared term.
       __m128i bias  = _mm_set1_epi16(8);
       __m128i curs = _mm_slli_epi16(curr, 2);
       __m128i prvd = _mm_sub_epi16(prev, curr);
@@ -3576,52 +2901,38 @@ static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stb
       __m128i even = _mm_add_epi16(prvd, curb);
       __m128i odd  = _mm_add_epi16(nxtd, curb);
 
-      // interleave even and odd pixels, then undo scaling.
       __m128i int0 = _mm_unpacklo_epi16(even, odd);
       __m128i int1 = _mm_unpackhi_epi16(even, odd);
       __m128i de0  = _mm_srli_epi16(int0, 4);
       __m128i de1  = _mm_srli_epi16(int1, 4);
 
-      // pack and write output
       __m128i outv = _mm_packus_epi16(de0, de1);
       _mm_storeu_si128((__m128i *) (out + i*2), outv);
 #elif defined(STBI_NEON)
-      // load and perform the vertical filtering pass
-      // this uses 3*x + y = 4*x + (y - x)
+
       uint8x8_t farb  = vld1_u8(in_far + i);
       uint8x8_t nearb = vld1_u8(in_near + i);
       int16x8_t diff  = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));
       int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));
-      int16x8_t curr  = vaddq_s16(nears, diff); // current row
+      int16x8_t curr  = vaddq_s16(nears, diff);
 
-      // horizontal filter works the same based on shifted vers of current
-      // row. "prev" is current row shifted right by 1 pixel; we need to
-      // insert the previous pixel value (from t1).
-      // "next" is current row shifted left by 1 pixel, with first pixel
-      // of next block of 8 pixels added in.
       int16x8_t prv0 = vextq_s16(curr, curr, 7);
       int16x8_t nxt0 = vextq_s16(curr, curr, 1);
       int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);
       int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7);
 
-      // horizontal filter, polyphase implementation since it's convenient:
-      // even pixels = 3*cur + prev = cur*4 + (prev - cur)
-      // odd  pixels = 3*cur + next = cur*4 + (next - cur)
-      // note the shared term.
       int16x8_t curs = vshlq_n_s16(curr, 2);
       int16x8_t prvd = vsubq_s16(prev, curr);
       int16x8_t nxtd = vsubq_s16(next, curr);
       int16x8_t even = vaddq_s16(curs, prvd);
       int16x8_t odd  = vaddq_s16(curs, nxtd);
 
-      // undo scaling and round, then store with even/odd phases interleaved
       uint8x8x2_t o;
       o.val[0] = vqrshrun_n_s16(even, 4);
       o.val[1] = vqrshrun_n_s16(odd,  4);
       vst2_u8(out + i*2, o);
 #endif
 
-      // "previous" value for next iter
       t1 = 3*in_near[i+7] + in_far[i+7];
    }
 
@@ -3645,7 +2956,7 @@ static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stb
 
 static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
 {
-   // resample with nearest-neighbor
+
    int i,j;
    STBI_NOTUSED(in_far);
    for (i=0; i < w; ++i)
@@ -3654,14 +2965,12 @@ static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_
    return out;
 }
 
-// this is a reduced-precision calculation of YCbCr-to-RGB introduced
-// to make sure the code produces the same results in both SIMD and scalar
 #define stbi__float2fixed(x)  (((int) ((x) * 4096.0f + 0.5f)) << 8)
 static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)
 {
    int i;
    for (i=0; i < count; ++i) {
-      int y_fixed = (y[i] << 20) + (1<<19); // rounding
+      int y_fixed = (y[i] << 20) + (1<<19);
       int r,g,b;
       int cr = pcr[i] - 128;
       int cb = pcb[i] - 128;
@@ -3688,33 +2997,29 @@ static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc cons
    int i = 0;
 
 #ifdef STBI_SSE2
-   // step == 3 is pretty ugly on the final interleave, and i'm not convinced
-   // it's useful in practice (you wouldn't use it for textures, for example).
-   // so just accelerate step == 4 case.
+
    if (step == 4) {
-      // this is a fairly straightforward implementation and not super-optimized.
+
       __m128i signflip  = _mm_set1_epi8(-0x80);
       __m128i cr_const0 = _mm_set1_epi16(   (short) ( 1.40200f*4096.0f+0.5f));
       __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f));
       __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f));
       __m128i cb_const1 = _mm_set1_epi16(   (short) ( 1.77200f*4096.0f+0.5f));
       __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128);
-      __m128i xw = _mm_set1_epi16(255); // alpha channel
+      __m128i xw = _mm_set1_epi16(255);
 
       for (; i+7 < count; i += 8) {
-         // load
+
          __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i));
          __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i));
          __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i));
-         __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128
-         __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128
+         __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip);
+         __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip);
 
-         // unpack to short (and left-shift cr, cb by 8)
          __m128i yw  = _mm_unpacklo_epi8(y_bias, y_bytes);
          __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased);
          __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased);
 
-         // color transform
          __m128i yws = _mm_srli_epi16(yw, 4);
          __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw);
          __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw);
@@ -3725,22 +3030,18 @@ static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc cons
          __m128i bws = _mm_add_epi16(yws, cb1);
          __m128i gws = _mm_add_epi16(gwt, cr1);
 
-         // descale
          __m128i rw = _mm_srai_epi16(rws, 4);
          __m128i bw = _mm_srai_epi16(bws, 4);
          __m128i gw = _mm_srai_epi16(gws, 4);
 
-         // back to byte, set up for transpose
          __m128i brb = _mm_packus_epi16(rw, bw);
          __m128i gxb = _mm_packus_epi16(gw, xw);
 
-         // transpose to interleave channels
          __m128i t0 = _mm_unpacklo_epi8(brb, gxb);
          __m128i t1 = _mm_unpackhi_epi8(brb, gxb);
          __m128i o0 = _mm_unpacklo_epi16(t0, t1);
          __m128i o1 = _mm_unpackhi_epi16(t0, t1);
 
-         // store
          _mm_storeu_si128((__m128i *) (out + 0), o0);
          _mm_storeu_si128((__m128i *) (out + 16), o1);
          out += 32;
@@ -3749,9 +3050,9 @@ static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc cons
 #endif
 
 #ifdef STBI_NEON
-   // in this version, step=3 support would be easy to add. but is there demand?
+
    if (step == 4) {
-      // this is a fairly straightforward implementation and not super-optimized.
+
       uint8x8_t signflip = vdup_n_u8(0x80);
       int16x8_t cr_const0 = vdupq_n_s16(   (short) ( 1.40200f*4096.0f+0.5f));
       int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f));
@@ -3759,19 +3060,17 @@ static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc cons
       int16x8_t cb_const1 = vdupq_n_s16(   (short) ( 1.77200f*4096.0f+0.5f));
 
       for (; i+7 < count; i += 8) {
-         // load
+
          uint8x8_t y_bytes  = vld1_u8(y + i);
          uint8x8_t cr_bytes = vld1_u8(pcr + i);
          uint8x8_t cb_bytes = vld1_u8(pcb + i);
          int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip));
          int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip));
 
-         // expand to s16
          int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4));
          int16x8_t crw = vshll_n_s8(cr_biased, 7);
          int16x8_t cbw = vshll_n_s8(cb_biased, 7);
 
-         // color transform
          int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0);
          int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0);
          int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1);
@@ -3780,14 +3079,12 @@ static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc cons
          int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1);
          int16x8_t bws = vaddq_s16(yws, cb1);
 
-         // undo scaling, round, convert to byte
          uint8x8x4_t o;
          o.val[0] = vqrshrun_n_s16(rws, 4);
          o.val[1] = vqrshrun_n_s16(gws, 4);
          o.val[2] = vqrshrun_n_s16(bws, 4);
          o.val[3] = vdup_n_u8(255);
 
-         // store, interleaving r/g/b/a
          vst4_u8(out, o);
          out += 8*4;
       }
@@ -3795,7 +3092,7 @@ static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc cons
 #endif
 
    for (; i < count; ++i) {
-      int y_fixed = (y[i] << 20) + (1<<19); // rounding
+      int y_fixed = (y[i] << 20) + (1<<19);
       int r,g,b;
       int cr = pcr[i] - 128;
       int cb = pcb[i] - 128;
@@ -3817,7 +3114,6 @@ static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc cons
 }
 #endif
 
-// set up the kernels
 static void stbi__setup_jpeg(stbi__jpeg *j)
 {
    j->idct_block_kernel = stbi__idct_block;
@@ -3839,7 +3135,6 @@ static void stbi__setup_jpeg(stbi__jpeg *j)
 #endif
 }
 
-// clean up the temporary component buffers
 static void stbi__cleanup_jpeg(stbi__jpeg *j)
 {
    stbi__free_jpeg_components(j, j->s->img_n, 0);
@@ -3849,13 +3144,12 @@ typedef struct
 {
    resample_row_func resample;
    stbi_uc *line0,*line1;
-   int hs,vs;   // expansion factor in each axis
-   int w_lores; // horizontal pixels pre-expansion
-   int ystep;   // how far through vertical expansion we are
-   int ypos;    // which pre-expansion row we're on
+   int hs,vs;
+   int w_lores;
+   int ystep;
+   int ypos;
 } stbi__resample;
 
-// fast 0..255 * 0..255 => 0..255 rounded multiplication
 static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)
 {
    unsigned int t = x*y + 128;
@@ -3865,15 +3159,12 @@ static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)
 static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
 {
    int n, decode_n, is_rgb;
-   z->s->img_n = 0; // make stbi__cleanup_jpeg safe
+   z->s->img_n = 0;
 
-   // validate req_comp
    if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
 
-   // load a jpeg image from whichever source, but leave in YCbCr format
    if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; }
 
-   // determine actual number of components to generate
    n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1;
 
    is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif));
@@ -3883,11 +3174,8 @@ static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp
    else
       decode_n = z->s->img_n;
 
-   // nothing to do if no components requested; check this now to avoid
-   // accessing uninitialized coutput[0] later
    if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; }
 
-   // resample and color-convert
    {
       int k;
       unsigned int i,j;
@@ -3899,8 +3187,6 @@ static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp
       for (k=0; k < decode_n; ++k) {
          stbi__resample *r = &res_comp[k];
 
-         // allocate line buffer big enough for upsampling off the edges
-         // with upsample factor of 4
          z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3);
          if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
 
@@ -3918,11 +3204,9 @@ static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp
          else                               r->resample = stbi__resample_row_generic;
       }
 
-      // can't error after this so, this is safe
       output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1);
       if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
 
-      // now go ahead and resample
       for (j=0; j < z->s->img_y; ++j) {
          stbi_uc *out = output + n * z->s->img_x * j;
          for (k=0; k < decode_n; ++k) {
@@ -3954,7 +3238,7 @@ static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp
                   z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
                }
             } else if (z->s->img_n == 4) {
-               if (z->app14_color_transform == 0) { // CMYK
+               if (z->app14_color_transform == 0) {
                   for (i=0; i < z->s->img_x; ++i) {
                      stbi_uc m = coutput[3][i];
                      out[0] = stbi__blinn_8x8(coutput[0][i], m);
@@ -3963,7 +3247,7 @@ static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp
                      out[3] = 255;
                      out += n;
                   }
-               } else if (z->app14_color_transform == 2) { // YCCK
+               } else if (z->app14_color_transform == 2) {
                   z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
                   for (i=0; i < z->s->img_x; ++i) {
                      stbi_uc m = coutput[3][i];
@@ -3972,13 +3256,13 @@ static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp
                      out[2] = stbi__blinn_8x8(255 - out[2], m);
                      out += n;
                   }
-               } else { // YCbCr + alpha?  Ignore the fourth channel for now
+               } else {
                   z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
                }
             } else
                for (i=0; i < z->s->img_x; ++i) {
                   out[0] = out[1] = out[2] = y[i];
-                  out[3] = 255; // not used if n==3
+                  out[3] = 255;
                   out += n;
                }
          } else {
@@ -4020,7 +3304,7 @@ static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp
       stbi__cleanup_jpeg(z);
       *out_x = z->s->img_x;
       *out_y = z->s->img_y;
-      if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output
+      if (comp) *comp = z->s->img_n >= 3 ? 3 : 1;
       return output;
    }
 }
@@ -4078,22 +3362,12 @@ static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)
 }
 #endif
 
-// public domain zlib decode    v0.2  Sean Barrett 2006-11-18
-//    simple implementation
-//      - all input must be provided in an upfront buffer
-//      - all output is written to a single output buffer (can malloc/realloc)
-//    performance
-//      - fast huffman
-
 #ifndef STBI_NO_ZLIB
 
-// fast-way is faster to check than jpeg huffman, but slow way is slower
-#define STBI__ZFAST_BITS  9 // accelerate all cases in default tables
+#define STBI__ZFAST_BITS  9
 #define STBI__ZFAST_MASK  ((1 << STBI__ZFAST_BITS) - 1)
-#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet
+#define STBI__ZNSYMS 288
 
-// zlib-style huffman encoding
-// (jpegs packs from left, zlib from right, so can't share code)
 typedef struct
 {
    stbi__uint16 fast[1 << STBI__ZFAST_BITS];
@@ -4116,8 +3390,7 @@ stbi_inline static int stbi__bitreverse16(int n)
 stbi_inline static int stbi__bit_reverse(int v, int bits)
 {
    STBI_ASSERT(bits <= 16);
-   // to bit reverse n bits, reverse 16 and shift
-   // e.g. 11 bits, bit reverse and shift away 5
+
    return stbi__bitreverse16(v) >> (16-bits);
 }
 
@@ -4126,7 +3399,6 @@ static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int
    int i,k=0;
    int code, next_code[16], sizes[17];
 
-   // DEFLATE spec for generating codes
    memset(sizes, 0, sizeof(sizes));
    memset(z->fast, 0, sizeof(z->fast));
    for (i=0; i < num; ++i)
@@ -4143,11 +3415,11 @@ static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int
       code = (code + sizes[i]);
       if (sizes[i])
          if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG");
-      z->maxcode[i] = code << (16-i); // preshift for inner loop
+      z->maxcode[i] = code << (16-i);
       code <<= 1;
       k += sizes[i];
    }
-   z->maxcode[16] = 0x10000; // sentinel
+   z->maxcode[16] = 0x10000;
    for (i=0; i < num; ++i) {
       int s = sizelist[i];
       if (s) {
@@ -4168,12 +3440,6 @@ static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int
    return 1;
 }
 
-// zlib-from-memory implementation for PNG reading
-//    because PNG allows splitting the zlib stream arbitrarily,
-//    and it's annoying structurally to have PNG call ZLIB call PNG,
-//    we require PNG read all the IDATs and combine them into a single
-//    memory buffer
-
 typedef struct
 {
    stbi_uc *zbuffer, *zbuffer_end;
@@ -4203,7 +3469,7 @@ static void stbi__fill_bits(stbi__zbuf *z)
 {
    do {
       if (z->code_buffer >= (1U << z->num_bits)) {
-        z->zbuffer = z->zbuffer_end;  /* treat this as EOF so we fail. */
+        z->zbuffer = z->zbuffer_end;
         return;
       }
       z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;
@@ -4224,17 +3490,16 @@ stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)
 static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
 {
    int b,s,k;
-   // not resolved by fast table, so compute it the slow way
-   // use jpeg approach, which requires MSbits at top
+
    k = stbi__bit_reverse(a->code_buffer, 16);
    for (s=STBI__ZFAST_BITS+1; ; ++s)
       if (k < z->maxcode[s])
          break;
-   if (s >= 16) return -1; // invalid code!
-   // code size is s, so:
+   if (s >= 16) return -1;
+
    b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
-   if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere!
-   if (z->size[b] != s) return -1;  // was originally an assert, but report failure instead.
+   if (b >= STBI__ZNSYMS) return -1;
+   if (z->size[b] != s) return -1;
    a->code_buffer >>= s;
    a->num_bits -= s;
    return z->value[b];
@@ -4246,14 +3511,11 @@ stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
    if (a->num_bits < 16) {
       if (stbi__zeof(a)) {
          if (!a->hit_zeof_once) {
-            // This is the first time we hit eof, insert 16 extra padding btis
-            // to allow us to keep going; if we actually consume any of them
-            // though, that is invalid data. This is caught later.
+
             a->hit_zeof_once = 1;
-            a->num_bits += 16; // add 16 implicit zero bits
+            a->num_bits += 16;
          } else {
-            // We already inserted our extra 16 padding bits and are again
-            // out, this stream is actually prematurely terminated.
+
             return -1;
          }
       } else {
@@ -4270,7 +3532,7 @@ stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
    return stbi__zhuffman_decode_slowpath(a, z);
 }
 
-static int stbi__zexpand(stbi__zbuf *z, char *zout, int n)  // need to make room for n bytes
+static int stbi__zexpand(stbi__zbuf *z, char *zout, int n)
 {
    char *q;
    unsigned int cur, limit, old_limit;
@@ -4312,7 +3574,7 @@ static int stbi__parse_huffman_block(stbi__zbuf *a)
    for(;;) {
       int z = stbi__zhuffman_decode(a, &a->z_length);
       if (z < 256) {
-         if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes
+         if (z < 0) return stbi__err("bad huffman code","Corrupt PNG");
          if (zout >= a->zout_end) {
             if (!stbi__zexpand(a, zout, 1)) return 0;
             zout = a->zout;
@@ -4324,20 +3586,17 @@ static int stbi__parse_huffman_block(stbi__zbuf *a)
          if (z == 256) {
             a->zout = zout;
             if (a->hit_zeof_once && a->num_bits < 16) {
-               // The first time we hit zeof, we inserted 16 extra zero bits into our bit
-               // buffer so the decoder can just do its speculative decoding. But if we
-               // actually consumed any of those bits (which is the case when num_bits < 16),
-               // the stream actually read past the end so it is malformed.
+
                return stbi__err("unexpected end","Corrupt PNG");
             }
             return 1;
          }
-         if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data
+         if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG");
          z -= 257;
          len = stbi__zlength_base[z];
          if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);
          z = stbi__zhuffman_decode(a, &a->z_distance);
-         if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data
+         if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG");
          dist = stbi__zdist_base[z];
          if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);
          if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG");
@@ -4346,7 +3605,7 @@ static int stbi__parse_huffman_block(stbi__zbuf *a)
             zout = a->zout;
          }
          p = (stbi_uc *) (zout - dist);
-         if (dist == 1) { // run of one byte; common in images.
+         if (dist == 1) {
             stbi_uc v = *p;
             if (len) { do *zout++ = v; while (--len); }
          } else {
@@ -4360,7 +3619,7 @@ static int stbi__compute_huffman_codes(stbi__zbuf *a)
 {
    static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
    stbi__zhuffman z_codelength;
-   stbi_uc lencodes[286+32+137];//padding for maximum single op
+   stbi_uc lencodes[286+32+137];
    stbi_uc codelength_sizes[19];
    int i,n;
 
@@ -4411,16 +3670,16 @@ static int stbi__parse_uncompressed_block(stbi__zbuf *a)
    stbi_uc header[4];
    int len,nlen,k;
    if (a->num_bits & 7)
-      stbi__zreceive(a, a->num_bits & 7); // discard
-   // drain the bit-packed data into header
+      stbi__zreceive(a, a->num_bits & 7);
+
    k = 0;
    while (a->num_bits > 0) {
-      header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check
+      header[k++] = (stbi_uc) (a->code_buffer & 255);
       a->code_buffer >>= 8;
       a->num_bits -= 8;
    }
    if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG");
-   // now fill header the normal way
+
    while (k < 4)
       header[k++] = stbi__zget8(a);
    len  = header[1] * 256 + header[0];
@@ -4439,13 +3698,13 @@ static int stbi__parse_zlib_header(stbi__zbuf *a)
 {
    int cmf   = stbi__zget8(a);
    int cm    = cmf & 15;
-   /* int cinfo = cmf >> 4; */
+
    int flg   = stbi__zget8(a);
-   if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
-   if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
-   if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
-   if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png
-   // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
+   if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG");
+   if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG");
+   if (flg & 32) return stbi__err("no preset dict","Corrupt PNG");
+   if (cm != 8) return stbi__err("bad compression","Corrupt PNG");
+
    return 1;
 }
 
@@ -4465,18 +3724,6 @@ static const stbi_uc stbi__zdefault_distance[32] =
 {
    5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5
 };
-/*
-Init algorithm:
-{
-   int i;   // use <= to match clearly with spec
-   for (i=0; i <= 143; ++i)     stbi__zdefault_length[i]   = 8;
-   for (   ; i <= 255; ++i)     stbi__zdefault_length[i]   = 9;
-   for (   ; i <= 279; ++i)     stbi__zdefault_length[i]   = 7;
-   for (   ; i <= 287; ++i)     stbi__zdefault_length[i]   = 8;
-
-   for (i=0; i <=  31; ++i)     stbi__zdefault_distance[i] = 5;
-}
-*/
 
 static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
 {
@@ -4495,7 +3742,7 @@ static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
          return 0;
       } else {
          if (type == 1) {
-            // use fixed code lengths
+
             if (!stbi__zbuild_huffman(&a->z_length  , stbi__zdefault_length  , STBI__ZNSYMS)) return 0;
             if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance,  32)) return 0;
          } else {
@@ -4593,16 +3840,6 @@ STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char
 }
 #endif
 
-// public domain "baseline" PNG decoder   v0.10  Sean Barrett 2006-11-18
-//    simple implementation
-//      - only 8-bit samples
-//      - no CRC checking
-//      - allocates lots of intermediate memory
-//        - avoids problem of streaming data between subsystems
-//        - avoids explicit window management
-//    performance
-//      - uses stb_zlib, a PD zlib implementation with fast huffman decoding
-
 #ifndef STBI_NO_PNG
 typedef struct
 {
@@ -4634,14 +3871,13 @@ typedef struct
    int depth;
 } stbi__png;
 
-
 enum {
    STBI__F_none=0,
    STBI__F_sub=1,
    STBI__F_up=2,
    STBI__F_avg=3,
    STBI__F_paeth=4,
-   // synthetic filter used for first scanline to avoid needing a dummy row of 0s
+
    STBI__F_avg_first
 };
 
@@ -4651,14 +3887,12 @@ static stbi_uc first_row_filter[5] =
    STBI__F_sub,
    STBI__F_none,
    STBI__F_avg_first,
-   STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub
+   STBI__F_sub
 };
 
 static int stbi__paeth(int a, int b, int c)
 {
-   // This formulation looks very different from the reference in the PNG spec, but is
-   // actually equivalent and has favorable data dependencies and admits straightforward
-   // generation of branch-free code, which helps performance significantly.
+
    int thresh = c*3 - (a + b);
    int lo = a < b ? a : b;
    int hi = a < b ? b : a;
@@ -4669,13 +3903,10 @@ static int stbi__paeth(int a, int b, int c)
 
 static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };
 
-// adds an extra all-255 alpha channel
-// dest == src is legal
-// img_n must be 1 or 3
 static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n)
 {
    int i;
-   // must process data backwards since we allow dest==src
+
    if (img_n == 1) {
       for (i=x-1; i >= 0; --i) {
          dest[i*2+1] = 255;
@@ -4692,7 +3923,6 @@ static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__ui
    }
 }
 
-// create the png data from post-deflated data
 static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)
 {
    int bytes = (depth == 16 ? 2 : 1);
@@ -4702,56 +3932,46 @@ static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 r
    stbi_uc *filter_buf;
    int all_ok = 1;
    int k;
-   int img_n = s->img_n; // copy it into a local for later
+   int img_n = s->img_n;
 
    int output_bytes = out_n*bytes;
    int filter_bytes = img_n*bytes;
    int width = x;
 
    STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1);
-   a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into
+   a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0);
    if (!a->out) return stbi__err("outofmem", "Out of memory");
 
-   // note: error exits here don't need to clean up a->out individually,
-   // stbi__do_png always does on error.
    if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG");
    img_width_bytes = (((img_n * x * depth) + 7) >> 3);
    if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err("too large", "Corrupt PNG");
    img_len = (img_width_bytes + 1) * y;
 
-   // we used to check for exact match between raw_len and img_len on non-interlaced PNGs,
-   // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros),
-   // so just check for raw_len < img_len always.
    if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG");
 
-   // Allocate two scan lines worth of filter workspace buffer.
    filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0);
    if (!filter_buf) return stbi__err("outofmem", "Out of memory");
 
-   // Filtering for low-bit-depth images
    if (depth < 8) {
       filter_bytes = 1;
       width = img_width_bytes;
    }
 
    for (j=0; j < y; ++j) {
-      // cur/prior filter buffers alternate
+
       stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes;
       stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes;
       stbi_uc *dest = a->out + stride*j;
       int nk = width * filter_bytes;
       int filter = *raw++;
 
-      // check filter type
       if (filter > 4) {
          all_ok = stbi__err("invalid filter","Corrupt PNG");
          break;
       }
 
-      // if first row, use special filter that doesn't sample previous row
       if (j == 0) filter = first_row_filter[filter];
 
-      // perform actual filtering
       switch (filter) {
       case STBI__F_none:
          memcpy(cur, raw, nk);
@@ -4773,7 +3993,7 @@ static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 r
          break;
       case STBI__F_paeth:
          for (k = 0; k < filter_bytes; ++k)
-            cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0)
+            cur[k] = STBI__BYTECAST(raw[k] + prior[k]);
          for (k = filter_bytes; k < nk; ++k)
             cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes]));
          break;
@@ -4786,15 +4006,13 @@ static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 r
 
       raw += nk;
 
-      // expand decoded bits in cur to dest, also adding an extra alpha channel if desired
       if (depth < 8) {
-         stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range
+         stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1;
          stbi_uc *in = cur;
          stbi_uc *out = dest;
          stbi_uc inb = 0;
          stbi__uint32 nsmp = x*img_n;
 
-         // expand bits to bytes first
          if (depth == 4) {
             for (i=0; i < nsmp; ++i) {
                if ((i & 1) == 0) inb = *in++;
@@ -4816,7 +4034,6 @@ static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 r
             }
          }
 
-         // insert alpha=255 values if desired
          if (img_n != out_n)
             stbi__create_png_alpha_expand8(dest, dest, x, img_n);
       } else if (depth == 8) {
@@ -4825,7 +4042,7 @@ static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 r
          else
             stbi__create_png_alpha_expand8(dest, cur, x, img_n);
       } else if (depth == 16) {
-         // convert the image data from big-endian to platform-native
+
          stbi__uint16 *dest16 = (stbi__uint16*)dest;
          stbi__uint32 nsmp = x*img_n;
 
@@ -4867,7 +4084,6 @@ static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint3
    if (!interlaced)
       return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);
 
-   // de-interlacing
    final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);
    if (!final) return stbi__err("outofmem", "Out of memory");
    for (p=0; p < 7; ++p) {
@@ -4876,7 +4092,7 @@ static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint3
       int xspc[]  = { 8,8,4,4,2,2,1 };
       int yspc[]  = { 8,8,8,4,4,2,2 };
       int i,j,x,y;
-      // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1
+
       x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];
       y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];
       if (x && y) {
@@ -4909,8 +4125,6 @@ static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)
    stbi__uint32 i, pixel_count = s->img_x * s->img_y;
    stbi_uc *p = z->out;
 
-   // compute color-based transparency, assuming we've
-   // already got 255 as the alpha value in the output
    STBI_ASSERT(out_n == 2 || out_n == 4);
 
    if (out_n == 2) {
@@ -4934,8 +4148,6 @@ static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int ou
    stbi__uint32 i, pixel_count = s->img_x * s->img_y;
    stbi__uint16 *p = (stbi__uint16*) z->out;
 
-   // compute color-based transparency, assuming we've
-   // already got 65535 as the alpha value in the output
    STBI_ASSERT(out_n == 2 || out_n == 4);
 
    if (out_n == 2) {
@@ -4961,7 +4173,6 @@ static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int
    p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0);
    if (p == NULL) return stbi__err("outofmem", "Out of memory");
 
-   // between here and free(out) below, exitting would leak
    temp_out = p;
 
    if (pal_img_n == 3) {
@@ -5028,7 +4239,7 @@ STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_conve
 #define stbi__de_iphone_flag  (stbi__de_iphone_flag_set                         \
                                 ? stbi__de_iphone_flag_local                    \
                                 : stbi__de_iphone_flag_global)
-#endif // STBI_THREAD_LOCAL
+#endif
 
 static void stbi__de_iphone(stbi__png *z)
 {
@@ -5036,7 +4247,7 @@ static void stbi__de_iphone(stbi__png *z)
    stbi__uint32 i, pixel_count = s->img_x * s->img_y;
    stbi_uc *p = z->out;
 
-   if (s->img_out_n == 3) {  // convert bgr to rgb
+   if (s->img_out_n == 3) {
       for (i=0; i < pixel_count; ++i) {
          stbi_uc t = p[0];
          p[0] = p[2];
@@ -5046,7 +4257,7 @@ static void stbi__de_iphone(stbi__png *z)
    } else {
       STBI_ASSERT(s->img_out_n == 4);
       if (stbi__unpremultiply_on_load) {
-         // convert bgr to rgb and unpremultiply
+
          for (i=0; i < pixel_count; ++i) {
             stbi_uc a = p[3];
             stbi_uc t = p[0];
@@ -5062,7 +4273,7 @@ static void stbi__de_iphone(stbi__png *z)
             p += 4;
          }
       } else {
-         // convert bgr to rgb
+
          for (i=0; i < pixel_count; ++i) {
             stbi_uc t = p[0];
             p[0] = p[2];
@@ -5120,12 +4331,11 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
                s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
                if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode");
             } else {
-               // if paletted, then pal_n is our final components, and
-               // img_n is # components to decompress/filter.
+
                s->img_n = 1;
                if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG");
             }
-            // even with SCAN_header, have to scan to see if we have a tRNS
+
             break;
          }
 
@@ -5157,14 +4367,14 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
                if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG");
                if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG");
                has_trans = 1;
-               // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now.
+
                if (scan == STBI__SCAN_header) { ++s->img_n; return 1; }
                if (z->depth == 16) {
-                  for (k = 0; k < s->img_n && k < 3; ++k) // extra loop test to suppress false GCC warning
-                     tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is
+                  for (k = 0; k < s->img_n && k < 3; ++k)
+                     tc16[k] = (stbi__uint16)stbi__get16be(s);
                } else {
                   for (k = 0; k < s->img_n && k < 3; ++k)
-                     tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger
+                     tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth];
                }
             }
             break;
@@ -5174,7 +4384,7 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
             if (first) return stbi__err("first not IHDR", "Corrupt PNG");
             if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG");
             if (scan == STBI__SCAN_header) {
-               // header scan definitely stops at first IDAT
+
                if (pal_img_n)
                   s->img_n = pal_img_n;
                return 1;
@@ -5201,11 +4411,11 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
             if (first) return stbi__err("first not IHDR", "Corrupt PNG");
             if (scan != STBI__SCAN_load) return 1;
             if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG");
-            // initial guess for decoded data size to avoid unnecessary reallocs
-            bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component
-            raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */;
+
+            bpl = (s->img_x * z->depth + 7) / 8;
+            raw_len = bpl * s->img_y * s->img_n  + s->img_y ;
             z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone);
-            if (z->expanded == NULL) return 0; // zlib should set error
+            if (z->expanded == NULL) return 0;
             STBI_FREE(z->idata); z->idata = NULL;
             if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
                s->img_out_n = s->img_n+1;
@@ -5222,28 +4432,28 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
             if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2)
                stbi__de_iphone(z);
             if (pal_img_n) {
-               // pal_img_n == 3 or 4
-               s->img_n = pal_img_n; // record the actual colors we had
+
+               s->img_n = pal_img_n;
                s->img_out_n = pal_img_n;
                if (req_comp >= 3) s->img_out_n = req_comp;
                if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))
                   return 0;
             } else if (has_trans) {
-               // non-paletted image with tRNS -> source image has (constant) alpha
+
                ++s->img_n;
             }
             STBI_FREE(z->expanded); z->expanded = NULL;
-            // end of PNG chunk, read and skip CRC
+
             stbi__get32be(s);
             return 1;
          }
 
          default:
-            // if critical, fail
+
             if (first) return stbi__err("first not IHDR", "Corrupt PNG");
             if ((c.type & (1 << 29)) == 0) {
                #ifndef STBI_NO_FAILURE_STRINGS
-               // not threadsafe
+
                static char invalid_chunk[] = "XXXX PNG chunk not known";
                invalid_chunk[0] = STBI__BYTECAST(c.type >> 24);
                invalid_chunk[1] = STBI__BYTECAST(c.type >> 16);
@@ -5255,7 +4465,7 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
             stbi__skip(s, c.length);
             break;
       }
-      // end of PNG chunk, read and skip CRC
+
       stbi__get32be(s);
    }
 }
@@ -5340,8 +4550,6 @@ static int stbi__png_is16(stbi__context *s)
 }
 #endif
 
-// Microsoft/Windows BMP image
-
 #ifndef STBI_NO_BMP
 static int stbi__bmp_test_raw(stbi__context *s)
 {
@@ -5349,10 +4557,10 @@ static int stbi__bmp_test_raw(stbi__context *s)
    int sz;
    if (stbi__get8(s) != 'B') return 0;
    if (stbi__get8(s) != 'M') return 0;
-   stbi__get32le(s); // discard filesize
-   stbi__get16le(s); // discard reserved
-   stbi__get16le(s); // discard reserved
-   stbi__get32le(s); // discard data offset
+   stbi__get32le(s);
+   stbi__get16le(s);
+   stbi__get16le(s);
+   stbi__get32le(s);
    sz = stbi__get32le(s);
    r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);
    return r;
@@ -5365,8 +4573,6 @@ static int stbi__bmp_test(stbi__context *s)
    return r;
 }
 
-
-// returns 0..31 for the highest set bit
 static int stbi__high_bit(unsigned int z)
 {
    int n=0;
@@ -5375,29 +4581,26 @@ static int stbi__high_bit(unsigned int z)
    if (z >= 0x00100) { n +=  8; z >>=  8; }
    if (z >= 0x00010) { n +=  4; z >>=  4; }
    if (z >= 0x00004) { n +=  2; z >>=  2; }
-   if (z >= 0x00002) { n +=  1;/* >>=  1;*/ }
+   if (z >= 0x00002) { n +=  1; }
    return n;
 }
 
 static int stbi__bitcount(unsigned int a)
 {
-   a = (a & 0x55555555) + ((a >>  1) & 0x55555555); // max 2
-   a = (a & 0x33333333) + ((a >>  2) & 0x33333333); // max 4
-   a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
-   a = (a + (a >> 8)); // max 16 per 8 bits
-   a = (a + (a >> 16)); // max 32 per 8 bits
+   a = (a & 0x55555555) + ((a >>  1) & 0x55555555);
+   a = (a & 0x33333333) + ((a >>  2) & 0x33333333);
+   a = (a + (a >> 4)) & 0x0f0f0f0f;
+   a = (a + (a >> 8));
+   a = (a + (a >> 16));
    return a & 0xff;
 }
 
-// extract an arbitrarily-aligned N-bit value (N=bits)
-// from v, and then make it 8-bits long and fractionally
-// extend it to full full range.
 static int stbi__shiftsigned(unsigned int v, int shift, int bits)
 {
    static unsigned int mul_table[9] = {
       0,
-      0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/,
-      0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/,
+      0xff, 0x55, 0x49, 0x11,
+      0x21, 0x41, 0x81, 0x01,
    };
    static unsigned int shift_table[9] = {
       0, 0,0,1,0,2,4,6,0,
@@ -5421,7 +4624,7 @@ typedef struct
 
 static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress)
 {
-   // BI_BITFIELDS specifies masks explicitly, don't override
+
    if (compress == 3)
       return 1;
 
@@ -5435,23 +4638,23 @@ static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress)
          info->mg = 0xffu <<  8;
          info->mb = 0xffu <<  0;
          info->ma = 0xffu << 24;
-         info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0
+         info->all_a = 0;
       } else {
-         // otherwise, use defaults, which is all-0
+
          info->mr = info->mg = info->mb = info->ma = 0;
       }
       return 1;
    }
-   return 0; // error
+   return 0;
 }
 
 static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
 {
    int hsz;
    if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP");
-   stbi__get32le(s); // discard filesize
-   stbi__get16le(s); // discard reserved
-   stbi__get16le(s); // discard reserved
+   stbi__get32le(s);
+   stbi__get16le(s);
+   stbi__get16le(s);
    info->offset = stbi__get32le(s);
    info->hsz = hsz = stbi__get32le(s);
    info->mr = info->mg = info->mb = info->ma = 0;
@@ -5472,13 +4675,13 @@ static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
    if (hsz != 12) {
       int compress = stbi__get32le(s);
       if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE");
-      if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes
-      if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel
-      stbi__get32le(s); // discard sizeof
-      stbi__get32le(s); // discard hres
-      stbi__get32le(s); // discard vres
-      stbi__get32le(s); // discard colorsused
-      stbi__get32le(s); // discard max important
+      if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression");
+      if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP");
+      stbi__get32le(s);
+      stbi__get32le(s);
+      stbi__get32le(s);
+      stbi__get32le(s);
+      stbi__get32le(s);
       if (hsz == 40 || hsz == 56) {
          if (hsz == 56) {
             stbi__get32le(s);
@@ -5494,16 +4697,16 @@ static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
                info->mg = stbi__get32le(s);
                info->mb = stbi__get32le(s);
                info->extra_read += 12;
-               // not documented, but generated by photoshop and handled by mspaint
+
                if (info->mr == info->mg && info->mg == info->mb) {
-                  // ?!?!?
+
                   return stbi__errpuc("bad BMP", "bad BMP");
                }
             } else
                return stbi__errpuc("bad BMP", "bad BMP");
          }
       } else {
-         // V4/V5 header
+
          int i;
          if (hsz != 108 && hsz != 124)
             return stbi__errpuc("bad BMP", "bad BMP");
@@ -5511,23 +4714,22 @@ static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
          info->mg = stbi__get32le(s);
          info->mb = stbi__get32le(s);
          info->ma = stbi__get32le(s);
-         if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs
+         if (compress != 3)
             stbi__bmp_set_mask_defaults(info, compress);
-         stbi__get32le(s); // discard color space
+         stbi__get32le(s);
          for (i=0; i < 12; ++i)
-            stbi__get32le(s); // discard color space parameters
+            stbi__get32le(s);
          if (hsz == 124) {
-            stbi__get32le(s); // discard rendering intent
-            stbi__get32le(s); // discard offset of profile data
-            stbi__get32le(s); // discard size of profile data
-            stbi__get32le(s); // discard reserved
+            stbi__get32le(s);
+            stbi__get32le(s);
+            stbi__get32le(s);
+            stbi__get32le(s);
          }
       }
    }
    return (void *) 1;
 }
 
-
 static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
 {
    stbi_uc *out;
@@ -5540,7 +4742,7 @@ static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req
 
    info.all_a = 255;
    if (stbi__bmp_parse_header(s, &info) == NULL)
-      return NULL; // error code already set
+      return NULL;
 
    flip_vertically = ((int) s->img_y) > 0;
    s->img_y = abs((int) s->img_y);
@@ -5562,18 +4764,14 @@ static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req
          psize = (info.offset - info.extra_read - info.hsz) >> 2;
    }
    if (psize == 0) {
-      // accept some number of extra bytes after the header, but if the offset points either to before
-      // the header ends or implies a large amount of extra data, reject the file as malformed
+
       int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original);
-      int header_limit = 1024; // max we actually read is below 256 bytes currently.
-      int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size.
+      int header_limit = 1024;
+      int extra_data_limit = 256*4;
       if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) {
          return stbi__errpuc("bad header", "Corrupt BMP");
       }
-      // we established that bytes_read_so_far is positive and sensible.
-      // the first half of this test rejects offsets that are either too small positives, or
-      // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn
-      // ensures the number computed in the second half of the test can't overflow.
+
       if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) {
          return stbi__errpuc("bad offset", "Corrupt BMP");
       } else {
@@ -5585,12 +4783,11 @@ static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req
       s->img_n = 3;
    else
       s->img_n = ma ? 4 : 3;
-   if (req_comp && req_comp >= 3) // we can directly decode 3 or 4
+   if (req_comp && req_comp >= 3)
       target = req_comp;
    else
-      target = s->img_n; // if they want monochrome, we'll post-convert
+      target = s->img_n;
 
-   // sanity-check size
    if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0))
       return stbi__errpuc("too large", "Corrupt BMP");
 
@@ -5658,7 +4855,7 @@ static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req
       stbi__skip(s, info.offset - info.extra_read - info.hsz);
       if (info.bpp == 24) width = 3 * s->img_x;
       else if (info.bpp == 16) width = 2*s->img_x;
-      else /* bpp = 32 and pad = 0 */ width=0;
+      else  width=0;
       pad = (-width) & 3;
       if (info.bpp == 24) {
          easy = 1;
@@ -5668,7 +4865,7 @@ static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req
       }
       if (!easy) {
          if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
-         // right shift amt to put high bit in position #7
+
          rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr);
          gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg);
          bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb);
@@ -5704,7 +4901,6 @@ static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req
       }
    }
 
-   // if alpha channel is all 0s, replace with all 255s
    if (target == 4 && all_a == 0)
       for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4)
          out[i] = 255;
@@ -5722,7 +4918,7 @@ static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req
 
    if (req_comp && req_comp != target) {
       out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);
-      if (out == NULL) return out; // stbi__convert_format frees input on failure
+      if (out == NULL) return out;
    }
 
    *x = s->img_x;
@@ -5732,21 +4928,19 @@ static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req
 }
 #endif
 
-// Targa Truevision - TGA
-// by Jonathan Dummer
 #ifndef STBI_NO_TGA
-// returns STBI_rgb or whatever, 0 on error
+
 static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)
 {
-   // only RGB or RGBA (incl. 16bit) or grey allowed
+
    if (is_rgb16) *is_rgb16 = 0;
    switch(bits_per_pixel) {
       case 8:  return STBI_grey;
       case 16: if(is_grey) return STBI_grey_alpha;
-               // fallthrough
+
       case 15: if(is_rgb16) *is_rgb16 = 1;
                return STBI_rgb;
-      case 24: // fallthrough
+      case 24:
       case 32: return bits_per_pixel/8;
       default: return 0;
    }
@@ -5756,50 +4950,49 @@ static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)
 {
     int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;
     int sz, tga_colormap_type;
-    stbi__get8(s);                   // discard Offset
-    tga_colormap_type = stbi__get8(s); // colormap type
+    stbi__get8(s);
+    tga_colormap_type = stbi__get8(s);
     if( tga_colormap_type > 1 ) {
         stbi__rewind(s);
-        return 0;      // only RGB or indexed allowed
+        return 0;
     }
-    tga_image_type = stbi__get8(s); // image type
-    if ( tga_colormap_type == 1 ) { // colormapped (paletted) image
+    tga_image_type = stbi__get8(s);
+    if ( tga_colormap_type == 1 ) {
         if (tga_image_type != 1 && tga_image_type != 9) {
             stbi__rewind(s);
             return 0;
         }
-        stbi__skip(s,4);       // skip index of first colormap entry and number of entries
-        sz = stbi__get8(s);    //   check bits per palette color entry
+        stbi__skip(s,4);
+        sz = stbi__get8(s);
         if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) {
             stbi__rewind(s);
             return 0;
         }
-        stbi__skip(s,4);       // skip image x and y origin
+        stbi__skip(s,4);
         tga_colormap_bpp = sz;
-    } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE
+    } else {
         if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) {
             stbi__rewind(s);
-            return 0; // only RGB or grey allowed, +/- RLE
+            return 0;
         }
-        stbi__skip(s,9); // skip colormap specification and image x/y origin
+        stbi__skip(s,9);
         tga_colormap_bpp = 0;
     }
     tga_w = stbi__get16le(s);
     if( tga_w < 1 ) {
         stbi__rewind(s);
-        return 0;   // test width
+        return 0;
     }
     tga_h = stbi__get16le(s);
     if( tga_h < 1 ) {
         stbi__rewind(s);
-        return 0;   // test height
+        return 0;
     }
-    tga_bits_per_pixel = stbi__get8(s); // bits per pixel
-    stbi__get8(s); // ignore alpha bits
+    tga_bits_per_pixel = stbi__get8(s);
+    stbi__get8(s);
     if (tga_colormap_bpp != 0) {
         if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) {
-            // when using a colormap, tga_bits_per_pixel is the size of the indexes
-            // I don't think anything but 8 or 16bit indexes makes sense
+
             stbi__rewind(s);
             return 0;
         }
@@ -5814,63 +5007,58 @@ static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)
     if (x) *x = tga_w;
     if (y) *y = tga_h;
     if (comp) *comp = tga_comp;
-    return 1;                   // seems to have passed everything
+    return 1;
 }
 
 static int stbi__tga_test(stbi__context *s)
 {
    int res = 0;
    int sz, tga_color_type;
-   stbi__get8(s);      //   discard Offset
-   tga_color_type = stbi__get8(s);   //   color type
-   if ( tga_color_type > 1 ) goto errorEnd;   //   only RGB or indexed allowed
-   sz = stbi__get8(s);   //   image type
-   if ( tga_color_type == 1 ) { // colormapped (paletted) image
-      if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9
-      stbi__skip(s,4);       // skip index of first colormap entry and number of entries
-      sz = stbi__get8(s);    //   check bits per palette color entry
+   stbi__get8(s);
+   tga_color_type = stbi__get8(s);
+   if ( tga_color_type > 1 ) goto errorEnd;
+   sz = stbi__get8(s);
+   if ( tga_color_type == 1 ) {
+      if (sz != 1 && sz != 9) goto errorEnd;
+      stbi__skip(s,4);
+      sz = stbi__get8(s);
       if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
-      stbi__skip(s,4);       // skip image x and y origin
-   } else { // "normal" image w/o colormap
-      if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE
-      stbi__skip(s,9); // skip colormap specification and image x/y origin
-   }
-   if ( stbi__get16le(s) < 1 ) goto errorEnd;      //   test width
-   if ( stbi__get16le(s) < 1 ) goto errorEnd;      //   test height
-   sz = stbi__get8(s);   //   bits per pixel
-   if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index
+      stbi__skip(s,4);
+   } else {
+      if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd;
+      stbi__skip(s,9);
+   }
+   if ( stbi__get16le(s) < 1 ) goto errorEnd;
+   if ( stbi__get16le(s) < 1 ) goto errorEnd;
+   sz = stbi__get8(s);
+   if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd;
    if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
 
-   res = 1; // if we got this far, everything's good and we can return 1 instead of 0
+   res = 1;
 
 errorEnd:
    stbi__rewind(s);
    return res;
 }
 
-// read 16bit value and convert to 24bit RGB
 static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)
 {
    stbi__uint16 px = (stbi__uint16)stbi__get16le(s);
    stbi__uint16 fiveBitMask = 31;
-   // we have 3 channels with 5bits each
+
    int r = (px >> 10) & fiveBitMask;
    int g = (px >> 5) & fiveBitMask;
    int b = px & fiveBitMask;
-   // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later
+
    out[0] = (stbi_uc)((r * 255)/31);
    out[1] = (stbi_uc)((g * 255)/31);
    out[2] = (stbi_uc)((b * 255)/31);
 
-   // some people claim that the most significant bit might be used for alpha
-   // (possibly if an alpha-bit is set in the "image descriptor byte")
-   // but that only made 16bit test images completely translucent..
-   // so let's treat all 15 and 16bit TGAs as RGB with no alpha.
 }
 
 static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
 {
-   //   read in the TGA header stuff
+
    int tga_offset = stbi__get8(s);
    int tga_indexed = stbi__get8(s);
    int tga_image_type = stbi__get8(s);
@@ -5885,8 +5073,7 @@ static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req
    int tga_bits_per_pixel = stbi__get8(s);
    int tga_comp, tga_rgb16=0;
    int tga_inverted = stbi__get8(s);
-   // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?)
-   //   image data
+
    unsigned char *tga_data;
    unsigned char *tga_palette = NULL;
    int i, j;
@@ -5895,13 +5082,12 @@ static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req
    int RLE_repeating = 0;
    int read_next_pixel = 1;
    STBI_NOTUSED(ri);
-   STBI_NOTUSED(tga_x_origin); // @TODO
-   STBI_NOTUSED(tga_y_origin); // @TODO
+   STBI_NOTUSED(tga_x_origin);
+   STBI_NOTUSED(tga_y_origin);
 
    if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
    if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
 
-   //   do a tiny bit of precessing
    if ( tga_image_type >= 8 )
    {
       tga_image_type -= 8;
@@ -5909,14 +5095,12 @@ static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req
    }
    tga_inverted = 1 - ((tga_inverted >> 5) & 1);
 
-   //   If I'm paletted, then I'll use the number of bits from the palette
    if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16);
    else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16);
 
-   if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency
+   if(!tga_comp)
       return stbi__errpuc("bad format", "Can't find out TGA pixelformat");
 
-   //   tga info
    *x = tga_width;
    *y = tga_height;
    if (comp) *comp = tga_comp;
@@ -5927,7 +5111,6 @@ static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req
    tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0);
    if (!tga_data) return stbi__errpuc("outofmem", "Out of memory");
 
-   // skip to the data's starting position (offset usually = 0)
    stbi__skip(s, tga_offset );
 
    if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) {
@@ -5937,17 +5120,16 @@ static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req
          stbi__getn(s, tga_row, tga_width * tga_comp);
       }
    } else  {
-      //   do I need to load a palette?
+
       if ( tga_indexed)
       {
-         if (tga_palette_len == 0) {  /* you have to have at least one entry! */
+         if (tga_palette_len == 0) {
             STBI_FREE(tga_data);
             return stbi__errpuc("bad palette", "Corrupt TGA");
          }
 
-         //   any data to skip? (offset usually = 0)
          stbi__skip(s, tga_palette_start );
-         //   load the palette
+
          tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0);
          if (!tga_palette) {
             STBI_FREE(tga_data);
@@ -5966,15 +5148,15 @@ static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req
                return stbi__errpuc("bad palette", "Corrupt TGA");
          }
       }
-      //   load the data
+
       for (i=0; i < tga_width * tga_height; ++i)
       {
-         //   if I'm in RLE mode, do I need to get a RLE stbi__pngchunk?
+
          if ( tga_is_RLE )
          {
             if ( RLE_count == 0 )
             {
-               //   yep, get the next byte as a RLE command
+
                int RLE_cmd = stbi__get8(s);
                RLE_count = 1 + (RLE_cmd & 127);
                RLE_repeating = RLE_cmd >> 7;
@@ -5987,16 +5169,16 @@ static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req
          {
             read_next_pixel = 1;
          }
-         //   OK, if I need to read a pixel, do it now
+
          if ( read_next_pixel )
          {
-            //   load however much data we did have
+
             if ( tga_indexed )
             {
-               // read in index, then perform the lookup
+
                int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s);
                if ( pal_idx >= tga_palette_len ) {
-                  // invalid index
+
                   pal_idx = 0;
                }
                pal_idx *= tga_comp;
@@ -6007,23 +5189,21 @@ static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req
                STBI_ASSERT(tga_comp == STBI_rgb);
                stbi__tga_read_rgb16(s, raw_data);
             } else {
-               //   read in the data raw
+
                for (j = 0; j < tga_comp; ++j) {
                   raw_data[j] = stbi__get8(s);
                }
             }
-            //   clear the reading flag for the next pixel
+
             read_next_pixel = 0;
-         } // end of reading a pixel
+         }
 
-         // copy data
          for (j = 0; j < tga_comp; ++j)
            tga_data[i*tga_comp+j] = raw_data[j];
 
-         //   in case we're in RLE mode, keep counting down
          --RLE_count;
       }
-      //   do I need to invert the image?
+
       if ( tga_inverted )
       {
          for (j = 0; j*2 < tga_height; ++j)
@@ -6040,14 +5220,13 @@ static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req
             }
          }
       }
-      //   clear my palette, if I had one
+
       if ( tga_palette != NULL )
       {
          STBI_FREE( tga_palette );
       }
    }
 
-   // swap RGB - if the source data was RGB16, it already is in the right order
    if (tga_comp >= 3 && !tga_rgb16)
    {
       unsigned char* tga_pixel = tga_data;
@@ -6060,23 +5239,17 @@ static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req
       }
    }
 
-   // convert to target component count
    if (req_comp && req_comp != tga_comp)
       tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);
 
-   //   the things I do to get rid of an error message, and yet keep
-   //   Microsoft's C compilers happy... [8^(
    tga_palette_start = tga_palette_len = tga_palette_bits =
          tga_x_origin = tga_y_origin = 0;
    STBI_NOTUSED(tga_palette_start);
-   //   OK, done
+
    return tga_data;
 }
 #endif
 
-// *************************************************************************************************
-// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB
-
 #ifndef STBI_NO_PSD
 static int stbi__psd_test(stbi__context *s)
 {
@@ -6093,11 +5266,11 @@ static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)
    while ((nleft = pixelCount - count) > 0) {
       len = stbi__get8(s);
       if (len == 128) {
-         // No-op.
+
       } else if (len < 128) {
-         // Copy next len+1 bytes literally.
+
          len++;
-         if (len > nleft) return 0; // corrupt data
+         if (len > nleft) return 0;
          count += len;
          while (len) {
             *p = stbi__get8(s);
@@ -6106,10 +5279,9 @@ static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)
          }
       } else if (len > 128) {
          stbi_uc   val;
-         // Next -len+1 bytes in the dest are replicated from next source byte.
-         // (Interpret len as a negative 8-bit int.)
+
          len = 257 - len;
-         if (len > nleft) return 0; // corrupt data
+         if (len > nleft) return 0;
          val = stbi__get8(s);
          count += len;
          while (len) {
@@ -6133,70 +5305,44 @@ static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req
    stbi_uc *out;
    STBI_NOTUSED(ri);
 
-   // Check identifier
-   if (stbi__get32be(s) != 0x38425053)   // "8BPS"
+   if (stbi__get32be(s) != 0x38425053)
       return stbi__errpuc("not PSD", "Corrupt PSD image");
 
-   // Check file type version.
    if (stbi__get16be(s) != 1)
       return stbi__errpuc("wrong version", "Unsupported version of PSD image");
 
-   // Skip 6 reserved bytes.
    stbi__skip(s, 6 );
 
-   // Read the number of channels (R, G, B, A, etc).
    channelCount = stbi__get16be(s);
    if (channelCount < 0 || channelCount > 16)
       return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image");
 
-   // Read the rows and columns of the image.
    h = stbi__get32be(s);
    w = stbi__get32be(s);
 
    if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
    if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
 
-   // Make sure the depth is 8 bits.
    bitdepth = stbi__get16be(s);
    if (bitdepth != 8 && bitdepth != 16)
       return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit");
 
-   // Make sure the color mode is RGB.
-   // Valid options are:
-   //   0: Bitmap
-   //   1: Grayscale
-   //   2: Indexed color
-   //   3: RGB color
-   //   4: CMYK color
-   //   7: Multichannel
-   //   8: Duotone
-   //   9: Lab color
    if (stbi__get16be(s) != 3)
       return stbi__errpuc("wrong color format", "PSD is not in RGB color format");
 
-   // Skip the Mode Data.  (It's the palette for indexed color; other info for other modes.)
    stbi__skip(s,stbi__get32be(s) );
 
-   // Skip the image resources.  (resolution, pen tool paths, etc)
    stbi__skip(s, stbi__get32be(s) );
 
-   // Skip the reserved data.
    stbi__skip(s, stbi__get32be(s) );
 
-   // Find out if the data is compressed.
-   // Known values:
-   //   0: no compression
-   //   1: RLE compressed
    compression = stbi__get16be(s);
    if (compression > 1)
       return stbi__errpuc("bad compression", "PSD has an unknown compression format");
 
-   // Check size
    if (!stbi__mad3sizes_valid(4, w, h, 0))
       return stbi__errpuc("too large", "Corrupt PSD");
 
-   // Create the destination image.
-
    if (!compression && bitdepth == 16 && bpc == 16) {
       out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0);
       ri->bits_per_channel = 16;
@@ -6206,34 +5352,20 @@ static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req
    if (!out) return stbi__errpuc("outofmem", "Out of memory");
    pixelCount = w*h;
 
-   // Initialize the data to zero.
-   //memset( out, 0, pixelCount * 4 );
-
-   // Finally, the image data.
    if (compression) {
-      // RLE as used by .PSD and .TIFF
-      // Loop until you get the number of unpacked bytes you are expecting:
-      //     Read the next source byte into n.
-      //     If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.
-      //     Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.
-      //     Else if n is 128, noop.
-      // Endloop
-
-      // The RLE-compressed data is preceded by a 2-byte data count for each row in the data,
-      // which we're going to just skip.
+
       stbi__skip(s, h * channelCount * 2 );
 
-      // Read the RLE data by channel.
       for (channel = 0; channel < 4; channel++) {
          stbi_uc *p;
 
          p = out+channel;
          if (channel >= channelCount) {
-            // Fill this channel with default data.
+
             for (i = 0; i < pixelCount; i++, p += 4)
                *p = (channel == 3 ? 255 : 0);
          } else {
-            // Read the RLE data.
+
             if (!stbi__psd_decode_rle(s, p, pixelCount)) {
                STBI_FREE(out);
                return stbi__errpuc("corrupt", "bad RLE data");
@@ -6242,13 +5374,10 @@ static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req
       }
 
    } else {
-      // We're at the raw image data.  It's each channel in order (Red, Green, Blue, Alpha, ...)
-      // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image.
 
-      // Read the data by channel.
       for (channel = 0; channel < 4; channel++) {
          if (channel >= channelCount) {
-            // Fill this channel with default data.
+
             if (bitdepth == 16 && bpc == 16) {
                stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
                stbi__uint16 val = channel == 3 ? 65535 : 0;
@@ -6261,13 +5390,13 @@ static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req
                   *p = val;
             }
          } else {
-            if (ri->bits_per_channel == 16) {    // output bpc
+            if (ri->bits_per_channel == 16) {
                stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
                for (i = 0; i < pixelCount; i++, q += 4)
                   *q = (stbi__uint16) stbi__get16be(s);
             } else {
                stbi_uc *p = out+channel;
-               if (bitdepth == 16) {  // input bpc
+               if (bitdepth == 16) {
                   for (i = 0; i < pixelCount; i++, p += 4)
                      *p = (stbi_uc) (stbi__get16be(s) >> 8);
                } else {
@@ -6279,7 +5408,6 @@ static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req
       }
    }
 
-   // remove weird white matte from PSD
    if (channelCount >= 4) {
       if (ri->bits_per_channel == 16) {
          for (i=0; i < w*h; ++i) {
@@ -6308,13 +5436,12 @@ static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req
       }
    }
 
-   // convert to desired output format
    if (req_comp && req_comp != 4) {
       if (ri->bits_per_channel == 16)
          out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h);
       else
          out = stbi__convert_format(out, 4, req_comp, w, h);
-      if (out == NULL) return out; // stbi__convert_format frees input on failure
+      if (out == NULL) return out;
    }
 
    if (comp) *comp = 4;
@@ -6325,13 +5452,6 @@ static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req
 }
 #endif
 
-// *************************************************************************************************
-// Softimage PIC loader
-// by Tom Seddon
-//
-// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format
-// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/
-
 #ifndef STBI_NO_PIC
 static int stbi__pic_is4(stbi__context *s,const char *str)
 {
@@ -6392,8 +5512,6 @@ static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *c
    int act_comp=0,num_packets=0,y,chained;
    stbi__pic_packet packets[10];
 
-   // this will (should...) cater for even some bizarre stuff like having data
-    // for the same channel in multiple packets.
    do {
       stbi__pic_packet *packet;
 
@@ -6413,7 +5531,7 @@ static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *c
       if (packet->size != 8)  return stbi__errpuc("bad format","packet isn't 8bpp");
    } while (chained);
 
-   *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel?
+   *comp = (act_comp & 0x10 ? 4 : 3);
 
    for(y=0; y<height; ++y) {
       int packet_idx;
@@ -6426,7 +5544,7 @@ static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *c
             default:
                return stbi__errpuc("bad format","packet has bad compression type");
 
-            case 0: {//uncompressed
+            case 0: {
                int x;
 
                for(x=0;x<width;++x, dest+=4)
@@ -6435,7 +5553,7 @@ static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *c
                break;
             }
 
-            case 1://Pure RLE
+            case 1:
                {
                   int left=width, i;
 
@@ -6457,13 +5575,13 @@ static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *c
                }
                break;
 
-            case 2: {//Mixed RLE
+            case 2: {
                int left=width;
                while (left>0) {
                   int count = stbi__get8(s), i;
                   if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (mixed read count)");
 
-                  if (count >= 128) { // Repeated
+                  if (count >= 128) {
                      stbi_uc value[4];
 
                      if (count==128)
@@ -6478,7 +5596,7 @@ static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *c
 
                      for(i=0;i<count;++i, dest += 4)
                         stbi__copyval(packet->channel,dest,value);
-                  } else { // Raw
+                  } else {
                      ++count;
                      if (count>left) return stbi__errpuc("bad file","scanline overrun");
 
@@ -6517,11 +5635,10 @@ static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_c
    if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (pic header)");
    if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode");
 
-   stbi__get32be(s); //skip `ratio'
-   stbi__get16be(s); //skip `fields'
-   stbi__get16be(s); //skip `pad'
+   stbi__get32be(s);
+   stbi__get16be(s);
+   stbi__get16be(s);
 
-   // intermediate buffer is RGBA
    result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0);
    if (!result) return stbi__errpuc("outofmem", "Out of memory");
    memset(result, 0xff, x*y*4);
@@ -6546,9 +5663,6 @@ static int stbi__pic_test(stbi__context *s)
 }
 #endif
 
-// *************************************************************************************************
-// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb
-
 #ifndef STBI_NO_GIF
 typedef struct
 {
@@ -6560,8 +5674,8 @@ typedef struct
 typedef struct
 {
    int w,h;
-   stbi_uc *out;                 // output buffer (always 4 components)
-   stbi_uc *background;          // The current "background" as far as a gif is concerned
+   stbi_uc *out;
+   stbi_uc *background;
    stbi_uc *history;
    int flags, bgindex, ratio, transparent, eflags;
    stbi_uc  pal[256][4];
@@ -6626,7 +5740,7 @@ static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_in
    if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
    if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
 
-   if (comp != 0) *comp = 4;  // can't actually tell whether it's 3 or 4 until we parse the comments
+   if (comp != 0) *comp = 4;
 
    if (is_info) return 1;
 
@@ -6656,8 +5770,6 @@ static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
    stbi_uc *p, *c;
    int idx;
 
-   // recurse to decode the prefixes, since the linked-list is backwards,
-   // and working backwards through an interleaved image would be nasty
    if (g->codes[code].prefix >= 0)
       stbi__out_gif_code(g, g->codes[code].prefix);
 
@@ -6668,7 +5780,7 @@ static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
    g->history[idx / 4] = 1;
 
    c = &g->color_table[g->codes[code].suffix * 4];
-   if (c[3] > 128) { // don't render transparent pixels;
+   if (c[3] > 128) {
       p[0] = c[2];
       p[1] = c[1];
       p[2] = c[0];
@@ -6710,7 +5822,6 @@ static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
       g->codes[init_code].suffix = (stbi_uc) init_code;
    }
 
-   // support no starting clear code
    avail = clear+2;
    oldcode = -1;
 
@@ -6718,7 +5829,7 @@ static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
    for(;;) {
       if (valid_bits < codesize) {
          if (len == 0) {
-            len = stbi__get8(s); // start new block
+            len = stbi__get8(s);
             if (len == 0)
                return g->out;
          }
@@ -6729,14 +5840,14 @@ static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
          stbi__int32 code = bits & codemask;
          bits >>= codesize;
          valid_bits -= codesize;
-         // @OPTIMIZE: is there some way we can accelerate the non-clear path?
-         if (code == clear) {  // clear code
+
+         if (code == clear) {
             codesize = lzw_cs + 1;
             codemask = (1 << codesize) - 1;
             avail = clear + 2;
             oldcode = -1;
             first = 0;
-         } else if (code == clear + 1) { // end of stream code
+         } else if (code == clear + 1) {
             stbi__skip(s, len);
             while ((len = stbi__get8(s)) > 0)
                stbi__skip(s,len);
@@ -6773,8 +5884,6 @@ static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
    }
 }
 
-// this function is designed to support animated gifs, although stb_image doesn't support it
-// two back is the image from two frames ago, used for a very specific disposal format
 static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)
 {
    int dispose;
@@ -6783,10 +5892,9 @@ static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, i
    int pcount;
    STBI_NOTUSED(req_comp);
 
-   // on first frame, any non-written pixels get the background colour (non-transparent)
    first_frame = 0;
    if (g->out == 0) {
-      if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header
+      if (!stbi__gif_header(s, g, comp,0)) return 0;
       if (!stbi__mad3sizes_valid(4, g->w, g->h, 0))
          return stbi__errpuc("too large", "GIF image is too large");
       pcount = g->w * g->h;
@@ -6796,53 +5904,45 @@ static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, i
       if (!g->out || !g->background || !g->history)
          return stbi__errpuc("outofmem", "Out of memory");
 
-      // image is treated as "transparent" at the start - ie, nothing overwrites the current background;
-      // background colour is only used for pixels that are not rendered first frame, after that "background"
-      // color refers to the color that was there the previous frame.
       memset(g->out, 0x00, 4 * pcount);
-      memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent)
-      memset(g->history, 0x00, pcount);        // pixels that were affected previous frame
+      memset(g->background, 0x00, 4 * pcount);
+      memset(g->history, 0x00, pcount);
       first_frame = 1;
    } else {
-      // second frame - how do we dispose of the previous one?
+
       dispose = (g->eflags & 0x1C) >> 2;
       pcount = g->w * g->h;
 
       if ((dispose == 3) && (two_back == 0)) {
-         dispose = 2; // if I don't have an image to revert back to, default to the old background
+         dispose = 2;
       }
 
-      if (dispose == 3) { // use previous graphic
+      if (dispose == 3) {
          for (pi = 0; pi < pcount; ++pi) {
             if (g->history[pi]) {
                memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 );
             }
          }
       } else if (dispose == 2) {
-         // restore what was changed last frame to background before that frame;
+
          for (pi = 0; pi < pcount; ++pi) {
             if (g->history[pi]) {
                memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 );
             }
          }
       } else {
-         // This is a non-disposal case eithe way, so just
-         // leave the pixels as is, and they will become the new background
-         // 1: do not dispose
-         // 0:  not specified.
+
       }
 
-      // background is what out is after the undoing of the previou frame;
       memcpy( g->background, g->out, 4 * g->w * g->h );
    }
 
-   // clear my history;
-   memset( g->history, 0x00, g->w * g->h );        // pixels that were affected previous frame
+   memset( g->history, 0x00, g->w * g->h );
 
    for (;;) {
       int tag = stbi__get8(s);
       switch (tag) {
-         case 0x2C: /* Image Descriptor */
+         case 0x2C:
          {
             stbi__int32 x, y, w, h;
             stbi_uc *o;
@@ -6862,17 +5962,13 @@ static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, i
             g->cur_x   = g->start_x;
             g->cur_y   = g->start_y;
 
-            // if the width of the specified rectangle is 0, that means
-            // we may not see *any* pixels or the image is malformed;
-            // to make sure this is caught, move the current y down to
-            // max_y (which is what out_gif_code checks).
             if (w == 0)
                g->cur_y = g->max_y;
 
             g->lflags = stbi__get8(s);
 
             if (g->lflags & 0x40) {
-               g->step = 8 * g->line_size; // first interlaced spacing
+               g->step = 8 * g->line_size;
                g->parse = 3;
             } else {
                g->step = g->line_size;
@@ -6890,13 +5986,12 @@ static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, i
             o = stbi__process_gif_raster(s, g);
             if (!o) return NULL;
 
-            // if this was the first frame,
             pcount = g->w * g->h;
             if (first_frame && (g->bgindex > 0)) {
-               // if first frame, any pixel not drawn to gets the background color
+
                for (pi = 0; pi < pcount; ++pi) {
                   if (g->history[pi] == 0) {
-                     g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be;
+                     g->pal[g->bgindex][3] = 255;
                      memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 );
                   }
                }
@@ -6905,17 +6000,16 @@ static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, i
             return o;
          }
 
-         case 0x21: // Comment Extension.
+         case 0x21:
          {
             int len;
             int ext = stbi__get8(s);
-            if (ext == 0xF9) { // Graphic Control Extension.
+            if (ext == 0xF9) {
                len = stbi__get8(s);
                if (len == 4) {
                   g->eflags = stbi__get8(s);
-                  g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths.
+                  g->delay = 10 * stbi__get16le(s);
 
-                  // unset old transparent
                   if (g->transparent >= 0) {
                      g->pal[g->transparent][3] = 255;
                   }
@@ -6925,7 +6019,7 @@ static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, i
                         g->pal[g->transparent][3] = 0;
                      }
                   } else {
-                     // don't need transparent
+
                      stbi__skip(s, 1);
                      g->transparent = -1;
                   }
@@ -6940,8 +6034,8 @@ static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, i
             break;
          }
 
-         case 0x3B: // gif stream termination code
-            return (stbi_uc *) s; // using '1' causes warning on some compilers
+         case 0x3B:
+            return (stbi_uc *) s;
 
          default:
             return stbi__errpuc("unknown code", "Corrupt GIF");
@@ -6982,7 +6076,7 @@ static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y,
 
       do {
          u = stbi__gif_load_next(s, &g, comp, req_comp, two_back);
-         if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
+         if (u == (stbi_uc *) s) u = 0;
 
          if (u) {
             *x = g.w;
@@ -7029,12 +6123,10 @@ static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y,
          }
       } while (u != 0);
 
-      // free temp buffer;
       STBI_FREE(g.out);
       STBI_FREE(g.history);
       STBI_FREE(g.background);
 
-      // do the final conversion after loading everything;
       if (req_comp && req_comp != 4)
          out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h);
 
@@ -7053,21 +6145,18 @@ static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req
    STBI_NOTUSED(ri);
 
    u = stbi__gif_load_next(s, &g, comp, req_comp, 0);
-   if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
+   if (u == (stbi_uc *) s) u = 0;
    if (u) {
       *x = g.w;
       *y = g.h;
 
-      // moved conversion to after successful load so that the same
-      // can be done for multiple frames.
       if (req_comp && req_comp != 4)
          u = stbi__convert_format(u, 4, req_comp, g.w, g.h);
    } else if (g.out) {
-      // if there was an error and we allocated an image buffer, free it!
+
       STBI_FREE(g.out);
    }
 
-   // free buffers needed for multiple frame loading;
    STBI_FREE(g.history);
    STBI_FREE(g.background);
 
@@ -7080,9 +6169,6 @@ static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)
 }
 #endif
 
-// *************************************************************************************************
-// Radiance RGBE HDR loader
-// originally by Nicolas Schulz
 #ifndef STBI_NO_HDR
 static int stbi__hdr_test_core(stbi__context *s, const char *signature)
 {
@@ -7116,7 +6202,7 @@ static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)
    while (!stbi__at_eof(z) && c != '\n') {
       buffer[len++] = c;
       if (len == STBI__HDR_BUFLEN-1) {
-         // flush to end of line
+
          while (!stbi__at_eof(z) && stbi__get8(z) != '\n')
             ;
          break;
@@ -7132,7 +6218,7 @@ static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
 {
    if ( input[3] != 0 ) {
       float f1;
-      // Exponent
+
       f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
       if (req_comp <= 2)
          output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
@@ -7145,10 +6231,10 @@ static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
       if (req_comp == 4) output[3] = 1;
    } else {
       switch (req_comp) {
-         case 4: output[3] = 1; /* fallthrough */
+         case 4: output[3] = 1;
          case 3: output[0] = output[1] = output[2] = 0;
                  break;
-         case 2: output[1] = 1; /* fallthrough */
+         case 2: output[1] = 1;
          case 1: output[0] = 0;
                  break;
       }
@@ -7169,12 +6255,10 @@ static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int re
    const char *headerToken;
    STBI_NOTUSED(ri);
 
-   // Check identifier
    headerToken = stbi__hdr_gettoken(s,buffer);
    if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0)
       return stbi__errpf("not HDR", "Corrupt HDR image");
 
-   // Parse header
    for(;;) {
       token = stbi__hdr_gettoken(s,buffer);
       if (token[0] == 0) break;
@@ -7183,8 +6267,6 @@ static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int re
 
    if (!valid)    return stbi__errpf("unsupported format", "Unsupported HDR format");
 
-   // Parse width and height
-   // can't use sscanf() if we're not using stdio!
    token = stbi__hdr_gettoken(s,buffer);
    if (strncmp(token, "-Y ", 3))  return stbi__errpf("unsupported data layout", "Unsupported HDR format");
    token += 3;
@@ -7206,15 +6288,12 @@ static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int re
    if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0))
       return stbi__errpf("too large", "HDR image is too large");
 
-   // Read data
    hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0);
    if (!hdr_data)
       return stbi__errpf("outofmem", "Out of memory");
 
-   // Load image data
-   // image data is stored as some number of sca
    if ( width < 8 || width >= 32768) {
-      // Read flat data
+
       for (j=0; j < height; ++j) {
          for (i=0; i < width; ++i) {
             stbi_uc rgbe[4];
@@ -7224,7 +6303,7 @@ static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int re
          }
       }
    } else {
-      // Read RLE-encoded data
+
       scanline = NULL;
 
       for (j = 0; j < height; ++j) {
@@ -7232,8 +6311,7 @@ static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int re
          c2 = stbi__get8(s);
          len = stbi__get8(s);
          if (c1 != 2 || c2 != 2 || (len & 0x80)) {
-            // not run-length encoded, so we have to actually use THIS data as a decoded
-            // pixel (note this can't be a valid pixel--one of RGB must be >= 128)
+
             stbi_uc rgbe[4];
             rgbe[0] = (stbi_uc) c1;
             rgbe[1] = (stbi_uc) c2;
@@ -7243,7 +6321,7 @@ static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int re
             i = 1;
             j = 0;
             STBI_FREE(scanline);
-            goto main_decode_loop; // yes, this makes no sense
+            goto main_decode_loop;
          }
          len <<= 8;
          len |= stbi__get8(s);
@@ -7262,14 +6340,14 @@ static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int re
             while ((nleft = width - i) > 0) {
                count = stbi__get8(s);
                if (count > 128) {
-                  // Run
+
                   value = stbi__get8(s);
                   count -= 128;
                   if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
                   for (z = 0; z < count; ++z)
                      scanline[i++ * 4 + k] = value;
                } else {
-                  // Dump
+
                   if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
                   for (z = 0; z < count; ++z)
                      scanline[i++ * 4 + k] = stbi__get8(s);
@@ -7329,7 +6407,7 @@ static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
    *comp = 3;
    return 1;
 }
-#endif // STBI_NO_HDR
+#endif
 
 #ifndef STBI_NO_BMP
 static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)
@@ -7478,17 +6556,6 @@ static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)
 }
 #endif
 
-// *************************************************************************************************
-// Portable Gray Map and Portable Pixel Map loader
-// by Ken Miller
-//
-// PGM: http://netpbm.sourceforge.net/doc/pgm.html
-// PPM: http://netpbm.sourceforge.net/doc/ppm.html
-//
-// Known limitations:
-//    Does not support comments in the header section
-//    Does not support ASCII image data (formats P2 and P3)
-
 #ifndef STBI_NO_PNM
 
 static int      stbi__pnm_test(stbi__context *s)
@@ -7535,7 +6602,7 @@ static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req
       } else {
          out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
       }
-      if (out == NULL) return out; // stbi__convert_format frees input on failure
+      if (out == NULL) return out;
    }
    return out;
 }
@@ -7589,7 +6656,6 @@ static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
 
    stbi__rewind(s);
 
-   // Get identifier
    p = (char) stbi__get8(s);
    t = (char) stbi__get8(s);
    if (p != 'P' || (t != '5' && t != '6')) {
@@ -7597,22 +6663,22 @@ static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
        return 0;
    }
 
-   *comp = (t == '6') ? 3 : 1;  // '5' is 1-component .pgm; '6' is 3-component .ppm
+   *comp = (t == '6') ? 3 : 1;
 
    c = (char) stbi__get8(s);
    stbi__pnm_skip_whitespace(s, &c);
 
-   *x = stbi__pnm_getinteger(s, &c); // read width
+   *x = stbi__pnm_getinteger(s, &c);
    if(*x == 0)
        return stbi__err("invalid width", "PPM image header had zero or overflowing width");
    stbi__pnm_skip_whitespace(s, &c);
 
-   *y = stbi__pnm_getinteger(s, &c); // read height
+   *y = stbi__pnm_getinteger(s, &c);
    if (*y == 0)
        return stbi__err("invalid width", "PPM image header had zero or overflowing width");
    stbi__pnm_skip_whitespace(s, &c);
 
-   maxv = stbi__pnm_getinteger(s, &c);  // read max value
+   maxv = stbi__pnm_getinteger(s, &c);
    if (maxv > 65535)
       return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images");
    else if (maxv > 255)
@@ -7663,7 +6729,6 @@ static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)
    if (stbi__hdr_info(s, x, y, comp))  return 1;
    #endif
 
-   // test tga last because it's a crappy test!
    #ifndef STBI_NO_TGA
    if (stbi__tga_info(s, x, y, comp))
        return 1;
@@ -7729,7 +6794,7 @@ STBIDEF int stbi_is_16_bit_from_file(FILE *f)
    fseek(f,pos,SEEK_SET);
    return r;
 }
-#endif // !STBI_NO_STDIO
+#endif
 
 STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
 {
@@ -7759,230 +6824,4 @@ STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user
    return stbi__is_16_main(&s);
 }
 
-#endif // STB_IMAGE_IMPLEMENTATION
-
-/*
-   revision history:
-      2.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
-      2.19  (2018-02-11) fix warning
-      2.18  (2018-01-30) fix warnings
-      2.17  (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug
-                         1-bit BMP
-                         *_is_16_bit api
-                         avoid warnings
-      2.16  (2017-07-23) all functions have 16-bit variants;
-                         STBI_NO_STDIO works again;
-                         compilation fixes;
-                         fix rounding in unpremultiply;
-                         optimize vertical flip;
-                         disable raw_len validation;
-                         documentation fixes
-      2.15  (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode;
-                         warning fixes; disable run-time SSE detection on gcc;
-                         uniform handling of optional "return" values;
-                         thread-safe initialization of zlib tables
-      2.14  (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
-      2.13  (2016-11-29) add 16-bit API, only supported for PNG right now
-      2.12  (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
-      2.11  (2016-04-02) allocate large structures on the stack
-                         remove white matting for transparent PSD
-                         fix reported channel count for PNG & BMP
-                         re-enable SSE2 in non-gcc 64-bit
-                         support RGB-formatted JPEG
-                         read 16-bit PNGs (only as 8-bit)
-      2.10  (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED
-      2.09  (2016-01-16) allow comments in PNM files
-                         16-bit-per-pixel TGA (not bit-per-component)
-                         info() for TGA could break due to .hdr handling
-                         info() for BMP to shares code instead of sloppy parse
-                         can use STBI_REALLOC_SIZED if allocator doesn't support realloc
-                         code cleanup
-      2.08  (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA
-      2.07  (2015-09-13) fix compiler warnings
-                         partial animated GIF support
-                         limited 16-bpc PSD support
-                         #ifdef unused functions
-                         bug with < 92 byte PIC,PNM,HDR,TGA
-      2.06  (2015-04-19) fix bug where PSD returns wrong '*comp' value
-      2.05  (2015-04-19) fix bug in progressive JPEG handling, fix warning
-      2.04  (2015-04-15) try to re-enable SIMD on MinGW 64-bit
-      2.03  (2015-04-12) extra corruption checking (mmozeiko)
-                         stbi_set_flip_vertically_on_load (nguillemot)
-                         fix NEON support; fix mingw support
-      2.02  (2015-01-19) fix incorrect assert, fix warning
-      2.01  (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2
-      2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG
-      2.00  (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg)
-                         progressive JPEG (stb)
-                         PGM/PPM support (Ken Miller)
-                         STBI_MALLOC,STBI_REALLOC,STBI_FREE
-                         GIF bugfix -- seemingly never worked
-                         STBI_NO_*, STBI_ONLY_*
-      1.48  (2014-12-14) fix incorrectly-named assert()
-      1.47  (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb)
-                         optimize PNG (ryg)
-                         fix bug in interlaced PNG with user-specified channel count (stb)
-      1.46  (2014-08-26)
-              fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG
-      1.45  (2014-08-16)
-              fix MSVC-ARM internal compiler error by wrapping malloc
-      1.44  (2014-08-07)
-              various warning fixes from Ronny Chevalier
-      1.43  (2014-07-15)
-              fix MSVC-only compiler problem in code changed in 1.42
-      1.42  (2014-07-09)
-              don't define _CRT_SECURE_NO_WARNINGS (affects user code)
-              fixes to stbi__cleanup_jpeg path
-              added STBI_ASSERT to avoid requiring assert.h
-      1.41  (2014-06-25)
-              fix search&replace from 1.36 that messed up comments/error messages
-      1.40  (2014-06-22)
-              fix gcc struct-initialization warning
-      1.39  (2014-06-15)
-              fix to TGA optimization when req_comp != number of components in TGA;
-              fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite)
-              add support for BMP version 5 (more ignored fields)
-      1.38  (2014-06-06)
-              suppress MSVC warnings on integer casts truncating values
-              fix accidental rename of 'skip' field of I/O
-      1.37  (2014-06-04)
-              remove duplicate typedef
-      1.36  (2014-06-03)
-              convert to header file single-file library
-              if de-iphone isn't set, load iphone images color-swapped instead of returning NULL
-      1.35  (2014-05-27)
-              various warnings
-              fix broken STBI_SIMD path
-              fix bug where stbi_load_from_file no longer left file pointer in correct place
-              fix broken non-easy path for 32-bit BMP (possibly never used)
-              TGA optimization by Arseny Kapoulkine
-      1.34  (unknown)
-              use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case
-      1.33  (2011-07-14)
-              make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements
-      1.32  (2011-07-13)
-              support for "info" function for all supported filetypes (SpartanJ)
-      1.31  (2011-06-20)
-              a few more leak fixes, bug in PNG handling (SpartanJ)
-      1.30  (2011-06-11)
-              added ability to load files via callbacks to accomidate custom input streams (Ben Wenger)
-              removed deprecated format-specific test/load functions
-              removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway
-              error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha)
-              fix inefficiency in decoding 32-bit BMP (David Woo)
-      1.29  (2010-08-16)
-              various warning fixes from Aurelien Pocheville
-      1.28  (2010-08-01)
-              fix bug in GIF palette transparency (SpartanJ)
-      1.27  (2010-08-01)
-              cast-to-stbi_uc to fix warnings
-      1.26  (2010-07-24)
-              fix bug in file buffering for PNG reported by SpartanJ
-      1.25  (2010-07-17)
-              refix trans_data warning (Won Chun)
-      1.24  (2010-07-12)
-              perf improvements reading from files on platforms with lock-heavy fgetc()
-              minor perf improvements for jpeg
-              deprecated type-specific functions so we'll get feedback if they're needed
-              attempt to fix trans_data warning (Won Chun)
-      1.23    fixed bug in iPhone support
-      1.22  (2010-07-10)
-              removed image *writing* support
-              stbi_info support from Jetro Lauha
-              GIF support from Jean-Marc Lienher
-              iPhone PNG-extensions from James Brown
-              warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva)
-      1.21    fix use of 'stbi_uc' in header (reported by jon blow)
-      1.20    added support for Softimage PIC, by Tom Seddon
-      1.19    bug in interlaced PNG corruption check (found by ryg)
-      1.18  (2008-08-02)
-              fix a threading bug (local mutable static)
-      1.17    support interlaced PNG
-      1.16    major bugfix - stbi__convert_format converted one too many pixels
-      1.15    initialize some fields for thread safety
-      1.14    fix threadsafe conversion bug
-              header-file-only version (#define STBI_HEADER_FILE_ONLY before including)
-      1.13    threadsafe
-      1.12    const qualifiers in the API
-      1.11    Support installable IDCT, colorspace conversion routines
-      1.10    Fixes for 64-bit (don't use "unsigned long")
-              optimized upsampling by Fabian "ryg" Giesen
-      1.09    Fix format-conversion for PSD code (bad global variables!)
-      1.08    Thatcher Ulrich's PSD code integrated by Nicolas Schulz
-      1.07    attempt to fix C++ warning/errors again
-      1.06    attempt to fix C++ warning/errors again
-      1.05    fix TGA loading to return correct *comp and use good luminance calc
-      1.04    default float alpha is 1, not 255; use 'void *' for stbi_image_free
-      1.03    bugfixes to STBI_NO_STDIO, STBI_NO_HDR
-      1.02    support for (subset of) HDR files, float interface for preferred access to them
-      1.01    fix bug: possible bug in handling right-side up bmps... not sure
-              fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all
-      1.00    interface to zlib that skips zlib header
-      0.99    correct handling of alpha in palette
-      0.98    TGA loader by lonesock; dynamically add loaders (untested)
-      0.97    jpeg errors on too large a file; also catch another malloc failure
-      0.96    fix detection of invalid v value - particleman@mollyrocket forum
-      0.95    during header scan, seek to markers in case of padding
-      0.94    STBI_NO_STDIO to disable stdio usage; rename all #defines the same
-      0.93    handle jpegtran output; verbose errors
-      0.92    read 4,8,16,24,32-bit BMP files of several formats
-      0.91    output 24-bit Windows 3.0 BMP files
-      0.90    fix a few more warnings; bump version number to approach 1.0
-      0.61    bugfixes due to Marc LeBlanc, Christopher Lloyd
-      0.60    fix compiling as c++
-      0.59    fix warnings: merge Dave Moore's -Wall fixes
-      0.58    fix bug: zlib uncompressed mode len/nlen was wrong endian
-      0.57    fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available
-      0.56    fix bug: zlib uncompressed mode len vs. nlen
-      0.55    fix bug: restart_interval not initialized to 0
-      0.54    allow NULL for 'int *comp'
-      0.53    fix bug in png 3->4; speedup png decoding
-      0.52    png handles req_comp=3,4 directly; minor cleanup; jpeg comments
-      0.51    obey req_comp requests, 1-component jpegs return as 1-component,
-              on 'test' only check type, not whether we support this variant
-      0.50  (2006-11-19)
-              first released version
-*/
-
-
-/*
-------------------------------------------------------------------------------
-This software is available under 2 licenses -- choose whichever you prefer.
-------------------------------------------------------------------------------
-ALTERNATIVE A - MIT License
-Copyright (c) 2017 Sean Barrett
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-------------------------------------------------------------------------------
-ALTERNATIVE B - Public Domain (www.unlicense.org)
-This is free and unencumbered software released into the public domain.
-Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
-software, either in source code form or as a compiled binary, for any purpose,
-commercial or non-commercial, and by any means.
-In jurisdictions that recognize copyright laws, the author or authors of this
-software dedicate any and all copyright interest in the software to the public
-domain. We make this dedication for the benefit of the public at large and to
-the detriment of our heirs and successors. We intend this dedication to be an
-overt act of relinquishment in perpetuity of all present and future rights to
-this software under copyright law.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-------------------------------------------------------------------------------
-*/
+#endif
diff --git a/clib/stb_image_write.h b/clib/stb_image_write.h
index e4b32ed1bc32ef9c962acbf47a9d10af01939e08..bea73efc7d2f7d29bfb82ad9230046265f5f3188 100644
--- a/clib/stb_image_write.h
+++ b/clib/stb_image_write.h
@@ -1,159 +1,8 @@
-/* stb_image_write - v1.16 - public domain - http://nothings.org/stb
-   writes out PNG/BMP/TGA/JPEG/HDR images to C stdio - Sean Barrett 2010-2015
-                                     no warranty implied; use at your own risk
-
-   Before #including,
-
-       #define STB_IMAGE_WRITE_IMPLEMENTATION
-
-   in the file that you want to have the implementation.
-
-   Will probably not work correctly with strict-aliasing optimizations.
-
-ABOUT:
-
-   This header file is a library for writing images to C stdio or a callback.
-
-   The PNG output is not optimal; it is 20-50% larger than the file
-   written by a decent optimizing implementation; though providing a custom
-   zlib compress function (see STBIW_ZLIB_COMPRESS) can mitigate that.
-   This library is designed for source code compactness and simplicity,
-   not optimal image file size or run-time performance.
-
-BUILDING:
-
-   You can #define STBIW_ASSERT(x) before the #include to avoid using assert.h.
-   You can #define STBIW_MALLOC(), STBIW_REALLOC(), and STBIW_FREE() to replace
-   malloc,realloc,free.
-   You can #define STBIW_MEMMOVE() to replace memmove()
-   You can #define STBIW_ZLIB_COMPRESS to use a custom zlib-style compress function
-   for PNG compression (instead of the builtin one), it must have the following signature:
-   unsigned char * my_compress(unsigned char *data, int data_len, int *out_len, int quality);
-   The returned data will be freed with STBIW_FREE() (free() by default),
-   so it must be heap allocated with STBIW_MALLOC() (malloc() by default),
-
-UNICODE:
-
-   If compiling for Windows and you wish to use Unicode filenames, compile
-   with
-       #define STBIW_WINDOWS_UTF8
-   and pass utf8-encoded filenames. Call stbiw_convert_wchar_to_utf8 to convert
-   Windows wchar_t filenames to utf8.
-
-USAGE:
-
-   There are five functions, one for each image file format:
-
-     int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
-     int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
-     int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
-     int stbi_write_jpg(char const *filename, int w, int h, int comp, const void *data, int quality);
-     int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data);
-
-     void stbi_flip_vertically_on_write(int flag); // flag is non-zero to flip data vertically
-
-   There are also five equivalent functions that use an arbitrary write function. You are
-   expected to open/close your file-equivalent before and after calling these:
-
-     int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void  *data, int stride_in_bytes);
-     int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void  *data);
-     int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void  *data);
-     int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data);
-     int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality);
-
-   where the callback is:
-      void stbi_write_func(void *context, void *data, int size);
-
-   You can configure it with these global variables:
-      int stbi_write_tga_with_rle;             // defaults to true; set to 0 to disable RLE
-      int stbi_write_png_compression_level;    // defaults to 8; set to higher for more compression
-      int stbi_write_force_png_filter;         // defaults to -1; set to 0..5 to force a filter mode
-
-
-   You can define STBI_WRITE_NO_STDIO to disable the file variant of these
-   functions, so the library will not use stdio.h at all. However, this will
-   also disable HDR writing, because it requires stdio for formatted output.
-
-   Each function returns 0 on failure and non-0 on success.
-
-   The functions create an image file defined by the parameters. The image
-   is a rectangle of pixels stored from left-to-right, top-to-bottom.
-   Each pixel contains 'comp' channels of data stored interleaved with 8-bits
-   per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is
-   monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall.
-   The *data pointer points to the first byte of the top-left-most pixel.
-   For PNG, "stride_in_bytes" is the distance in bytes from the first byte of
-   a row of pixels to the first byte of the next row of pixels.
-
-   PNG creates output files with the same number of components as the input.
-   The BMP format expands Y to RGB in the file format and does not
-   output alpha.
-
-   PNG supports writing rectangles of data even when the bytes storing rows of
-   data are not consecutive in memory (e.g. sub-rectangles of a larger image),
-   by supplying the stride between the beginning of adjacent rows. The other
-   formats do not. (Thus you cannot write a native-format BMP through the BMP
-   writer, both because it is in BGR order and because it may have padding
-   at the end of the line.)
-
-   PNG allows you to set the deflate compression level by setting the global
-   variable 'stbi_write_png_compression_level' (it defaults to 8).
-
-   HDR expects linear float data. Since the format is always 32-bit rgb(e)
-   data, alpha (if provided) is discarded, and for monochrome data it is
-   replicated across all three channels.
-
-   TGA supports RLE or non-RLE compressed data. To use non-RLE-compressed
-   data, set the global variable 'stbi_write_tga_with_rle' to 0.
-
-   JPEG does ignore alpha channels in input data; quality is between 1 and 100.
-   Higher quality looks better but results in a bigger image.
-   JPEG baseline (no JPEG progressive).
-
-CREDITS:
-
-
-   Sean Barrett           -    PNG/BMP/TGA
-   Baldur Karlsson        -    HDR
-   Jean-Sebastien Guay    -    TGA monochrome
-   Tim Kelsey             -    misc enhancements
-   Alan Hickman           -    TGA RLE
-   Emmanuel Julien        -    initial file IO callback implementation
-   Jon Olick              -    original jo_jpeg.cpp code
-   Daniel Gibson          -    integrate JPEG, allow external zlib
-   Aarni Koskela          -    allow choosing PNG filter
-
-   bugfixes:
-      github:Chribba
-      Guillaume Chereau
-      github:jry2
-      github:romigrou
-      Sergio Gonzalez
-      Jonas Karlsson
-      Filip Wasil
-      Thatcher Ulrich
-      github:poppolopoppo
-      Patrick Boettcher
-      github:xeekworx
-      Cap Petschulat
-      Simon Rodriguez
-      Ivan Tikhonov
-      github:ignotion
-      Adam Schackart
-      Andrew Kensler
-
-LICENSE
-
-  See end of file for license information.
-
-*/
-
 #ifndef INCLUDE_STB_IMAGE_WRITE_H
 #define INCLUDE_STB_IMAGE_WRITE_H
 
 #include <stdlib.h>
 
-// if STB_IMAGE_WRITE_STATIC causes problems, try defining STBIWDEF to 'inline' or 'static inline'
 #ifndef STBIWDEF
 #ifdef STB_IMAGE_WRITE_STATIC
 #define STBIWDEF  static
@@ -166,7 +15,7 @@ LICENSE
 #endif
 #endif
 
-#ifndef STB_IMAGE_WRITE_STATIC  // C++ forbids static forward declarations
+#ifndef STB_IMAGE_WRITE_STATIC
 STBIWDEF int stbi_write_tga_with_rle;
 STBIWDEF int stbi_write_png_compression_level;
 STBIWDEF int stbi_write_force_png_filter;
@@ -194,7 +43,7 @@ STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x,
 
 STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean);
 
-#endif//INCLUDE_STB_IMAGE_WRITE_H
+#endif
 
 #ifdef STB_IMAGE_WRITE_IMPLEMENTATION
 
@@ -209,7 +58,7 @@ STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean);
 
 #ifndef STBI_WRITE_NO_STDIO
 #include <stdio.h>
-#endif // STBI_WRITE_NO_STDIO
+#endif
 
 #include <stdarg.h>
 #include <stdlib.h>
@@ -217,9 +66,9 @@ STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean);
 #include <math.h>
 
 #if defined(STBIW_MALLOC) && defined(STBIW_FREE) && (defined(STBIW_REALLOC) || defined(STBIW_REALLOC_SIZED))
-// ok
+
 #elif !defined(STBIW_MALLOC) && !defined(STBIW_FREE) && !defined(STBIW_REALLOC) && !defined(STBIW_REALLOC_SIZED)
-// ok
+
 #else
 #error "Must define all or none of STBIW_MALLOC, STBIW_FREE, and STBIW_REALLOC (or STBIW_REALLOC_SIZED)."
 #endif
@@ -234,12 +83,10 @@ STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean);
 #define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz)
 #endif
 
-
 #ifndef STBIW_MEMMOVE
 #define STBIW_MEMMOVE(a,b,sz) memmove(a,b,sz)
 #endif
 
-
 #ifndef STBIW_ASSERT
 #include <assert.h>
 #define STBIW_ASSERT(x) assert(x)
@@ -272,7 +119,6 @@ typedef struct
    int buf_used;
 } stbi__write_context;
 
-// initialize a callback-based context
 static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func *c, void *context)
 {
    s->func    = c;
@@ -297,7 +143,7 @@ STBIW_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned in
 
 STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)
 {
-   return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);
+   return WideCharToMultiByte(65001 , 0, input, -1, buffer, (int) bufferlen, NULL, NULL);
 }
 #endif
 
@@ -307,10 +153,10 @@ static FILE *stbiw__fopen(char const *filename, char const *mode)
 #if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8)
    wchar_t wMode[64];
    wchar_t wFilename[1024];
-   if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename)))
+   if (0 == MultiByteToWideChar(65001 , 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename)))
       return 0;
 
-   if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode)))
+   if (0 == MultiByteToWideChar(65001 , 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode)))
       return 0;
 
 #if defined(_MSC_VER) && _MSC_VER >= 1400
@@ -341,7 +187,7 @@ static void stbi__end_write_file(stbi__write_context *s)
    fclose((FILE *)s->context);
 }
 
-#endif // !STBI_WRITE_NO_STDIO
+#endif
 
 typedef unsigned int stbiw_uint32;
 typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1];
@@ -424,22 +270,22 @@ static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, in
       stbiw__write1(s, d[comp - 1]);
 
    switch (comp) {
-      case 2: // 2 pixels = mono + alpha, alpha is written separately, so same as 1-channel case
+      case 2:
       case 1:
          if (expand_mono)
-            stbiw__write3(s, d[0], d[0], d[0]); // monochrome bmp
+            stbiw__write3(s, d[0], d[0], d[0]);
          else
-            stbiw__write1(s, d[0]);  // monochrome TGA
+            stbiw__write1(s, d[0]);
          break;
       case 4:
          if (!write_alpha) {
-            // composite against pink background
+
             for (k = 0; k < 3; ++k)
                px[k] = bg[k] + ((d[k] - bg[k]) * d[3]) / 255;
             stbiw__write3(s, px[1 - rgb_dir], px[1], px[1 + rgb_dir]);
             break;
          }
-         /* FALLTHROUGH */
+
       case 3:
          stbiw__write3(s, d[1 - rgb_dir], d[1], d[1 + rgb_dir]);
          break;
@@ -492,20 +338,18 @@ static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x,
 static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data)
 {
    if (comp != 4) {
-      // write RGB bitmap
+
       int pad = (-x*3) & 3;
       return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *) data,0,pad,
               "11 4 22 4" "4 44 22 444444",
-              'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40,  // file header
-               40, x,y, 1,24, 0,0,0,0,0,0);             // bitmap header
+              'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40,
+               40, x,y, 1,24, 0,0,0,0,0,0);
    } else {
-      // RGBA bitmaps need a v4 header
-      // use BI_BITFIELDS mode with 32bpp and alpha mask
-      // (straight BI_RGB with alpha mask doesn't work in most readers)
+
       return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *)data,1,0,
          "11 4 22 4" "4 44 22 444444 4444 4 444 444 444 444",
-         'B', 'M', 14+108+x*y*4, 0, 0, 14+108, // file header
-         108, x,y, 1,32, 3,0,0,0,0,0, 0xff0000,0xff00,0xff,0xff000000u, 0, 0,0,0, 0,0,0, 0,0,0, 0,0,0); // bitmap V4 header
+         'B', 'M', 14+108+x*y*4, 0, 0, 14+108,
+         108, x,y, 1,32, 3,0,0,0,0,0, 0xff0000,0xff00,0xff,0xff000000u, 0, 0,0,0, 0,0,0, 0,0,0, 0,0,0);
    }
 }
 
@@ -527,13 +371,13 @@ STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const
    } else
       return 0;
 }
-#endif //!STBI_WRITE_NO_STDIO
+#endif
 
 static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data)
 {
    int has_alpha = (comp == 2 || comp == 4);
    int colorbytes = has_alpha ? comp-1 : comp;
-   int format = colorbytes < 2 ? 3 : 2; // 3 color channels (RGB/RGBA) = 2, 1 color channel (Y/YA) = 3
+   int format = colorbytes < 2 ? 3 : 2;
 
    if (y < 0 || x < 0)
       return 0;
@@ -628,10 +472,6 @@ STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const
 }
 #endif
 
-// *************************************************************************************************
-// Radiance RGBE HDR writer
-// by Baldur Karlsson
-
 #define stbiw__max(a, b)  ((a) > (b) ? (a) : (b))
 
 #ifndef STBI_WRITE_NO_STDIO
@@ -664,7 +504,7 @@ static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned c
 static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data)
 {
    unsigned char lengthbyte = STBIW_UCHAR(length);
-   STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code
+   STBIW_ASSERT(length <= 128);
    s->func(s->context, &lengthbyte, 1);
    s->func(s->context, data, length);
 }
@@ -679,11 +519,10 @@ static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int nco
    scanlineheader[2] = (width&0xff00)>>8;
    scanlineheader[3] = (width&0x00ff);
 
-   /* skip RLE for images too small or large */
    if (width < 8 || width >= 32768) {
       for (x=0; x < width; x++) {
          switch (ncomp) {
-            case 4: /* fallthrough */
+            case 4:
             case 3: linear[2] = scanline[x*ncomp + 2];
                     linear[1] = scanline[x*ncomp + 1];
                     linear[0] = scanline[x*ncomp + 0];
@@ -697,10 +536,10 @@ static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int nco
       }
    } else {
       int c,r;
-      /* encode into scratch buffer */
+
       for (x=0; x < width; x++) {
          switch(ncomp) {
-            case 4: /* fallthrough */
+            case 4:
             case 3: linear[2] = scanline[x*ncomp + 2];
                     linear[1] = scanline[x*ncomp + 1];
                     linear[0] = scanline[x*ncomp + 0];
@@ -718,13 +557,12 @@ static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int nco
 
       s->func(s->context, scanlineheader, 4);
 
-      /* RLE each component separately */
       for (c=0; c < 4; c++) {
          unsigned char *comp = &scratch[width*c];
 
          x = 0;
          while (x < width) {
-            // find first run
+
             r = x;
             while (r+2 < width) {
                if (comp[r] == comp[r+1] && comp[r] == comp[r+2])
@@ -733,19 +571,19 @@ static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int nco
             }
             if (r+2 >= width)
                r = width;
-            // dump up to first run
+
             while (x < r) {
                int len = r-x;
                if (len > 128) len = 128;
                stbiw__write_dump_data(s, len, &comp[x]);
                x += len;
             }
-            // if there's a run, output it
-            if (r+2 < width) { // same test as what we break out of in search loop, so only true if we break'd
-               // find next byte after run
+
+            if (r+2 < width) {
+
                while (r < width && comp[r] == comp[x])
                   ++r;
-               // output run up to r
+
                while (x < r) {
                   int len = r-x;
                   if (len > 127) len = 127;
@@ -763,7 +601,7 @@ static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, f
    if (y <= 0 || x <= 0 || data == NULL)
       return 0;
    else {
-      // Each component is stored separately. Allocate scratch space for full output scanline.
+
       unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4);
       int i, len;
       char buffer[128];
@@ -801,16 +639,10 @@ STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const
    } else
       return 0;
 }
-#endif // STBI_WRITE_NO_STDIO
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// PNG writer
-//
+#endif
 
 #ifndef STBIW_ZLIB_COMPRESS
-// stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount() == vector<>::size()
+
 #define stbiw__sbraw(a) ((int *) (void *) (a) - 2)
 #define stbiw__sbm(a)   stbiw__sbraw(a)[0]
 #define stbiw__sbn(a)   stbiw__sbraw(a)[1]
@@ -880,7 +712,7 @@ static unsigned int stbiw__zhash(unsigned char *data)
 #define stbiw__zlib_add(code,codebits) \
       (bitbuf |= (code) << bitcount, bitcount += (codebits), stbiw__zlib_flush())
 #define stbiw__zlib_huffa(b,c)  stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c)
-// default huffman tables
+
 #define stbiw__zlib_huff1(n)  stbiw__zlib_huffa(0x30 + (n), 8)
 #define stbiw__zlib_huff2(n)  stbiw__zlib_huffa(0x190 + (n)-144, 9)
 #define stbiw__zlib_huff3(n)  stbiw__zlib_huffa(0 + (n)-256,7)
@@ -890,14 +722,14 @@ static unsigned int stbiw__zhash(unsigned char *data)
 
 #define stbiw__ZHASH   16384
 
-#endif // STBIW_ZLIB_COMPRESS
+#endif
 
 STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)
 {
 #ifdef STBIW_ZLIB_COMPRESS
-   // user provided a zlib compress implementation, use that
+
    return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality);
-#else // use builtin
+#else
    static unsigned short lengthc[] = { 3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258, 259 };
    static unsigned char  lengtheb[]= { 0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,  4,  5,  5,  5,  5,  0 };
    static unsigned short distc[]   = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577, 32768 };
@@ -910,28 +742,28 @@ STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, i
       return NULL;
    if (quality < 5) quality = 5;
 
-   stbiw__sbpush(out, 0x78);   // DEFLATE 32K window
-   stbiw__sbpush(out, 0x5e);   // FLEVEL = 1
-   stbiw__zlib_add(1,1);  // BFINAL = 1
-   stbiw__zlib_add(1,2);  // BTYPE = 1 -- fixed huffman
+   stbiw__sbpush(out, 0x78);
+   stbiw__sbpush(out, 0x5e);
+   stbiw__zlib_add(1,1);
+   stbiw__zlib_add(1,2);
 
    for (i=0; i < stbiw__ZHASH; ++i)
       hash_table[i] = NULL;
 
    i=0;
    while (i < data_len-3) {
-      // hash next 3 bytes of data to be compressed
+
       int h = stbiw__zhash(data+i)&(stbiw__ZHASH-1), best=3;
       unsigned char *bestloc = 0;
       unsigned char **hlist = hash_table[h];
       int n = stbiw__sbcount(hlist);
       for (j=0; j < n; ++j) {
-         if (hlist[j]-data > i-32768) { // if entry lies within window
+         if (hlist[j]-data > i-32768) {
             int d = stbiw__zlib_countm(hlist[j], data+i, data_len-i);
             if (d >= best) { best=d; bestloc=hlist[j]; }
          }
       }
-      // when hash table entry is too long, delete half the entries
+
       if (hash_table[h] && stbiw__sbn(hash_table[h]) == 2*quality) {
          STBIW_MEMMOVE(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality);
          stbiw__sbn(hash_table[h]) = quality;
@@ -939,14 +771,14 @@ STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, i
       stbiw__sbpush(hash_table[h],data+i);
 
       if (bestloc) {
-         // "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal
+
          h = stbiw__zhash(data+i+1)&(stbiw__ZHASH-1);
          hlist = hash_table[h];
          n = stbiw__sbcount(hlist);
          for (j=0; j < n; ++j) {
             if (hlist[j]-data > i-32767) {
                int e = stbiw__zlib_countm(hlist[j], data+i+1, data_len-i-1);
-               if (e > best) { // if next match is better, bail on current match
+               if (e > best) {
                   bestloc = NULL;
                   break;
                }
@@ -955,7 +787,7 @@ STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, i
       }
 
       if (bestloc) {
-         int d = (int) (data+i - bestloc); // distance back
+         int d = (int) (data+i - bestloc);
          STBIW_ASSERT(d <= 32767 && best <= 258);
          for (j=0; best > lengthc[j+1]-1; ++j);
          stbiw__zlib_huff(j+257);
@@ -969,11 +801,11 @@ STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, i
          ++i;
       }
    }
-   // write out final bytes
+
    for (;i < data_len; ++i)
       stbiw__zlib_huffb(data[i]);
-   stbiw__zlib_huff(256); // end of block
-   // pad with 0 bits to byte boundary
+   stbiw__zlib_huff(256);
+
    while (bitcount)
       stbiw__zlib_add(0,1);
 
@@ -981,16 +813,15 @@ STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, i
       (void) stbiw__sbfree(hash_table[i]);
    STBIW_FREE(hash_table);
 
-   // store uncompressed instead if compression was worse
    if (stbiw__sbn(out) > data_len + 2 + ((data_len+32766)/32767)*5) {
-      stbiw__sbn(out) = 2;  // truncate to DEFLATE 32K window and FLEVEL = 1
+      stbiw__sbn(out) = 2;
       for (j = 0; j < data_len;) {
          int blocklen = data_len - j;
          if (blocklen > 32767) blocklen = 32767;
-         stbiw__sbpush(out, data_len - j == blocklen); // BFINAL = ?, BTYPE = 0 -- no compression
-         stbiw__sbpush(out, STBIW_UCHAR(blocklen)); // LEN
+         stbiw__sbpush(out, data_len - j == blocklen);
+         stbiw__sbpush(out, STBIW_UCHAR(blocklen));
          stbiw__sbpush(out, STBIW_UCHAR(blocklen >> 8));
-         stbiw__sbpush(out, STBIW_UCHAR(~blocklen)); // NLEN
+         stbiw__sbpush(out, STBIW_UCHAR(~blocklen));
          stbiw__sbpush(out, STBIW_UCHAR(~blocklen >> 8));
          memcpy(out+stbiw__sbn(out), data+j, blocklen);
          stbiw__sbn(out) += blocklen;
@@ -999,7 +830,7 @@ STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, i
    }
 
    {
-      // compute adler32 on input
+
       unsigned int s1=1, s2=0;
       int blocklen = (int) (data_len % 5552);
       j=0;
@@ -1015,10 +846,10 @@ STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, i
       stbiw__sbpush(out, STBIW_UCHAR(s1));
    }
    *out_len = stbiw__sbn(out);
-   // make returned pointer freeable
+
    STBIW_MEMMOVE(stbiw__sbraw(out), out, *out_len);
    return (unsigned char *) stbiw__sbraw(out);
-#endif // STBIW_ZLIB_COMPRESS
+#endif
 }
 
 static unsigned int stbiw__crc32(unsigned char *buffer, int len)
@@ -1088,7 +919,6 @@ static unsigned char stbiw__paeth(int a, int b, int c)
    return STBIW_UCHAR(c);
 }
 
-// @OPTIMIZE: provide an option that always forces left-predict or paeth predict
 static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int width, int height, int y, int n, int filter_type, signed char *line_buffer)
 {
    static int mapping[] = { 0,1,2,3,4 };
@@ -1104,7 +934,6 @@ static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int
       return;
    }
 
-   // first loop isn't optimized since it's just one pixel
    for (i = 0; i < n; ++i) {
       switch (type) {
          case 1: line_buffer[i] = z[i]; break;
@@ -1148,12 +977,11 @@ STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int s
       if (force_filter > -1) {
          filter_type = force_filter;
          stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, force_filter, line_buffer);
-      } else { // Estimate the best filter by running through all of them:
+      } else {
          int best_filter = 0, best_filter_val = 0x7fffffff, est, i;
          for (filter_type = 0; filter_type < 5; filter_type++) {
             stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, filter_type, line_buffer);
 
-            // Estimate the entropy of the line using this filter; the less, the better.
             est = 0;
             for (i = 0; i < x*n; ++i) {
                est += abs((signed char) line_buffer[i]);
@@ -1163,12 +991,12 @@ STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int s
                best_filter = filter_type;
             }
          }
-         if (filter_type != best_filter) {  // If the last iteration already got us the best filter, don't redo it
+         if (filter_type != best_filter) {
             stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, best_filter, line_buffer);
             filter_type = best_filter;
          }
       }
-      // when we get here, filter_type contains the filter type, and line_buffer contains the data
+
       filt[j*(x*n+1)] = (unsigned char) filter_type;
       STBIW_MEMMOVE(filt+j*(x*n+1)+1, line_buffer, x*n);
    }
@@ -1177,14 +1005,13 @@ STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int s
    STBIW_FREE(filt);
    if (!zlib) return 0;
 
-   // each tag requires 12 bytes of overhead
    out = (unsigned char *) STBIW_MALLOC(8 + 12+13 + 12+zlen + 12);
    if (!out) return 0;
    *out_len = 8 + 12+13 + 12+zlen + 12;
 
    o=out;
    STBIW_MEMMOVE(o,sig,8); o+= 8;
-   stbiw__wp32(o, 13); // header length
+   stbiw__wp32(o, 13);
    stbiw__wptag(o, "IHDR");
    stbiw__wp32(o, x);
    stbiw__wp32(o, y);
@@ -1238,15 +1065,6 @@ STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x,
    return 1;
 }
 
-
-/* ***************************************************************************
- *
- * JPEG writer
- *
- * This is based on Jon Olick's jo_jpeg.cpp:
- * public domain Simple, Minimalistic JPEG writer - http://www.jonolick.com/code.html
- */
-
 static const unsigned char stbiw__jpg_ZigZag[] = { 0,1,5,6,14,15,27,28,2,4,7,13,16,26,29,42,3,8,12,17,25,30,41,43,9,11,18,
       24,31,40,44,53,10,19,23,32,39,45,52,54,20,22,33,38,46,51,55,60,21,34,37,47,50,56,59,61,35,36,48,49,57,58,62,63 };
 
@@ -1280,34 +1098,31 @@ static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float
    float tmp3 = d3 + d4;
    float tmp4 = d3 - d4;
 
-   // Even part
-   float tmp10 = tmp0 + tmp3;   // phase 2
+   float tmp10 = tmp0 + tmp3;
    float tmp13 = tmp0 - tmp3;
    float tmp11 = tmp1 + tmp2;
    float tmp12 = tmp1 - tmp2;
 
-   d0 = tmp10 + tmp11;       // phase 3
+   d0 = tmp10 + tmp11;
    d4 = tmp10 - tmp11;
 
-   z1 = (tmp12 + tmp13) * 0.707106781f; // c4
-   d2 = tmp13 + z1;       // phase 5
+   z1 = (tmp12 + tmp13) * 0.707106781f;
+   d2 = tmp13 + z1;
    d6 = tmp13 - z1;
 
-   // Odd part
-   tmp10 = tmp4 + tmp5;       // phase 2
+   tmp10 = tmp4 + tmp5;
    tmp11 = tmp5 + tmp6;
    tmp12 = tmp6 + tmp7;
 
-   // The rotator is modified from fig 4-8 to avoid extra negations.
-   z5 = (tmp10 - tmp12) * 0.382683433f; // c6
-   z2 = tmp10 * 0.541196100f + z5; // c2-c6
-   z4 = tmp12 * 1.306562965f + z5; // c2+c6
-   z3 = tmp11 * 0.707106781f; // c4
+   z5 = (tmp10 - tmp12) * 0.382683433f;
+   z2 = tmp10 * 0.541196100f + z5;
+   z4 = tmp12 * 1.306562965f + z5;
+   z3 = tmp11 * 0.707106781f;
 
-   z11 = tmp7 + z3;      // phase 5
+   z11 = tmp7 + z3;
    z13 = tmp7 - z3;
 
-   *d5p = z13 + z2;         // phase 6
+   *d5p = z13 + z2;
    *d3p = z13 - z2;
    *d1p = z11 + z4;
    *d7p = z11 - z4;
@@ -1331,28 +1146,25 @@ static int stbiw__jpg_processDU(stbi__write_context *s, int *bitBuf, int *bitCnt
    int dataOff, i, j, n, diff, end0pos, x, y;
    int DU[64];
 
-   // DCT rows
    for(dataOff=0, n=du_stride*8; dataOff<n; dataOff+=du_stride) {
       stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff+1], &CDU[dataOff+2], &CDU[dataOff+3], &CDU[dataOff+4], &CDU[dataOff+5], &CDU[dataOff+6], &CDU[dataOff+7]);
    }
-   // DCT columns
+
    for(dataOff=0; dataOff<8; ++dataOff) {
       stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff+du_stride], &CDU[dataOff+du_stride*2], &CDU[dataOff+du_stride*3], &CDU[dataOff+du_stride*4],
                      &CDU[dataOff+du_stride*5], &CDU[dataOff+du_stride*6], &CDU[dataOff+du_stride*7]);
    }
-   // Quantize/descale/zigzag the coefficients
+
    for(y = 0, j=0; y < 8; ++y) {
       for(x = 0; x < 8; ++x,++j) {
          float v;
          i = y*du_stride+x;
          v = CDU[i]*fdtbl[j];
-         // DU[stbiw__jpg_ZigZag[j]] = (int)(v < 0 ? ceilf(v - 0.5f) : floorf(v + 0.5f));
-         // ceilf() and floorf() are C99, not C89, but I /think/ they're not needed here anyway?
+
          DU[stbiw__jpg_ZigZag[j]] = (int)(v < 0 ? v - 0.5f : v + 0.5f);
       }
    }
 
-   // Encode DC
    diff = DU[0] - DC;
    if (diff == 0) {
       stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTDC[0]);
@@ -1362,11 +1174,11 @@ static int stbiw__jpg_processDU(stbi__write_context *s, int *bitBuf, int *bitCnt
       stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTDC[bits[1]]);
       stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits);
    }
-   // Encode ACs
+
    end0pos = 63;
    for(; (end0pos>0)&&(DU[end0pos]==0); --end0pos) {
    }
-   // end0pos = first element in reverse order !=0
+
    if(end0pos == 0) {
       stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB);
       return DU[0];
@@ -1396,7 +1208,7 @@ static int stbiw__jpg_processDU(stbi__write_context *s, int *bitBuf, int *bitCnt
 }
 
 static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) {
-   // Constants that don't pollute global namespace
+
    static const unsigned char std_dc_luminance_nrcodes[] = {0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0};
    static const unsigned char std_dc_luminance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11};
    static const unsigned char std_ac_luminance_nrcodes[] = {0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d};
@@ -1421,7 +1233,7 @@ static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, in
       0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,
       0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa
    };
-   // Huffman tables
+
    static const unsigned short YDC_HT[256][2] = { {0,2},{2,3},{3,3},{4,3},{5,3},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9}};
    static const unsigned short UVDC_HT[256][2] = { {0,2},{1,2},{2,2},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9},{1022,10},{2046,11}};
    static const unsigned short YAC_HT[256][2] = {
@@ -1494,7 +1306,6 @@ static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, in
       }
    }
 
-   // Write Headers
    {
       static const unsigned char head0[] = { 0xFF,0xD8,0xFF,0xE0,0,0x10,'J','F','I','F',0,1,1,0,0,1,0,1,0,0,0xFF,0xDB,0,0x84,0 };
       static const unsigned char head2[] = { 0xFF,0xDA,0,0xC,3,1,0,2,0x11,3,0x11,0,0x3F,0 };
@@ -1507,24 +1318,23 @@ static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, in
       s->func(s->context, (void*)head1, sizeof(head1));
       s->func(s->context, (void*)(std_dc_luminance_nrcodes+1), sizeof(std_dc_luminance_nrcodes)-1);
       s->func(s->context, (void*)std_dc_luminance_values, sizeof(std_dc_luminance_values));
-      stbiw__putc(s, 0x10); // HTYACinfo
+      stbiw__putc(s, 0x10);
       s->func(s->context, (void*)(std_ac_luminance_nrcodes+1), sizeof(std_ac_luminance_nrcodes)-1);
       s->func(s->context, (void*)std_ac_luminance_values, sizeof(std_ac_luminance_values));
-      stbiw__putc(s, 1); // HTUDCinfo
+      stbiw__putc(s, 1);
       s->func(s->context, (void*)(std_dc_chrominance_nrcodes+1), sizeof(std_dc_chrominance_nrcodes)-1);
       s->func(s->context, (void*)std_dc_chrominance_values, sizeof(std_dc_chrominance_values));
-      stbiw__putc(s, 0x11); // HTUACinfo
+      stbiw__putc(s, 0x11);
       s->func(s->context, (void*)(std_ac_chrominance_nrcodes+1), sizeof(std_ac_chrominance_nrcodes)-1);
       s->func(s->context, (void*)std_ac_chrominance_values, sizeof(std_ac_chrominance_values));
       s->func(s->context, (void*)head2, sizeof(head2));
    }
 
-   // Encode 8x8 macroblocks
    {
       static const unsigned short fillBits[] = {0x7F, 7};
       int DCY=0, DCU=0, DCV=0;
       int bitBuf=0, bitCnt=0;
-      // comp == 2 is grey+alpha (alpha is ignored)
+
       int ofsG = comp > 2 ? 1 : 0, ofsB = comp > 2 ? 2 : 0;
       const unsigned char *dataR = (const unsigned char *)data;
       const unsigned char *dataG = dataR + ofsG;
@@ -1535,11 +1345,11 @@ static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, in
             for(x = 0; x < width; x += 16) {
                float Y[256], U[256], V[256];
                for(row = y, pos = 0; row < y+16; ++row) {
-                  // row >= height => use last input row
+
                   int clamped_row = (row < height) ? row : height - 1;
                   int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp;
                   for(col = x; col < x+16; ++col, ++pos) {
-                     // if col >= width => use pixel from last input column
+
                      int p = base_p + ((col < width) ? col : (width-1))*comp;
                      float r = dataR[p], g = dataG[p], b = dataB[p];
                      Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128;
@@ -1552,7 +1362,6 @@ static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, in
                DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+128, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
                DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+136, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
 
-               // subsample U,V
                {
                   float subU[64], subV[64];
                   int yy, xx;
@@ -1573,11 +1382,11 @@ static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, in
             for(x = 0; x < width; x += 8) {
                float Y[64], U[64], V[64];
                for(row = y, pos = 0; row < y+8; ++row) {
-                  // row >= height => use last input row
+
                   int clamped_row = (row < height) ? row : height - 1;
                   int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp;
                   for(col = x; col < x+8; ++col, ++pos) {
-                     // if col >= width => use pixel from last input column
+
                      int p = base_p + ((col < width) ? col : (width-1))*comp;
                      float r = dataR[p], g = dataG[p], b = dataB[p];
                      Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128;
@@ -1593,11 +1402,9 @@ static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, in
          }
       }
 
-      // Do the bit alignment of the EOI marker
       stbiw__jpg_writeBits(s, &bitBuf, &bitCnt, fillBits);
    }
 
-   // EOI
    stbiw__putc(s, 0xFF);
    stbiw__putc(s, 0xD9);
 
@@ -1611,7 +1418,6 @@ STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x,
    return stbi_write_jpg_core(&s, x, y, comp, (void *) data, quality);
 }
 
-
 #ifndef STBI_WRITE_NO_STDIO
 STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality)
 {
@@ -1625,100 +1431,4 @@ STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const
 }
 #endif
 
-#endif // STB_IMAGE_WRITE_IMPLEMENTATION
-
-/* Revision history
-      1.16  (2021-07-11)
-             make Deflate code emit uncompressed blocks when it would otherwise expand
-             support writing BMPs with alpha channel
-      1.15  (2020-07-13) unknown
-      1.14  (2020-02-02) updated JPEG writer to downsample chroma channels
-      1.13
-      1.12
-      1.11  (2019-08-11)
-
-      1.10  (2019-02-07)
-             support utf8 filenames in Windows; fix warnings and platform ifdefs
-      1.09  (2018-02-11)
-             fix typo in zlib quality API, improve STB_I_W_STATIC in C++
-      1.08  (2018-01-29)
-             add stbi__flip_vertically_on_write, external zlib, zlib quality, choose PNG filter
-      1.07  (2017-07-24)
-             doc fix
-      1.06 (2017-07-23)
-             writing JPEG (using Jon Olick's code)
-      1.05   ???
-      1.04 (2017-03-03)
-             monochrome BMP expansion
-      1.03   ???
-      1.02 (2016-04-02)
-             avoid allocating large structures on the stack
-      1.01 (2016-01-16)
-             STBIW_REALLOC_SIZED: support allocators with no realloc support
-             avoid race-condition in crc initialization
-             minor compile issues
-      1.00 (2015-09-14)
-             installable file IO function
-      0.99 (2015-09-13)
-             warning fixes; TGA rle support
-      0.98 (2015-04-08)
-             added STBIW_MALLOC, STBIW_ASSERT etc
-      0.97 (2015-01-18)
-             fixed HDR asserts, rewrote HDR rle logic
-      0.96 (2015-01-17)
-             add HDR output
-             fix monochrome BMP
-      0.95 (2014-08-17)
-             add monochrome TGA output
-      0.94 (2014-05-31)
-             rename private functions to avoid conflicts with stb_image.h
-      0.93 (2014-05-27)
-             warning fixes
-      0.92 (2010-08-01)
-             casts to unsigned char to fix warnings
-      0.91 (2010-07-17)
-             first public release
-      0.90   first internal release
-*/
-
-/*
-------------------------------------------------------------------------------
-This software is available under 2 licenses -- choose whichever you prefer.
-------------------------------------------------------------------------------
-ALTERNATIVE A - MIT License
-Copyright (c) 2017 Sean Barrett
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-------------------------------------------------------------------------------
-ALTERNATIVE B - Public Domain (www.unlicense.org)
-This is free and unencumbered software released into the public domain.
-Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
-software, either in source code form or as a compiled binary, for any purpose,
-commercial or non-commercial, and by any means.
-In jurisdictions that recognize copyright laws, the author or authors of this
-software dedicate any and all copyright interest in the software to the public
-domain. We make this dedication for the benefit of the public at large and to
-the detriment of our heirs and successors. We intend this dedication to be an
-overt act of relinquishment in perpetuity of all present and future rights to
-this software under copyright law.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-------------------------------------------------------------------------------
-*/
+#endif