Wrong or misleading piece of docs about the "synchronized mode" of streaming decompression

 *  Special : if decompression side sets a ring buffer, it must respect one of the following conditions :
[...]
 *  - Synchronized mode :
 *    Decompression buffer size is _exactly_ the same as compression buffer size,
 *    and follows exactly same update rule (block boundaries at same positions),
 *    and decoding function is provided with exact decompressed size of each block (exception for last block of the stream),
 *    _then_ decoding & encoding ring buffer can have any size, including small ones ( < 64 KB).

/*
 * lz4.h documents synchronized ring buffer mode as:
 *
 *  - Synchronized mode :
 *    Decompression buffer size is _exactly_ the same as compression buffer size,
 *    and follows exactly same update rule (block boundaries at same positions),
 *    and decoding function is provided with exact decompressed size of each block (exception for last block of the stream),
 *    _then_ decoding & encoding ring buffer can have any size, including small ones ( < 64 KB).
 *
 * But actually there is no "exception for last block".
 * This program shows what I mean.
 *
 * cc -std=c99 -O2 lz4_last_block_ring_reproducer.c -llz4 -o repro && ./repro
 *
 * Tested against lz4 1.10.0.
 */

#include <lz4.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define RING      80
#define MAX_BLOCK (RING / 2)            /* 40 */
#define NBLOCKS   3

/* One 105 byte message, compressed from a 80-byte ring buffer, in 3 blocks:
 *
 *   block 1, 40 bytes -> ring[ 0..40)
 *   block 2, 40 bytes -> ring[40..80)
 *   block 3, 25 bytes -> ring[ 0..25)
 */
static const char message[] =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!?#$"
        "jklmnopqrstuvwxyz0987654321@#$%^&*()_+<>"
        "abcdefghabcdeZ0123wxyz-+*";
static const int block_sizes[NBLOCKS] = { 40, 40, 25 };

/* The compressor emits three sequences for block 3:
 *
 *     81 'a'..'h' 08 00     8 literals, match at op=8  len=5 offset=8
 *                           (in-block, "abcde")
 *     01 44 00              0 literals, match at op=13 len=5 offset=68
 *                           (reaches back past ring[0] into ring[25..30),
 *                           "Z0123")
 *     70 'w'..'*'           7 literals
 *
 * If we decompress this block with an output size sufficiently bigger than the actual output size,
 * then ring[25] gets overwritten during the decoding of the first sequence,
 * which causes a wrong decompression result for the second sequence. */

int main(void) {
    char enc_ring[RING], dec_ring[RING];
    char cbuf[NBLOCKS][LZ4_COMPRESSBOUND(MAX_BLOCK)];
    int csize[NBLOCKS];

    LZ4_stream_t cstream;
    LZ4_initStream(&cstream, sizeof(cstream));
    int in_off = 0, ring_off = 0;
    for (int b = 0; b < NBLOCKS; b++) {
        if (ring_off + MAX_BLOCK > RING) {
            ring_off = 0;                       /* the ring update rule */
        }
        memcpy(enc_ring + ring_off, message + in_off, block_sizes[b]);
        csize[b] = LZ4_compress_fast_continue(&cstream, enc_ring + ring_off,
                cbuf[b], block_sizes[b], (int)sizeof(cbuf[b]), 1);
        if (csize[b] <= 0) {
            printf("compression failed\n");
            return 2;
        }
        in_off += block_sizes[b];
        ring_off += block_sizes[b];
    }

    LZ4_streamDecode_t dstream;
    LZ4_setStreamDecode(&dstream, NULL, 0);
    int n = 0;
    ring_off = 0;
    for (int b = 0; b < NBLOCKS; b++) {
        if (ring_off + MAX_BLOCK > RING) {
            ring_off = 0;
        }
#if 0
        // Works fine.
        int block_size = block_sizes[b];
#else
        // The "Synchronized mode" comment suggests we can do this, but this is wrong and gives a corrupted result.
        int block_size = MAX_BLOCK;
#endif
        n = LZ4_decompress_safe_continue(&dstream, cbuf[b], dec_ring + ring_off,
                csize[b], block_size);
        ring_off += block_size;
    }

    const char *last_block = message + block_sizes[0] + block_sizes[1];
    printf("last block decoded to %d bytes: \"%.*s\"\n", n, n, dec_ring);
    printf("                      expected: \"%s\"\n", last_block);
    return memcmp(dec_ring, last_block, block_sizes[NBLOCKS - 1]) == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}