// Copyright 2024 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT

// --------

// Thumbhash is a tiny image format (maximum image dimensions are 32×32 pixels;
// maximum image file size is 29 bytes or 32 bytes with a 3-byte header), based
// on the Discrete Cosine Transform.
//
// https://evanw.github.io/thumbhash/ has the original description and
// implementation. This implementation assumes a 3-byte magic identifier is
// prepended, unless QUIRK_JUST_RAW_THUMBHASH is enabled, so that /usr/bin/file
// or similar programs can identify the data as thumbhash-formatted data.
//
// That 3-byte magic string is "\xC3\xBE\xFE", which is arbitrary and not part
// of the original thumbhash description or implementation. But "\xC3\xBE" is
// the UTF-8 encoding of 'þ' (U+00FE LATIN SMALL LETTER THORN) and "\xFE" is
// invalid UTF-8 but is the ISO-8859-1 encoding of 'þ'. The Old English letter
// 'þ' is pronounced like the "th" that starts "thumbhash".
//
// This implementation also uses fixed point math instead of floating point.

pub status "#bad header"
pub status "#truncated input"

pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0

pub struct decoder? implements base.image_decoder(
        pixfmt           : base.u32,
        w_dimension_code : base.u8[..= 7],
        h_dimension_code : base.u8[..= 7],

        // The call sequence state machine is discussed in
        // (/doc/std/image-decoders-call-sequence.md).
        call_sequence : base.u8,

        frame_config_io_position : base.u8[..= 9],

        // The L, P and Q DC values occupy 6 bits in the file format.
        // Conceptually, they range from 0 to 1 (for L) or from -1 to +1 (for P
        // and Q). That's what values are calculated in the original JavaScript
        // reference implementation, which uses floating point.
        //
        // This implementation uses fixed point. The fx and fy cosine tables
        // and the FROM_4_BITS_TO_PLUS_MINUS_ETC tables are all stored as 2.14
        // signed fixed point (represented in this code as a base.u16, since
        // Wuffs as of 2024 only speaks unsigned integers). Multiplying two of
        // those uses 4.28 (as a base.u32). Multiplying three of those uses
        // 22.42 (as a base.u64).
        //
        // We eventually combine L, P and Q values so we need them to use the
        // same denominator. l_scale is out of 31 and p_scale and q_scale are
        // out of 63, so the common denominator is ((63 * 31) << 42) =
        // 8589_384836_186112 = 0x001E_8400_0000_0000.
        //
        // The A channel is not combined with L, P or Q and a_scale is out of
        // 15, so we can keep the a_dc denominator at (15 << 42).
        //
        // Let LDENOM = ((63 * 31) << 14) = 0x01E8_4000.
        //
        // Let ADENOM = ( 15       << 14) = 0x0003_C000.
        l_dc : base.u64,  // Fixed-point denominator is (LDENOM << 28).
        p_dc : base.u64,  // Fixed-point denominator is (LDENOM << 28).
        q_dc : base.u64,  // Fixed-point denominator is (LDENOM << 28).
        a_dc : base.u64,  // Fixed-point denominator is (ADENOM << 28).

        quirk_just_raw_thumbhash : base.bool,

        l_scale : base.u8[..= 31],
        p_scale : base.u8[..= 63],
        q_scale : base.u8[..= 63],
        a_scale : base.u8[..= 15],

        // The first three fields determine lx and ly: the exclusive max of the
        // (cx, cy) pairs indexing two-dimensional AC coefficients. The (0, 0)
        // pair is the DC coefficient. (lx / ly) is also the image's aspect
        // ratio, after rounding width and height to a whole number of pixels
        // such that the longest dimension is 32.
        //
        // Let lminor and lmajor alias lx and ly if is_landscape is 0 (false).
        // If is_landscape is 1 (true) then these are swapped.
        //
        // lminor equals max(3, l_count). lmajor equals 7 or 5, depending on
        // whether has_alpha is 0 or 1. For example, if has_alpha = 0, l_count
        // = 5 and is_landscape = 1 then lx = 7 and ly = 5, so that width = 32
        // and height = 23.
        //
        // lx and ly then detemine the number of L AC coefficients (the number
        // of lac elements that are used), ranging in 10 ..= 27. The number for
        // P and Q is always 5 and the number for A is 0 or 14, depending on
        // has_alpha. Total file size is an optional 3-byte magic identifier
        // plus (5 + has_alpha) bytes of header plus 4 bits per AC coefficient.
        // As a table:
        //
        // When has_alpha = 0 and is_landscape = 0:
        // l_count: 3   lx / ly = 3 / 7   w = 14   h = 32   #lac = 14   #pac = #qac = 5   #aac =  0   file_size = 3 + 17
        // l_count: 4   lx / ly = 4 / 7   w = 18   h = 32   #lac = 18   #pac = #qac = 5   #aac =  0   file_size = 3 + 19
        // l_count: 5   lx / ly = 5 / 7   w = 23   h = 32   #lac = 22   #pac = #qac = 5   #aac =  0   file_size = 3 + 21
        // l_count: 6   lx / ly = 6 / 7   w = 27   h = 32   #lac = 26   #pac = #qac = 5   #aac =  0   file_size = 3 + 23
        // l_count: 7   lx / ly = 7 / 7   w = 32   h = 32   #lac = 27   #pac = #qac = 5   #aac =  0   file_size = 3 + 24
        //
        // When has_alpha = 1 and is_landscape = 0:
        // l_count: 3   lx / ly = 3 / 5   w = 19   h = 32   #lac = 10   #pac = #qac = 5   #aac = 14   file_size = 3 + 23
        // l_count: 4   lx / ly = 4 / 5   w = 26   h = 32   #lac = 13   #pac = #qac = 5   #aac = 14   file_size = 3 + 25
        // l_count: 5   lx / ly = 5 / 5   w = 32   h = 32   #lac = 14   #pac = #qac = 5   #aac = 14   file_size = 3 + 25
        // l_count: 6   lx / ly = 6 / 5   w = 32   h = 27   #lac = 19   #pac = #qac = 5   #aac = 14   file_size = 3 + 28
        // l_count: 7   lx / ly = 7 / 5   w = 32   h = 23   #lac = 22   #pac = #qac = 5   #aac = 14   file_size = 3 + 29
        //
        // A "(cx * ly) < (lx * (ly - cy))" constraint determines which L AC
        // coefficients are used. Here are some visualizations, where 'D' is
        // the DC coefficient. When has_alpha = 0:
        //  - the       14  '3' coefficients are always used,
        //  - the (18 - 14) '4' coefficients are also used when (l_count >= 4),
        //  - the (22 - 18) '5' coefficients are also used when (l_count >= 5),
        //  - the (26 - 22) '6' coefficients are also used when (l_count >= 6),
        //  - the (27 - 26) '7' coefficients are also used when (l_count >= 7),
        //
        // When has_alpha = 0:
        // D334567
        // 333456
        // 33356
        // 3346
        // 335
        // 34
        // 3
        //
        // When has_alpha = 1:
        // D334567
        // 333467
        // 33467
        // 336
        // 36
        //
        // The same visualization for P and Q:
        // D33
        // 33
        // 3
        //
        // The same visualization for A (when has_alpha = 1):
        // D3333
        // 3333
        // 333
        // 33
        // 3
        has_alpha    : base.u8[..= 1],
        l_count      : base.u8[..= 7],
        is_landscape : base.u8[..= 1],
        lx           : base.u32[..= 7],
        ly           : base.u32[..= 7],

        swizzler : base.pixel_swizzler,
        util     : base.utility,
) + (
        // AC coefficients, doubled (†) when stored here to simplify the later
        // (fx[cx] * fy[cy]) calculation in from_coeffs_to_pixels.
        //
        // Before doubling, these conceptually range from -1 to +1 (for L and
        // A) or from -1.25 to +1.25 (for P and Q, boosted "to compensate for
        // quantization" in the original JavaScript reference implementation).
        //
        // These AC values will eventually be multiplied by fx[cx] and fy[cy],
        // both of which are 2.14 signed fixed point, so these fixed point
        // values use the DC value denominators right-shifted by 28: LDENOM =
        // ((63 * 31) << 14) for L, P and Q and ADENOM = (15 << 14) for A.
        //
        // For example, if lac[10] was 23998464 as a base.u32 here in Wuffs
        // code, the corresponding undoubled floating point value in JavaScript
        // code would be (23998464.0 / (2 * LDENOM)) = 0.375.
        //
        // Not every element is used, only the first up-to-27 (lac), 5 (pac and
        // qac) or 14 (aac). But we round up the array sizes up to a power of 2
        // (and bitwise-and the array indexes) to simplify bounds checking.
        lac : array[32] base.u32,  // Fixed-point denominator is LDENOM.
        pac : array[8] base.u32,  //  Fixed-point denominator is LDENOM.
        qac : array[8] base.u32,  //  Fixed-point denominator is LDENOM.
        aac : array[16] base.u32,  // Fixed-point denominator is ADENOM.

        // 32 rows, 32 BGRA pixels per row.
        pixels : array[32] array[128] base.u8,
)

pub func decoder.get_quirk(key: base.u32) base.u64 {
    if (args.key == QUIRK_JUST_RAW_THUMBHASH) and this.quirk_just_raw_thumbhash {
        return 1
    }
    return 0
}

pub func decoder.set_quirk!(key: base.u32, value: base.u64) base.status {
    if args.key == QUIRK_JUST_RAW_THUMBHASH {
        this.quirk_just_raw_thumbhash = args.value > 0
        return ok
    }
    return base."#unsupported option"
}

pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_reader) {
    var status : base.status

    while true {
        status =? this.do_decode_image_config?(dst: args.dst, src: args.src)
        if (status == base."$short read") and args.src.is_closed() {
            return "#truncated input"
        }
        yield? status
    }
}

pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.io_reader) {
    var c32  : base.u32
    var swap : base.u8[..= 7]

    if this.call_sequence <> 0x00 {
        return base."#bad call sequence"
    }

    if not this.quirk_just_raw_thumbhash {
        c32 = args.src.read_u24le_as_u32?()
        if c32 <> '\xC3\xBE\xFE'le {
            return "#bad header"
        }
    }

    c32 = args.src.read_u24le_as_u32?()
    this.l_dc = (((c32 >> 0x00) & 63) as base.u64) * (31 << 42)
    this.p_dc = ((((c32 >> 0x06) & 63) as base.u64) * (31 << 43)) ~mod- ((63 * 31) << 42)
    this.q_dc = ((((c32 >> 0x0C) & 63) as base.u64) * (31 << 43)) ~mod- ((63 * 31) << 42)
    this.l_scale = ((c32 >> 0x12) & 31) as base.u8
    this.has_alpha = ((c32 >> 0x17) & 1) as base.u8

    c32 = args.src.read_u16le_as_u32?()
    this.l_count = ((c32 >> 0x00) & 7) as base.u8
    this.p_scale = ((c32 >> 0x03) & 63) as base.u8
    this.q_scale = ((c32 >> 0x09) & 63) as base.u8
    this.is_landscape = ((c32 >> 0x0F) & 1) as base.u8
    this.w_dimension_code = (DIMENSION_CODES_FROM_HAS_ALPHA_AND_L_COUNT[this.has_alpha][this.l_count] >> 4) & 7
    this.h_dimension_code = (DIMENSION_CODES_FROM_HAS_ALPHA_AND_L_COUNT[this.has_alpha][this.l_count] >> 0) & 7
    if this.is_landscape <> 0 {
        swap = this.w_dimension_code
        this.w_dimension_code = this.h_dimension_code
        this.h_dimension_code = swap
    }

    if this.is_landscape <> 0 {
        this.lx = (7 - (2 * this.has_alpha)) as base.u32
        this.ly = (this.l_count.max(no_less_than: 3)) as base.u32
    } else {
        this.lx = (this.l_count.max(no_less_than: 3)) as base.u32
        this.ly = (7 - (2 * this.has_alpha)) as base.u32
    }

    this.frame_config_io_position = 8
    assert this.frame_config_io_position >= 8
    if this.has_alpha <> 0 {
        c32 = args.src.read_u8_as_u32?()
        this.a_dc = (((c32 >> 0x00) & 15) as base.u64) << 42
        this.a_scale = ((c32 >> 0x04) & 15) as base.u8
        this.frame_config_io_position = 9
        assert this.frame_config_io_position >= 8
    }

    if this.quirk_just_raw_thumbhash {
        this.frame_config_io_position -= 3
    }

    this.pixfmt = base.PIXEL_FORMAT__BGRX
    if this.has_alpha <> 0 {
        this.pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL
    }

    if args.dst <> nullptr {
        args.dst.set!(
                pixfmt: this.pixfmt,
                pixsub: 0,
                width: DIMENSIONS_FROM_DIMENSION_CODES[this.w_dimension_code] as base.u32,
                height: DIMENSIONS_FROM_DIMENSION_CODES[this.h_dimension_code] as base.u32,
                first_frame_io_position: this.frame_config_io_position as base.u64,
                first_frame_is_opaque: this.has_alpha == 0)
    }

    this.call_sequence = 0x20
}

pub func decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
    var status : base.status

    while true {
        status =? this.do_decode_frame_config?(dst: args.dst, src: args.src)
        if (status == base."$short read") and args.src.is_closed() {
            return "#truncated input"
        }
        yield? status
    }
}

pri func decoder.do_decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
    var pixfmt : base.pixel_format

    if this.call_sequence == 0x20 {
        // No-op.
    } else if this.call_sequence < 0x20 {
        this.do_decode_image_config?(dst: nullptr, src: args.src)
    } else if this.call_sequence == 0x28 {
        if (this.frame_config_io_position as base.u64) <> args.src.position() {
            return base."#bad restart"
        }
    } else if this.call_sequence == 0x40 {
        this.call_sequence = 0x60
        return base."@end of data"
    } else {
        return base."@end of data"
    }

    if args.dst <> nullptr {
        pixfmt = this.util.make_pixel_format(repr: this.pixfmt)
        args.dst.set!(bounds: this.util.make_rect_ie_u32(
                min_incl_x: 0,
                min_incl_y: 0,
                max_excl_x: DIMENSIONS_FROM_DIMENSION_CODES[this.w_dimension_code] as base.u32,
                max_excl_y: DIMENSIONS_FROM_DIMENSION_CODES[this.h_dimension_code] as base.u32),
                duration: 0,
                index: 0,
                io_position: this.frame_config_io_position as base.u64,
                disposal: 0,
                opaque_within_bounds: this.has_alpha == 0,
                overwrite_instead_of_blend: false,
                background_color: pixfmt.default_background_color())
    }

    this.call_sequence = 0x40
}

pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
    var status : base.status

    while true {
        status =? this.do_decode_frame?(dst: args.dst, src: args.src, blend: args.blend, workbuf: args.workbuf, opts: args.opts)
        if (status == base."$short read") and args.src.is_closed() {
            return "#truncated input"
        }
        yield? status
    }
}

pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
    var status : base.status

    if this.call_sequence == 0x40 {
        // No-op.
    } else if this.call_sequence < 0x40 {
        this.do_decode_frame_config?(dst: nullptr, src: args.src)
    } else {
        return base."@end of data"
    }

    status = this.swizzler.prepare!(
            dst_pixfmt: args.dst.pixel_format(),
            dst_palette: args.dst.palette(),
            src_pixfmt: this.util.make_pixel_format(repr: this.pixfmt),
            src_palette: this.util.empty_slice_u8(),
            blend: args.blend)
    if not status.is_ok() {
        return status
    }

    this.from_src_to_coeffs?(src: args.src)
    this.from_coeffs_to_pixels!()
    status = this.from_pixels_to_dst!(dst: args.dst)
    if not status.is_ok() {
        return status
    }

    this.call_sequence = 0x60
}

pri func decoder.from_src_to_coeffs?(src: base.io_reader) {
    var c8       : base.u8
    var cy       : base.u32
    var cx       : base.u32
    var i        : base.u32
    var has_bits : base.bool

    // Read L AC coefficients.
    i = 0
    cy = 0
    while cy < this.ly {
        cx = 0
        if cy == 0 {
            cx = 1
        }
        while (cx ~mod* this.ly) < (this.lx ~mod* (this.ly ~mod- cy)) {
            if has_bits {
                has_bits = false
                c8 >>= 4
            } else {
                has_bits = true
                c8 = args.src.read_u8?()
            }

            // Multiply by (63 * 2) to double (†) and get to LDENOM.
            this.lac[i & 31] = ((this.l_scale as base.u32) ~mod* 126) ~mod*
                    this.util.sign_extend_convert_u16_u32(a: FROM_4_BITS_TO_PLUS_MINUS_1_00[c8 & 15])

            i ~mod+= 1
            cx ~mod+= 1
        }
        cy ~mod+= 1
    }

    // Read P AC coefficients.
    i = 0
    cx = 0
    while cx < 5 {
        if has_bits {
            has_bits = false
            c8 >>= 4
        } else {
            has_bits = true
            c8 = args.src.read_u8?()
        }

        // Multiply by (31 * 2) to double (†) and get to LDENOM.
        this.pac[i & 7] = ((this.p_scale as base.u32) ~mod* 62) ~mod*
                this.util.sign_extend_convert_u16_u32(a: FROM_4_BITS_TO_PLUS_MINUS_1_25[c8 & 15])

        i ~mod+= 1
        cx ~mod+= 1
    }

    // Read Q AC coefficients.
    i = 0
    cx = 0
    while cx < 5 {
        if has_bits {
            has_bits = false
            c8 >>= 4
        } else {
            has_bits = true
            c8 = args.src.read_u8?()
        }

        // Multiply by (31 * 2) to double (†) and get to LDENOM.
        this.qac[i & 7] = ((this.q_scale as base.u32) ~mod* 62) ~mod*
                this.util.sign_extend_convert_u16_u32(a: FROM_4_BITS_TO_PLUS_MINUS_1_25[c8 & 15])

        i ~mod+= 1
        cx ~mod+= 1
    }

    // Read A AC coefficients.
    if this.has_alpha == 0 {
        return ok
    }
    i = 0
    cx = 0
    while cx < 14 {
        if has_bits {
            has_bits = false
            c8 >>= 4
        } else {
            has_bits = true
            c8 = args.src.read_u8?()
        }

        // Multiply by 2 to double (†). We're already at ADENOM.
        this.aac[i & 15] = ((this.a_scale as base.u32) ~mod* 2) ~mod*
                this.util.sign_extend_convert_u16_u32(a: FROM_4_BITS_TO_PLUS_MINUS_1_00[c8 & 15])

        i ~mod+= 1
        cx ~mod+= 1
    }
}

pri func decoder.from_coeffs_to_pixels!() {
    var h : base.u32[..= 32]
    var w : base.u32[..= 32]

    // fx[7] and fy[7] are unused but we round up the array sizes up to a power
    // of 2 (and bitwise-and the array indexes) to simplify bounds checking.
    var fy : array[8] base.u32
    var fx : array[8] base.u32

    var cosines_base_y : base.u32[..= 127]
    var cosines_base_x : base.u32[..= 127]

    var y : base.u32
    var x : base.u32

    var f : base.u32
    var l : base.u64
    var p : base.u64
    var q : base.u64
    var b : base.u64
    var g : base.u64
    var r : base.u64
    var a : base.u64

    var i  : base.u32
    var cy : base.u32
    var cx : base.u32

    h = DIMENSIONS_FROM_DIMENSION_CODES[this.h_dimension_code] as base.u32
    w = DIMENSIONS_FROM_DIMENSION_CODES[this.w_dimension_code] as base.u32
    fy[0] = 0x4000  // This is always cos(0), scaled by 0x4000 = (1 << 14).
    fx[0] = 0x4000  // This is always cos(0), scaled by 0x4000 = (1 << 14).
    a = 0xFF

    y = 0
    while y < h {
        assert y < 32 via "a < b: a < c; c <= b"(c: h)

        cosines_base_y = CUMULATIVE_DIMENSIONS[this.h_dimension_code] as base.u32
        fy[1] = this.util.sign_extend_convert_u16_u32(a: COSINES[cosines_base_y + y][0])
        fy[2] = this.util.sign_extend_convert_u16_u32(a: COSINES[cosines_base_y + y][1])
        fy[3] = this.util.sign_extend_convert_u16_u32(a: COSINES[cosines_base_y + y][2])
        fy[4] = this.util.sign_extend_convert_u16_u32(a: COSINES[cosines_base_y + y][3])
        fy[5] = this.util.sign_extend_convert_u16_u32(a: COSINES[cosines_base_y + y][4])
        fy[6] = this.util.sign_extend_convert_u16_u32(a: COSINES[cosines_base_y + y][5])

        // The original JavaScript reference implementation also multiplied
        // fy[cy] by 2 but we have already adjusted for that (†).

        x = 0
        while x < w,
                inv y < 32,
        {
            assert x < 32 via "a < b: a < c; c <= b"(c: w)

            cosines_base_x = CUMULATIVE_DIMENSIONS[this.w_dimension_code] as base.u32
            fx[1] = this.util.sign_extend_convert_u16_u32(a: COSINES[cosines_base_x + x][0])
            fx[2] = this.util.sign_extend_convert_u16_u32(a: COSINES[cosines_base_x + x][1])
            fx[3] = this.util.sign_extend_convert_u16_u32(a: COSINES[cosines_base_x + x][2])
            fx[4] = this.util.sign_extend_convert_u16_u32(a: COSINES[cosines_base_x + x][3])
            fx[5] = this.util.sign_extend_convert_u16_u32(a: COSINES[cosines_base_x + x][4])
            fx[6] = this.util.sign_extend_convert_u16_u32(a: COSINES[cosines_base_x + x][5])

            // Accumulate L.
            l = this.l_dc
            i = 0
            cy = 0
            while cy < this.ly,
                    inv y < 32,
                    inv x < 32,
            {
                cx = 0
                if cy == 0 {
                    cx = 1
                }
                while (cx ~mod* this.ly) < (this.lx ~mod* (this.ly ~mod- cy)),
                        inv y < 32,
                        inv x < 32,
                {
                    f = fx[cx & 7] ~mod* fy[cy & 7]
                    l ~mod+= this.util.sign_extend_convert_u32_u64(a: f) ~mod*
                            this.util.sign_extend_convert_u32_u64(a: this.lac[i & 31])
                    i ~mod+= 1
                    cx ~mod+= 1
                }
                cy ~mod+= 1
            }

            // Accumulate P and Q.
            p = this.p_dc
            q = this.q_dc
            i = 0
            cy = 0
            while cy < 3,
                    inv y < 32,
                    inv x < 32,
            {
                cx = 0
                if cy == 0 {
                    cx = 1
                }
                while cx < (3 - cy),
                        inv y < 32,
                        inv x < 32,
                        inv cy < 3,
                {
                    assert cx < 3 via "a < b: a < c; c <= b"(c: 3 - cy)
                    f = fx[cx] ~mod* fy[cy]
                    p ~mod+= this.util.sign_extend_convert_u32_u64(a: f) ~mod*
                            this.util.sign_extend_convert_u32_u64(a: this.pac[i & 7])
                    q ~mod+= this.util.sign_extend_convert_u32_u64(a: f) ~mod*
                            this.util.sign_extend_convert_u32_u64(a: this.qac[i & 7])
                    i ~mod+= 1
                    cx ~mod+= 1
                }
                cy ~mod+= 1
            }

            // Convert LPQ to RGB. The code is the i64 equivalents of:
            //   b = l - ((2 * p) / 3)
            //   r = (((3 * l) + q) - b) / 2
            //   g = r - q
            b = l ~mod- this.util.i64_divide(a: 2 ~mod* p, b: 3)
            r = this.util.sign_extend_rshift_u64(a: ((3 ~mod* l) ~mod+ q) ~mod- b, n: 1)
            g = r ~mod- q

            // Rescale from (LDENOM << 28) to 255 and clamp.
            //
            // (LDENOM << 28) = 8589_384836_186112 = (33_683862_102690 * 255) + 162
            //
            // Rounding down (instead of rounding to nearest) more closely
            // matches the original JavaScript reference implementation. The
            // two implementations aren't a 100% match, due to floating point
            // versus fixed point rounding errors, but they're pretty close.
            if (b >> 63) <> 0 {
                b = 0
            } else if b >= (33_683862_102690 * 255) {
                b = 255
            } else {
                b /= 33_683862_102690
            }
            if (g >> 63) <> 0 {
                g = 0
            } else if g >= (33_683862_102690 * 255) {
                g = 255
            } else {
                g /= 33_683862_102690
            }
            if (r >> 63) <> 0 {
                r = 0
            } else if r >= (33_683862_102690 * 255) {
                r = 255
            } else {
                r /= 33_683862_102690
            }

            // Accumulate, rescale from (ADENOM << 28) and clamp A.
            if this.has_alpha <> 0 {
                a = this.a_dc
                i = 0
                cy = 0
                while cy < 5,
                        inv y < 32,
                        inv x < 32,
                {
                    cx = 0
                    if cy == 0 {
                        cx = 1
                    }
                    while cx < (5 - cy),
                            inv y < 32,
                            inv x < 32,
                            inv cy < 5,
                    {
                        assert cx < 5 via "a < b: a < c; c <= b"(c: 5 - cy)
                        f = fx[cx] ~mod* fy[cy]
                        a ~mod+= this.util.sign_extend_convert_u32_u64(a: f) ~mod*
                                this.util.sign_extend_convert_u32_u64(a: this.aac[i & 15])
                        i ~mod+= 1
                        cx ~mod+= 1
                    }
                    cy ~mod+= 1
                }

                // (ADENOM << 28) = 65_970697_666560 = (258708_618300 * 255) + 60
                if (a >> 63) <> 0 {
                    a = 0
                } else if a >= (258708_618300 * 255) {
                    a = 255
                } else {
                    a /= 258708_618300
                }
            }

            // Store the BGRA pixel.
            this.pixels[y][(4 * x) + 0] = (b & 0xFF) as base.u8
            this.pixels[y][(4 * x) + 1] = (g & 0xFF) as base.u8
            this.pixels[y][(4 * x) + 2] = (r & 0xFF) as base.u8
            this.pixels[y][(4 * x) + 3] = (a & 0xFF) as base.u8

            x += 1
        }
        y += 1
    }
}

pri func decoder.from_pixels_to_dst!(dst: ptr base.pixel_buffer) base.status {
    var h : base.u32[..= 32]
    var w : base.u32[..= 32]

    var dst_pixfmt          : base.pixel_format
    var dst_bits_per_pixel  : base.u32[..= 256]
    var dst_bytes_per_pixel : base.u32[..= 32]
    var dst_bytes_per_row   : base.u64
    var tab                 : table base.u8
    var y                   : base.u32
    var dst                 : slice base.u8
    var src                 : slice base.u8

    h = DIMENSIONS_FROM_DIMENSION_CODES[this.h_dimension_code] as base.u32
    w = DIMENSIONS_FROM_DIMENSION_CODES[this.w_dimension_code] as base.u32

    // TODO: the dst_pixfmt variable shouldn't be necessary. We should be able
    // to chain the two calls: "args.dst.pixel_format().bits_per_pixel()".
    dst_pixfmt = args.dst.pixel_format()
    dst_bits_per_pixel = dst_pixfmt.bits_per_pixel()
    if (dst_bits_per_pixel & 7) <> 0 {
        return base."#unsupported option"
    }
    dst_bytes_per_pixel = dst_bits_per_pixel / 8
    dst_bytes_per_row = (w * dst_bytes_per_pixel) as base.u64
    tab = args.dst.plane(p: 0)

    while y < h {
        assert y < 32 via "a < b: a < c; c <= b"(c: h)
        src = this.pixels[y][.. w * 4]

        dst = tab.row_u32(y: y)
        if dst_bytes_per_row < dst.length() {
            dst = dst[.. dst_bytes_per_row]
        }

        this.swizzler.swizzle_interleaved_from_slice!(
                dst: dst,
                dst_palette: args.dst.palette(),
                src: src)

        y += 1
    }

    return ok
}

pub func decoder.frame_dirty_rect() base.rect_ie_u32 {
    return this.util.make_rect_ie_u32(
            min_incl_x: 0,
            min_incl_y: 0,
            max_excl_x: DIMENSIONS_FROM_DIMENSION_CODES[this.w_dimension_code] as base.u32,
            max_excl_y: DIMENSIONS_FROM_DIMENSION_CODES[this.h_dimension_code] as base.u32)
}

pub func decoder.num_animation_loops() base.u32 {
    return 0
}

pub func decoder.num_decoded_frame_configs() base.u64 {
    if this.call_sequence > 0x20 {
        return 1
    }
    return 0
}

pub func decoder.num_decoded_frames() base.u64 {
    if this.call_sequence > 0x40 {
        return 1
    }
    return 0
}

pub func decoder.restart_frame!(index: base.u64, io_position: base.u64) base.status {
    if this.call_sequence < 0x20 {
        return base."#bad call sequence"
    }
    if (args.index <> 0) or (args.io_position <> (this.frame_config_io_position as base.u64)) {
        return base."#bad argument"
    }
    this.call_sequence = 0x28
    return ok
}

pub func decoder.set_report_metadata!(fourcc: base.u32, report: base.bool) {
    // No-op. Thumbhash doesn't support metadata.
}

pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_information, src: base.io_reader) {
    return base."#no more information"
}

pub func decoder.workbuf_len() base.range_ii_u64 {
    return this.util.make_range_ii_u64(min_incl: 0, max_incl: 0)
}

// DIMENSIONS_FROM_DIMENSION_CODES enumerates all possible widths and heights.
pri const DIMENSIONS_FROM_DIMENSION_CODES : roarray[8] base.u8[..= 32] = [
        0, 14, 18, 19, 23, 26, 27, 32,
]

// CUMULATIVE_DIMENSIONS is the sum-table of DIMENSIONS_FROM_DIMENSION_CODES.
pri const CUMULATIVE_DIMENSIONS : roarray[8] base.u8[..= 127] = [
        0, 0, 14, 32, 51, 74, 100, 127,
]

// DIMENSION_CODES_FROM_HAS_ALPHA_AND_L_COUNT holds the width (high 4 bits) and
// height (low 4 bits) codes. For example, if has_alpha is 0 and l_count is 5
// then the 0x47 value means that the image is 23×32 (so the aspect ratio is
// 0.71875), because:
//  - the width  is DIMENSIONS_FROM_DIMENSION_CODES[4] = 23
//  - the height is DIMENSIONS_FROM_DIMENSION_CODES[7] = 32
//
// If is_landscape is 1 (true) then the width and height are swapped.
pri const DIMENSION_CODES_FROM_HAS_ALPHA_AND_L_COUNT : roarray[2] roarray[8] base.u8 = [
        [0x17, 0x17, 0x17, 0x17, 0x27, 0x47, 0x67, 0x77],
        [0x37, 0x37, 0x37, 0x37, 0x57, 0x77, 0x76, 0x74],
]

// FROM_4_BITS_TO_PLUS_MINUS_1_00 converts AC coefficients to 2.14 fixed point.
pri const FROM_4_BITS_TO_PLUS_MINUS_1_00 : roarray[16] base.u16 = [
        0xC000,  // -1.000
        0xC889,  // -0.867
        0xD111,  // -0.733
        0xD99A,  // -0.600
        0xE222,  // -0.467
        0xEAAB,  // -0.333
        0xF333,  // -0.200
        0xFBBC,  // -0.067
        0x0444,  // +0.067
        0x0CCD,  // +0.200
        0x1555,  // +0.333
        0x1DDE,  // +0.467
        0x2666,  // +0.600
        0x2EEF,  // +0.733
        0x3777,  // +0.867
        0x4000,  // +1.000
]

// FROM_4_BITS_TO_PLUS_MINUS_1_25 converts AC coefficients to 2.14 fixed point.
pri const FROM_4_BITS_TO_PLUS_MINUS_1_25 : roarray[16] base.u16 = [
        0xB000,  // -1.250
        0xBAAB,  // -1.083
        0xC555,  // -0.917
        0xD000,  // -0.750
        0xDAAB,  // -0.583
        0xE555,  // -0.417
        0xF000,  // -0.250
        0xFAAB,  // -0.083
        0x0555,  // +0.083
        0x1000,  // +0.250
        0x1AAB,  // +0.417
        0x2555,  // +0.583
        0x3000,  // +0.750
        0x3AAB,  // +0.917
        0x4555,  // +1.083
        0x5000,  // +1.250
]

// COSINES[etc][cx - 1] holds cos(π * cx * (x + 0.5) / w) as 2.14 fixed point.
// Each 6-element row is copied to fx[1 .. 7] and fy[1 .. 7]. fx[0] and fy[0]
// are always equal to 0x4000, which is cos(0) as 2.14 fixed point. fx[7] and
// fy[7] are unused.
//
// (x + 0.5) ranges from (0 + 0.5) to (w - 0.5). Valid w values are given by
// the positive elements of DIMENSIONS_FROM_DIMENSION_CODES.
pri const COSINES : roarray[159] roarray[6] base.u16 = [
        // w = 14
        [0x3F99, 0x3E65, 0x3C69, 0x39A9, 0x3631, 0x320A],  // x =  0
        [0x3C69, 0x320A, 0x220D, 0x0E3E, 0xF8D6, 0xE43B],  // x =  1
        [0x3631, 0x1BC5, 0xF8D6, 0xD819, 0xC397, 0xC19B],  // x =  2
        [0x2D41, 0x0000, 0xD2BF, 0xC000, 0xD2BF, 0x0000],  // x =  3
        [0x220D, 0xE43B, 0xC067, 0xD819, 0x1523, 0x3E65],  // x =  4
        [0x1523, 0xCDF6, 0xC9CF, 0x0E3E, 0x3F99, 0x1BC5],  // x =  5
        [0x072A, 0xC19B, 0xEADD, 0x39A9, 0x220D, 0xCDF6],  // x =  6
        [0xF8D6, 0xC19B, 0x1523, 0x39A9, 0xDDF3, 0xCDF6],  // x =  7
        [0xEADD, 0xCDF6, 0x3631, 0x0E3E, 0xC067, 0x1BC5],  // x =  8
        [0xDDF3, 0xE43B, 0x3F99, 0xD819, 0xEADD, 0x3E65],  // x =  9
        [0xD2BF, 0x0000, 0x2D41, 0xC000, 0x2D41, 0x0000],  // x = 10
        [0xC9CF, 0x1BC5, 0x072A, 0xD819, 0x3C69, 0xC19B],  // x = 11
        [0xC397, 0x320A, 0xDDF3, 0x0E3E, 0x072A, 0xE43B],  // x = 12
        [0xC067, 0x3E65, 0xC397, 0x39A9, 0xC9CF, 0x320A],  // x = 13

        // w = 18
        [0x3FC2, 0x3F07, 0x3DD2, 0x3C24, 0x3A01, 0x376D],  // x =  0
        [0x3DD2, 0x376D, 0x2D41, 0x2000, 0x1090, 0x0000],  // x =  1
        [0x3A01, 0x2923, 0x1090, 0xF4E3, 0xDB4B, 0xC893],  // x =  2
        [0x346D, 0x15E4, 0xEF70, 0xCEF9, 0xC03E, 0xC893],  // x =  3
        [0x2D41, 0x0000, 0xD2BF, 0xC000, 0xD2BF, 0x0000],  // x =  4
        [0x24B5, 0xEA1C, 0xC22E, 0xCEF9, 0x0594, 0x376D],  // x =  5
        [0x1B0C, 0xD6DD, 0xC22E, 0xF4E3, 0x346D, 0x376D],  // x =  6
        [0x1090, 0xC893, 0xD2BF, 0x2000, 0x3DD2, 0x0000],  // x =  7
        [0x0594, 0xC0F9, 0xEF70, 0x3C24, 0x1B0C, 0xC893],  // x =  8
        [0xFA6C, 0xC0F9, 0x1090, 0x3C24, 0xE4F4, 0xC893],  // x =  9
        [0xEF70, 0xC893, 0x2D41, 0x2000, 0xC22E, 0x0000],  // x = 10
        [0xE4F4, 0xD6DD, 0x3DD2, 0xF4E3, 0xCB93, 0x376D],  // x = 11
        [0xDB4B, 0xEA1C, 0x3DD2, 0xCEF9, 0xFA6C, 0x376D],  // x = 12
        [0xD2BF, 0x0000, 0x2D41, 0xC000, 0x2D41, 0x0000],  // x = 13
        [0xCB93, 0x15E4, 0x1090, 0xCEF9, 0x3FC2, 0xC893],  // x = 14
        [0xC5FF, 0x2923, 0xEF70, 0xF4E3, 0x24B5, 0xC893],  // x = 15
        [0xC22E, 0x376D, 0xD2BF, 0x2000, 0xEF70, 0x0000],  // x = 16
        [0xC03E, 0x3F07, 0xC22E, 0x3C24, 0xC5FF, 0x376D],  // x = 17

        // w = 19
        [0x3FC8, 0x3F21, 0x3E0B, 0x3C88, 0x3A9C, 0x3849],  // x =  0
        [0x3E0B, 0x3849, 0x2F16, 0x2301, 0x14C8, 0x0549],  // x =  1
        [0x3A9C, 0x2B59, 0x14C8, 0xFAB7, 0xE18A, 0xCD7F],  // x =  2
        [0x3594, 0x19B5, 0xF577, 0xD4A7, 0xC1F5, 0xC378],  // x =  3
        [0x2F16, 0x0549, 0xD8B1, 0xC0DF, 0xCA6C, 0xF04A],  // x =  4
        [0x274F, 0xF04A, 0xC564, 0xC7B7, 0xF577, 0x2B59],  // x =  5
        [0x1E76, 0xDCFF, 0xC038, 0xE64B, 0x274F, 0x3F21],  // x =  6
        [0x14C8, 0xCD7F, 0xCA6C, 0x0FB6, 0x3FC8, 0x19B5],  // x =  7
        [0x0A89, 0xC378, 0xE18A, 0x3281, 0x2F16, 0xDCFF],  // x =  8
        [0x0000, 0xC000, 0x0000, 0x4000, 0x0000, 0xC000],  // x =  9
        [0xF577, 0xC378, 0x1E76, 0x3281, 0xD0EA, 0xDCFF],  // x = 10
        [0xEB38, 0xCD7F, 0x3594, 0x0FB6, 0xC038, 0x19B5],  // x = 11
        [0xE18A, 0xDCFF, 0x3FC8, 0xE64B, 0xD8B1, 0x3F21],  // x = 12
        [0xD8B1, 0xF04A, 0x3A9C, 0xC7B7, 0x0A89, 0x2B59],  // x = 13
        [0xD0EA, 0x0549, 0x274F, 0xC0DF, 0x3594, 0xF04A],  // x = 14
        [0xCA6C, 0x19B5, 0x0A89, 0xD4A7, 0x3E0B, 0xC378],  // x = 15
        [0xC564, 0x2B59, 0xEB38, 0xFAB7, 0x1E76, 0xCD7F],  // x = 16
        [0xC1F5, 0x3849, 0xD0EA, 0x2301, 0xEB38, 0x0549],  // x = 17
        [0xC038, 0x3F21, 0xC1F5, 0x3C88, 0xC564, 0x3849],  // x = 18

        // w = 23
        [0x3FDA, 0x3F67, 0x3EA9, 0x3DA0, 0x3C4E, 0x3AB4],  // x =  0
        [0x3EA9, 0x3AB4, 0x3449, 0x2BAF, 0x2141, 0x156F],  // x =  1
        [0x3C4E, 0x31A5, 0x2141, 0x0D05, 0xF749, 0xE28E],  // x =  2
        [0x38D3, 0x24E8, 0x08B7, 0xEA91, 0xD13A, 0xC260],  // x =  3
        [0x3449, 0x156F, 0xEEBC, 0xCE5B, 0xC026, 0xC951],  // x =  4
        [0x2EC6, 0x045E, 0xD79C, 0xC099, 0xCBB7, 0xF2FB],  // x =  5
        [0x2864, 0xF2FB, 0xC72D, 0xC54C, 0xEEBC, 0x24E8],  // x =  6
        [0x2141, 0xE28E, 0xC026, 0xDB18, 0x197F, 0x3F67],  // x =  7
        [0x197F, 0xD451, 0xC3B2, 0xFBA2, 0x38D3, 0x31A5],  // x =  8
        [0x1144, 0xC951, 0xD13A, 0x1D72, 0x3EA9, 0x045E],  // x =  9
        [0x08B7, 0xC260, 0xE681, 0x36AF, 0x2864, 0xD451],  // x = 10
        [0x0000, 0xC000, 0x0000, 0x4000, 0x0000, 0xC000],  // x = 11
        [0xF749, 0xC260, 0x197F, 0x36AF, 0xD79C, 0xD451],  // x = 12
        [0xEEBC, 0xC951, 0x2EC6, 0x1D72, 0xC157, 0x045E],  // x = 13
        [0xE681, 0xD451, 0x3C4E, 0xFBA2, 0xC72D, 0x31A5],  // x = 14
        [0xDEBF, 0xE28E, 0x3FDA, 0xDB18, 0xE681, 0x3F67],  // x = 15
        [0xD79C, 0xF2FB, 0x38D3, 0xC54C, 0x1144, 0x24E8],  // x = 16
        [0xD13A, 0x045E, 0x2864, 0xC099, 0x3449, 0xF2FB],  // x = 17
        [0xCBB7, 0x156F, 0x1144, 0xCE5B, 0x3FDA, 0xC951],  // x = 18
        [0xC72D, 0x24E8, 0xF749, 0xEA91, 0x2EC6, 0xC260],  // x = 19
        [0xC3B2, 0x31A5, 0xDEBF, 0x0D05, 0x08B7, 0xE28E],  // x = 20
        [0xC157, 0x3AB4, 0xCBB7, 0x2BAF, 0xDEBF, 0x156F],  // x = 21
        [0xC026, 0x3F67, 0xC157, 0x3DA0, 0xC3B2, 0x3AB4],  // x = 22

        // w = 26
        [0x3FE2, 0x3F89, 0x3EF4, 0x3E24, 0x3D1A, 0x3BD7],  // x =  0
        [0x3EF4, 0x3BD7, 0x36C5, 0x2FE8, 0x2778, 0x1DBE],  // x =  1
        [0x3D1A, 0x34AC, 0x2778, 0x16B2, 0x03DD, 0xF0AF],  // x =  2
        [0x3A5D, 0x2A71, 0x130A, 0xF849, 0xDEE4, 0xCB54],  // x =  3
        [0x36C5, 0x1DBE, 0xFC23, 0xDBA5, 0xC5A3, 0xC077],  // x =  4
        [0x3261, 0x0F51, 0xE5BC, 0xC755, 0xC10C, 0xD58F],  // x =  5
        [0x2D41, 0x0000, 0xD2BF, 0xC000, 0xD2BF, 0x0000],  // x =  6
        [0x2778, 0xF0AF, 0xC5A3, 0xC755, 0xF477, 0x2A71],  // x =  7
        [0x211C, 0xE242, 0xC01E, 0xDBA5, 0x1A44, 0x3F89],  // x =  8
        [0x1A44, 0xD58F, 0xC2E6, 0xF849, 0x36C5, 0x34AC],  // x =  9
        [0x130A, 0xCB54, 0xCD9F, 0x16B2, 0x3FE2, 0x0F51],  // x = 10
        [0x0B89, 0xC429, 0xDEE4, 0x2FE8, 0x3261, 0xE242],  // x = 11
        [0x03DD, 0xC077, 0xF477, 0x3E24, 0x130A, 0xC429],  // x = 12
        [0xFC23, 0xC077, 0x0B89, 0x3E24, 0xECF6, 0xC429],  // x = 13
        [0xF477, 0xC429, 0x211C, 0x2FE8, 0xCD9F, 0xE242],  // x = 14
        [0xECF6, 0xCB54, 0x3261, 0x16B2, 0xC01E, 0x0F51],  // x = 15
        [0xE5BC, 0xD58F, 0x3D1A, 0xF849, 0xC93B, 0x34AC],  // x = 16
        [0xDEE4, 0xE242, 0x3FE2, 0xDBA5, 0xE5BC, 0x3F89],  // x = 17
        [0xD888, 0xF0AF, 0x3A5D, 0xC755, 0x0B89, 0x2A71],  // x = 18
        [0xD2BF, 0x0000, 0x2D41, 0xC000, 0x2D41, 0x0000],  // x = 19
        [0xCD9F, 0x0F51, 0x1A44, 0xC755, 0x3EF4, 0xD58F],  // x = 20
        [0xC93B, 0x1DBE, 0x03DD, 0xDBA5, 0x3A5D, 0xC077],  // x = 21
        [0xC5A3, 0x2A71, 0xECF6, 0xF849, 0x211C, 0xCB54],  // x = 22
        [0xC2E6, 0x34AC, 0xD888, 0x16B2, 0xFC23, 0xF0AF],  // x = 23
        [0xC10C, 0x3BD7, 0xC93B, 0x2FE8, 0xD888, 0x1DBE],  // x = 24
        [0xC01E, 0x3F89, 0xC10C, 0x3E24, 0xC2E6, 0x3BD7],  // x = 25

        // w = 27
        [0x3FE4, 0x3F91, 0x3F07, 0x3E46, 0x3D50, 0x3C24],  // x =  0
        [0x3F07, 0x3C24, 0x376D, 0x3107, 0x2923, 0x2000],  // x =  1
        [0x3D50, 0x3579, 0x2923, 0x1959, 0x076E, 0xF4E3],  // x =  2
        [0x3AC4, 0x2BEB, 0x15E4, 0xFC47, 0xE347, 0xCEF9],  // x =  3
        [0x376D, 0x2000, 0x0000, 0xE000, 0xC893, 0xC000],  // x =  4
        [0x3356, 0x125B, 0xEA1C, 0xCA87, 0xC01C, 0xCEF9],  // x =  5
        [0x2E8D, 0x03B9, 0xD6DD, 0xC06F, 0xCCAA, 0xF4E3],  // x =  6
        [0x2923, 0xF4E3, 0xC893, 0xC3DC, 0xEA1C, 0x2000],  // x =  7
        [0x232B, 0xE6A7, 0xC0F9, 0xD415, 0x0EC2, 0x3C24],  // x =  8
        [0x1CB9, 0xD9C8, 0xC0F9, 0xEDA5, 0x2E8D, 0x3C24],  // x =  9
        [0x15E4, 0xCEF9, 0xC893, 0x0B1D, 0x3F07, 0x2000],  // x = 10
        [0x0EC2, 0xC6CF, 0xD6DD, 0x2638, 0x3AC4, 0xF4E3],  // x = 11
        [0x076E, 0xC1BA, 0xEA1C, 0x3931, 0x232B, 0xCEF9],  // x = 12
        [0x0000, 0xC000, 0x0000, 0x4000, 0x0000, 0xC000],  // x = 13
        [0xF892, 0xC1BA, 0x15E4, 0x3931, 0xDCD5, 0xCEF9],  // x = 14
        [0xF13E, 0xC6CF, 0x2923, 0x2638, 0xC53C, 0xF4E3],  // x = 15
        [0xEA1C, 0xCEF9, 0x376D, 0x0B1D, 0xC0F9, 0x2000],  // x = 16
        [0xE347, 0xD9C8, 0x3F07, 0xEDA5, 0xD173, 0x3C24],  // x = 17
        [0xDCD5, 0xE6A7, 0x3F07, 0xD415, 0xF13E, 0x3C24],  // x = 18
        [0xD6DD, 0xF4E3, 0x376D, 0xC3DC, 0x15E4, 0x2000],  // x = 19
        [0xD173, 0x03B9, 0x2923, 0xC06F, 0x3356, 0xF4E3],  // x = 20
        [0xCCAA, 0x125B, 0x15E4, 0xCA87, 0x3FE4, 0xCEF9],  // x = 21
        [0xC893, 0x2000, 0x0000, 0xE000, 0x376D, 0xC000],  // x = 22
        [0xC53C, 0x2BEB, 0xEA1C, 0xFC47, 0x1CB9, 0xCEF9],  // x = 23
        [0xC2B0, 0x3579, 0xD6DD, 0x1959, 0xF892, 0xF4E3],  // x = 24
        [0xC0F9, 0x3C24, 0xC893, 0x3107, 0xD6DD, 0x2000],  // x = 25
        [0xC01C, 0x3F91, 0xC0F9, 0x3E46, 0xC2B0, 0x3C24],  // x = 26

        // w = 32
        [0x3FEC, 0x3FB1, 0x3F4F, 0x3EC5, 0x3E15, 0x3D3F],  // x =  0
        [0x3F4F, 0x3D3F, 0x39DB, 0x3537, 0x2F6C, 0x289A],  // x =  1
        [0x3E15, 0x3871, 0x2F6C, 0x238E, 0x1590, 0x0646],  // x =  2
        [0x3C42, 0x3179, 0x20E7, 0x0C7C, 0xF69C, 0xE1D5],  // x =  3
        [0x39DB, 0x289A, 0x0F8D, 0xF384, 0xD9E0, 0xC78F],  // x =  4
        [0x36E5, 0x1E2B, 0xFCDC, 0xDC72, 0xC625, 0xC04F],  // x =  5
        [0x3368, 0x1294, 0xEA70, 0xCAC9, 0xC014, 0xCE87],  // x =  6
        [0x2F6C, 0x0646, 0xD9E0, 0xC13B, 0xC91B, 0xED6C],  // x =  7
        [0x2AFB, 0xF9BA, 0xCC98, 0xC13B, 0xDF19, 0x1294],  // x =  8
        [0x2620, 0xED6C, 0xC3BE, 0xCAC9, 0xFCDC, 0x3179],  // x =  9
        [0x20E7, 0xE1D5, 0xC014, 0xDC72, 0x1B5D, 0x3FB1],  // x = 10
        [0x1B5D, 0xD766, 0xC1EB, 0xF384, 0x3368, 0x3871],  // x = 11
        [0x1590, 0xCE87, 0xC91B, 0x0C7C, 0x3F4F, 0x1E2B],  // x = 12
        [0x0F8D, 0xC78F, 0xD505, 0x238E, 0x3C42, 0xF9BA],  // x = 13
        [0x0964, 0xC2C1, 0xE4A3, 0x3537, 0x2AFB, 0xD766],  // x = 14
        [0x0324, 0xC04F, 0xF69C, 0x3EC5, 0x0F8D, 0xC2C1],  // x = 15
        [0xFCDC, 0xC04F, 0x0964, 0x3EC5, 0xF073, 0xC2C1],  // x = 16
        [0xF69C, 0xC2C1, 0x1B5D, 0x3537, 0xD505, 0xD766],  // x = 17
        [0xF073, 0xC78F, 0x2AFB, 0x238E, 0xC3BE, 0xF9BA],  // x = 18
        [0xEA70, 0xCE87, 0x36E5, 0x0C7C, 0xC0B1, 0x1E2B],  // x = 19
        [0xE4A3, 0xD766, 0x3E15, 0xF384, 0xCC98, 0x3871],  // x = 20
        [0xDF19, 0xE1D5, 0x3FEC, 0xDC72, 0xE4A3, 0x3FB1],  // x = 21
        [0xD9E0, 0xED6C, 0x3C42, 0xCAC9, 0x0324, 0x3179],  // x = 22
        [0xD505, 0xF9BA, 0x3368, 0xC13B, 0x20E7, 0x1294],  // x = 23
        [0xD094, 0x0646, 0x2620, 0xC13B, 0x36E5, 0xED6C],  // x = 24
        [0xCC98, 0x1294, 0x1590, 0xCAC9, 0x3FEC, 0xCE87],  // x = 25
        [0xC91B, 0x1E2B, 0x0324, 0xDC72, 0x39DB, 0xC04F],  // x = 26
        [0xC625, 0x289A, 0xF073, 0xF384, 0x2620, 0xC78F],  // x = 27
        [0xC3BE, 0x3179, 0xDF19, 0x0C7C, 0x0964, 0xE1D5],  // x = 28
        [0xC1EB, 0x3871, 0xD094, 0x238E, 0xEA70, 0x0646],  // x = 29
        [0xC0B1, 0x3D3F, 0xC625, 0x3537, 0xD094, 0x289A],  // x = 30
        [0xC014, 0x3FB1, 0xC0B1, 0x3EC5, 0xC1EB, 0x3D3F],  // x = 31
]