granite_decode.txt

# Processing files: /home/leegao/meh/Granite/assets/shaders/decode
  Staging directories: decode_D_1723235339
  + astc.comp
    #version 450
    /* Copyright (c) 2020-2024 Hans-Kristian Arntzen
     *
     * 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.
    
    #extension GL_EXT_samplerless_texture_functions : require
    layout(local_size_x_id = 0, local_size_y_id = 1, local_size_z = 4) in;
    
    #include "bitextract.h"
    
    layout(set = 1, binding = 0) uniform utextureBuffer LUTRemainingBitsToEndpointQuantizer;
    layout(set = 1, binding = 1) uniform utextureBuffer LUTEndpointUnquantize;
    layout(set = 1, binding = 2) uniform utextureBuffer LUTWeightQuantizer;
    layout(set = 1, binding = 3) uniform utextureBuffer LUTWeightUnquantize;
    layout(set = 1, binding = 4) uniform utextureBuffer LUTTritQuintDecode;
    layout(set = 1, binding = 5) uniform utexture2D LUTPartitionTable;
    
    layout(set = 0, binding = 0) writeonly uniform uimage2D OutputImage;
    layout(set = 0, binding = 1) uniform utexture2D PayloadInput;
    layout(constant_id = 2) const bool DECODE_8BIT = false;
    
    const int MODE_LDR = 0;
    const int MODE_HDR = 1;
    const int MODE_HDR_LDR_ALPHA = 2;
    
    layout(push_constant) uniform Registers
    {
        uvec4 error_color;
        ivec2 resolution;
    } registers;
    
    void swap(inout int a, inout int b)
    {
        int tmp = a;
        a = b;
        b = tmp;
    }
    
    ivec4 build_coord()
    {
        ivec2 payload_coord = ivec2(gl_WorkGroupID.xy) * 2;
        payload_coord.x += int(gl_LocalInvocationID.z) & 1;
        payload_coord.y += (int(gl_LocalInvocationID.z) >> 1) & 1;
        ivec2 coord = payload_coord * ivec2(gl_WorkGroupSize.xy);
        coord += ivec2(gl_LocalInvocationID.xy);
        return ivec4(coord, payload_coord);
    }
    
    ivec4 interpolate_endpoint(ivec4 ep0, ivec4 ep1, ivec4 weight, int decode_mode)
    {
        if (decode_mode == MODE_HDR)
        {
            ep0 <<= 4;
            ep1 <<= 4;
        }
        else if (decode_mode == MODE_HDR_LDR_ALPHA)
        {
            ep0.rgb <<= 4;
            ep1.rgb <<= 4;
            ep0.a *= 0x101;
            ep1.a *= 0x101;
        }
        else if (DECODE_8BIT)
        {
            // This isn't quite right in all cases.
            // In normal ASTC with sRGB, the alpha channel is supposed to
            // be decoded as FP16,
            // even when color components are SRGB 8-bit (?!?!?!?!).
            // This is correct if decode_unorm8 mode is used though,
            // for sanity, we're going to assume unorm8 decoding mode
            // is implied when using sRGB.
            ep0 = (ep0 << 8) | ivec4(0x80);
            ep1 = (ep1 << 8) | ivec4(0x80);
        }
        else
        {
            ep0 *= 0x101;
            ep1 *= 0x101;
        }
    
        ivec4 color = (ep0 * (64 - weight) + ep1 * weight + 32) >> 6;
        return color;
    }
    
    bvec4 bvec_or(bvec4 a, bvec4 b)
    {
        return bvec4(ivec4(a) | ivec4(b));
    }
    
    uint round_down_quantize_fp16(int color)
    {
        // ASTC has a very peculiar way of converting the decoded result to FP16.
        // 0xffff -> 1.0, and for everything else we get roundDownQuantizeFP16(vec4(c) / vec4(0x10000)).
        int msb = findMSB(color);
        int shamt = msb;
        int m = ((color << 10) >> shamt) & 0x3ff;
        int e = msb - 1;
        uint decoded = color == 0xffff ? 0x3c00u : (e < 1 ? (color << 8) : (m | (e << 10)));
        return decoded;
    }
    
    uvec4 round_down_quantize_fp16(ivec4 color)
    {
        // ASTC has a very peculiar way of converting the decoded result to FP16.
        // 0xffff -> 1.0, and for everything else we get roundDownQuantizeFP16(vec4(c) / vec4(0x10000)).
        ivec4 msb = findMSB(color);
        ivec4 shamt = msb;
        ivec4 m = ((color << 10) >> shamt) & 0x3ff;
        ivec4 e = msb - 1;
        uvec4 decoded = m | (e << 10);
        uvec4 denorm_decode = color << 8;
        decoded = mix(decoded, uvec4(denorm_decode), lessThan(e, ivec4(1)));
        decoded = mix(decoded, uvec4(0x3c00), equal(color, ivec4(0xffff)));
        return decoded;
    }
    
    uvec4 decode_fp16(ivec4 color, int decode_mode)
    {
        if (decode_mode != MODE_LDR)
        {
            // Interpret the value as FP16, but with some extra fixups along the way to make the interpolation more
            // logarithmic (apparently). From spec:
            ivec4 e = color >> 11;
            ivec4 m = color & 0x7ff;
            ivec4 mt = 4 * m - 512;
            mt = mix(mt, ivec4(3 * m), lessThan(m, ivec4(512)));
            mt = mix(mt, ivec4(5 * m - 2048), greaterThanEqual(m, ivec4(1536)));
    
            ivec4 decoded = (e << 10) + (mt >> 3);
            // +Inf or NaN are decoded to 0x7bff (max finite value).
            decoded = mix(decoded, ivec4(0x7bff), bvec_or(greaterThan(decoded & 0x7fff, ivec4(0x7c00)), equal(decoded, ivec4(0x7c00))));
    
            if (decode_mode == MODE_HDR_LDR_ALPHA)
                decoded.a = int(round_down_quantize_fp16(color.a));
    
            return decoded;
        }
        else
        {
            return round_down_quantize_fp16(color);
        }
    }
    
    struct BlockMode
    {
        ivec2 weight_grid_size;
        int weight_mode_index;
        int num_partitions;
        int seed;
        int cem;
        int config_bits;
        int primary_config_bits;
        bool dual_plane;
        bool void_extent;
    };
    
    bool decode_error = false;
    
    BlockMode decode_block_mode(uvec4 payload)
    {
        BlockMode mode;
        mode.void_extent = (payload.x & 0x1ffu) == 0x1fcu;
        if (mode.void_extent)
            return mode;
    
        mode.dual_plane = (payload.x & (1u << 10u)) != 0u;
    
        uint higher = (payload.x >> 2u) & 3u;
        uint lower = payload.x & 3u;
    
        if (lower != 0)
        {
            mode.weight_mode_index = int((payload.x >> 4u) & 1u);
            mode.weight_mode_index |= int((payload.x << 1u) & 6u);
            mode.weight_mode_index |= int((payload.x >> 6u) & 8u);
    
            if (higher < 2u)
            {
                mode.weight_grid_size.x = int(bitfieldExtract(payload.x, 7, 2) + 4 + 4 * higher);
                mode.weight_grid_size.y = int(bitfieldExtract(payload.x, 5, 2) + 2);
            }
            else if (higher == 2u)
            {
                mode.weight_grid_size.x = int(bitfieldExtract(payload.x, 5, 2) + 2);
                mode.weight_grid_size.y = int(bitfieldExtract(payload.x, 7, 2) + 8);
            }
            else
            {
                if ((payload.x & (1u << 8u)) != 0u)
                {
                    mode.weight_grid_size.x = int(bitfieldExtract(payload.x, 7, 1) + 2);
                    mode.weight_grid_size.y = int(bitfieldExtract(payload.x, 5, 2) + 2);
                }
                else
                {
                    mode.weight_grid_size.x = int(bitfieldExtract(payload.x, 5, 2) + 2);
                    mode.weight_grid_size.y = int(bitfieldExtract(payload.x, 7, 1) + 6);
                }
            }
        }
        else
        {
            int p3 = int(bitfieldExtract(payload.x, 9, 1));
            int hi = int(bitfieldExtract(payload.x, 7, 2));
            int lo = int(bitfieldExtract(payload.x, 5, 2));
            if (hi == 0)
            {
                mode.weight_grid_size.x = 12;
                mode.weight_grid_size.y = lo + 2;
            }
            else if (hi == 1)
            {
                mode.weight_grid_size.x = lo + 2;
                mode.weight_grid_size.y = 12;
            }
            else if (hi == 2)
            {
                mode.dual_plane = false;
                p3 = 0;
                mode.weight_grid_size.x = lo + 6;
                mode.weight_grid_size.y = int(bitfieldExtract(payload.x, 9, 2) + 6);
            }
            else
            {
                if (lo == 0)
                    mode.weight_grid_size = ivec2(6, 10);
                else if (lo == 1)
                    mode.weight_grid_size = ivec2(10, 6);
                else
                    decode_error = true;
            }
    
            int p0 = int(bitfieldExtract(payload.x, 4, 1));
            int p1 = int(bitfieldExtract(payload.x, 2, 1));
            int p2 = int(bitfieldExtract(payload.x, 3, 1));
            mode.weight_mode_index = p0 + (p1 << 1) + (p2 << 2) + (p3 << 3);
        }
    
        // 11 bits for block mode.
        // 2 bits for partition select
        // If partitions > 1:
        //   4 bits CEM selector
        //   If dual_plane:
        //     2 bits of CCS
        // else:
        //   10 for partition seed
        //   2 bits for CEM main selector
        //   If CEM[1:0] = 00:
        //     4 bits for CEM extra selector if all same type.
        //   else:
        //     (1 + 2) * num_partitions if different types.
        //     First 4 bits are encoded next to CEM[1:0], otherwise, packed before weights.
        //   If dual_plane:
        //     2 bits of CCS before extra CEM bits.
        const int CONFIG_BITS_BLOCK = 11;
        const int CONFIG_BITS_PARTITION_MODE = 2;
        const int CONFIG_BITS_SEED = 10;
        const int CONFIG_BITS_PRIMARY_MULTI_CEM = 2;
        const int CONFIG_BITS_CEM = 4;
        const int CONFIG_BITS_EXTRA_CEM_PER_PARTITION = 3;
        const int CONFIG_BITS_CCS = 2;
    
        mode.num_partitions = int(bitfieldExtract(payload.x, CONFIG_BITS_BLOCK, CONFIG_BITS_PARTITION_MODE)) + 1;
    
        if (mode.num_partitions > 1)
        {
            mode.seed = int(bitfieldExtract(payload.x, CONFIG_BITS_BLOCK + CONFIG_BITS_PARTITION_MODE, CONFIG_BITS_SEED));
            mode.cem = int(bitfieldExtract(payload.x, CONFIG_BITS_BLOCK + CONFIG_BITS_PARTITION_MODE + CONFIG_BITS_SEED,
                                           CONFIG_BITS_PRIMARY_MULTI_CEM + CONFIG_BITS_CEM));
        }
        else
            mode.cem = int(bitfieldExtract(payload.x, CONFIG_BITS_BLOCK + CONFIG_BITS_PARTITION_MODE, CONFIG_BITS_CEM));
    
        int config_bits;
        if (mode.num_partitions > 1)
        {
            bool single_cem = (mode.cem & 3) == 0;
            if (single_cem)
            {
                config_bits = CONFIG_BITS_BLOCK + CONFIG_BITS_PARTITION_MODE +
                              CONFIG_BITS_SEED + CONFIG_BITS_PRIMARY_MULTI_CEM + CONFIG_BITS_CEM;
            }
            else
            {
                config_bits = CONFIG_BITS_BLOCK + CONFIG_BITS_PARTITION_MODE +
                              CONFIG_BITS_SEED + CONFIG_BITS_PRIMARY_MULTI_CEM +
                              CONFIG_BITS_EXTRA_CEM_PER_PARTITION * mode.num_partitions;
            }
        }
        else
        {
            config_bits = CONFIG_BITS_BLOCK + CONFIG_BITS_PARTITION_MODE + CONFIG_BITS_CEM;
        }
    
        // Other config bits are packed before the weights.
        int primary_config_bits;
        if (mode.num_partitions > 1)
        {
            primary_config_bits = CONFIG_BITS_BLOCK + CONFIG_BITS_PARTITION_MODE + CONFIG_BITS_SEED +
                                  CONFIG_BITS_PRIMARY_MULTI_CEM + CONFIG_BITS_CEM;
        }
        else
            primary_config_bits = config_bits;
    
        if (mode.dual_plane)
            config_bits += CONFIG_BITS_CCS;
    
        // This is not allowed.
        if (any(greaterThan(mode.weight_grid_size, ivec2(gl_WorkGroupSize.xy))))
            decode_error = true;
        if (mode.dual_plane && mode.num_partitions > 3)
            decode_error = true;
    
        mode.config_bits = config_bits;
        mode.primary_config_bits = primary_config_bits;
        return mode;
    }
    
    int idiv3_floor(int v)
    {
        return (v * 0x5556) >> 16;
    }
    
    int idiv3_ceil(int v)
    {
        return idiv3_floor(v + 2);
    }
    
    int idiv5_floor(int v)
    {
        return (v * 0x3334) >> 16;
    }
    
    int idiv5_ceil(int v)
    {
        return idiv5_floor(v + 4);
    }
    
    uvec4 build_bitmask(int bits)
    {
        ivec4 num_bits = ivec4(bits, bits - 32, bits - 64, bits - 96);
        uvec4 mask = uvec4(1) << clamp(num_bits, ivec4(0), ivec4(31));
        mask--;
        mask = mix(mask, uvec4(0xffffffffu), greaterThanEqual(uvec4(bits), uvec4(32, 64, 96, 128)));
        return mask;
    }
    
    int decode_integer_sequence(uvec4 payload, int start_bit, int index, ivec3 quant)
    {
        int ret;
        if (quant.y != 0)
        {
            // Trit-decoding.
            int block = idiv5_floor(index);
            int offset = index - block * 5;
            start_bit += block * (5 * quant.x + 8);
    
            int t0_t1_offset = start_bit + (quant.x * 1 + 0);
            int t2_t3_offset = start_bit + (quant.x * 2 + 2);
            int t4_offset    = start_bit + (quant.x * 3 + 4);
            int t5_t6_offset = start_bit + (quant.x * 4 + 5);
            int t7_offset    = start_bit + (quant.x * 5 + 7);
    
            int t = (extract_bits(payload, t0_t1_offset, 2) << 0) |
                    (extract_bits(payload, t2_t3_offset, 2) << 2) |
                    (extract_bits(payload, t4_offset, 1) << 4) |
                    (extract_bits(payload, t5_t6_offset, 2) << 5) |
                    (extract_bits(payload, t7_offset, 1) << 7);
    
            t = int(texelFetch(LUTTritQuintDecode, t).x);
            t = (t >> (3 * offset)) & 7;
    
            int m_offset = offset * quant.x;
            m_offset += idiv5_ceil(offset * 8);
    
            if (quant.x != 0)
            {
                int m = extract_bits(payload, m_offset + start_bit, quant.x);
                ret = (t << quant.x) | m;
            }
            else
                ret = t;
        }
        else if (quant.z != 0)
        {
            // Quint-decoding
            int block = idiv3_floor(index);
            int offset = index - block * 3;
            start_bit += block * (3 * quant.x + 7);
    
            int q0_q1_q2_offset = start_bit + (quant.x * 1 + 0);
            int q3_q4_offset    = start_bit + (quant.x * 2 + 3);
            int q5_q6_offset    = start_bit + (quant.x * 3 + 5);
    
            int q = (extract_bits(payload, q0_q1_q2_offset, 3) << 0) |
                    (extract_bits(payload, q3_q4_offset, 2) << 3) |
                    (extract_bits(payload, q5_q6_offset, 2) << 5);
    
            q = int(texelFetch(LUTTritQuintDecode, 256 + q).x);
            q = (q >> (3 * offset)) & 7;
    
            int m_offset = offset * quant.x;
            m_offset += idiv3_ceil(offset * 7);
    
            if (quant.x != 0)
            {
                int m = extract_bits(payload, m_offset + start_bit, quant.x);
                ret = (q << quant.x) | m;
            }
            else
                ret = q;
        }
        else
        {
            int bit = index * quant.x;
            ret = extract_bits(payload, start_bit + bit, quant.x);
        }
        return ret;
    }
    
    ivec2 normalize_coord(ivec2 pixel_coord)
    {
        // This resolves to a compile-time constant.
        const ivec2 D = ivec2((vec2((1024 + ivec2(gl_WorkGroupSize.xy >> 1))) + 0.5) / vec2(gl_WorkGroupSize.xy - 1));
        ivec2 c = D * pixel_coord;
        return c;
    }
    
    int decode_weight(uvec4 payload, int weight_index, ivec4 quant)
    {
        int primary_weight = decode_integer_sequence(payload, 0, weight_index, quant.xyz);
        primary_weight = int(texelFetch(LUTWeightUnquantize, primary_weight + quant.w).x);
        return primary_weight;
    }
    
    int decode_weight_bilinear(uvec4 payload, ivec2 coord, int weight_resolution,
                               int stride, int offset, ivec2 fractional, ivec4 quant)
    {
        int index = coord.y * weight_resolution + coord.x;
        int p00 = decode_weight(payload, stride * index + offset, quant);
        int p10, p01, p11;
    
        if (fractional.x != 0)
            p10 = decode_weight(payload, stride * (index + 1) + offset, quant);
        else
            p10 = p00;
    
        if (fractional.y != 0)
        {
            p01 = decode_weight(payload, stride * (index + weight_resolution) + offset, quant);
            if (fractional.x != 0)
                p11 = decode_weight(payload, stride * (index + weight_resolution + 1) + offset, quant);
            else
                p11 = p01;
        }
        else
        {
            p01 = p00;
            p11 = p10;
        }
    
        int w11 = (fractional.x * fractional.y + 8) >> 4;
        int w10 = fractional.x - w11;
        int w01 = fractional.y - w11;
        int w00 = 16 - fractional.x - fractional.y + w11;
        return (p00 * w00 + p10 * w10 + p01 * w01 + p11 * w11 + 8) >> 4;
    }
    
    ivec4 decode_weights(uvec4 payload, BlockMode mode, ivec2 normalized_pixel, out int weight_cost_bits)
    {
        ivec4 quant = ivec4(texelFetch(LUTWeightQuantizer, mode.weight_mode_index));
        int num_weights = mode.weight_grid_size.x * mode.weight_grid_size.y;
        num_weights <<= int(mode.dual_plane);
        weight_cost_bits =
            quant.x * num_weights +
            idiv5_ceil(num_weights * 8 * quant.y) +
            idiv3_ceil(num_weights * 7 * quant.z);
    
        // Decoders must deal with error conditions and return the correct error color.
        if (weight_cost_bits < 24 || weight_cost_bits > 96 || num_weights > 64)
        {
            decode_error = true;
            return ivec4(0);
        }
    
        int ccs;
        if (mode.dual_plane)
        {
            int extra_cem_bits = 0;
            if ((mode.cem & 3) != 0)
                extra_cem_bits = max(mode.num_partitions * 3 - 4, 0);
            ccs = extract_bits(payload, 126 - weight_cost_bits - extra_cem_bits, 2);
        }
    
        payload = bitfieldReverse(payload);
        payload = payload.wzyx;
        payload &= build_bitmask(weight_cost_bits);
    
        // Scale the normalized coordinate to weight grid.
        ivec2 weight_pixel_fixed_point = (normalized_pixel * (mode.weight_grid_size - 1) + 32) >> 6;
        ivec2 weight_pixel = weight_pixel_fixed_point >> 4;
        ivec2 weight_pixel_fractional = weight_pixel_fixed_point & 0xf;
    
        ivec4 ret;
        int primary_weight = decode_weight_bilinear(payload, weight_pixel, mode.weight_grid_size.x,
                                                    1 << int(mode.dual_plane), 0,
                                                    weight_pixel_fractional, quant);
        if (mode.dual_plane)
        {
            int secondary_weight = decode_weight_bilinear(payload, weight_pixel, mode.weight_grid_size.x,
                                                          2, 1,
                                                          weight_pixel_fractional, quant);
            ret = mix(ivec4(primary_weight), ivec4(secondary_weight), equal(ivec4(ccs), ivec4(0, 1, 2, 3)));
        }
        else
            ret = ivec4(primary_weight);
    
        return ret;
    }
    
    void decode_endpoint_ldr_luma_direct(out ivec4 ep0, out ivec4 ep1,
            int v0, int v1)
    {
        ep0 = ivec4(ivec3(v0), 0xff);
        ep1 = ivec4(ivec3(v1), 0xff);
    }
    
    void decode_endpoint_hdr_luma_direct(out ivec4 ep0, out ivec4 ep1,
            int v0, int v1)
    {
        int y0, y1;
        if (v1 >= v0)
        {
            y0 = v0 << 4;
            y1 = v1 << 4;
        }
        else
        {
            y0 = (v1 << 4) + 8;
            y1 = (v0 << 4) - 8;
        }
    
        ep0 = ivec4(ivec3(y0), 0x780);
        ep1 = ivec4(ivec3(y1), 0x780);
    }
    
    void decode_endpoint_hdr_luma_direct_small_range(out ivec4 ep0, out ivec4 ep1,
            int v0, int v1)
    {
        int y0, y1, d;
    
        if ((v0 & 0x80) != 0)
        {
            y0 = ((v1 & 0xe0) << 4) | ((v0 & 0x7f) << 2);
            d = (v1 & 0x1f) << 2;
        }
        else
        {
            y0 = ((v1 & 0xf0) << 4) | ((v0 & 0x7f) << 1);
            d = (v1 & 0x0f)  << 1;
        }
    
        y1 = min(y0 + d, 0xfff);
    
        ep0 = ivec4(ivec3(y0), 0x780);
        ep1 = ivec4(ivec3(y1), 0x780);
    }
    
    void decode_endpoint_ldr_luma_base_offset(out ivec4 ep0, out ivec4 ep1,
            int v0, int v1)
    {
        int l0 = (v0 >> 2) | (v1 & 0xc0);
        int l1 = l0 + (v1 & 0x3f);
        l1 = min(l1, 0xff);
        ep0 = ivec4(ivec3(l0), 0xff);
        ep1 = ivec4(ivec3(l1), 0xff);
    }
    
    void decode_endpoint_ldr_luma_alpha_direct(out ivec4 ep0, out ivec4 ep1,
        int v0, int v1, int v2, int v3)
    {
        ep0 = ivec4(ivec3(v0), v2);
        ep1 = ivec4(ivec3(v1), v3);
    }
    
    ivec4 blue_contract(int r, int g, int b, int a)
    {
        ivec4 ret;
        ret.r = (r + b) >> 1;
        ret.g = (g + b) >> 1;
        ret.b = b;
        ret.a = a;
        return ret;
    }
    
    void bit_transfer_signed(inout int a, inout int b)
    {
        b >>= 1;
        b |= a & 0x80;
        a >>= 1;
        a &= 0x3f;
        a = bitfieldExtract(a, 0, 6);
    }
    
    void decode_endpoint_ldr_luma_alpha_base_offset(out ivec4 ep0, out ivec4 ep1,
        int v0, int v1, int v2, int v3)
    {
        bit_transfer_signed(v1, v0);
        bit_transfer_signed(v3, v2);
        int v0_v1 = clamp(v0 + v1, 0, 0xff);
        int v2_v3 = clamp(v2 + v3, 0, 0xff);
        v0 = clamp(v0, 0, 0xff);
        v2 = clamp(v2, 0, 0xff);
        ep0 = ivec4(ivec3(v0), v2);
        ep1 = ivec4(ivec3(v0_v1), v2_v3);
    }
    
    void decode_endpoint_ldr_rgb_base_scale(out ivec4 ep0, out ivec4 ep1,
            int v0, int v1, int v2, int v3)
    {
        ep0 = ivec4((ivec3(v0, v1, v2) * v3) >> 8, 0xff);
        ep1 = ivec4(v0, v1, v2, 0xff);
    }
    
    void decode_endpoint_ldr_rgb_base_scale_two_a(out ivec4 ep0, out ivec4 ep1,
            int v0, int v1, int v2, int v3, int v4, int v5)
    {
        ep0 = ivec4((ivec3(v0, v1, v2) * v3) >> 8, v4);
        ep1 = ivec4(v0, v1, v2, v5);
    }
    
    void decode_endpoint_ldr_rgb_direct(out ivec4 ep0, out ivec4 ep1,
            int v0, int v1, int v2, int v3, int v4, int v5)
    {
        int s0 = v0 + v2 + v4;
        int s1 = v1 + v3 + v5;
        if (s1 >= s0)
        {
            ep0 = ivec4(v0, v2, v4, 0xff);
            ep1 = ivec4(v1, v3, v5, 0xff);
        }
        else
        {
            ep0 = blue_contract(v1, v3, v5, 0xff);
            ep1 = blue_contract(v0, v2, v4, 0xff);
        }
    }
    
    void decode_endpoint_hdr_rgb_scale(out ivec4 ep0, out ivec4 ep1,
        int v0, int v1, int v2, int v3)
    {
        // Mind-numbing weird format, just copy from spec ...
        int mode_value = ((v0 & 0xc0) >> 6) | ((v1 & 0x80) >> 5) | ((v2 & 0x80) >> 4);
        int major_component;
        int mode;
    
        if ((mode_value & 0xc) != 0xc)
        {
            major_component = mode_value >> 2;
            mode = mode_value & 3;
        }
        else if (mode_value != 0xf)
        {
            major_component = mode_value & 3;
            mode = 4;
        }
        else
        {
            major_component = 0;
            mode = 5;
        }
    
        int red = v0 & 0x3f;
        int green = v1 & 0x1f;
        int blue = v2 & 0x1f;
        int scale = v3 & 0x1f;
    
        int x0 = (v1 >> 6) & 1;
        int x1 = (v1 >> 5) & 1;
        int x2 = (v2 >> 6) & 1;
        int x3 = (v2 >> 5) & 1;
        int x4 = (v3 >> 7) & 1;
        int x5 = (v3 >> 6) & 1;
        int x6 = (v3 >> 5) & 1;
    
        int ohm = 1 << mode;
        if ((ohm & 0x30) != 0) green |= x0 << 6;
        if ((ohm & 0x3a) != 0) green |= x1 << 5;
        if ((ohm & 0x30) != 0) blue |= x2 << 6;
        if ((ohm & 0x3a) != 0) blue |= x3 << 5;
        if ((ohm & 0x3d) != 0) scale |= x6 << 5;
        if ((ohm & 0x2d) != 0) scale |= x5 << 6;
        if ((ohm & 0x04) != 0) scale |= x4 << 7;
        if ((ohm & 0x3b) != 0) red |= x4 << 6;
        if ((ohm & 0x04) != 0) red |= x3 << 6;
        if ((ohm & 0x10) != 0) red |= x5 << 7;
        if ((ohm & 0x0f) != 0) red |= x2 << 7;
        if ((ohm & 0x05) != 0) red |= x1 << 8;
        if ((ohm & 0x0a) != 0) red |= x0 << 8;
        if ((ohm & 0x05) != 0) red |= x0 << 9;
        if ((ohm & 0x02) != 0) red |= x6 << 9;
        if ((ohm & 0x01) != 0) red |= x3 << 10;
        if ((ohm & 0x02) != 0) red |= x5 << 10;
    
        int shamt = max(mode, 1);
        red <<= shamt;
        green <<= shamt;
        blue <<= shamt;
        scale <<= shamt;
    
        if (mode != 5)
        {
            green = red - green;
            blue = red - blue;
        }
    
        if (major_component == 1)
            swap(red, green);
        else if (major_component == 2)
            swap(red, blue);
    
        ep1 = ivec4(clamp(ivec3(red, green, blue), ivec3(0), ivec3(0xfff)), 0x780);
        ep0 = ivec4(clamp(ivec3(red, green, blue) - scale, ivec3(0), ivec3(0xfff)), 0x780);
    }
    
    void decode_endpoint_hdr_rgb_direct(out ivec4 ep0, out ivec4 ep1,
            int v0, int v1, int v2, int v3, int v4, int v5)
    {
        int major_component = ((v4 & 0x80) >> 7) | ((v5 & 0x80) >> 6);
    
        if (major_component == 3)
        {
            ep0 = ivec4(v0 << 4, v2 << 4, (v4 & 0x7f) << 5, 0x780);
            ep1 = ivec4(v1 << 4, v3 << 4, (v5 & 0x7f) << 5, 0x780);
            return;
        }
    
        int mode = ((v1 & 0x80) >> 7) | ((v2 & 0x80) >> 6) | ((v3 & 0x80) >> 5);
        int va = v0 | ((v1 & 0x40) << 2);
        int vb0 = v2 & 0x3f;
        int vb1 =  v3 & 0x3f;
        int vc = v1 & 0x3f;
        int vd0 = v4 & 0x7f;
        int vd1 = v5 & 0x7f;
    
        int d_bits = 7 - (mode & 1);
        if ((mode & 5) == 4)
            d_bits -= 2;
    
        vd0 = bitfieldExtract(vd0, 0, d_bits);
        vd1 = bitfieldExtract(vd1, 0, d_bits);
    
        int x0 = (v2 >> 6) & 1;
        int x1 = (v3 >> 6) & 1;
        int x2 = (v4 >> 6) & 1;
        int x3 = (v5 >> 6) & 1;
        int x4 = (v4 >> 5) & 1;
        int x5 = (v5 >> 5) & 1;
    
        int ohm = 1 << mode;
        if ((ohm & 0xa4) != 0) va |= x0 << 9;
        if ((ohm & 0x08) != 0) va |= x2 << 9;
        if ((ohm & 0x50) != 0) va |= x4 << 9;
        if ((ohm & 0x50) != 0) va |= x5 << 10;
        if ((ohm & 0xa0) != 0) va |= x1 << 10;
        if ((ohm & 0xc0) != 0) va |= x2 << 11;
    
        if ((ohm & 0x04) != 0) vc |= x1 << 6;
        if ((ohm & 0xe8) != 0) vc |= x3 << 6;
        if ((ohm & 0x20) != 0) vc |= x2 << 7;
    
        if ((ohm & 0x5b) != 0) vb0 |= x0 << 6;
        if ((ohm & 0x5b) != 0) vb1 |= x1 << 6;
        if ((ohm & 0x12) != 0) vb0 |= x2 << 7;
        if ((ohm & 0x12) != 0) vb1 |= x3 << 7;
    
        int shamt = (mode >> 1) ^ 3;
        va <<= shamt;
        vb0 <<= shamt;
        vb1 <<= shamt;
        vc <<= shamt;
        vd0 <<= shamt;
        vd1 <<= shamt;
    
        ep1 = ivec4(clamp(ivec3(va, va - vb0, va - vb1), ivec3(0), ivec3(0xfff)), 0x780);
        ep0 = ivec4(clamp(ivec3(va - vc, va - vb0 - vc - vd0, va - vb1 - vc - vd1), ivec3(0), ivec3(0xfff)), 0x780);
    
        if (major_component == 1)
        {
            swap(ep0.r, ep0.g);
            swap(ep1.r, ep1.g);
        }
        else if (major_component == 2)
        {
            swap(ep0.r, ep0.b);
            swap(ep1.r, ep1.b);
        }
    }
    
    void decode_endpoint_ldr_rgb_base_offset(out ivec4 ep0, out ivec4 ep1,
            int v0, int v1, int v2, int v3, int v4, int v5)
    {
        bit_transfer_signed(v1, v0);
        bit_transfer_signed(v3, v2);
        bit_transfer_signed(v5, v4);
        if (v1 + v3 + v5 >= 0)
        {
            ep0 = ivec4(v0, v2, v4, 0xff);
            ep1 = ivec4(v0 + v1, v2 + v3, v4 + v5, 0xff);
        }
        else
        {
            ep0 = blue_contract(v0 + v1, v2 + v3, v4 + v5, 0xff);
            ep1 = blue_contract(v0, v2, v4, 0xff);
        }
    
        ep0.rgb = clamp(ep0.rgb, ivec3(0), ivec3(0xff));
        ep1.rgb = clamp(ep1.rgb, ivec3(0), ivec3(0xff));
    }
    
    void decode_endpoint_ldr_rgba_direct(out ivec4 ep0, out ivec4 ep1,
            int v0, int v1, int v2, int v3,
            int v4, int v5, int v6, int v7)
    {
        int s0 = v0 + v2 + v4;
        int s1 = v1 + v3 + v5;
        if (s1 >= s0)
        {
            ep0 = ivec4(v0, v2, v4, v6);
            ep1 = ivec4(v1, v3, v5, v7);
        }
        else
        {
            ep0 = blue_contract(v1, v3, v5, v7);
            ep1 = blue_contract(v0, v2, v4, v6);
        }
    }
    
    void decode_endpoint_ldr_rgba_base_offset(out ivec4 ep0, out ivec4 ep1,
            int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7)
    {
        bit_transfer_signed(v1, v0);
        bit_transfer_signed(v3, v2);
        bit_transfer_signed(v5, v4);
        bit_transfer_signed(v7, v6);
    
        if (v1 + v3 + v5 >= 0)
        {
            ep0 = ivec4(v0, v2, v4, v6);
            ep1 = ivec4(v0 + v1, v2 + v3, v4 + v5, v6 + v7);
        }
        else
        {
            ep0 = blue_contract(v0 + v1, v2 + v3, v4 + v5, v6 + v7);
            ep1 = blue_contract(v0, v2, v4, v6);
        }
    
        ep0 = clamp(ep0, ivec4(0), ivec4(0xff));
        ep1 = clamp(ep1, ivec4(0), ivec4(0xff));
    }
    
    void decode_endpoint_hdr_alpha(out int ep0, out int ep1, int v6, int v7)
    {
        int mode = ((v6 >> 7) & 1) | ((v7 >> 6) & 2);
        v6 &= 0x7f;
        v7 &= 0x7f;
    
        if (mode == 3)
        {
            ep0 = v6 << 5;
            ep1 = v7 << 5;
        }
        else
        {
            v6 |= (v7 << (mode + 1)) & 0x780;
            v7 &= 0x3f >> mode;
            v7 ^= 0x20 >> mode;
            v7 -= 0x20 >> mode;
            v6 <<= 4 - mode;
            v7 <<= 4 - mode;
            v7 += v6;
            v7 = clamp(v7, 0, 0xfff);
            ep0 = v6;
            ep1 = v7;
        }
    }
    
    void decode_endpoint(out ivec4 ep0, out ivec4 ep1, out int decode_mode,
                         uvec4 payload, int bit_offset, ivec4 quant, int ep_mode,
                         int base_endpoint_index, int num_endpoint_bits)
    {
        num_endpoint_bits += bit_offset;
        payload &= build_bitmask(num_endpoint_bits);
    
        // Could of course use an array, but that doesn't lower nicely to indexed registers on all GPUs.
        int v0, v1, v2, v3, v4, v5, v6, v7;
        int num_values = 2 * ((ep_mode >> 2) + 1);
    
    #define DECODE_EP(i) \
        int(texelFetch(LUTEndpointUnquantize, quant.w + decode_integer_sequence(payload, bit_offset, i + base_endpoint_index, quant.xyz)).x)
    
        int hi_bits = ep_mode >> 2;
        v0 = DECODE_EP(0);
        v1 = DECODE_EP(1);
    
        if (hi_bits >= 1)
        {
            v2 = DECODE_EP(2);
            v3 = DECODE_EP(3);
        }
    
        if (hi_bits >= 2)
        {
            v4 = DECODE_EP(4);
            v5 = DECODE_EP(5);
        }
    
        if (hi_bits >= 3)
        {
            v6 = DECODE_EP(6);
            v7 = DECODE_EP(7);
        }
    
        switch (ep_mode)
        {
        case 0:
            decode_endpoint_ldr_luma_direct(ep0, ep1,
                v0, v1);
            decode_mode = MODE_LDR;
            break;
    
        case 1:
            decode_endpoint_ldr_luma_base_offset(ep0, ep1,
                v0, v1);
            decode_mode = MODE_LDR;
            break;
    
        case 2:
            decode_endpoint_hdr_luma_direct(ep0, ep1,
                v0, v1);
            decode_mode = MODE_HDR;
            break;
    
        case 3:
            decode_endpoint_hdr_luma_direct_small_range(ep0, ep1,
                v0, v1);
            decode_mode = MODE_HDR;
            break;
    
        case 4:
            decode_endpoint_ldr_luma_alpha_direct(ep0, ep1,
                v0, v1, v2, v3);
            decode_mode = MODE_LDR;
            break;
    
        case 5:
            decode_endpoint_ldr_luma_alpha_base_offset(ep0, ep1,
                v0, v1, v2, v3);
            decode_mode = MODE_LDR;
            break;
    
        case 6:
            decode_endpoint_ldr_rgb_base_scale(ep0, ep1,
                v0, v1, v2, v3);
            decode_mode = MODE_LDR;
            break;
    
        case 7:
            decode_endpoint_hdr_rgb_scale(ep0, ep1,
                v0, v1, v2, v3);
            decode_mode = MODE_HDR;
            break;
    
        case 8:
            decode_endpoint_ldr_rgb_direct(ep0, ep1,
                v0, v1, v2, v3, v4, v5);
            decode_mode = MODE_LDR;
            break;
    
        case 9:
            decode_endpoint_ldr_rgb_base_offset(ep0, ep1,
                v0, v1, v2, v3, v4, v5);
            decode_mode = MODE_LDR;
            break;
    
        case 10:
            decode_endpoint_ldr_rgb_base_scale_two_a(ep0, ep1,
                v0, v1, v2, v3, v4, v5);
            decode_mode = MODE_LDR;
            break;
    
        case 11:
        case 14:
        case 15:
            decode_endpoint_hdr_rgb_direct(ep0, ep1,
                v0, v1, v2, v3, v4, v5);
            if (ep_mode == 14)
            {
                ep0.a = v6;
                ep1.a = v7;
                decode_mode = MODE_HDR_LDR_ALPHA;
            }
            else if (ep_mode == 15)
            {
                decode_endpoint_hdr_alpha(ep0.a, ep1.a, v6, v7);
                decode_mode = MODE_HDR;
            }
            else
                decode_mode = MODE_HDR;
            break;
    
        case 12:
            decode_endpoint_ldr_rgba_direct(ep0, ep1,
                v0, v1, v2, v3, v4, v5, v6, v7);
            decode_mode = MODE_LDR;
            break;
    
        case 13:
            decode_endpoint_ldr_rgba_base_offset(ep0, ep1,
                v0, v1, v2, v3, v4, v5, v6, v7);
            decode_mode = MODE_LDR;
            break;
        }
    
        if (DECODE_8BIT && decode_mode != MODE_LDR)
            decode_error = true;
    }
    
    #define CHECK_DECODE_ERROR() do { \
        if (decode_error) \
        { \
            emit_decode_error(coord.xy); \
            return; \
        } \
    } while(false)
    
    void emit_decode_error(ivec2 coord)
    {
        imageStore(OutputImage, coord, registers.error_color);
    }
    
    int compute_num_endpoint_pairs(int num_partitions, int cem)
    {
        int ret;
        if (num_partitions > 1)
        {
            bool single_cem = (cem & 3) == 0;
            if (single_cem)
                ret = ((cem >> 4) + 1) * num_partitions;
            else
                ret = (cem & 3) * num_partitions + bitCount(bitfieldExtract(uint(cem), 2, num_partitions));
        }
        else
        {
            ret = (cem >> 2) + 1;
        }
        return ret;
    }
    
    void decode_cem_base_endpoint(uvec4 payload, int weight_cost_bits, inout int cem, out int base_endpoint_index,
        int num_partitions, int partition_index)
    {
        if (num_partitions > 1)
        {
            bool single_cem = (cem & 3) == 0;
            if (single_cem)
            {
                cem >>= 2;
                base_endpoint_index = ((cem >> 2) + 1) * partition_index;
            }
            else
            {
                if (partition_index != 0)
                    base_endpoint_index = (cem & 3) * partition_index + bitCount(bitfieldExtract(uint(cem), 2, partition_index));
                else
                    base_endpoint_index = 0;
    
                int base_class = (cem & 3) - 1;
                int extra_cem_bits = num_partitions * 3 - 4;
                int extra_bits = extract_bits(payload, 128 - weight_cost_bits - extra_cem_bits, extra_cem_bits);
                cem = (extra_bits << 4) | (cem >> 2);
    
                int class_offset_bit = (cem >> partition_index) & 1;
                int ep_bits = (cem >> (num_partitions + 2 * partition_index)) & 3;
    
                cem = 4 * (base_class + class_offset_bit) + ep_bits;
            }
            base_endpoint_index *= 2;
        }
        else
        {
            base_endpoint_index = 0;
        }
    }
    
    ivec4 void_extent_color(uvec4 payload, out int decode_mode)
    {
        int min_s = extract_bits(payload, 12, 13);
        int max_s = extract_bits(payload, 12 + 13, 13);
        int min_t = extract_bits(payload, 12 + 2 * 13, 13);
        int max_t = extract_bits(payload, 12 + 3 * 13, 13);
    
        int reserved = extract_bits(payload, 10, 2);
        if (reserved != 3)
        {
            decode_error = true;
            return ivec4(0);
        }
    
        if (!all(equal(ivec4(min_s, max_s, min_t, max_t), ivec4((1 << 13) - 1))))
        {
            if (any(greaterThanEqual(ivec2(min_s, min_t), ivec2(max_s, max_t))))
            {
                decode_error = true;
                return ivec4(0);
            }
        }
    
        decode_mode = (payload.x & (1u << 9)) != 0u ? MODE_HDR : MODE_LDR;
    
        int r = extract_bits(payload, 64, 16);
        int g = extract_bits(payload, 64 + 16, 16);
        int b = extract_bits(payload, 64 + 32, 16);
        int a = extract_bits(payload, 64 + 48, 16);
    
        return ivec4(r, g, b, a);
    }
    
    void main()
    {
        ivec4 coord = build_coord();
        if (any(greaterThanEqual(coord.xy, registers.resolution)))
            return;
    
        ivec2 pixel_coord = ivec2(gl_LocalInvocationID.xy);
        int linear_pixel = int(gl_WorkGroupSize.x) * pixel_coord.y + pixel_coord.x;
        uvec4 payload = texelFetch(PayloadInput, coord.zw, 0);
    
        BlockMode block_mode = decode_block_mode(payload);
        CHECK_DECODE_ERROR();
    
        ivec4 final_color;
        int decode_mode;
        if (block_mode.void_extent)
        {
            final_color = void_extent_color(payload, decode_mode);
            CHECK_DECODE_ERROR();
        }
        else
        {
            int weight_cost_bits;
            ivec4 weights = decode_weights(payload, block_mode, normalize_coord(pixel_coord), weight_cost_bits);
    
            int partition_index = 0;
            if (block_mode.num_partitions > 1)
            {
                int lut_x = pixel_coord.x + int(gl_WorkGroupSize.x) * (block_mode.seed & 31);
                int lut_y = pixel_coord.y + int(gl_WorkGroupSize.y) * (block_mode.seed >> 5);
                partition_index = int(texelFetch(LUTPartitionTable, ivec2(lut_x, lut_y), 0).x);
                partition_index = (partition_index >> (2 * block_mode.num_partitions - 4)) & 3;
            }
    
            int available_endpoint_bits = max(128 - block_mode.config_bits - weight_cost_bits, 0);
    
            // In multi-partition mode, the 6-bit CEM field is encoded as
            // First two bits tell if all CEM field are the same, if not we specify a class offset, and N bits
            // after that will offset the class by 1.
            int num_endpoint_pairs = compute_num_endpoint_pairs(block_mode.num_partitions, block_mode.cem);
    
            // Error color must be emitted if we need more than 18 integer sequence encoded values of color.
            if (num_endpoint_pairs > 9)
            {
                decode_error = true;
                emit_decode_error(coord.xy);
                return;
            }
    
            ivec4 endpoint_quant = ivec4(texelFetch(LUTRemainingBitsToEndpointQuantizer,
                    128 * (num_endpoint_pairs - 1) + available_endpoint_bits));
    
            // Only read the bits we need for endpoints.
            int num_endpoint_values = num_endpoint_pairs * 2;
            available_endpoint_bits =
                endpoint_quant.x * num_endpoint_values +
                idiv5_ceil(endpoint_quant.y * 8 * num_endpoint_values) +
                idiv3_ceil(endpoint_quant.z * 7 * num_endpoint_values);
    
            // No space left for color endpoints.
            if (all(equal(endpoint_quant.xyz, ivec3(0))))
            {
                decode_error = true;
                emit_decode_error(coord.xy);
                return;
            }
    
            int endpoint_bit_offset = block_mode.primary_config_bits;
            ivec4 ep0, ep1;
    
            // Decode CEM for multi-partition schemes.
            int cem = block_mode.cem;
            int base_endpoint_index;
            decode_cem_base_endpoint(payload, weight_cost_bits, cem, base_endpoint_index,
                                     block_mode.num_partitions, partition_index);
    
            decode_endpoint(ep0, ep1, decode_mode, payload, endpoint_bit_offset, endpoint_quant,
                            cem, base_endpoint_index, available_endpoint_bits);
            CHECK_DECODE_ERROR();
    
            final_color = interpolate_endpoint(ep0, ep1, weights, decode_mode);
        }
    
        if (DECODE_8BIT)
        {
            imageStore(OutputImage, coord.xy, uvec4(final_color >> 8));
        }
        else
        {
            uvec4 encoded;
            if (block_mode.void_extent && decode_mode == MODE_HDR)
                encoded = final_color;
            else
                encoded = decode_fp16(final_color, decode_mode);
            imageStore(OutputImage, coord.xy, encoded);
        }
    }
  + bc6.comp
    #version 450
    /* Copyright (c) 2020-2024 Hans-Kristian Arntzen
     *
     * 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.
    
    #extension GL_EXT_samplerless_texture_functions : require
    layout(local_size_x = 4, local_size_y = 4, local_size_z = 4) in;
    
    #include "bitextract.h"
    
    layout(set = 0, binding = 0, rgba16ui) writeonly uniform uimage2D uOutput;
    layout(set = 0, binding = 1) uniform utexture2D uInput;
    
    layout(constant_id = 0) const bool SIGNED = false;
    
    layout(push_constant) uniform Registers
    {
        ivec2 resolution;
    } registers;
    
    ivec2 build_coord()
    {
        ivec2 base = ivec2(gl_WorkGroupID.xy) * 8;
        base.x += 4 * (int(gl_LocalInvocationID.z) & 1);
        base.y += 2 * (int(gl_LocalInvocationID.z) & 2);
        base += ivec2(gl_LocalInvocationID.xy);
        return base;
    }
    
    const int weight_table3[8] = int[](0, 9, 18, 27, 37, 46, 55, 64);
    const int weight_table4[16] = int[](0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64);
    
    #define P2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) \
        (((a) << 0) | ((b) << 1) | ((c) << 2) | ((d) << 3) | \
        ((e) << 4) | ((f) << 5) | ((g) << 6) | ((h) << 7) | \
        ((i) << 8) | ((j) << 9) | ((k) << 10) | ((l) << 11) | \
        ((m) << 12) | ((n) << 13) | ((o) << 14) | ((p) << 15))
    
    const int partition_table2[32] = int[](
        P2(0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1),
        P2(0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1),
        P2(0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1),
        P2(0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1),
        P2(0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1),
        P2(0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1),
        P2(0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1),
        P2(0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1),
    
        P2(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1),
        P2(0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
        P2(0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1),
        P2(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1),
        P2(0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
        P2(0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1),
        P2(0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
        P2(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1),
    
        P2(0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1),
        P2(0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0),
        P2(0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0),
        P2(0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0),
        P2(0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0),
        P2(0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0),
        P2(0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0),
        P2(0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1),
    
        P2(0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0),
        P2(0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0),
        P2(0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0),
        P2(0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0),
        P2(0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0),
        P2(0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0),
        P2(0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0),
        P2(0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0));
    
    const int anchor_table2[32] = int[](
        15, 15, 15, 15, 15, 15, 15, 15,
        15, 15, 15, 15, 15, 15, 15, 15,
        15, 2, 8, 2, 2, 8, 8, 15,
        2, 8, 2, 2, 8, 8, 2, 2);
    
    struct DecodedInterpolation
    {
        ivec3 ep0, ep1;
        int weight;
    };
    
    ivec3 interpolate_endpoint(DecodedInterpolation interp)
    {
        ivec3 rgb = ((64 - interp.weight) * interp.ep0 + interp.weight * interp.ep1 + 32) >> 6;
        return rgb;
    }
    
    ivec3 unquantize_endpoint(ivec3 ep, int bits)
    {
        ivec3 unq;
        if (SIGNED)
        {
            ep = bitfieldExtract(ep, 0, bits);
            if (bits < 16)
            {
                ivec3 sgn = 1 - ((ep >> 30) & 2);
                ivec3 abs_ep = abs(ep);
                unq = ((abs_ep << 15) + 0x4000) >> (bits - 1);
                unq = mix(unq, ivec3(0), equal(ep, ivec3(0)));
                unq = mix(unq, ivec3(0x7fff), greaterThanEqual(abs_ep, ivec3((1 << (bits - 1)) - 1)));
                unq *= sgn;
            }
            else
                unq = ep;
        }
        else
        {
            ep = ivec3(bitfieldExtract(uvec3(ep), 0, bits));
            if (bits < 15)
            {
                unq = ((ep << 15) + 0x4000) >> (bits - 1);
                unq = mix(unq, ivec3(0), equal(ep, ivec3(0)));
                unq = mix(unq, ivec3(0xffff), equal(ep, ivec3((1 << bits) - 1)));
            }
            else
                unq = ep;
        }
        return unq;
    }
    
    DecodedInterpolation decode_bc6_mode0(uvec4 payload, int linear_pixel, int part, int anchor_pixel)
    {
        ivec3 ep0, ep1;
    
        int r0 = extract_bits(payload, 5, 10);
        int g0 = extract_bits(payload, 15, 10);
        int b0 = extract_bits(payload, 25, 10);
        ep0 = ivec3(r0, g0, b0);
    
        if (part != 0)
        {
            int r2 = extract_bits_sign(payload, 65, 5);
            int g2 = extract_bits(payload, 41, 4) | (extract_bits_sign(payload, 2, 1) << 4);
            int b2 = extract_bits(payload, 61, 4) | (extract_bits_sign(payload, 3, 1) << 4);
    
            int r3 = extract_bits_sign(payload, 71, 5);
            int g3 = extract_bits(payload, 51, 4) | (extract_bits_sign(payload, 40, 1) << 4);
            int b3 = extract_bits(payload, 50, 1) | (extract_bits(payload, 60, 1) << 1) | (extract_bits(payload, 70, 1) << 2) |
                    (extract_bits(payload, 76, 1) << 3) | (extract_bits_sign(payload, 4, 1) << 4);
    
            ep1 = ivec3(r3, g3, b3) + ep0;
            ep0 += ivec3(r2, g2, b2);
        }
        else
        {
            int r1 = extract_bits_sign(payload, 35, 5);
            int g1 = extract_bits_sign(payload, 45, 5);
            int b1 = extract_bits_sign(payload, 55, 5);
            ep1 = ivec3(r1, g1, b1) + ep0;
        }
    
        ep0 = unquantize_endpoint(ep0, 10);
        ep1 = unquantize_endpoint(ep1, 10);
    
        int index = extract_bits(
            payload,
            max(81 + linear_pixel * 3 - int(linear_pixel > anchor_pixel), 82),
            (linear_pixel == 0 || linear_pixel == anchor_pixel) ? 2 : 3);
    
        int w = weight_table3[index];
        return DecodedInterpolation(ep0, ep1, w);
    }
    
    DecodedInterpolation decode_bc6_mode1(uvec4 payload, int linear_pixel, int part, int anchor_pixel)
    {
        ivec3 ep0, ep1;
    
        int r0 = extract_bits(payload, 5, 7);
        int g0 = extract_bits(payload, 15, 7);
        int b0 = extract_bits(payload, 25, 7);
        ep0 = ivec3(r0, g0, b0);
    
        if (part != 0)
        {
            int r2 = extract_bits_sign(payload, 65, 6);
            int g2 = extract_bits(payload, 41, 4) | (extract_bits(payload, 24, 1) << 4) | (extract_bits_sign(payload, 2, 1) << 5);
            int b2 = extract_bits(payload, 61, 4) | (extract_bits(payload, 14, 1) << 4) | (extract_bits_sign(payload, 22, 1) << 5);
    
            int r3 = extract_bits_sign(payload, 71, 6);
            int g3 = extract_bits(payload, 51, 4) | (extract_bits_sign(payload, 3, 2) << 4);
            int b3 = extract_bits(payload, 12, 2) | (extract_bits(payload, 23, 1) << 2) | (extract_bits(payload, 32, 1) << 3) |
                    (extract_bits(payload, 34, 1) << 4) | (extract_bits_sign(payload, 33, 1) << 5);
    
            ep1 = ivec3(r3, g3, b3) + ep0;
            ep0 += ivec3(r2, g2, b2);
        }
        else
        {
            int r1 = extract_bits_sign(payload, 35, 6);
            int g1 = extract_bits_sign(payload, 45, 6);
            int b1 = extract_bits_sign(payload, 55, 6);
            ep1 = ivec3(r1, g1, b1) + ep0;
        }
    
        ep0 = unquantize_endpoint(ep0, 7);
        ep1 = unquantize_endpoint(ep1, 7);
    
        int index = extract_bits(
            payload,
            max(81 + linear_pixel * 3 - int(linear_pixel > anchor_pixel), 82),
            (linear_pixel == 0 || linear_pixel == anchor_pixel) ? 2 : 3);
    
        int w = weight_table3[index];
        return DecodedInterpolation(ep0, ep1, w);
    }
    
    DecodedInterpolation decode_bc6_mode2(uvec4 payload, int linear_pixel, int part, int anchor_pixel)
    {
        ivec3 ep0, ep1;
    
        int r0 = extract_bits(payload, 5, 10) | (extract_bits(payload, 40, 1) << 10);
        int g0 = extract_bits(payload, 15, 10) | (extract_bits(payload, 49, 1) << 10);
        int b0 = extract_bits(payload, 25, 10) | (extract_bits(payload, 59, 1) << 10);
        ep0 = ivec3(r0, g0, b0);
    
        if (part != 0)
        {
            int r2 = extract_bits_sign(payload, 65, 5);
            int g2 = extract_bits_sign(payload, 41, 4);
            int b2 = extract_bits_sign(payload, 61, 4);
    
            int r3 = extract_bits_sign(payload, 71, 5);
            int g3 = extract_bits_sign(payload, 51, 4);
            int b3 = extract_bits(payload, 50, 1) | (extract_bits(payload, 60, 1) << 1) |
                    (extract_bits(payload, 70, 1) << 2) | (extract_bits_sign(payload, 76, 1) << 3);
    
            ep1 = ivec3(r3, g3, b3) + ep0;
            ep0 += ivec3(r2, g2, b2);
        }
        else
        {
            int r1 = extract_bits_sign(payload, 35, 5);
            int g1 = extract_bits_sign(payload, 45, 4);
            int b1 = extract_bits_sign(payload, 55, 4);
            ep1 = ivec3(r1, g1, b1) + ep0;
        }
    
        ep0 = unquantize_endpoint(ep0, 11);
        ep1 = unquantize_endpoint(ep1, 11);
    
        int index = extract_bits(
            payload,
            max(81 + linear_pixel * 3 - int(linear_pixel > anchor_pixel), 82),
            (linear_pixel == 0 || linear_pixel == anchor_pixel) ? 2 : 3);
    
        int w = weight_table3[index];
        return DecodedInterpolation(ep0, ep1, w);
    }
    
    DecodedInterpolation decode_bc6_mode3(uvec4 payload, int linear_pixel)
    {
        int r0 = extract_bits(payload, 5, 10);
        int g0 = extract_bits(payload, 15, 10);
        int b0 = extract_bits(payload, 25, 10);
        int r1 = extract_bits(payload, 35, 10);
        int g1 = extract_bits(payload, 45, 10);
        int b1 = extract_bits(payload, 55, 10);
    
        ivec3 ep0 = ivec3(r0, g0, b0);
        ivec3 ep1 = ivec3(r1, g1, b1);
        ep0 = unquantize_endpoint(ep0, 10);
        ep1 = unquantize_endpoint(ep1, 10);
    
        int index = extract_bits(
            payload,
            max(64 + linear_pixel * 4, 65),
            linear_pixel == 0 ? 3 : 4);
    
        int w = weight_table4[index];
        return DecodedInterpolation(ep0, ep1, w);
    }
    
    DecodedInterpolation decode_bc6_mode6(uvec4 payload, int linear_pixel, int part, int anchor_pixel)
    {
        ivec3 ep0, ep1;
    
        int r0 = extract_bits(payload, 5, 10) | (extract_bits(payload, 39, 1) << 10);
        int g0 = extract_bits(payload, 15, 10) | (extract_bits(payload, 50, 1) << 10);
        int b0 = extract_bits(payload, 25, 10) | (extract_bits(payload, 59, 1) << 10);
        ep0 = ivec3(r0, g0, b0);
    
        if (part != 0)
        {
            int r2 = extract_bits_sign(payload, 65, 4);
            int g2 = extract_bits(payload, 41, 4) | (extract_bits_sign(payload, 75, 1) << 4);
            int b2 = extract_bits_sign(payload, 61, 4);
    
            int r3 = extract_bits_sign(payload, 71, 4);
            int g3 = extract_bits(payload, 51, 4) | (extract_bits_sign(payload, 40, 1) << 4);
            int b3 = extract_bits(payload, 69, 1) | (extract_bits(payload, 60, 1) << 1) |
                    (extract_bits(payload, 70, 1) << 2) | (extract_bits_sign(payload, 76, 1) << 3);
    
            ep1 = ivec3(r3, g3, b3) + ep0;
            ep0 += ivec3(r2, g2, b2);
        }
        else
        {
            int r1 = extract_bits_sign(payload, 35, 4);
            int g1 = extract_bits_sign(payload, 45, 5);
            int b1 = extract_bits_sign(payload, 55, 4);
            ep1 = ivec3(r1, g1, b1) + ep0;
        }
    
        ep0 = unquantize_endpoint(ep0, 11);
        ep1 = unquantize_endpoint(ep1, 11);
    
        int index = extract_bits(
            payload,
            max(81 + linear_pixel * 3 - int(linear_pixel > anchor_pixel), 82),
            (linear_pixel == 0 || linear_pixel == anchor_pixel) ? 2 : 3);
    
        int w = weight_table3[index];
        return DecodedInterpolation(ep0, ep1, w);
    }
    
    DecodedInterpolation decode_bc6_mode7(uvec4 payload, int linear_pixel)
    {
        int r0 = extract_bits(payload, 5, 10) | (extract_bits(payload, 44, 1) << 10);
        int g0 = extract_bits(payload, 15, 10) | (extract_bits(payload, 54, 1) << 10);
        int b0 = extract_bits(payload, 25, 10) | (extract_bits(payload, 64, 1) << 10);
    
        int r1 = extract_bits_sign(payload, 35, 9);
        int g1 = extract_bits_sign(payload, 45, 9);
        int b1 = extract_bits_sign(payload, 55, 9);
    
        r1 += r0;
        g1 += g0;
        b1 += b0;
    
        ivec3 ep0 = ivec3(r0, g0, b0);
        ivec3 ep1 = ivec3(r1, g1, b1);
        ep0 = unquantize_endpoint(ep0, 11);
        ep1 = unquantize_endpoint(ep1, 11);
    
        int index = extract_bits(
            payload,
            max(64 + linear_pixel * 4, 65),
            linear_pixel == 0 ? 3 : 4);
    
        int w = weight_table4[index];
        return DecodedInterpolation(ep0, ep1, w);
    }
    
    DecodedInterpolation decode_bc6_mode10(uvec4 payload, int linear_pixel, int part, int anchor_pixel)
    {
        ivec3 ep0, ep1;
    
        int r0 = extract_bits(payload, 5, 10) | (extract_bits(payload, 39, 1) << 10);
        int g0 = extract_bits(payload, 15, 10) | (extract_bits(payload, 49, 1) << 10);
        int b0 = extract_bits(payload, 25, 10) | (extract_bits(payload, 60, 1) << 10);
        ep0 = ivec3(r0, g0, b0);
    
        if (part != 0)
        {
            int r2 = extract_bits_sign(payload, 65, 4);
            int g2 = extract_bits_sign(payload, 41, 4);
            int b2 = extract_bits(payload, 61, 4) | (extract_bits_sign(payload, 40, 1) << 4);
    
            int r3 = extract_bits_sign(payload, 71, 4);
            int g3 = extract_bits_sign(payload, 51, 4);
            int b3 = extract_bits(payload, 50, 1) | (extract_bits(payload, 69, 2) << 1) |
                    (extract_bits(payload, 76, 1) << 3) | (extract_bits_sign(payload, 75, 1) << 4);
    
            ep1 = ivec3(r3, g3, b3) + ep0;
            ep0 += ivec3(r2, g2, b2);
        }
        else
        {
            int r1 = extract_bits_sign(payload, 35, 4);
            int g1 = extract_bits_sign(payload, 45, 4);
            int b1 = extract_bits_sign(payload, 55, 5);
            ep1 = ivec3(r1, g1, b1) + ep0;
        }
    
        ep0 = unquantize_endpoint(ep0, 11);
        ep1 = unquantize_endpoint(ep1, 11);
    
        int index = extract_bits(
            payload,
            max(81 + linear_pixel * 3 - int(linear_pixel > anchor_pixel), 82),
            (linear_pixel == 0 || linear_pixel == anchor_pixel) ? 2 : 3);
    
        int w = weight_table3[index];
        return DecodedInterpolation(ep0, ep1, w);
    }
    
    DecodedInterpolation decode_bc6_mode11(uvec4 payload, int linear_pixel)
    {
        int r0 = extract_bits(payload, 5, 10) | (extract_bits_reverse(payload, 43, 2) << 10);
        int g0 = extract_bits(payload, 15, 10) | (extract_bits_reverse(payload, 53, 2) << 10);
        int b0 = extract_bits(payload, 25, 10) | (extract_bits_reverse(payload, 63, 2) << 10);
    
        int r1 = extract_bits_sign(payload, 35, 8);
        int g1 = extract_bits_sign(payload, 45, 8);
        int b1 = extract_bits_sign(payload, 55, 8);
    
        r1 += r0;
        g1 += g0;
        b1 += b0;
    
        ivec3 ep0 = ivec3(r0, g0, b0);
        ivec3 ep1 = ivec3(r1, g1, b1);
        ep0 = unquantize_endpoint(ep0, 12);
        ep1 = unquantize_endpoint(ep1, 12);
    
        int index = extract_bits(
            payload,
            max(64 + linear_pixel * 4, 65),
            linear_pixel == 0 ? 3 : 4);
    
        int w = weight_table4[index];
        return DecodedInterpolation(ep0, ep1, w);
    }
    
    DecodedInterpolation decode_bc6_mode14(uvec4 payload, int linear_pixel, int part, int anchor_pixel)
    {
        ivec3 ep0, ep1;
    
        int r0 = extract_bits(payload, 5, 9);
        int g0 = extract_bits(payload, 15, 9);
        int b0 = extract_bits(payload, 25, 9);
        ep0 = ivec3(r0, g0, b0);
    
        if (part != 0)
        {
            int r2 = extract_bits_sign(payload, 65, 5);
            int g2 = extract_bits(payload, 41, 4) | (extract_bits_sign(payload, 24, 1) << 4);
            int b2 = extract_bits(payload, 61, 4) | (extract_bits_sign(payload, 14, 1) << 4);
    
            int r3 = extract_bits_sign(payload, 71, 5);
            int g3 = extract_bits(payload, 51, 4) | (extract_bits_sign(payload, 40, 1) << 4);
            int b3 = extract_bits(payload, 50, 1) | (extract_bits(payload, 60, 1) << 1) |
                    (extract_bits(payload, 70, 1) << 2) |
                    (extract_bits(payload, 76, 1) << 3) | (extract_bits_sign(payload, 34, 1) << 4);
    
            ep1 = ivec3(r3, g3, b3) + ep0;
            ep0 += ivec3(r2, g2, b2);
        }
        else
        {
            int r1 = extract_bits_sign(payload, 35, 5);
            int g1 = extract_bits_sign(payload, 45, 5);
            int b1 = extract_bits_sign(payload, 55, 5);
            ep1 = ivec3(r1, g1, b1) + ep0;
        }
    
        ep0 = unquantize_endpoint(ep0, 9);
        ep1 = unquantize_endpoint(ep1, 9);
    
        int index = extract_bits(
            payload,
            max(81 + linear_pixel * 3 - int(linear_pixel > anchor_pixel), 82),
            (linear_pixel == 0 || linear_pixel == anchor_pixel) ? 2 : 3);
    
        int w = weight_table3[index];
        return DecodedInterpolation(ep0, ep1, w);
    }
    
    DecodedInterpolation decode_bc6_mode15(uvec4 payload, int linear_pixel)
    {
        int r0 = extract_bits(payload, 5, 10) | (extract_bits_reverse(payload, 39, 6) << 10);
        int g0 = extract_bits(payload, 15, 10) | (extract_bits_reverse(payload, 49, 6) << 10);
        int b0 = extract_bits(payload, 25, 10) | (extract_bits_reverse(payload, 59, 6) << 10);
    
        int r1 = extract_bits_sign(payload, 35, 4);
        int g1 = extract_bits_sign(payload, 45, 4);
        int b1 = extract_bits_sign(payload, 55, 4);
    
        r1 += r0;
        g1 += g0;
        b1 += b0;
    
        ivec3 ep0 = ivec3(r0, g0, b0);
        ivec3 ep1 = ivec3(r1, g1, b1);
        ep0 = unquantize_endpoint(ep0, 16);
        ep1 = unquantize_endpoint(ep1, 16);
    
        int index = extract_bits(
            payload,
            max(64 + linear_pixel * 4, 65),
            linear_pixel == 0 ? 3 : 4);
    
        int w = weight_table4[index];
        return DecodedInterpolation(ep0, ep1, w);
    }
    
    DecodedInterpolation decode_bc6_mode18(uvec4 payload, int linear_pixel, int part, int anchor_pixel)
    {
        ivec3 ep0, ep1;
    
        int r0 = extract_bits(payload, 5, 8);
        int g0 = extract_bits(payload, 15, 8);
        int b0 = extract_bits(payload, 25, 8);
        ep0 = ivec3(r0, g0, b0);
    
        if (part != 0)
        {
            int r2 = extract_bits_sign(payload, 65, 6);
            int g2 = extract_bits(payload, 41, 4) | (extract_bits_sign(payload, 24, 1) << 4);
            int b2 = extract_bits(payload, 61, 4) | (extract_bits_sign(payload, 14, 1) << 4);
    
            int r3 = extract_bits_sign(payload, 71, 6);
            int g3 = extract_bits(payload, 51, 4) | (extract_bits_sign(payload, 13, 1) << 4);
            int b3 = extract_bits(payload, 50, 1) | (extract_bits(payload, 60, 1) << 1) |
                    (extract_bits(payload, 23, 1) << 2) | (extract_bits_sign(payload, 33, 2) << 3);
    
            ep1 = ivec3(r3, g3, b3) + ep0;
            ep0 += ivec3(r2, g2, b2);
        }
        else
        {
            int r1 = extract_bits_sign(payload, 35, 6);
            int g1 = extract_bits_sign(payload, 45, 5);
            int b1 = extract_bits_sign(payload, 55, 5);
            ep1 = ivec3(r1, g1, b1) + ep0;
        }
    
        ep0 = unquantize_endpoint(ep0, 8);
        ep1 = unquantize_endpoint(ep1, 8);
    
        int index = extract_bits(
            payload,
            max(81 + linear_pixel * 3 - int(linear_pixel > anchor_pixel), 82),
            (linear_pixel == 0 || linear_pixel == anchor_pixel) ? 2 : 3);
    
        int w = weight_table3[index];
        return DecodedInterpolation(ep0, ep1, w);
    }
    
    DecodedInterpolation decode_bc6_mode22(uvec4 payload, int linear_pixel, int part, int anchor_pixel)
    {
        ivec3 ep0, ep1;
    
        int r0 = extract_bits(payload, 5, 8);
        int g0 = extract_bits(payload, 15, 8);
        int b0 = extract_bits(payload, 25, 8);
        ep0 = ivec3(r0, g0, b0);
    
        if (part != 0)
        {
            int r2 = extract_bits_sign(payload, 65, 5);
            int g2 = extract_bits(payload, 41, 4) | (extract_bits(payload, 24, 1) << 4) | (extract_bits_sign(payload, 23, 1) << 5);
            int b2 = extract_bits(payload, 61, 4) | (extract_bits_sign(payload, 14, 1) << 4);
    
            int r3 = extract_bits_sign(payload, 71, 5);
            int g3 = extract_bits(payload, 51, 4) | (extract_bits(payload, 40, 1) << 4) | (extract_bits_sign(payload, 33, 1) << 5);
            int b3 = extract_bits(payload, 13, 1) | (extract_bits(payload, 60, 1) << 1) |
                    (extract_bits(payload, 70, 1) << 2) | (extract_bits(payload, 76, 1) << 3) |
                    (extract_bits_sign(payload, 34, 1) << 4);
    
            ep1 = ivec3(r3, g3, b3) + ep0;
            ep0 += ivec3(r2, g2, b2);
        }
        else
        {
            int r1 = extract_bits_sign(payload, 35, 5);
            int g1 = extract_bits_sign(payload, 45, 6);
            int b1 = extract_bits_sign(payload, 55, 5);
            ep1 = ivec3(r1, g1, b1) + ep0;
        }
    
        ep0 = unquantize_endpoint(ep0, 8);
        ep1 = unquantize_endpoint(ep1, 8);
    
        int index = extract_bits(
            payload,
            max(81 + linear_pixel * 3 - int(linear_pixel > anchor_pixel), 82),
            (linear_pixel == 0 || linear_pixel == anchor_pixel) ? 2 : 3);
    
        int w = weight_table3[index];
        return DecodedInterpolation(ep0, ep1, w);
    }
    
    DecodedInterpolation decode_bc6_mode26(uvec4 payload, int linear_pixel, int part, int anchor_pixel)
    {
        ivec3 ep0, ep1;
    
        int r0 = extract_bits(payload, 5, 8);
        int g0 = extract_bits(payload, 15, 8);
        int b0 = extract_bits(payload, 25, 8);
        ep0 = ivec3(r0, g0, b0);
    
        if (part != 0)
        {
            int r2 = extract_bits_sign(payload, 65, 5);
            int g2 = extract_bits(payload, 41, 4) | (extract_bits_sign(payload, 24, 1) << 4);
            int b2 = extract_bits(payload, 61, 4) | (extract_bits(payload, 14, 1) << 4) | (extract_bits_sign(payload, 23, 1) << 5);
    
            int r3 = extract_bits_sign(payload, 71, 5);
            int g3 = extract_bits(payload, 51, 4) | (extract_bits_sign(payload, 40, 1) << 4);
            int b3 = extract_bits(payload, 50, 1) | (extract_bits(payload, 13, 1) << 1) |
                    (extract_bits(payload, 70, 1) << 2) | (extract_bits(payload, 76, 1) << 3) |
                    (extract_bits(payload, 34, 1) << 4) | (extract_bits_sign(payload, 33, 1) << 5);
    
            ep1 = ivec3(r3, g3, b3) + ep0;
            ep0 += ivec3(r2, g2, b2);
        }
        else
        {
            int r1 = extract_bits_sign(payload, 35, 5);
            int g1 = extract_bits_sign(payload, 45, 5);
            int b1 = extract_bits_sign(payload, 55, 6);
            ep1 = ivec3(r1, g1, b1) + ep0;
        }
    
        ep0 = unquantize_endpoint(ep0, 8);
        ep1 = unquantize_endpoint(ep1, 8);
    
        int index = extract_bits(
            payload,
            max(81 + linear_pixel * 3 - int(linear_pixel > anchor_pixel), 82),
            (linear_pixel == 0 || linear_pixel == anchor_pixel) ? 2 : 3);
    
        int w = weight_table3[index];
        return DecodedInterpolation(ep0, ep1, w);
    }
    
    DecodedInterpolation decode_bc6_mode30(uvec4 payload, int linear_pixel, int part, int anchor_pixel)
    {
        ivec3 ep0, ep1;
    
        if (part != 0)
        {
            int r2 = extract_bits(payload, 65, 6);
            int g2 = extract_bits(payload, 41, 4) | (extract_bits(payload, 24, 1) << 4) | (extract_bits(payload, 21, 1) << 5);
            int b2 = extract_bits(payload, 61, 4) | (extract_bits(payload, 14, 1) << 4) | (extract_bits(payload, 22, 1) << 5);
    
            int r3 = extract_bits(payload, 71, 6);
            int g3 = extract_bits(payload, 51, 4) | (extract_bits(payload, 11, 1) << 4) | (extract_bits(payload, 31, 1) << 5);
            int b3 = extract_bits(payload, 12, 2) | (extract_bits(payload, 23, 1) << 2) |
                (extract_bits(payload, 32, 1) << 3) | (extract_bits(payload, 34, 1) << 4) | (extract_bits(payload, 33, 1) << 5);
    
            ep0 = ivec3(r2, g2, b2);
            ep1 = ivec3(r3, g3, b3);
        }
        else
        {
            int r0 = extract_bits(payload, 5, 6);
            int g0 = extract_bits(payload, 15, 6);
            int b0 = extract_bits(payload, 25, 6);
    
            int r1 = extract_bits(payload, 35, 6);
            int g1 = extract_bits(payload, 45, 6);
            int b1 = extract_bits(payload, 55, 6);
    
            ep0 = ivec3(r0, g0, b0);
            ep1 = ivec3(r1, g1, b1);
        }
    
        ep0 = unquantize_endpoint(ep0, 6);
        ep1 = unquantize_endpoint(ep1, 6);
    
        int index = extract_bits(
            payload,
            max(81 + linear_pixel * 3 - int(linear_pixel > anchor_pixel), 82),
            (linear_pixel == 0 || linear_pixel == anchor_pixel) ? 2 : 3);
    
        int w = weight_table3[index];
        return DecodedInterpolation(ep0, ep1, w);
    }
    
    void main()
    {
        ivec2 coord = build_coord();
        if (any(greaterThanEqual(coord, registers.resolution)))
            return;
    
        ivec2 tile_coord = coord >> 2;
        ivec2 pixel_coord = coord & 3;
        int linear_pixel = 4 * pixel_coord.y + pixel_coord.x;
        uvec4 payload = texelFetch(uInput, tile_coord, 0);
    
        DecodedInterpolation interp;
    
        int mode = extract_bits(payload, 0, 5);
        int part_index = extract_bits(payload, 77, 5);
        int part = (partition_table2[part_index] >> linear_pixel) & 1;
        int anchor_pixel = anchor_table2[part_index];
    
        if ((mode & 2) == 0)
        {
            if ((mode & 1) != 0)
                interp = decode_bc6_mode1(payload, linear_pixel, part, anchor_pixel);
            else
                interp = decode_bc6_mode0(payload, linear_pixel, part, anchor_pixel);
        }
        else
        {
            switch (mode)
            {
            case 2:
                interp = decode_bc6_mode2(payload, linear_pixel, part, anchor_pixel);
                break;
            case 3:
                interp = decode_bc6_mode3(payload, linear_pixel);
                break;
            case 6:
                interp = decode_bc6_mode6(payload, linear_pixel, part, anchor_pixel);
                break;
            case 7:
                interp = decode_bc6_mode7(payload, linear_pixel);
                break;
            case 10:
                interp = decode_bc6_mode10(payload, linear_pixel, part, anchor_pixel);
                break;
            case 11:
                interp = decode_bc6_mode11(payload, linear_pixel);
                break;
            case 14:
                interp = decode_bc6_mode14(payload, linear_pixel, part, anchor_pixel);
                break;
            case 15:
                interp = decode_bc6_mode15(payload, linear_pixel);
                break;
            case 18:
                interp = decode_bc6_mode18(payload, linear_pixel, part, anchor_pixel);
                break;
            case 22:
                interp = decode_bc6_mode22(payload, linear_pixel, part, anchor_pixel);
                break;
            case 26:
                interp = decode_bc6_mode26(payload, linear_pixel, part, anchor_pixel);
                break;
            case 30:
                interp = decode_bc6_mode30(payload, linear_pixel, part, anchor_pixel);
                break;
            default:
                interp = DecodedInterpolation(ivec3(0), ivec3(0), 0);
                break;
            }
        }
    
        ivec3 rgba_result = interpolate_endpoint(interp);
    
        // Squeeze range.
        if (SIGNED)
        {
            ivec3 neg_result = 0x8000 | (((-rgba_result) * 31) >> 5);
            ivec3 pos_result = (rgba_result * 31) >> 5;
            rgba_result = mix(pos_result, neg_result, lessThan(rgba_result, ivec3(0)));
    
            // Fixup for -0.0. Seems to not be emitted by hardware decoder.
            rgba_result = mix(rgba_result, ivec3(0), equal(rgba_result, ivec3(0x8000)));
        }
        else
        {
            rgba_result = (rgba_result * 31) >> 6;
        }
    
        imageStore(uOutput, coord, uvec4(rgba_result, 0x3c00));
    }
  + bc7.comp
    #version 450
    /* Copyright (c) 2020-2024 Hans-Kristian Arntzen
     *
     * 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.
    
    #extension GL_EXT_samplerless_texture_functions : require
    layout(local_size_x = 4, local_size_y = 4, local_size_z = 4) in;
    
    #include "bitextract.h"
    
    layout(set = 0, binding = 0, rgba8ui) writeonly uniform uimage2D uOutput;
    layout(set = 0, binding = 1) uniform utexture2D uInput;
    
    layout(push_constant) uniform Registers
    {
        ivec2 resolution;
    } registers;
    
    ivec2 build_coord()
    {
        ivec2 base = ivec2(gl_WorkGroupID.xy) * 8;
        base.x += 4 * (int(gl_LocalInvocationID.z) & 1);
        base.y += 2 * (int(gl_LocalInvocationID.z) & 2);
        base += ivec2(gl_LocalInvocationID.xy);
        return base;
    }
    
    const int weight_table2[4] = int[](0, 21, 43, 64);
    const int weight_table3[8] = int[](0, 9, 18, 27, 37, 46, 55, 64);
    const int weight_table4[16] = int[](0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64);
    
    #define P3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) \
        (((a) << 0) | ((b) << 2) | ((c) << 4) | ((d) << 6) | \
        ((e) << 8) | ((f) << 10) | ((g) << 12) | ((h) << 14) | \
        ((i) << 16) | ((j) << 18) | ((k) << 20) | ((l) << 22) | \
        ((m) << 24) | ((n) << 26) | ((o) << 28) | ((p) << 30))
    
    const int partition_table3[64] = int[](
        P3(0, 0, 1, 1, 0, 0, 1, 1, 0, 2, 2, 1, 2, 2, 2, 2),
        P3(0, 0, 0, 1, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2, 2, 1),
        P3(0, 0, 0, 0, 2, 0, 0, 1, 2, 2, 1, 1, 2, 2, 1, 1),
        P3(0, 2, 2, 2, 0, 0, 2, 2, 0, 0, 1, 1, 0, 1, 1, 1),
        P3(0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2),
        P3(0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 2, 2, 0, 0, 2, 2),
        P3(0, 0, 2, 2, 0, 0, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1),
        P3(0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1),
    
        P3(0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2),
        P3(0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2),
        P3(0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2),
        P3(0, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2),
        P3(0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2),
        P3(0, 1, 2, 2, 0, 1, 2, 2, 0, 1, 2, 2, 0, 1, 2, 2),
        P3(0, 0, 1, 1, 0, 1, 1, 2, 1, 1, 2, 2, 1, 2, 2, 2),
        P3(0, 0, 1, 1, 2, 0, 0, 1, 2, 2, 0, 0, 2, 2, 2, 0),
    
        P3(0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 2, 1, 1, 2, 2),
        P3(0, 1, 1, 1, 0, 0, 1, 1, 2, 0, 0, 1, 2, 2, 0, 0),
        P3(0, 0, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2),
        P3(0, 0, 2, 2, 0, 0, 2, 2, 0, 0, 2, 2, 1, 1, 1, 1),
        P3(0, 1, 1, 1, 0, 1, 1, 1, 0, 2, 2, 2, 0, 2, 2, 2),
        P3(0, 0, 0, 1, 0, 0, 0, 1, 2, 2, 2, 1, 2, 2, 2, 1),
        P3(0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 2, 2, 0, 1, 2, 2),
        P3(0, 0, 0, 0, 1, 1, 0, 0, 2, 2, 1, 0, 2, 2, 1, 0),
    
        P3(0, 1, 2, 2, 0, 1, 2, 2, 0, 0, 1, 1, 0, 0, 0, 0),
        P3(0, 0, 1, 2, 0, 0, 1, 2, 1, 1, 2, 2, 2, 2, 2, 2),
        P3(0, 1, 1, 0, 1, 2, 2, 1, 1, 2, 2, 1, 0, 1, 1, 0),
        P3(0, 0, 0, 0, 0, 1, 1, 0, 1, 2, 2, 1, 1, 2, 2, 1),
        P3(0, 0, 2, 2, 1, 1, 0, 2, 1, 1, 0, 2, 0, 0, 2, 2),
        P3(0, 1, 1, 0, 0, 1, 1, 0, 2, 0, 0, 2, 2, 2, 2, 2),
        P3(0, 0, 1, 1, 0, 1, 2, 2, 0, 1, 2, 2, 0, 0, 1, 1),
        P3(0, 0, 0, 0, 2, 0, 0, 0, 2, 2, 1, 1, 2, 2, 2, 1),
    
        P3(0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 2, 2, 1, 2, 2, 2),
        P3(0, 2, 2, 2, 0, 0, 2, 2, 0, 0, 1, 2, 0, 0, 1, 1),
        P3(0, 0, 1, 1, 0, 0, 1, 2, 0, 0, 2, 2, 0, 2, 2, 2),
        P3(0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2, 0),
        P3(0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 0, 0, 0, 0),
        P3(0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0),
        P3(0, 1, 2, 0, 2, 0, 1, 2, 1, 2, 0, 1, 0, 1, 2, 0),
        P3(0, 0, 1, 1, 2, 2, 0, 0, 1, 1, 2, 2, 0, 0, 1, 1),
    
        P3(0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 0, 0, 0, 0, 1, 1),
        P3(0, 1, 0, 1, 0, 1, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2),
        P3(0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 2, 1, 2, 1, 2, 1),
        P3(0, 0, 2, 2, 1, 1, 2, 2, 0, 0, 2, 2, 1, 1, 2, 2),
        P3(0, 0, 2, 2, 0, 0, 1, 1, 0, 0, 2, 2, 0, 0, 1, 1),
        P3(0, 2, 2, 0, 1, 2, 2, 1, 0, 2, 2, 0, 1, 2, 2, 1),
        P3(0, 1, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 0, 1, 0, 1),
        P3(0, 0, 0, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1),
    
        P3(0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 2, 2, 2),
        P3(0, 2, 2, 2, 0, 1, 1, 1, 0, 2, 2, 2, 0, 1, 1, 1),
        P3(0, 0, 0, 2, 1, 1, 1, 2, 0, 0, 0, 2, 1, 1, 1, 2),
        P3(0, 0, 0, 0, 2, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2),
        P3(0, 2, 2, 2, 0, 1, 1, 1, 0, 1, 1, 1, 0, 2, 2, 2),
        P3(0, 0, 0, 2, 1, 1, 1, 2, 1, 1, 1, 2, 0, 0, 0, 2),
        P3(0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 2, 2, 2, 2),
        P3(0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 2, 2, 1, 1, 2),
    
        P3(0, 1, 1, 0, 0, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2),
        P3(0, 0, 2, 2, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 2, 2),
        P3(0, 0, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, 0, 0, 2, 2),
        P3(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 2),
        P3(0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 1),
        P3(0, 2, 2, 2, 1, 2, 2, 2, 0, 2, 2, 2, 1, 2, 2, 2),
        P3(0, 1, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2),
        P3(0, 1, 1, 1, 2, 0, 1, 1, 2, 2, 0, 1, 2, 2, 2, 0));
    
    #define P2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) \
        (((a) << 0) | ((b) << 1) | ((c) << 2) | ((d) << 3) | \
        ((e) << 4) | ((f) << 5) | ((g) << 6) | ((h) << 7) | \
        ((i) << 8) | ((j) << 9) | ((k) << 10) | ((l) << 11) | \
        ((m) << 12) | ((n) << 13) | ((o) << 14) | ((p) << 15))
    const int partition_table2[64] = int[](
        P2(0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1),
        P2(0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1),
        P2(0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1),
        P2(0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1),
        P2(0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1),
        P2(0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1),
        P2(0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1),
        P2(0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1),
    
        P2(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1),
        P2(0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
        P2(0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1),
        P2(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1),
        P2(0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
        P2(0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1),
        P2(0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
        P2(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1),
    
        P2(0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1),
        P2(0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0),
        P2(0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0),
        P2(0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0),
        P2(0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0),
        P2(0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0),
        P2(0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0),
        P2(0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1),
    
        P2(0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0),
        P2(0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0),
        P2(0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0),
        P2(0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0),
        P2(0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0),
        P2(0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0),
        P2(0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0),
        P2(0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0),
    
        P2(0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1),
        P2(0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1),
        P2(0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0),
        P2(0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0),
        P2(0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0),
        P2(0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0),
        P2(0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1),
        P2(0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1),
    
        P2(0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0),
        P2(0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0),
        P2(0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0),
        P2(0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0),
        P2(0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0),
        P2(0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1),
        P2(0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1),
        P2(0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0),
    
        P2(0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0),
        P2(0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0),
        P2(0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0),
        P2(0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0),
        P2(0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1),
        P2(0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1),
        P2(0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0),
        P2(0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0),
    
        P2(0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1),
        P2(0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1),
        P2(0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1),
        P2(0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1),
        P2(0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1),
        P2(0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0),
        P2(0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0),
        P2(0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1));
    
    const int anchor_table2[64] = int[](
        15, 15, 15, 15, 15, 15, 15, 15,
        15, 15, 15, 15, 15, 15, 15, 15,
        15, 2, 8, 2, 2, 8, 8, 15,
        2, 8, 2, 2, 8, 8, 2, 2,
        15, 15, 6, 8, 2, 8, 15, 15,
        2, 8, 2, 2, 2, 15, 15, 6,
        6, 2, 6, 8, 15, 15, 2, 2,
        15, 15, 15, 15, 15, 2, 2, 15);
    
    const ivec2 anchor_table3[64] = ivec2[](
        ivec2(3, 15), ivec2(3, 8), ivec2(15, 8), ivec2(15, 3), ivec2(8, 15), ivec2(3, 15), ivec2(15, 3), ivec2(15, 8),
        ivec2(8, 15), ivec2(8, 15), ivec2(6, 15), ivec2(6, 15), ivec2(6, 15), ivec2(5, 15), ivec2(3, 15), ivec2(3, 8),
        ivec2(3, 15), ivec2(3, 8), ivec2(8, 15), ivec2(15, 3), ivec2(3, 15), ivec2(3, 8), ivec2(6, 15), ivec2(10, 8),
        ivec2(5, 3), ivec2(8, 15), ivec2(8, 6), ivec2(6, 10), ivec2(8, 15), ivec2(5, 15), ivec2(15, 10), ivec2(15, 8),
        ivec2(8, 15), ivec2(15, 3), ivec2(3, 15), ivec2(5, 10), ivec2(6, 10), ivec2(10, 8), ivec2(8, 9), ivec2(15, 10),
        ivec2(15, 6), ivec2(3, 15), ivec2(15, 8), ivec2(5, 15), ivec2(15, 3), ivec2(15, 6), ivec2(15, 6), ivec2(15, 8),
        ivec2(3, 15), ivec2(15, 3), ivec2(5, 15), ivec2(5, 15), ivec2(5, 15), ivec2(8, 15), ivec2(5, 15), ivec2(10, 15),
        ivec2(5, 15), ivec2(10, 15), ivec2(8, 15), ivec2(13, 15), ivec2(15, 3), ivec2(12, 15), ivec2(3, 15), ivec2(3, 8)
    );
    
    struct DecodedInterpolation
    {
        uvec4 ep0, ep1;
        uint color_weight;
        uint alpha_weight;
        uint rotation;
    };
    
    DecodedInterpolation decode_bc7_mode0(uvec4 payload, int linear_pixel)
    {
        int part_index = extract_bits(payload, 1, 4);
        int part = (partition_table3[part_index] >> (2 * linear_pixel)) & 3;
        int bit_offset = part * 8;
    
        int r0 = extract_bits(payload, 5 + bit_offset, 4);
        int r1 = extract_bits(payload, 9 + bit_offset, 4);
        int g0 = extract_bits(payload, 29 + bit_offset, 4);
        int g1 = extract_bits(payload, 33 + bit_offset, 4);
        int b0 = extract_bits(payload, 53 + bit_offset, 4);
        int b1 = extract_bits(payload, 57 + bit_offset, 4);
    
        int sep0 = extract_bits(payload, 77 + part * 2, 1);
        int sep1 = extract_bits(payload, 78 + part * 2, 1);
    
        ivec2 anchor_pixels = anchor_table3[part_index];
        int index = extract_bits(
                payload,
                max(82 + linear_pixel * 3 - int(linear_pixel > anchor_pixels.x) - int(linear_pixel > anchor_pixels.y), 83),
                (linear_pixel == anchor_pixels.y || linear_pixel == anchor_pixels.x || linear_pixel == 0) ? 2 : 3);
    
        ivec3 rgb0 = ivec3(r0, g0, b0);
        ivec3 rgb1 = ivec3(r1, g1, b1);
        rgb0 = (rgb0 << 4) | (sep0 << 3) | (rgb0 >> 1);
        rgb1 = (rgb1 << 4) | (sep1 << 3) | (rgb1 >> 1);
    
        int w = weight_table3[index];
        return DecodedInterpolation(uvec4(rgb0, 0xff), uvec4(rgb1, 0xff), w, w, 0);
    }
    
    DecodedInterpolation decode_bc7_mode1(uvec4 payload, int linear_pixel)
    {
        int part_index = extract_bits(payload, 2, 6);
        int part = (partition_table2[part_index] >> linear_pixel) & 1;
        int bit_offset = part * 12;
    
        int r0 = extract_bits(payload, 8 + bit_offset, 6);
        int r1 = extract_bits(payload, 14 + bit_offset, 6);
        int g0 = extract_bits(payload, 32 + bit_offset, 6);
        int g1 = extract_bits(payload, 38 + bit_offset, 6);
        int b0 = extract_bits(payload, 56 + bit_offset, 6);
        int b1 = extract_bits(payload, 62 + bit_offset, 6);
        int sep = extract_bits(payload, 80 + part, 1) << 1;
    
        int anchor_pixel = anchor_table2[part_index];
    
        int index = extract_bits(
            payload,
            max(81 + linear_pixel * 3 - int(linear_pixel > anchor_pixel), 82),
            (linear_pixel == anchor_pixel || linear_pixel == 0) ? 2 : 3);
    
        ivec3 rgb0 = ivec3(r0, g0, b0);
        ivec3 rgb1 = ivec3(r1, g1, b1);
        rgb0 = (rgb0 << 2) | sep | (rgb0 >> 5);
        rgb1 = (rgb1 << 2) | sep | (rgb1 >> 5);
    
        int w = weight_table3[index];
        return DecodedInterpolation(uvec4(rgb0, 0xff), uvec4(rgb1, 0xff), w, w, 0);
    }
    
    DecodedInterpolation decode_bc7_mode2(uvec4 payload, int linear_pixel)
    {
        int part_index = extract_bits(payload, 3, 6);
        int part = (partition_table3[part_index] >> (2 * linear_pixel)) & 3;
        int bit_offset = part * 10;
    
        int r0 = extract_bits(payload, 9 + bit_offset, 5);
        int r1 = extract_bits(payload, 14 + bit_offset, 5);
        int g0 = extract_bits(payload, 39 + bit_offset, 5);
        int g1 = extract_bits(payload, 44 + bit_offset, 5);
        int b0 = extract_bits(payload, 69 + bit_offset, 5);
        int b1 = extract_bits(payload, 74 + bit_offset, 5);
    
        ivec2 anchor_pixels = anchor_table3[part_index];
        int index = extract_bits(
                payload,
                max(98 + linear_pixel * 2 - int(linear_pixel > anchor_pixels.x) - int(linear_pixel > anchor_pixels.y), 99),
                (linear_pixel == anchor_pixels.y || linear_pixel == anchor_pixels.x || linear_pixel == 0) ? 1 : 2);
    
        ivec3 rgb0 = ivec3(r0, g0, b0);
        ivec3 rgb1 = ivec3(r1, g1, b1);
        rgb0 = (rgb0 << 3) | (rgb0 >> 2);
        rgb1 = (rgb1 << 3) | (rgb1 >> 2);
    
        int w = weight_table2[index];
        return DecodedInterpolation(uvec4(rgb0, 0xff), uvec4(rgb1, 0xff), w, w, 0);
    }
    
    DecodedInterpolation decode_bc7_mode3(uvec4 payload, int linear_pixel)
    {
        int part_index = extract_bits(payload, 4, 6);
        int part = (partition_table2[part_index] >> linear_pixel) & 1;
        int bit_offset = part * 14;
    
        int r0 = extract_bits(payload, 10 + bit_offset, 7);
        int r1 = extract_bits(payload, 17 + bit_offset, 7);
        int g0 = extract_bits(payload, 38 + bit_offset, 7);
        int g1 = extract_bits(payload, 45 + bit_offset, 7);
        int b0 = extract_bits(payload, 66 + bit_offset, 7);
        int b1 = extract_bits(payload, 73 + bit_offset, 7);
    
        int sep0 = extract_bits(payload, 94 + part * 2, 1);
        int sep1 = extract_bits(payload, 95 + part * 2, 1);
    
        int anchor_pixel = anchor_table2[part_index];
    
        int index = extract_bits(
            payload,
            max(97 + linear_pixel * 2 - int(linear_pixel > anchor_pixel), 98),
            (linear_pixel == anchor_pixel || linear_pixel == 0) ? 1 : 2);
    
        ivec3 rgb0 = ivec3(r0, g0, b0);
        ivec3 rgb1 = ivec3(r1, g1, b1);
        rgb0 = (rgb0 << 1) | sep0;
        rgb1 = (rgb1 << 1) | sep1;
    
        int w = weight_table2[index];
        return DecodedInterpolation(uvec4(rgb0, 0xff), uvec4(rgb1, 0xff), w, w, 0);
    }
    
    DecodedInterpolation decode_bc7_mode4(uvec4 payload, int linear_pixel)
    {
        int rot = extract_bits(payload, 5, 2);
        bool isb = (payload.x & 0x80u) != 0u;
        int r0 = extract_bits(payload, 8, 5);
        int r1 = extract_bits(payload, 13, 5);
        int g0 = extract_bits(payload, 18, 5);
        int g1 = extract_bits(payload, 23, 5);
        int b0 = extract_bits(payload, 28, 5);
        int b1 = extract_bits(payload, 33, 5);
        int a0 = extract_bits(payload, 38, 6);
        int a1 = extract_bits(payload, 44, 6);
    
        int primary_index = extract_bits(
                payload,
                max(49 + linear_pixel * 2, 50),
                linear_pixel == 0 ? 1 : 2);
        int secondary_index = extract_bits(
                payload,
                max(80 + linear_pixel * 3, 81),
                linear_pixel == 0 ? 2 : 3);
    
        int color_weight = weight_table2[primary_index];
        int alpha_weight = weight_table3[secondary_index];
    
        if (isb)
        {
            int tmp = color_weight;
            color_weight = alpha_weight;
            alpha_weight = tmp;
        }
    
        ivec3 rgb0 = ivec3(r0, g0, b0);
        ivec3 rgb1 = ivec3(r1, g1, b1);
        rgb0 = (rgb0 << 3) | (rgb0 >> 2);
        rgb1 = (rgb1 << 3) | (rgb1 >> 2);
        a0 = (a0 << 2) | (a0 >> 4);
        a1 = (a1 << 2) | (a1 >> 4);
        return DecodedInterpolation(uvec4(rgb0, a0), uvec4(rgb1, a1), color_weight, alpha_weight, rot);
    }
    
    DecodedInterpolation decode_bc7_mode5(uvec4 payload, int linear_pixel)
    {
        int rot = extract_bits(payload, 6, 2);
        int r0 = extract_bits(payload, 8, 7);
        int r1 = extract_bits(payload, 15, 7);
        int g0 = extract_bits(payload, 22, 7);
        int g1 = extract_bits(payload, 29, 7);
        int b0 = extract_bits(payload, 36, 7);
        int b1 = extract_bits(payload, 43, 7);
        int a0 = extract_bits(payload, 50, 8);
        int a1 = extract_bits(payload, 58, 8);
    
        int primary_index = extract_bits(
                payload,
                max(65 + linear_pixel * 2, 66),
                linear_pixel == 0 ? 1 : 2);
        int secondary_index = extract_bits(
                payload,
                max(96 + linear_pixel * 2, 97),
                linear_pixel == 0 ? 1 : 2);
    
        int color_weight = weight_table2[primary_index];
        int alpha_weight = weight_table2[secondary_index];
    
        ivec3 rgb0 = ivec3(r0, g0, b0);
        ivec3 rgb1 = ivec3(r1, g1, b1);
        rgb0 = (rgb0 << 1) | (rgb0 >> 6);
        rgb1 = (rgb1 << 1) | (rgb1 >> 6);
        return DecodedInterpolation(uvec4(rgb0, a0), uvec4(rgb1, a1), color_weight, alpha_weight, rot);
    }
    
    DecodedInterpolation decode_bc7_mode6(uvec4 payload, int linear_pixel)
    {
        int sep0 = extract_bits(payload, 63, 1);
        int sep1 = extract_bits(payload, 64, 1);
        int r0 = extract_bits(payload, 7, 7);
        int r1 = extract_bits(payload, 14, 7);
        int g0 = extract_bits(payload, 21, 7);
        int g1 = extract_bits(payload, 28, 7);
        int b0 = extract_bits(payload, 35, 7);
        int b1 = extract_bits(payload, 42, 7);
        int a0 = extract_bits(payload, 49, 7);
        int a1 = extract_bits(payload, 56, 7);
    
        ivec4 ep0 = ivec4(r0, g0, b0, a0) * 2 + sep0;
        ivec4 ep1 = ivec4(r1, g1, b1, a1) * 2 + sep1;
    
        int index = extract_bits(
                payload,
                max(64 + linear_pixel * 4, 65),
                linear_pixel == 0 ? 3 : 4);
    
        int w = weight_table4[index];
        return DecodedInterpolation(ep0, ep1, w, w, 0);
    }
    
    DecodedInterpolation decode_bc7_mode7(uvec4 payload, int linear_pixel)
    {
        int part_index = extract_bits(payload, 8, 6);
        int part = (partition_table2[part_index] >> linear_pixel) & 1;
        int bit_offset = part * 10;
    
        int r0 = extract_bits(payload, 14 + bit_offset, 5);
        int r1 = extract_bits(payload, 19 + bit_offset, 5);
        int g0 = extract_bits(payload, 34 + bit_offset, 5);
        int g1 = extract_bits(payload, 39 + bit_offset, 5);
        int b0 = extract_bits(payload, 54 + bit_offset, 5);
        int b1 = extract_bits(payload, 59 + bit_offset, 5);
        int a0 = extract_bits(payload, 74 + bit_offset, 5);
        int a1 = extract_bits(payload, 79 + bit_offset, 5);
    
        int sep0 = extract_bits(payload, 94 + part * 2, 1);
        int sep1 = extract_bits(payload, 95 + part * 2, 1);
    
        int anchor_pixel = anchor_table2[part_index];
    
        int index = extract_bits(
            payload,
            max(97 + linear_pixel * 2 - int(linear_pixel > anchor_pixel), 98),
            (linear_pixel == anchor_pixel || linear_pixel == 0) ? 1 : 2);
    
        ivec4 rgba0 = ivec4(r0, g0, b0, a0);
        ivec4 rgba1 = ivec4(r1, g1, b1, a1);
        rgba0 = (rgba0 << 3) | (rgba0 >> 3) | (sep0 << 2);
        rgba1 = (rgba1 << 3) | (rgba1 >> 3) | (sep1 << 2);
    
        int w = weight_table2[index];
        return DecodedInterpolation(rgba0, rgba1, w, w, 0);
    }
    
    uvec4 interpolate_endpoint(DecodedInterpolation interp)
    {
        uvec3 rgb = (((64u - interp.color_weight) * interp.ep0.rgb + interp.color_weight * interp.ep1.rgb + 32) >> 6);
        uint a = (((64u - interp.alpha_weight) * interp.ep0.a + interp.alpha_weight * interp.ep1.a + 32) >> 6);
        uvec4 rgba = uvec4(rgb, a);
    
        switch (interp.rotation)
        {
        default:
            break;
        case 1u:
            rgba = rgba.agbr;
            break;
        case 2u:
            rgba = rgba.rabg;
            break;
        case 3u:
            rgba = rgba.rgab;
            break;
        }
    
        return rgba;
    }
    
    void main()
    {
        ivec2 coord = build_coord();
        if (any(greaterThanEqual(coord, registers.resolution)))
            return;
    
        ivec2 tile_coord = coord >> 2;
        ivec2 pixel_coord = coord & 3;
        int linear_pixel = 4 * pixel_coord.y + pixel_coord.x;
        uvec4 payload = texelFetch(uInput, tile_coord, 0);
    
        DecodedInterpolation interp;
    
        int mode = findLSB(payload.x);
        switch (mode)
        {
        case 0:
            interp = decode_bc7_mode0(payload, linear_pixel);
            break;
    
        case 1:
            interp = decode_bc7_mode1(payload, linear_pixel);
            break;
    
        case 2:
            interp = decode_bc7_mode2(payload, linear_pixel);
            break;
    
        case 3:
            interp = decode_bc7_mode3(payload, linear_pixel);
            break;
    
        case 4:
            interp = decode_bc7_mode4(payload, linear_pixel);
            break;
    
        case 5:
            interp = decode_bc7_mode5(payload, linear_pixel);
            break;
    
        case 6:
            interp = decode_bc7_mode6(payload, linear_pixel);
            break;
    
        case 7:
            interp = decode_bc7_mode7(payload, linear_pixel);
            break;
    
        default:
            interp = DecodedInterpolation(uvec4(0), uvec4(0), 0, 0, 0);
            break;
        }
    
        uvec4 rgba_result = interpolate_endpoint(interp);
        imageStore(uOutput, coord, rgba_result);
    }
  + bitextract.h
    
    #ifndef BITEXTRACT_H_
    #define BITEXTRACT_H_
    
    int extract_bits(uvec4 payload, int offset, int bits)
    {
    	int last_offset = offset + bits - 1;
    	int result;
    
    	if (bits <= 0)
    		result = 0;
    	else if ((last_offset >> 5) == (offset >> 5))
    		result = int(bitfieldExtract(payload[offset >> 5], offset & 31, bits));
    	else
    	{
    		int first_bits = 32 - (offset & 31);
    		int result_first = int(bitfieldExtract(payload[offset >> 5], offset & 31, first_bits));
    		int result_second = int(bitfieldExtract(payload[(offset >> 5) + 1], 0, bits - first_bits));
    		result = result_first | (result_second << first_bits);
    	}
    	return result;
    }
    
    int extract_bits_sign(uvec4 payload, int offset, int bits)
    {
    	int last_offset = offset + bits - 1;
    	int result;
    
    	if (bits <= 0)
    		result = 0;
    	else if ((last_offset >> 5) == (offset >> 5))
    		result = bitfieldExtract(int(payload[offset >> 5]), offset & 31, bits);
    	else
    	{
    		int first_bits = 32 - (offset & 31);
    		int result_first = int(bitfieldExtract(payload[offset >> 5], offset & 31, first_bits));
    		int result_second = bitfieldExtract(int(payload[(offset >> 5) + 1]), 0, bits - first_bits);
    		result = result_first | (result_second << first_bits);
    	}
    	return result;
    }
    
    int extract_bits_reverse(uvec4 payload, int offset, int bits)
    {
    	int last_offset = offset + bits - 1;
    	int result;
    
    	if (bits <= 0)
    		result = 0;
    	else if ((last_offset >> 5) == (offset >> 5))
    		result = int(bitfieldReverse(bitfieldExtract(payload[offset >> 5], offset & 31, bits)) >> (32 - bits));
    	else
    	{
    		int first_bits = 32 - (offset & 31);
    		uint result_first = bitfieldExtract(payload[offset >> 5], offset & 31, first_bits);
    		uint result_second = bitfieldExtract(payload[(offset >> 5) + 1], 0, bits - first_bits);
    		result = int(bitfieldReverse(result_first | (result_second << first_bits)) >> (32 - bits));
    	}
    	return result;
    }
    
    #endif
  + eac.comp
    #version 450
    /* Copyright (c) 2020-2024 Hans-Kristian Arntzen
     *
     * 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.
    
    #extension GL_EXT_samplerless_texture_functions : require
    layout(local_size_x = 4, local_size_y = 4, local_size_z = 4) in;
    
    layout(set = 0, binding = 0) writeonly uniform image2D uOutput;
    layout(set = 0, binding = 1) uniform utexture2D uInput;
    
    layout(constant_id = 0) const int COMPONENTS = 1;
    
    layout(push_constant) uniform Registers
    {
        ivec2 resolution;
    } registers;
    
    ivec2 build_coord()
    {
        ivec2 base = ivec2(gl_WorkGroupID.xy) * 8;
        base.x += 4 * (int(gl_LocalInvocationID.z) & 1);
        base.y += 2 * (int(gl_LocalInvocationID.z) & 2);
        base += ivec2(gl_LocalInvocationID.xy);
        return base;
    }
    
    uint flip_endian(uint v)
    {
        uvec4 words = uvec4(v) >> uvec4(0, 8, 16, 24);
        words &= 0xffu;
        return (words.x << 24u) | (words.y << 16u) | (words.z << 8u) | (words.w << 0u);
    }
    
    uvec2 flip_endian(uvec2 v)
    {
        return uvec2(flip_endian(v.y), flip_endian(v.x));
    }
    
    const ivec4 etc2_alpha_modifier_table[16] = ivec4[](
        ivec4(2, 5, 8, 14),
        ivec4(2, 6, 9, 12),
        ivec4(1, 4, 7, 12),
        ivec4(1, 3, 5, 12),
        ivec4(2, 5, 7, 11),
        ivec4(2, 6, 8, 10),
        ivec4(3, 6, 7, 10),
        ivec4(2, 4, 7, 10),
        ivec4(1, 5, 7, 9),
        ivec4(1, 4, 7, 9),
        ivec4(1, 3, 7, 9),
        ivec4(1, 4, 6, 9),
        ivec4(2, 3, 6, 9),
        ivec4(0, 1, 2, 9),
        ivec4(3, 5, 7, 8),
        ivec4(2, 4, 6, 8)
    );
    
    uint decode_eac_alpha(uvec2 payload, int linear_pixel)
    {
        int bit_offset = 45 - 3 * linear_pixel;
        int base = int(bitfieldExtract(payload.y, 24, 8)) * 8 + 4;
        int multiplier = max(int(bitfieldExtract(payload.y, 20, 4)) * 8, 1);
        int table = int(bitfieldExtract(payload.y, 16, 4));
    
        int lsb_index = int(bitfieldExtract(payload[bit_offset >> 5], bit_offset & 31, 2));
        bit_offset += 2;
        int msb = int((payload[bit_offset >> 5] >> (bit_offset & 31)) & 1);
        int mod = etc2_alpha_modifier_table[table][lsb_index] ^ (msb - 1);
        int a = base + mod * multiplier;
        return clamp(a, 0, 2047);
    }
    
    void main()
    {
        ivec2 coord = build_coord();
        if (any(greaterThanEqual(coord, registers.resolution)))
            return;
    
        ivec2 tile_coord = coord >> 2;
        ivec2 pixel_coord = coord & 3;
        int linear_pixel = 4 * pixel_coord.x + pixel_coord.y;
        uvec4 payload = texelFetch(uInput, tile_coord, 0);
    
        uint r = decode_eac_alpha(flip_endian(payload.xy), linear_pixel);
    
        if (COMPONENTS == 1)
            imageStore(uOutput, coord, vec4(float(r) / 2047.0, 0.0, 0.0, 1.0));
        else if (COMPONENTS == 2)
        {
            uint g = decode_eac_alpha(flip_endian(payload.zw), linear_pixel);
            imageStore(uOutput, coord, vec4(float(r) / 2047.0, float(g) / 2047.0, 0.0, 1.0));
        }
    }
  + etc2.comp
    #version 450
    /* Copyright (c) 2020-2024 Hans-Kristian Arntzen
     *
     * 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.
    
    #extension GL_EXT_samplerless_texture_functions : require
    layout(local_size_x = 4, local_size_y = 4, local_size_z = 4) in;
    
    layout(set = 0, binding = 0, rgba8ui) writeonly uniform uimage2D uOutput;
    layout(set = 0, binding = 1) uniform utexture2D uInput;
    
    layout(constant_id = 0) const int ALPHA_BITS = 0;
    
    layout(push_constant) uniform Registers
    {
        ivec2 resolution;
    } registers;
    
    ivec2 build_coord()
    {
        ivec2 base = ivec2(gl_WorkGroupID.xy) * 8;
        base.x += 4 * (int(gl_LocalInvocationID.z) & 1);
        base.y += 2 * (int(gl_LocalInvocationID.z) & 2);
        base += ivec2(gl_LocalInvocationID.xy);
        return base;
    }
    
    uint flip_endian(uint v)
    {
        uvec4 words = uvec4(v) >> uvec4(0, 8, 16, 24);
        words &= 0xffu;
        return (words.x << 24u) | (words.y << 16u) | (words.z << 8u) | (words.w << 0u);
    }
    
    uvec2 flip_endian(uvec2 v)
    {
        return uvec2(flip_endian(v.y), flip_endian(v.x));
    }
    
    const ivec2 etc1_color_modifier_table[8] = ivec2[](
        ivec2(2, 8),
        ivec2(5, 17),
        ivec2(9, 29),
        ivec2(13, 42),
        ivec2(18, 60),
        ivec2(24, 80),
        ivec2(33, 106),
        ivec2(47, 183));
    
    const ivec4 etc2_alpha_modifier_table[16] = ivec4[](
        ivec4(2, 5, 8, 14),
        ivec4(2, 6, 9, 12),
        ivec4(1, 4, 7, 12),
        ivec4(1, 3, 5, 12),
        ivec4(2, 5, 7, 11),
        ivec4(2, 6, 8, 10),
        ivec4(3, 6, 7, 10),
        ivec4(2, 4, 7, 10),
        ivec4(1, 5, 7, 9),
        ivec4(1, 4, 7, 9),
        ivec4(1, 3, 7, 9),
        ivec4(1, 4, 6, 9),
        ivec4(2, 3, 6, 9),
        ivec4(0, 1, 2, 9),
        ivec4(3, 5, 7, 8),
        ivec4(2, 4, 6, 8)
    );
    
    const int etc2_distance_table[8] = int[](3, 6, 11, 16, 23, 32, 41, 64);
    
    uint decode_etc2_alpha(uvec2 payload, int linear_pixel)
    {
        int bit_offset = 45 - 3 * linear_pixel;
        int base = int(bitfieldExtract(payload.y, 24, 8));
        int multiplier = int(bitfieldExtract(payload.y, 20, 4));
        int table = int(bitfieldExtract(payload.y, 16, 4));
    
        int lsb_index = int(bitfieldExtract(payload[bit_offset >> 5], bit_offset & 31, 2));
        bit_offset += 2;
        int msb = int((payload[bit_offset >> 5] >> (bit_offset & 31)) & 1);
        int mod = etc2_alpha_modifier_table[table][lsb_index] ^ (msb - 1);
        int a = base + mod * multiplier;
        return clamp(a, 0, 0xff);
    }
    
    void main()
    {
        ivec2 coord = build_coord();
        if (any(greaterThanEqual(coord, registers.resolution)))
            return;
    
        ivec2 tile_coord = coord >> 2;
        ivec2 pixel_coord = coord & 3;
        int linear_pixel = 4 * pixel_coord.x + pixel_coord.y;
        uvec4 payload = texelFetch(uInput, tile_coord, 0);
    
        uvec2 color_payload;
        uint alpha_result;
        bool punchthrough;
        if (ALPHA_BITS == 8)
        {
            uvec2 alpha_payload = flip_endian(payload.xy);
            alpha_result = decode_etc2_alpha(alpha_payload, linear_pixel);
            color_payload = flip_endian(payload.zw);
        }
        else
        {
            color_payload = flip_endian(payload.xy);
            alpha_result = 0xffu;
        }
    
        uvec3 rgb_result;
        ivec3 base_rgb;
        uint flip = color_payload.y & 1u;
        uint subblock = (pixel_coord[flip] & 2u) >> 1u;
        bool etc1_compat = false;
    
        if (ALPHA_BITS == 1)
            punchthrough = (color_payload.y & 2u) == 0u;
        else
            punchthrough = false;
    
        if (ALPHA_BITS != 1 && (color_payload.y & 2u) == 0u)
        {
            // Individual mode (ETC1)
            etc1_compat = true;
            base_rgb = ivec3(color_payload.yyy >> (uvec3(28, 20, 12) - 4 * subblock));
            base_rgb &= 0xf;
            base_rgb *= 0x11;
        }
        else
        {
            int r = int(bitfieldExtract(color_payload.y, 27, 5));
            int rd = bitfieldExtract(int(color_payload.y), 24, 3);
            int g = int(bitfieldExtract(color_payload.y, 19, 5));
            int gd = bitfieldExtract(int(color_payload.y), 16, 3);
            int b = int(bitfieldExtract(color_payload.y, 11, 5));
            int bd = bitfieldExtract(int(color_payload.y), 8, 3);
    
            int r1 = r + rd;
            int g1 = g + gd;
            int b1 = b + bd;
    
            if (uint(r1) > 31)
            {
                int r1 = int(bitfieldExtract(color_payload.y, 56 - 32, 2)) |
                        (int(bitfieldExtract(color_payload.y, 59 - 32, 2)) << 2);
                int g1 = int(bitfieldExtract(color_payload.y, 52 - 32, 4));
                int b1 = int(bitfieldExtract(color_payload.y, 48 - 32, 4));
                int r2 = int(bitfieldExtract(color_payload.y, 44 - 32, 4));
                int g2 = int(bitfieldExtract(color_payload.y, 40 - 32, 4));
                int b2 = int(bitfieldExtract(color_payload.y, 36 - 32, 4));
                uint da = (bitfieldExtract(color_payload.y, 34 - 32, 2) << 1) |
                        (color_payload.y & 1u);
                int dist = etc2_distance_table[da];
    
                int msb = int((color_payload.x >> (15 + linear_pixel)) & 2u);
                int lsb = int((color_payload.x >> linear_pixel) & 1u);
                int index = msb | lsb;
    
                if (punchthrough)
                    punchthrough = index == 2;
    
                if (index == 0)
                {
                    rgb_result = uvec3(r1, g1, b1);
                    rgb_result *= 0x11u;
                }
                else
                {
                    int mod = 2 - index;
                    ivec3 rgb = ivec3(r2, g2, b2) * 0x11 + mod * dist;
                    rgb_result = clamp(rgb, ivec3(0), ivec3(255));
                }
            }
            else if (uint(g1) > 31)
            {
                int r1 = int(bitfieldExtract(color_payload.y, 59 - 32, 4));
                int g1 = (int(bitfieldExtract(color_payload.y, 56 - 32, 3)) << 1) |
                        int((color_payload.y >> 20u) & 1u);
                int b1 = int(bitfieldExtract(color_payload.y, 47 - 32, 3)) |
                        int((color_payload.y >> 16u) & 8u);
                int r2 = int(bitfieldExtract(color_payload.y, 43 - 32, 4));
                int g2 = int(bitfieldExtract(color_payload.y, 39 - 32, 4));
                int b2 = int(bitfieldExtract(color_payload.y, 35 - 32, 4));
                uint da = color_payload.y & 4u;
                uint db = color_payload.y & 1u;
                uint d = da + 2 * db;
                d += uint((r1 * 0x10000 + g1 * 0x100 + b1) >= (r2 * 0x10000 + g2 * 0x100 + b2));
                int dist = etc2_distance_table[d];
                int msb = int((color_payload.x >> (15 + linear_pixel)) & 2u);
                int lsb = int((color_payload.x >> linear_pixel) & 1u);
    
                if (punchthrough)
                    punchthrough = (msb + lsb) == 2;
    
                ivec3 base = msb != 0 ? ivec3(r2, g2, b2) : ivec3(r1, g1, b1);
                base *= 0x11;
                int mod = 1 - 2 * lsb;
                base += mod * dist;
                rgb_result = clamp(base, ivec3(0), ivec3(0xff));
            }
            else if (uint(b1) > 31)
            {
                // Planar mode
                int r = int(bitfieldExtract(color_payload.y, 57 - 32, 6));
                int g = int(bitfieldExtract(color_payload.y, 49 - 32, 6)) |
                        (int(color_payload.y >> 18) & 0x40);
                int b = int(bitfieldExtract(color_payload.y, 39 - 32, 3)) |
                        (int(bitfieldExtract(color_payload.y, 43 - 32, 2)) << 3) |
                        (int(color_payload.y >> 11) & 0x20);
                int rh = int(color_payload.y & 1u) |
                        (int(bitfieldExtract(color_payload.y, 2, 5)) << 1);
                int rv = int(bitfieldExtract(color_payload.x, 13, 6));
                int gh = int(bitfieldExtract(color_payload.x, 25, 7));
                int gv = int(bitfieldExtract(color_payload.x, 6, 7));
                int bh = int(bitfieldExtract(color_payload.x, 19, 6));
                int bv = int(bitfieldExtract(color_payload.x, 0, 6));
    
                r = (r << 2) | (r >> 4);
                rh = (rh << 2) | (rh >> 4);
                rv = (rv << 2) | (rv >> 4);
                g = (g << 1) | (g >> 6);
                gh = (gh << 1) | (gh >> 6);
                gv = (gv << 1) | (gv >> 6);
                b = (b << 2) | (b >> 4);
                bh = (bh << 2) | (bh >> 4);
                bv = (bv << 2) | (bv >> 4);
    
                ivec3 rgb = ivec3(r, g, b);
                ivec3 dx = ivec3(rh, gh, bh) - rgb;
                ivec3 dy = ivec3(rv, gv, bv) - rgb;
                dx *= pixel_coord.x;
                dy *= pixel_coord.y;
                rgb = rgb + ((dx + dy + 2) >> 2);
                rgb = clamp(rgb, ivec3(0), ivec3(255));
                rgb_result = rgb;
                punchthrough = false;
            }
            else
            {
                // Differential mode (ETC1)
                etc1_compat = true;
                base_rgb = ivec3(r, g, b) + int(subblock) * ivec3(rd, gd, bd);
                base_rgb = (base_rgb << 3) | (base_rgb >> 2);
            }
        }
    
        if (etc1_compat)
        {
            uint etc1_table_index = bitfieldExtract(color_payload.y, 5 - 3 * int(subblock != 0u), 3);
            int msb = int((color_payload.x >> (15 + linear_pixel)) & 2u);
            int lsb = int((color_payload.x >> linear_pixel) & 1u);
            int sgn = 1 - msb;
            if (punchthrough)
            {
                sgn *= lsb;
                punchthrough = (msb + lsb) == 2;
            }
            int offset = etc1_color_modifier_table[etc1_table_index][lsb] * sgn;
            base_rgb = clamp(base_rgb + offset, ivec3(0), ivec3(255));
            rgb_result = base_rgb;
        }
    
        if (ALPHA_BITS == 1 && punchthrough)
        {
            rgb_result = uvec3(0);
            alpha_result = 0;
        }
    
        imageStore(uOutput, coord, uvec4(rgb_result, alpha_result));
    }
  + meshlet_decode.comp
    #version 450
    
    #extension GL_EXT_scalar_block_layout : require
    #include "../inc/meshlet_payload_constants.h"
    #extension GL_KHR_shader_subgroup_basic : require
    
    layout(local_size_x = 32, local_size_y = 8) in;
    
    layout(constant_id = 0) const uint NUM_U32_STREAMS = MESHLET_PAYLOAD_MAX_STREAMS;
    layout(constant_id = 1) const bool UNROLLED_MESH = false;
    layout(constant_id = 2) const uint TARGET_MESH_STYLE = 0;
    layout(constant_id = 3) const bool RUNTIME_MESH = false;
    
    #define MESHLET_PAYLOAD_DESCRIPTOR_SET 0
    #define MESHLET_PAYLOAD_STREAM_BINDING 0
    #define MESHLET_PAYLOAD_PAYLOAD_BINDING 1
    #include "../inc/meshlet_payload_decode.h"
    #include "../inc/meshlet_attribute_decode.h"
    #include "../inc/meshlet_payload_constants.h"
    
    const int MESH_STYLE_WIREFRAME = 0;
    const int MESH_STYLE_TEXTURED = 1;
    const int MESH_STYLE_SKINNED = 2;
    
    layout(set = 0, binding = 2, scalar) writeonly buffer OutputIndices
    {
        uvec3 data[];
    } output_indices32;
    
    layout(set = 0, binding = 2, scalar) writeonly buffer OutputIndices8
    {
        u8vec3 data[];
    } output_indices8;
    
    layout(set = 0, binding = 3, scalar) writeonly buffer OutputStreamPos
    {
        vec3 data[];
    } output_stream_pos;
    
    struct TexturedAttr
    {
        uint normal;
        uint tangent;
        vec2 uv;
    };
    
    layout(set = 0, binding = 4, std430) writeonly buffer OutputStreamTextured
    {
        TexturedAttr data[];
    } output_stream_textured_attr;
    
    layout(set = 0, binding = 5, std430) writeonly buffer OutputStreamSkin
    {
        uvec2 data[];
    } output_stream_skin;
    
    struct Offsets
    {
        uint primitive_output_offset;
        uint vertex_output_offset;
        uint index_offset;
    };
    
    layout(set = 0, binding = 6, std430) readonly buffer OutputOffsets
    {
        Offsets data[];
    } output_offsets;
    
    layout(push_constant, std430) uniform Registers
    {
        uint primitive_offset;
        uint vertex_offset;
        uint meshlet_count;
        uint wg_offset;
    } registers;
    
    uint pack_a2bgr10(vec4 v)
    {
        ivec4 quantized = ivec4(round(clamp(v, vec4(-1.0), vec4(1.0)) * vec4(511.0, 511.0, 511.0, 1.0))) & ivec4(1023, 1023, 1023, 3);
        return (quantized.a << 30) | (quantized.b << 20) | (quantized.g << 10) | (quantized.r << 0);
    }
    
    void main()
    {
        uint meshlet_index = gl_WorkGroupID.x + registers.wg_offset;
    
        uint lane_index;
        if (gl_SubgroupSize == 32)
        {
            lane_index = gl_SubgroupInvocationID;
            meshlet_index = 8 * meshlet_index + gl_SubgroupID;
        }
        else
        {
            lane_index = gl_LocalInvocationID.x;
            meshlet_index = 8 * meshlet_index + gl_LocalInvocationID.y;
        }
    
        if (meshlet_index >= registers.meshlet_count)
            return;
    
        Offsets offsets = output_offsets.data[meshlet_index];
        offsets.primitive_output_offset += registers.primitive_offset;
    
        MeshletInfo info = meshlet_get_meshlet_info(meshlet_index * NUM_U32_STREAMS);
    
        // Index
        if (lane_index < info.primitive_count)
        {
            uvec3 indices = meshlet_decode_index_buffer(
                    meshlet_index * NUM_U32_STREAMS + MESHLET_STREAM_TYPE_PRIMITIVE,
                    lane_index);
    
            indices += offsets.index_offset;
    
            if (UNROLLED_MESH)
                output_indices32.data[offsets.primitive_output_offset + lane_index] = indices;
            else
                output_indices8.data[offsets.primitive_output_offset + lane_index] = u8vec3(indices);
        }
    
        // Attributes
        if (lane_index < info.vertex_count)
        {
            int exponent;
            i16vec3 pos = meshlet_decode_snorm_scaled_i16x3(
                    meshlet_index * NUM_U32_STREAMS + MESHLET_STREAM_TYPE_POSITION,
                    lane_index, exponent);
    
            vec3 fp_pos = ldexp(vec3(pos), ivec3(exponent));
            offsets.vertex_output_offset += registers.vertex_offset;
            output_stream_pos.data[offsets.vertex_output_offset + lane_index] = fp_pos;
    
            if (TARGET_MESH_STYLE >= MESH_STYLE_TEXTURED)
            {
                bool t_sign;
                u8vec4 nt = meshlet_decode_normal_tangent_oct8(
                        meshlet_index * NUM_U32_STREAMS + MESHLET_STREAM_TYPE_NORMAL_TANGENT_OCT8,
                        lane_index, t_sign);
                i16vec2 uv = meshlet_decode_snorm_scaled_i16x2(
                        meshlet_index * NUM_U32_STREAMS + MESHLET_STREAM_TYPE_UV,
                        lane_index, exponent);
                vec2 fp_uv = attribute_decode_snorm_exp_uv(uv, exponent);
    
                mediump mat2x4 NT = attribute_decode_oct8_normal_tangent(nt, t_sign);
                output_stream_textured_attr.data[offsets.vertex_output_offset + lane_index] =
                    TexturedAttr(pack_a2bgr10(NT[0]), pack_a2bgr10(NT[1]), fp_uv);
            }
        }
    }
  + rgtc.comp
    #version 450
    /* Copyright (c) 2020-2024 Hans-Kristian Arntzen
     *
     * 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.
    
    #extension GL_EXT_samplerless_texture_functions : require
    layout(local_size_x = 4, local_size_y = 4, local_size_z = 4) in;
    
    #include "rgtc.h"
    
    layout(set = 0, binding = 0) writeonly uniform image2D uOutput;
    layout(set = 0, binding = 1) uniform utexture2D uInput;
    
    layout(push_constant) uniform Registers
    {
        ivec2 resolution;
    } registers;
    
    layout(constant_id = 0) const bool DUAL_COMPONENT = false;
    
    ivec2 build_coord()
    {
        ivec2 base = ivec2(gl_WorkGroupID.xy) * 8;
        base.x += 4 * (int(gl_LocalInvocationID.z) & 1);
        base.y += 2 * (int(gl_LocalInvocationID.z) & 2);
        base += ivec2(gl_LocalInvocationID.xy);
        return base;
    }
    
    void main()
    {
        ivec2 coord = build_coord();
        if (any(greaterThanEqual(coord, registers.resolution)))
            return;
    
        ivec2 tile_coord = coord >> 2;
        ivec2 pixel_coord = coord & 3;
        int linear_pixel = 4 * pixel_coord.y + pixel_coord.x;
        uvec4 payload = texelFetch(uInput, tile_coord, 0);
    
        vec4 rg = vec4(0);
        rg.x = decode_alpha_rgtc(payload.xy, linear_pixel);
        if (DUAL_COMPONENT)
            rg.y = decode_alpha_rgtc(payload.zw, linear_pixel);
    
        imageStore(uOutput, coord, rg);
    }
  + rgtc.h
    
    #ifndef RGTC_H_
    #define RGTC_H_
    
    float decode_alpha_rgtc(uvec2 payload, int linear_pixel)
    {
    	float ep0 = float(int(payload.x & 0xffu)) / 255.0;
    	float ep1 = float(((payload.x >> 8) & 0xffu)) / 255.0;
    	bool range7 = ep0 > ep1;
    
    	int bit_offset = 16 + linear_pixel * 3;
    	uint bits;
    	if (bit_offset <= 29)
    		bits = bitfieldExtract(payload.x, bit_offset, 3);
    	else if (bit_offset >= 32)
    		bits = bitfieldExtract(payload.y, bit_offset - 32, 3);
    	else
    		bits = bitfieldExtract(payload.x, 31, 1) | ((payload.y & 3) << 1);
    
    	float res;
    
    	if (bits < 2)
    		res = bits != 0 ? ep1 : ep0;
    	else if (range7)
    		res = mix(ep0, ep1, (1.0 / 7.0) * float(bits - 1));
    	else if (bits > 5)
    		res = float(bits & 1);
    	else
    		res = mix(ep0, ep1, (1.0 / 5.0) * float(bits - 1));
    
    	return res;
    }
    
    #endif
  + s3tc.comp
    #version 450
    /* Copyright (c) 2020-2024 Hans-Kristian Arntzen
     *
     * 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.
    
    #extension GL_EXT_samplerless_texture_functions : require
    layout(local_size_x = 4, local_size_y = 4, local_size_z = 4) in;
    
    #include "rgtc.h"
    
    layout(set = 0, binding = 0, rgba8) writeonly uniform image2D uOutput;
    layout(set = 0, binding = 1) uniform utexture2D uInput;
    
    layout(push_constant) uniform Registers
    {
        ivec2 resolution;
    } registers;
    
    layout(constant_id = 0) const bool USE_ALPHA = false;
    layout(constant_id = 1) const int BC_VERSION = 1;
    
    vec3 decode_endpoint_color(uint color)
    {
        ivec3 c = ivec3(color) >> ivec3(11, 5, 0);
        c &= ivec3(31, 63, 31);
        return vec3(c) / vec3(31.0, 63.0, 31.0);
    }
    
    bool decode_endpoints_color(uint payload, out vec3 ep0, out vec3 ep1)
    {
        uint color0 = payload & 0xffffu;
        uint color1 = payload >> 16u;
        bool opaque_mode = (BC_VERSION > 1) || (color0 > color1);
        ep0 = decode_endpoint_color(color0);
        ep1 = decode_endpoint_color(color1);
        return opaque_mode;
    }
    
    vec4 interpolate_endpoint_color(vec3 ep0, vec3 ep1, int bits, bool opaque_mode)
    {
        vec4 res;
        vec3 lerped;
        if (opaque_mode)
        {
            if (bits < 2)
                lerped = bits != 0 ? ep1 : ep0;
            else
                lerped = mix(ep0, ep1, (1.0 / 3.0) * float(bits - 1));
            res = vec4(lerped, 1.0);
        }
        else
        {
            if (bits == 3)
            {
                res = vec4(0);
            }
            else
            {
                if (bits == 0)
                    lerped = ep0;
                else if (bits == 1)
                    lerped = ep1;
                else
                    lerped = 0.5 * (ep0 + ep1);
                res = vec4(lerped, 1.0);
            }
        }
    
        return res;
    }
    
    float decode_alpha_4bit(uvec2 payload, int pixel)
    {
        uint offset = pixel * 4;
        return float((payload[offset >> 5] >> (offset & 31)) & 0xf) / 15.0;
    }
    
    ivec2 build_coord()
    {
        ivec2 base = ivec2(gl_WorkGroupID.xy) * 8;
        base.x += 4 * (int(gl_LocalInvocationID.z) & 1);
        base.y += 2 * (int(gl_LocalInvocationID.z) & 2);
        base += ivec2(gl_LocalInvocationID.xy);
        return base;
    }
    
    void main()
    {
        ivec2 coord = build_coord();
        if (any(greaterThanEqual(coord, registers.resolution)))
            return;
    
        ivec2 tile_coord = coord >> 2;
        ivec2 pixel_coord = coord & 3;
        int linear_pixel = 4 * pixel_coord.y + pixel_coord.x;
        uvec4 payload = texelFetch(uInput, tile_coord, 0);
    
        uvec2 color_payload, alpha_payload;
        if (BC_VERSION == 1)
            color_payload = payload.xy;
        else
            color_payload = payload.zw;
    
        float alpha;
        if (BC_VERSION > 1)
        {
            alpha_payload = payload.xy;
            int ep0, ep1;
            if (BC_VERSION == 2)
                alpha = decode_alpha_4bit(alpha_payload, linear_pixel);
            else
                alpha = decode_alpha_rgtc(alpha_payload, linear_pixel);
        }
    
        vec3 ep0, ep1;
        bool opaque_mode = decode_endpoints_color(color_payload.x, ep0, ep1);
        vec4 decoded = interpolate_endpoint_color(ep0, ep1, int((color_payload.y >> (2 * linear_pixel)) & 3), opaque_mode);
        if (!USE_ALPHA)
            decoded.a = 1.0;
        else if (BC_VERSION > 1)
            decoded.a = alpha;
    
        imageStore(uOutput, coord, decoded);
    }