zenjpeg 0.8.3

//! Pre-trained Huffman tables (CLIC 2025, 32 images)
//! Generated: 2026-01-28
//! Overhead: ~2-2.5% vs optimal, ~3-4% better than standard

#![allow(dead_code)] // Table library — consumers select by quality level
use crate::huffman::optimize::{HuffmanTableSet, OptimizedTable};

pub fn trained_tables_q0() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [1, 1, 1, 1, 1, 1, 0, 1, 5, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [1, 0, 2, 2, 1, 2, 5, 2, 4, 3, 3, 3, 4, 2, 7, 121],
            vec![
                0, 1, 2, 3, 17, 18, 33, 49, 4, 19, 34, 65, 81, 50, 97, 20, 66, 82, 113, 51, 98,
                129, 35, 145, 177, 114, 161, 193, 5, 130, 209, 240, 67, 83, 6, 7, 36, 99, 146, 225,
                241, 8, 9, 10, 21, 22, 23, 24, 25, 26, 37, 38, 39, 40, 41, 42, 52, 53, 54, 55, 56,
                57, 58, 68, 69, 70, 71, 72, 73, 74, 84, 85, 86, 87, 88, 89, 90, 100, 101, 102, 103,
                104, 105, 106, 115, 116, 117, 118, 119, 120, 121, 122, 131, 132, 133, 134, 135,
                136, 137, 138, 147, 148, 149, 150, 151, 152, 153, 154, 162, 163, 164, 165, 166,
                167, 168, 169, 170, 178, 179, 180, 181, 182, 183, 184, 185, 186, 194, 195, 196,
                197, 198, 199, 200, 201, 202, 210, 211, 212, 213, 214, 215, 216, 217, 218, 226,
                227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [1, 1, 1, 1, 1, 1, 0, 1, 5, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [1, 0, 2, 2, 1, 3, 3, 2, 4, 3, 3, 1, 3, 0, 49, 85],
            vec![
                0, 1, 2, 17, 18, 49, 3, 19, 33, 65, 81, 97, 34, 50, 4, 82, 113, 129, 20, 66, 98,
                130, 145, 161, 193, 177, 209, 240, 5, 6, 7, 8, 9, 10, 21, 22, 23, 24, 25, 26, 35,
                36, 37, 38, 39, 40, 41, 42, 51, 52, 53, 54, 55, 56, 57, 58, 67, 68, 69, 70, 71, 72,
                73, 74, 83, 84, 85, 86, 87, 88, 89, 90, 99, 100, 101, 225, 241, 102, 103, 104, 105,
                106, 114, 115, 116, 117, 118, 119, 120, 121, 122, 131, 132, 133, 134, 135, 136,
                137, 138, 146, 147, 148, 149, 150, 151, 152, 153, 154, 162, 163, 164, 165, 166,
                167, 168, 169, 170, 178, 179, 180, 181, 182, 183, 184, 185, 186, 194, 195, 196,
                197, 198, 199, 200, 201, 202, 210, 211, 212, 213, 214, 215, 216, 217, 218, 226,
                227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q5() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [1, 1, 1, 1, 1, 1, 0, 1, 5, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [1, 0, 2, 2, 1, 3, 3, 2, 4, 2, 5, 4, 2, 3, 3, 125],
            vec![
                0, 1, 2, 3, 17, 18, 4, 33, 49, 19, 34, 65, 50, 81, 20, 66, 82, 97, 113, 129, 5, 35,
                51, 98, 145, 114, 161, 177, 193, 130, 240, 67, 83, 209, 36, 146, 225, 6, 7, 8, 9,
                10, 21, 22, 23, 24, 25, 26, 37, 38, 39, 40, 41, 42, 52, 53, 54, 55, 56, 57, 58, 68,
                69, 70, 71, 72, 73, 74, 84, 85, 86, 87, 88, 89, 90, 99, 100, 101, 102, 103, 104,
                105, 106, 115, 116, 117, 118, 119, 120, 121, 122, 131, 132, 133, 134, 135, 136,
                137, 138, 147, 148, 149, 150, 151, 152, 153, 154, 162, 163, 164, 165, 166, 167,
                168, 169, 170, 178, 179, 180, 181, 182, 183, 184, 185, 186, 194, 195, 196, 197,
                198, 199, 200, 201, 202, 210, 211, 212, 213, 214, 215, 216, 217, 218, 226, 227,
                228, 229, 230, 231, 232, 233, 234, 241, 242, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [1, 1, 1, 1, 1, 1, 0, 1, 5, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [1, 0, 2, 2, 2, 1, 3, 2, 4, 3, 3, 3, 1, 2, 26, 107],
            vec![
                0, 1, 2, 17, 18, 3, 49, 33, 19, 65, 81, 50, 97, 4, 34, 113, 129, 20, 66, 82, 98,
                145, 161, 130, 193, 240, 177, 51, 209, 5, 6, 7, 8, 9, 10, 21, 22, 23, 24, 25, 26,
                35, 36, 37, 38, 39, 40, 41, 42, 52, 53, 54, 114, 225, 241, 55, 56, 57, 58, 67, 68,
                69, 70, 71, 72, 73, 74, 83, 84, 85, 86, 87, 88, 89, 90, 99, 100, 101, 102, 103,
                104, 105, 106, 115, 116, 117, 118, 119, 120, 121, 122, 131, 132, 133, 134, 135,
                136, 137, 138, 146, 147, 148, 149, 150, 151, 152, 153, 154, 162, 163, 164, 165,
                166, 167, 168, 169, 170, 178, 179, 180, 181, 182, 183, 184, 185, 186, 194, 195,
                196, 197, 198, 199, 200, 201, 202, 210, 211, 212, 213, 214, 215, 216, 217, 218,
                226, 227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248,
                249, 250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q10() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [1, 1, 1, 1, 1, 1, 1, 0, 2, 3, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [1, 0, 2, 2, 1, 3, 2, 3, 6, 2, 5, 2, 7, 2, 3, 121],
            vec![
                0, 1, 2, 3, 17, 18, 4, 33, 49, 19, 34, 50, 65, 81, 5, 20, 66, 82, 97, 113, 35, 129,
                51, 98, 145, 161, 177, 114, 193, 21, 52, 67, 83, 130, 209, 240, 146, 225, 36, 162,
                241, 6, 7, 8, 9, 10, 22, 23, 24, 25, 26, 37, 38, 39, 40, 41, 42, 53, 54, 55, 56,
                57, 58, 68, 69, 70, 71, 72, 73, 74, 84, 85, 86, 87, 88, 89, 90, 99, 100, 101, 102,
                103, 104, 105, 106, 115, 116, 117, 118, 119, 120, 121, 122, 131, 132, 133, 134,
                135, 136, 137, 138, 147, 148, 149, 150, 151, 152, 153, 154, 163, 164, 165, 166,
                167, 168, 169, 170, 178, 179, 180, 181, 182, 183, 184, 185, 186, 194, 195, 196,
                197, 198, 199, 200, 201, 202, 210, 211, 212, 213, 214, 215, 216, 217, 218, 226,
                227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [1, 1, 1, 1, 1, 1, 0, 1, 5, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [1, 0, 2, 2, 1, 2, 4, 4, 4, 3, 2, 4, 4, 2, 24, 103],
            vec![
                0, 1, 2, 17, 18, 3, 33, 49, 19, 65, 81, 97, 4, 34, 50, 113, 20, 66, 82, 129, 98,
                145, 161, 193, 240, 5, 51, 130, 177, 35, 114, 209, 225, 21, 241, 6, 7, 8, 9, 10,
                22, 23, 24, 25, 26, 36, 37, 38, 39, 40, 41, 42, 52, 53, 54, 55, 56, 67, 83, 57, 58,
                68, 69, 70, 71, 72, 73, 74, 84, 85, 86, 87, 88, 89, 90, 99, 100, 101, 102, 103,
                104, 105, 106, 115, 116, 117, 118, 119, 120, 121, 122, 131, 132, 133, 134, 135,
                136, 137, 138, 146, 147, 148, 149, 150, 151, 152, 153, 154, 162, 163, 164, 165,
                166, 167, 168, 169, 170, 178, 179, 180, 181, 182, 183, 184, 185, 186, 194, 195,
                196, 197, 198, 199, 200, 201, 202, 210, 211, 212, 213, 214, 215, 216, 217, 218,
                226, 227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248,
                249, 250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q15() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [1, 1, 1, 1, 1, 1, 1, 0, 2, 3, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [1, 0, 2, 2, 1, 2, 4, 3, 5, 3, 6, 5, 5, 3, 3, 117],
            vec![
                0, 1, 2, 3, 17, 18, 4, 33, 19, 34, 49, 65, 5, 50, 81, 20, 66, 82, 97, 113, 35, 129,
                145, 21, 51, 98, 114, 161, 177, 52, 83, 130, 193, 240, 67, 146, 178, 209, 225, 6,
                36, 162, 99, 194, 241, 7, 8, 9, 10, 22, 23, 24, 25, 26, 37, 38, 39, 40, 41, 42, 53,
                54, 55, 56, 57, 58, 68, 69, 70, 71, 72, 73, 74, 84, 85, 86, 87, 88, 89, 90, 100,
                101, 102, 103, 104, 105, 106, 115, 116, 117, 118, 119, 120, 121, 122, 131, 132,
                133, 134, 135, 136, 137, 138, 147, 148, 149, 150, 151, 152, 153, 154, 163, 164,
                165, 166, 167, 168, 169, 170, 179, 180, 181, 182, 183, 184, 185, 186, 195, 196,
                197, 198, 199, 200, 201, 202, 210, 211, 212, 213, 214, 215, 216, 217, 218, 226,
                227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [1, 1, 1, 1, 1, 1, 1, 0, 2, 3, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [1, 0, 2, 1, 4, 0, 4, 3, 5, 3, 4, 2, 5, 2, 113, 13],
            vec![
                0, 1, 2, 17, 3, 18, 33, 49, 4, 19, 65, 81, 34, 50, 97, 20, 66, 82, 113, 129, 98,
                145, 161, 5, 177, 193, 240, 35, 51, 21, 83, 114, 209, 225, 130, 241, 6, 7, 8, 9,
                10, 22, 23, 24, 25, 26, 36, 37, 38, 39, 40, 41, 42, 52, 53, 54, 55, 56, 57, 58, 67,
                68, 69, 70, 71, 72, 73, 74, 84, 85, 86, 87, 88, 89, 90, 99, 100, 101, 102, 103,
                104, 105, 106, 115, 116, 117, 118, 119, 120, 121, 122, 131, 132, 133, 134, 135,
                136, 137, 138, 146, 147, 148, 149, 150, 151, 152, 153, 154, 162, 163, 164, 165,
                166, 167, 168, 169, 170, 178, 179, 180, 181, 182, 183, 184, 185, 186, 194, 195,
                196, 197, 198, 199, 200, 201, 202, 210, 211, 212, 213, 214, 215, 216, 217, 218,
                226, 227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248,
                249, 250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q20() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [1, 0, 3, 1, 1, 1, 1, 0, 3, 1, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 2, 2, 1, 2, 3, 5, 5, 4, 5, 7, 4, 3, 4, 4, 111],
            vec![
                0, 1, 2, 3, 17, 4, 18, 19, 33, 49, 5, 34, 50, 65, 81, 20, 66, 82, 97, 113, 35, 129,
                145, 161, 21, 51, 98, 114, 177, 6, 52, 83, 130, 193, 209, 240, 67, 146, 178, 225,
                36, 162, 241, 99, 115, 194, 210, 7, 8, 9, 226, 10, 22, 23, 24, 25, 26, 37, 38, 39,
                40, 41, 42, 53, 54, 55, 56, 57, 58, 68, 69, 70, 71, 72, 73, 74, 84, 85, 86, 87, 88,
                89, 90, 100, 101, 102, 103, 104, 105, 106, 116, 117, 118, 119, 120, 121, 122, 131,
                132, 133, 134, 135, 136, 137, 138, 147, 148, 149, 150, 151, 152, 153, 154, 163,
                164, 165, 166, 167, 168, 169, 170, 179, 180, 181, 182, 183, 184, 185, 186, 195,
                196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217, 218, 227,
                228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248, 249, 250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [1, 1, 1, 1, 1, 1, 1, 0, 2, 3, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [1, 0, 2, 1, 3, 1, 6, 3, 5, 4, 5, 4, 1, 2, 19, 105],
            vec![
                0, 1, 2, 17, 3, 18, 33, 49, 4, 19, 34, 65, 81, 97, 50, 113, 129, 20, 66, 82, 145,
                161, 5, 98, 177, 240, 21, 35, 51, 193, 209, 83, 114, 225, 241, 130, 67, 99, 6, 7,
                8, 9, 10, 22, 23, 24, 25, 26, 36, 37, 38, 39, 40, 41, 42, 52, 146, 53, 54, 55, 56,
                57, 58, 68, 69, 70, 71, 72, 73, 74, 84, 85, 86, 87, 88, 89, 90, 100, 101, 102, 103,
                104, 105, 106, 115, 116, 117, 118, 119, 120, 121, 122, 131, 132, 133, 134, 135,
                136, 137, 138, 147, 148, 149, 150, 151, 152, 153, 154, 162, 163, 164, 165, 166,
                167, 168, 169, 170, 178, 179, 180, 181, 182, 183, 184, 185, 186, 194, 195, 196,
                197, 198, 199, 200, 201, 202, 210, 211, 212, 213, 214, 215, 216, 217, 218, 226,
                227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q25() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 2, 3, 1, 1, 1, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 2, 2, 1, 2, 3, 5, 3, 7, 5, 7, 5, 4, 3, 113, 0],
            vec![
                0, 1, 2, 3, 17, 4, 18, 5, 33, 49, 19, 34, 50, 65, 81, 66, 97, 113, 6, 20, 35, 82,
                129, 145, 161, 21, 51, 98, 114, 177, 83, 130, 178, 193, 209, 225, 240, 36, 52, 67,
                146, 162, 22, 115, 194, 241, 53, 99, 210, 7, 8, 9, 10, 23, 24, 25, 26, 37, 38, 39,
                40, 41, 42, 54, 55, 56, 57, 58, 68, 69, 70, 71, 72, 73, 74, 84, 85, 86, 87, 88, 89,
                90, 100, 101, 102, 103, 104, 105, 106, 116, 117, 118, 119, 120, 121, 122, 131, 132,
                133, 134, 135, 136, 137, 138, 147, 148, 149, 150, 151, 152, 153, 154, 163, 164,
                165, 166, 167, 168, 169, 170, 179, 180, 181, 182, 183, 184, 185, 186, 195, 196,
                197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217, 218, 226, 227,
                228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248, 249, 250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [1, 1, 1, 1, 1, 1, 1, 0, 2, 3, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [1, 0, 2, 1, 3, 1, 6, 3, 6, 2, 5, 5, 0, 5, 1, 121],
            vec![
                0, 1, 2, 17, 3, 18, 33, 49, 4, 19, 34, 65, 81, 97, 50, 113, 129, 5, 20, 66, 82,
                145, 161, 98, 177, 21, 51, 193, 209, 240, 35, 83, 114, 225, 241, 6, 67, 99, 130,
                146, 162, 7, 8, 9, 10, 22, 23, 24, 25, 26, 36, 37, 38, 39, 40, 41, 42, 52, 53, 54,
                55, 56, 57, 58, 68, 69, 70, 71, 72, 73, 74, 84, 85, 86, 87, 88, 89, 90, 100, 101,
                102, 103, 104, 105, 106, 115, 116, 117, 118, 119, 120, 121, 122, 131, 132, 133,
                134, 135, 136, 137, 138, 147, 148, 149, 150, 151, 152, 153, 154, 163, 164, 165,
                166, 167, 168, 169, 170, 178, 179, 180, 181, 182, 183, 184, 185, 186, 194, 195,
                196, 197, 198, 199, 200, 201, 202, 210, 211, 212, 213, 214, 215, 216, 217, 218,
                226, 227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248,
                249, 250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q30() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 2, 3, 1, 1, 1, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 2, 2, 1, 2, 3, 5, 3, 7, 7, 7, 4, 4, 3, 3, 109],
            vec![
                0, 1, 2, 3, 17, 4, 18, 5, 33, 49, 19, 34, 50, 65, 81, 66, 97, 113, 6, 20, 35, 82,
                129, 145, 161, 21, 51, 98, 114, 177, 193, 240, 67, 83, 130, 146, 178, 209, 225, 36,
                52, 162, 241, 22, 115, 194, 210, 53, 99, 226, 7, 68, 84, 8, 9, 10, 23, 24, 25, 26,
                37, 38, 39, 40, 41, 42, 54, 55, 56, 57, 58, 69, 70, 71, 72, 73, 74, 85, 86, 87, 88,
                89, 90, 100, 101, 102, 103, 104, 105, 106, 116, 117, 118, 119, 120, 121, 122, 131,
                132, 133, 134, 135, 136, 137, 138, 147, 148, 149, 150, 151, 152, 153, 154, 163,
                164, 165, 166, 167, 168, 169, 170, 179, 180, 181, 182, 183, 184, 185, 186, 195,
                196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217, 218, 227,
                228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248, 249, 250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [1, 1, 1, 1, 1, 1, 1, 1, 0, 3, 1, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [1, 0, 2, 1, 2, 4, 4, 2, 7, 2, 5, 5, 3, 2, 117, 5],
            vec![
                0, 1, 2, 17, 3, 18, 4, 33, 49, 65, 19, 34, 81, 97, 50, 113, 5, 20, 66, 82, 129,
                145, 161, 98, 177, 21, 193, 209, 225, 240, 35, 51, 83, 114, 241, 6, 130, 146, 67,
                99, 7, 8, 9, 10, 22, 23, 24, 25, 26, 36, 37, 38, 39, 40, 41, 42, 52, 53, 54, 55,
                56, 57, 58, 68, 69, 70, 71, 72, 73, 74, 84, 85, 86, 87, 88, 89, 90, 100, 101, 102,
                103, 104, 105, 106, 115, 116, 117, 118, 119, 120, 121, 122, 131, 132, 133, 134,
                135, 136, 137, 138, 147, 148, 149, 150, 151, 152, 153, 154, 162, 163, 164, 165,
                166, 167, 168, 169, 170, 178, 179, 180, 181, 182, 183, 184, 185, 186, 194, 195,
                196, 197, 198, 199, 200, 201, 202, 210, 211, 212, 213, 214, 215, 216, 217, 218,
                226, 227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248,
                249, 250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q35() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 2, 3, 1, 1, 1, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 3, 3, 1, 5, 3, 7, 8, 6, 5, 4, 5, 1, 5, 105],
            vec![
                0, 1, 2, 3, 4, 17, 18, 33, 5, 19, 34, 49, 65, 50, 81, 97, 6, 20, 66, 82, 113, 129,
                145, 35, 51, 98, 114, 161, 177, 193, 240, 21, 83, 130, 146, 209, 225, 36, 52, 67,
                162, 178, 22, 115, 194, 241, 53, 99, 179, 210, 226, 7, 37, 68, 84, 131, 242, 8, 9,
                10, 23, 24, 25, 26, 38, 39, 40, 41, 42, 54, 55, 56, 57, 58, 69, 70, 71, 72, 73, 74,
                85, 86, 87, 88, 89, 90, 100, 101, 102, 103, 104, 105, 106, 116, 117, 118, 119, 120,
                121, 122, 132, 133, 134, 135, 136, 137, 138, 147, 148, 149, 150, 151, 152, 153,
                154, 163, 164, 165, 166, 167, 168, 169, 170, 180, 181, 182, 183, 184, 185, 186,
                195, 196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217, 218,
                227, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249, 250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [1, 1, 1, 1, 1, 1, 1, 1, 0, 3, 1, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [1, 0, 2, 1, 2, 3, 5, 4, 5, 6, 6, 3, 3, 2, 119, 0],
            vec![
                0, 1, 2, 17, 3, 18, 4, 33, 49, 19, 34, 65, 81, 97, 5, 50, 113, 129, 20, 66, 82,
                145, 161, 21, 98, 177, 193, 209, 240, 6, 35, 51, 83, 114, 225, 130, 146, 241, 22,
                67, 99, 7, 162, 8, 9, 10, 23, 24, 25, 26, 36, 37, 38, 39, 40, 41, 42, 52, 53, 54,
                55, 56, 57, 58, 68, 69, 70, 71, 72, 73, 74, 84, 85, 86, 87, 88, 89, 90, 100, 101,
                102, 103, 104, 105, 106, 115, 116, 117, 118, 119, 120, 121, 122, 131, 132, 133,
                134, 135, 136, 137, 138, 147, 148, 149, 150, 151, 152, 153, 154, 163, 164, 165,
                166, 167, 168, 169, 170, 178, 179, 180, 181, 182, 183, 184, 185, 186, 194, 195,
                196, 197, 198, 199, 200, 201, 202, 210, 211, 212, 213, 214, 215, 216, 217, 218,
                226, 227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248,
                249, 250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q40() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 2, 3, 1, 1, 1, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 3, 3, 1, 5, 3, 7, 8, 6, 4, 6, 5, 2, 3, 105],
            vec![
                0, 1, 2, 3, 4, 17, 18, 33, 5, 19, 34, 49, 65, 50, 81, 97, 6, 20, 66, 82, 113, 129,
                145, 35, 51, 98, 114, 161, 177, 193, 240, 21, 83, 130, 146, 209, 225, 36, 67, 162,
                178, 22, 52, 115, 194, 210, 241, 53, 99, 131, 179, 226, 7, 84, 37, 68, 147, 8, 9,
                10, 23, 24, 25, 26, 38, 39, 40, 41, 42, 54, 55, 56, 57, 58, 69, 70, 71, 72, 73, 74,
                85, 86, 87, 88, 89, 90, 100, 101, 102, 103, 104, 105, 106, 116, 117, 118, 119, 120,
                121, 122, 132, 133, 134, 135, 136, 137, 138, 148, 149, 150, 151, 152, 153, 154,
                163, 164, 165, 166, 167, 168, 169, 170, 180, 181, 182, 183, 184, 185, 186, 195,
                196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217, 218, 227,
                228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248, 249, 250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [1, 1, 1, 1, 1, 1, 1, 1, 0, 3, 1, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [1, 0, 2, 1, 2, 3, 5, 4, 5, 6, 6, 3, 3, 2, 119, 0],
            vec![
                0, 1, 2, 17, 3, 18, 4, 33, 49, 19, 34, 65, 81, 97, 5, 50, 113, 129, 20, 66, 82,
                145, 161, 21, 98, 177, 193, 209, 240, 35, 51, 83, 114, 225, 241, 6, 130, 146, 67,
                99, 162, 22, 36, 7, 8, 9, 10, 23, 24, 25, 26, 37, 38, 39, 40, 41, 42, 52, 53, 54,
                55, 56, 57, 58, 68, 69, 70, 71, 72, 73, 74, 84, 85, 86, 87, 88, 89, 90, 100, 101,
                102, 103, 104, 105, 106, 115, 116, 117, 118, 119, 120, 121, 122, 131, 132, 133,
                134, 135, 136, 137, 138, 147, 148, 149, 150, 151, 152, 153, 154, 163, 164, 165,
                166, 167, 168, 169, 170, 178, 179, 180, 181, 182, 183, 184, 185, 186, 194, 195,
                196, 197, 198, 199, 200, 201, 202, 210, 211, 212, 213, 214, 215, 216, 217, 218,
                226, 227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248,
                249, 250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q45() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 2, 3, 1, 1, 1, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 3, 3, 1, 5, 3, 7, 8, 6, 4, 6, 5, 2, 3, 105],
            vec![
                0, 1, 2, 3, 4, 17, 18, 33, 5, 19, 34, 49, 65, 50, 81, 97, 6, 20, 66, 82, 113, 129,
                145, 35, 98, 114, 161, 177, 193, 209, 240, 21, 51, 83, 130, 146, 225, 67, 162, 178,
                241, 22, 36, 52, 115, 194, 210, 53, 99, 131, 179, 226, 7, 84, 37, 68, 147, 8, 9,
                10, 23, 24, 25, 26, 38, 39, 40, 41, 42, 54, 55, 56, 57, 58, 69, 70, 71, 72, 73, 74,
                85, 86, 87, 88, 89, 90, 100, 101, 102, 103, 104, 105, 106, 116, 117, 118, 119, 120,
                121, 122, 132, 133, 134, 135, 136, 137, 138, 148, 149, 150, 151, 152, 153, 154,
                163, 164, 165, 166, 167, 168, 169, 170, 180, 181, 182, 183, 184, 185, 186, 195,
                196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217, 218, 227,
                228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248, 249, 250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [1, 1, 1, 1, 1, 1, 1, 1, 0, 3, 1, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [1, 0, 2, 1, 2, 3, 5, 4, 5, 7, 4, 4, 1, 3, 115, 5],
            vec![
                0, 1, 2, 17, 3, 18, 4, 33, 49, 19, 34, 65, 81, 97, 5, 50, 113, 129, 20, 66, 82,
                145, 161, 21, 98, 177, 193, 209, 225, 240, 35, 51, 83, 114, 6, 130, 146, 241, 67,
                22, 99, 162, 7, 8, 9, 10, 23, 24, 25, 26, 36, 37, 38, 39, 40, 41, 42, 52, 53, 54,
                55, 56, 57, 58, 68, 69, 70, 71, 72, 73, 74, 84, 85, 86, 87, 88, 89, 90, 100, 101,
                102, 103, 104, 105, 106, 115, 116, 117, 118, 119, 120, 121, 122, 131, 132, 133,
                134, 135, 136, 137, 138, 147, 148, 149, 150, 151, 152, 153, 154, 163, 164, 165,
                166, 167, 168, 169, 170, 178, 179, 180, 181, 182, 183, 184, 185, 186, 194, 195,
                196, 197, 198, 199, 200, 201, 202, 210, 211, 212, 213, 214, 215, 216, 217, 218,
                226, 227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248,
                249, 250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q50() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 2, 3, 1, 1, 1, 1, 0, 3, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 3, 3, 1, 5, 3, 7, 7, 6, 5, 6, 5, 2, 99, 9],
            vec![
                0, 1, 2, 3, 4, 17, 18, 33, 5, 19, 34, 49, 65, 50, 81, 97, 6, 20, 66, 82, 113, 129,
                145, 35, 98, 161, 177, 193, 209, 240, 21, 51, 114, 130, 146, 225, 67, 83, 162, 178,
                241, 22, 36, 52, 115, 194, 210, 53, 99, 131, 179, 226, 7, 84, 8, 9, 10, 23, 24, 25,
                26, 37, 38, 39, 40, 41, 42, 54, 55, 56, 57, 58, 68, 69, 70, 71, 72, 73, 74, 85, 86,
                87, 88, 89, 90, 100, 101, 102, 103, 104, 105, 106, 116, 117, 118, 119, 120, 121,
                122, 132, 133, 134, 135, 136, 137, 138, 147, 148, 149, 150, 151, 152, 153, 154,
                163, 164, 165, 166, 167, 168, 169, 170, 180, 181, 182, 183, 184, 185, 186, 195,
                196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217, 218, 227,
                228, 229, 230, 231, 232, 233, 242, 234, 243, 244, 245, 246, 247, 248, 249, 250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [1, 1, 1, 1, 1, 1, 1, 1, 0, 3, 1, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [1, 0, 2, 1, 2, 3, 5, 4, 5, 6, 6, 3, 3, 2, 119, 0],
            vec![
                0, 1, 2, 17, 3, 18, 4, 33, 49, 19, 34, 65, 81, 97, 5, 50, 113, 129, 20, 66, 82,
                145, 161, 21, 98, 177, 193, 209, 240, 6, 35, 51, 83, 114, 225, 130, 146, 241, 67,
                99, 162, 22, 52, 7, 8, 9, 10, 23, 24, 25, 26, 36, 37, 38, 39, 40, 41, 42, 53, 54,
                55, 56, 57, 58, 68, 69, 70, 71, 72, 73, 74, 84, 85, 86, 87, 88, 89, 90, 100, 101,
                102, 103, 104, 105, 106, 115, 116, 117, 118, 119, 120, 121, 122, 131, 132, 133,
                134, 135, 136, 137, 138, 147, 148, 149, 150, 151, 152, 153, 154, 163, 164, 165,
                166, 167, 168, 169, 170, 178, 179, 180, 181, 182, 183, 184, 185, 186, 194, 195,
                196, 197, 198, 199, 200, 201, 202, 210, 211, 212, 213, 214, 215, 216, 217, 218,
                226, 227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248,
                249, 250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q55() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 2, 3, 1, 1, 1, 1, 0, 3, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 3, 3, 1, 5, 3, 7, 8, 5, 6, 6, 5, 2, 4, 103],
            vec![
                0, 1, 2, 3, 4, 17, 18, 33, 5, 19, 34, 49, 65, 50, 81, 97, 6, 20, 66, 82, 113, 129,
                145, 35, 98, 114, 161, 177, 193, 209, 240, 21, 51, 130, 146, 225, 36, 67, 83, 162,
                178, 241, 7, 22, 52, 115, 194, 210, 53, 99, 131, 179, 226, 68, 84, 37, 116, 147,
                242, 8, 9, 10, 23, 24, 25, 26, 38, 39, 40, 41, 42, 54, 55, 56, 57, 58, 69, 70, 71,
                72, 73, 74, 85, 86, 87, 88, 89, 90, 100, 101, 102, 103, 104, 105, 106, 117, 118,
                119, 120, 121, 122, 132, 133, 134, 135, 136, 137, 138, 148, 149, 150, 151, 152,
                153, 154, 163, 164, 165, 166, 167, 168, 169, 170, 180, 181, 182, 183, 184, 185,
                186, 195, 196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217,
                218, 227, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [1, 1, 1, 1, 1, 1, 1, 1, 0, 3, 1, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [1, 0, 2, 1, 2, 3, 5, 4, 6, 6, 5, 5, 1, 3, 5, 113],
            vec![
                0, 1, 2, 17, 3, 18, 4, 33, 49, 19, 34, 65, 81, 97, 5, 50, 113, 129, 20, 66, 82,
                145, 161, 177, 21, 98, 193, 209, 225, 240, 6, 35, 51, 83, 114, 99, 130, 146, 162,
                241, 67, 22, 52, 84, 7, 8, 9, 36, 178, 10, 23, 24, 25, 26, 37, 38, 39, 40, 41, 42,
                53, 54, 55, 56, 57, 58, 68, 69, 70, 71, 72, 73, 74, 85, 86, 87, 88, 89, 90, 100,
                101, 102, 103, 104, 105, 106, 115, 116, 117, 118, 119, 120, 121, 122, 131, 132,
                133, 134, 135, 136, 137, 138, 147, 148, 149, 150, 151, 152, 153, 154, 163, 164,
                165, 166, 167, 168, 169, 170, 179, 180, 181, 182, 183, 184, 185, 186, 194, 195,
                196, 197, 198, 199, 200, 201, 202, 210, 211, 212, 213, 214, 215, 216, 217, 218,
                226, 227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248,
                249, 250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q60() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 2, 3, 1, 1, 1, 1, 0, 3, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 3, 3, 1, 5, 3, 7, 8, 5, 6, 5, 7, 3, 2, 103],
            vec![
                0, 1, 2, 3, 4, 17, 18, 33, 5, 19, 34, 49, 65, 50, 81, 97, 6, 20, 66, 82, 113, 129,
                145, 35, 98, 114, 161, 177, 193, 209, 240, 21, 51, 130, 146, 225, 36, 67, 83, 162,
                178, 241, 22, 52, 179, 194, 210, 7, 53, 84, 99, 115, 131, 226, 68, 116, 147, 37,
                242, 8, 9, 10, 23, 24, 25, 26, 38, 39, 40, 41, 42, 54, 55, 56, 57, 58, 69, 70, 71,
                72, 73, 74, 85, 86, 87, 88, 89, 90, 100, 101, 102, 103, 104, 105, 106, 117, 118,
                119, 120, 121, 122, 132, 133, 134, 135, 136, 137, 138, 148, 149, 150, 151, 152,
                153, 154, 163, 164, 165, 166, 167, 168, 169, 170, 180, 181, 182, 183, 184, 185,
                186, 195, 196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217,
                218, 227, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [1, 1, 1, 1, 1, 1, 1, 1, 0, 3, 1, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [1, 0, 2, 1, 2, 3, 5, 4, 6, 6, 5, 4, 3, 3, 6, 111],
            vec![
                0, 1, 2, 17, 3, 18, 4, 33, 49, 19, 34, 65, 81, 97, 5, 50, 113, 129, 20, 66, 82,
                145, 161, 177, 35, 98, 193, 209, 225, 240, 6, 21, 51, 83, 114, 130, 146, 162, 241,
                22, 67, 99, 52, 84, 178, 7, 8, 9, 36, 194, 210, 10, 23, 24, 25, 26, 37, 38, 39, 40,
                41, 42, 53, 54, 55, 56, 57, 58, 68, 69, 70, 71, 72, 73, 74, 85, 86, 87, 88, 89, 90,
                100, 101, 102, 103, 104, 105, 106, 115, 116, 117, 118, 119, 120, 121, 122, 131,
                132, 133, 134, 135, 136, 137, 138, 147, 148, 149, 150, 151, 152, 153, 154, 163,
                164, 165, 166, 167, 168, 169, 170, 179, 180, 181, 182, 183, 184, 185, 186, 195,
                196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217, 218, 226,
                227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q65() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 2, 3, 1, 1, 1, 1, 0, 3, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 3, 2, 3, 4, 5, 8, 6, 4, 8, 6, 5, 3, 3, 101],
            vec![
                0, 1, 2, 3, 4, 17, 5, 18, 33, 19, 34, 49, 65, 6, 50, 81, 97, 113, 20, 66, 82, 129,
                145, 161, 177, 240, 35, 51, 98, 114, 193, 209, 21, 130, 146, 225, 7, 36, 67, 83,
                162, 178, 194, 241, 22, 52, 115, 179, 210, 226, 53, 84, 99, 116, 131, 37, 68, 147,
                8, 163, 242, 9, 10, 23, 24, 25, 26, 38, 39, 40, 41, 42, 54, 55, 56, 57, 58, 69, 70,
                71, 72, 73, 74, 85, 86, 87, 88, 89, 90, 100, 101, 102, 103, 104, 105, 106, 117,
                118, 119, 120, 121, 122, 132, 133, 134, 135, 136, 137, 138, 148, 149, 150, 151,
                152, 153, 154, 164, 165, 166, 167, 168, 169, 170, 180, 181, 182, 183, 184, 185,
                186, 195, 196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217,
                218, 227, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 3, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [1, 0, 2, 1, 2, 3, 5, 4, 5, 6, 5, 5, 3, 3, 117, 0],
            vec![
                0, 1, 2, 17, 3, 18, 4, 33, 49, 19, 34, 65, 81, 97, 5, 50, 113, 129, 20, 66, 82,
                145, 161, 35, 98, 177, 193, 209, 240, 6, 21, 51, 114, 225, 83, 130, 146, 162, 241,
                67, 84, 99, 22, 52, 178, 7, 8, 9, 10, 23, 24, 25, 26, 36, 37, 38, 39, 40, 41, 42,
                53, 54, 55, 56, 57, 58, 68, 69, 70, 71, 72, 73, 74, 85, 86, 87, 88, 89, 90, 100,
                101, 102, 103, 104, 105, 106, 115, 116, 117, 118, 119, 120, 121, 122, 131, 132,
                133, 134, 135, 136, 137, 138, 147, 148, 149, 150, 151, 152, 153, 154, 163, 164,
                165, 166, 167, 168, 169, 170, 179, 180, 181, 182, 183, 184, 185, 186, 194, 195,
                196, 197, 198, 199, 200, 201, 202, 210, 211, 212, 213, 214, 215, 216, 217, 218,
                226, 227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248,
                249, 250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q70() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 1, 5, 1, 1, 1, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 3, 2, 2, 6, 5, 8, 6, 5, 6, 5, 8, 1, 3, 101],
            vec![
                0, 1, 2, 3, 4, 17, 18, 33, 5, 19, 34, 49, 65, 81, 6, 50, 97, 113, 240, 20, 35, 66,
                82, 129, 145, 161, 177, 51, 98, 114, 193, 209, 225, 21, 130, 146, 162, 241, 36, 67,
                83, 178, 194, 210, 7, 22, 52, 115, 179, 53, 68, 84, 99, 116, 131, 147, 226, 37,
                163, 180, 242, 8, 9, 10, 23, 24, 25, 26, 38, 39, 40, 41, 42, 54, 55, 56, 57, 58,
                69, 70, 71, 72, 73, 74, 85, 86, 87, 88, 89, 90, 100, 101, 102, 103, 104, 105, 106,
                117, 118, 119, 120, 121, 122, 132, 133, 134, 135, 136, 137, 138, 148, 149, 150,
                151, 152, 153, 154, 164, 165, 166, 167, 168, 169, 170, 181, 182, 183, 184, 185,
                186, 195, 196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217,
                218, 227, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 3, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [1, 0, 2, 1, 2, 3, 5, 4, 6, 5, 7, 4, 2, 7, 2, 111],
            vec![
                0, 1, 2, 17, 3, 18, 4, 33, 49, 19, 34, 65, 81, 97, 5, 50, 113, 129, 20, 66, 82,
                145, 161, 177, 35, 98, 193, 209, 240, 6, 21, 51, 114, 130, 146, 225, 67, 83, 162,
                241, 22, 99, 36, 52, 84, 178, 194, 210, 226, 115, 147, 7, 8, 9, 10, 23, 24, 25, 26,
                37, 38, 39, 40, 41, 42, 53, 54, 55, 56, 57, 58, 68, 69, 70, 71, 72, 73, 74, 85, 86,
                87, 88, 89, 90, 100, 101, 102, 103, 104, 105, 106, 116, 117, 118, 119, 120, 121,
                122, 131, 132, 133, 134, 135, 136, 137, 138, 148, 149, 150, 151, 152, 153, 154,
                163, 164, 165, 166, 167, 168, 169, 170, 179, 180, 181, 182, 183, 184, 185, 186,
                195, 196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217, 218,
                227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q75() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 3, 2, 2, 6, 5, 8, 5, 7, 6, 5, 7, 3, 5, 97],
            vec![
                2, 0, 1, 3, 4, 17, 18, 33, 5, 19, 34, 49, 65, 81, 6, 50, 97, 113, 240, 20, 35, 66,
                82, 129, 145, 161, 177, 98, 114, 193, 209, 225, 21, 51, 130, 146, 162, 178, 241, 7,
                36, 67, 83, 194, 210, 22, 52, 99, 115, 226, 53, 68, 84, 116, 131, 147, 179, 37,
                132, 180, 54, 163, 195, 211, 242, 8, 9, 10, 23, 24, 25, 26, 38, 39, 40, 41, 42, 55,
                56, 57, 58, 69, 70, 71, 72, 73, 74, 85, 86, 87, 88, 89, 90, 100, 101, 102, 103,
                104, 105, 106, 117, 118, 119, 120, 121, 122, 133, 134, 135, 136, 137, 138, 148,
                149, 150, 151, 152, 153, 154, 164, 165, 166, 167, 168, 169, 170, 181, 182, 183,
                184, 185, 186, 196, 197, 198, 199, 200, 201, 202, 212, 213, 214, 215, 216, 217,
                218, 227, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [1, 0, 3, 1, 1, 1, 1, 1, 0, 3, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [0, 2, 1, 3, 1, 5, 4, 6, 6, 6, 5, 3, 6, 3, 4, 107],
            vec![
                0, 1, 2, 3, 17, 18, 33, 4, 34, 49, 65, 81, 19, 50, 97, 113, 5, 66, 82, 129, 145,
                161, 20, 98, 177, 193, 209, 240, 6, 21, 35, 51, 114, 225, 83, 130, 146, 162, 241,
                22, 67, 99, 52, 84, 178, 194, 210, 226, 36, 115, 147, 7, 8, 68, 242, 9, 10, 23, 24,
                25, 26, 37, 38, 39, 40, 41, 42, 53, 54, 55, 56, 57, 58, 69, 70, 71, 72, 73, 74, 85,
                86, 87, 88, 89, 90, 100, 101, 102, 103, 104, 105, 106, 116, 117, 118, 119, 120,
                121, 122, 131, 132, 133, 134, 135, 136, 137, 138, 148, 149, 150, 151, 152, 153,
                154, 163, 164, 165, 166, 167, 168, 169, 170, 179, 180, 181, 182, 183, 184, 185,
                186, 195, 196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217,
                218, 227, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q80() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 3, 2, 2, 6, 5, 8, 5, 7, 6, 4, 8, 6, 4, 95],
            vec![
                2, 0, 1, 3, 4, 17, 18, 33, 5, 19, 34, 49, 65, 81, 6, 50, 97, 113, 240, 20, 35, 66,
                82, 129, 145, 161, 177, 98, 114, 193, 209, 225, 7, 21, 51, 130, 146, 162, 241, 36,
                67, 83, 178, 194, 210, 22, 52, 99, 115, 53, 68, 84, 131, 147, 179, 180, 226, 37,
                54, 116, 132, 163, 242, 23, 117, 195, 211, 8, 9, 10, 24, 25, 26, 38, 39, 40, 41,
                42, 55, 56, 57, 58, 69, 70, 71, 72, 73, 74, 85, 86, 87, 88, 89, 90, 100, 101, 102,
                103, 104, 105, 106, 118, 119, 120, 121, 122, 133, 134, 135, 136, 137, 138, 148,
                149, 150, 151, 152, 153, 154, 164, 165, 166, 167, 168, 169, 170, 181, 182, 183,
                184, 185, 186, 196, 197, 198, 199, 200, 201, 202, 212, 213, 214, 215, 216, 217,
                218, 227, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [0, 2, 3, 1, 1, 1, 1, 0, 3, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [0, 2, 1, 3, 1, 4, 6, 5, 7, 6, 4, 7, 6, 1, 109, 0],
            vec![
                0, 1, 2, 3, 17, 18, 33, 4, 34, 49, 65, 5, 19, 50, 81, 97, 113, 66, 82, 129, 145,
                161, 20, 35, 98, 177, 193, 209, 240, 6, 51, 114, 130, 146, 225, 21, 83, 162, 241,
                22, 67, 84, 99, 178, 194, 210, 7, 36, 52, 115, 147, 226, 163, 8, 9, 10, 23, 24, 25,
                26, 37, 38, 39, 40, 41, 42, 53, 54, 55, 56, 57, 58, 68, 69, 70, 71, 72, 73, 74, 85,
                86, 87, 88, 89, 90, 100, 101, 102, 103, 104, 105, 106, 116, 117, 118, 119, 120,
                121, 122, 131, 132, 133, 134, 135, 136, 137, 138, 148, 149, 150, 151, 152, 153,
                154, 164, 165, 166, 167, 168, 169, 170, 179, 180, 181, 182, 183, 184, 185, 186,
                195, 196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217, 218,
                227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q85() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 0, 7, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 3, 2, 2, 6, 5, 8, 5, 7, 6, 4, 7, 8, 5, 93],
            vec![
                2, 0, 1, 3, 4, 17, 18, 33, 5, 19, 34, 49, 65, 81, 6, 50, 97, 113, 240, 20, 35, 66,
                82, 129, 145, 161, 177, 7, 98, 114, 193, 209, 21, 51, 130, 146, 162, 225, 241, 36,
                67, 83, 178, 194, 210, 22, 52, 99, 115, 68, 84, 131, 147, 179, 180, 226, 23, 37,
                53, 54, 132, 163, 211, 242, 8, 100, 116, 117, 195, 9, 10, 24, 25, 26, 38, 39, 40,
                41, 42, 55, 56, 57, 58, 69, 70, 71, 72, 73, 74, 85, 86, 87, 88, 89, 90, 101, 102,
                103, 104, 105, 106, 118, 119, 120, 121, 122, 133, 134, 135, 136, 137, 138, 148,
                149, 150, 151, 152, 153, 154, 164, 165, 166, 167, 168, 169, 170, 181, 182, 183,
                184, 185, 186, 196, 197, 198, 199, 200, 201, 202, 212, 213, 214, 215, 216, 217,
                218, 227, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [0, 2, 3, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [0, 2, 1, 2, 3, 5, 4, 4, 10, 5, 6, 5, 7, 3, 2, 103],
            vec![
                0, 1, 2, 3, 17, 4, 18, 33, 19, 34, 49, 65, 81, 5, 50, 97, 113, 66, 82, 129, 145, 6,
                20, 35, 98, 114, 161, 177, 193, 209, 240, 21, 51, 130, 146, 225, 67, 83, 162, 178,
                210, 241, 7, 22, 36, 194, 226, 52, 84, 99, 100, 115, 147, 163, 68, 131, 242, 23,
                85, 8, 9, 10, 24, 25, 26, 37, 38, 39, 40, 41, 42, 53, 54, 55, 56, 57, 58, 69, 70,
                71, 72, 73, 74, 86, 87, 88, 89, 90, 101, 102, 103, 104, 105, 106, 116, 117, 118,
                119, 120, 121, 122, 132, 133, 134, 135, 136, 137, 138, 148, 149, 150, 151, 152,
                153, 154, 164, 165, 166, 167, 168, 169, 170, 179, 180, 181, 182, 183, 184, 185,
                186, 195, 196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217,
                218, 227, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q89() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 0, 7, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 2, 4, 3, 4, 5, 8, 5, 7, 5, 6, 7, 7, 9, 89],
            vec![
                2, 1, 3, 0, 4, 17, 18, 5, 33, 49, 19, 34, 65, 81, 6, 50, 66, 97, 113, 7, 20, 35,
                82, 129, 145, 161, 240, 98, 114, 177, 193, 209, 21, 51, 130, 146, 162, 225, 241,
                36, 67, 83, 178, 194, 22, 52, 99, 115, 147, 210, 8, 37, 68, 84, 131, 179, 226, 23,
                53, 54, 163, 180, 211, 242, 85, 100, 116, 117, 132, 133, 148, 181, 195, 9, 10, 24,
                25, 26, 38, 39, 40, 41, 42, 55, 56, 57, 58, 69, 70, 71, 72, 73, 74, 86, 87, 88, 89,
                90, 101, 102, 103, 104, 105, 106, 118, 119, 120, 121, 122, 134, 135, 136, 137, 138,
                149, 150, 151, 152, 153, 154, 164, 165, 166, 167, 168, 169, 170, 182, 183, 184,
                185, 186, 196, 197, 198, 199, 200, 201, 202, 212, 213, 214, 215, 216, 217, 218,
                227, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249, 250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [0, 2, 3, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [0, 2, 1, 2, 3, 4, 5, 8, 6, 4, 8, 5, 6, 4, 7, 97],
            vec![
                0, 2, 1, 3, 17, 4, 18, 33, 19, 34, 49, 65, 5, 50, 81, 97, 113, 6, 20, 35, 66, 82,
                129, 145, 240, 98, 114, 161, 177, 193, 209, 51, 130, 146, 225, 7, 21, 67, 83, 162,
                178, 210, 241, 22, 36, 99, 194, 226, 52, 84, 100, 115, 147, 163, 68, 85, 131, 242,
                23, 37, 53, 148, 179, 211, 227, 8, 9, 10, 24, 25, 26, 38, 39, 40, 41, 42, 54, 55,
                56, 57, 58, 69, 70, 71, 72, 73, 74, 86, 87, 88, 89, 90, 101, 102, 103, 104, 105,
                106, 116, 117, 118, 119, 120, 121, 122, 132, 133, 134, 135, 136, 137, 138, 149,
                150, 151, 152, 153, 154, 164, 165, 166, 167, 168, 169, 170, 180, 181, 182, 183,
                184, 185, 186, 195, 196, 197, 198, 199, 200, 201, 202, 212, 213, 214, 215, 216,
                217, 218, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q90() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 0, 7, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 2, 4, 3, 4, 5, 8, 5, 7, 5, 6, 6, 9, 10, 87],
            vec![
                2, 1, 3, 0, 4, 17, 18, 5, 33, 49, 19, 34, 65, 81, 6, 50, 66, 97, 113, 7, 20, 35,
                82, 129, 145, 161, 240, 98, 114, 177, 193, 209, 21, 51, 130, 146, 162, 225, 241,
                36, 67, 83, 178, 210, 22, 52, 99, 115, 147, 194, 8, 37, 68, 131, 179, 226, 23, 53,
                84, 116, 163, 180, 181, 211, 242, 54, 69, 85, 100, 117, 132, 133, 148, 195, 227, 9,
                10, 24, 25, 26, 38, 39, 40, 41, 42, 55, 56, 57, 58, 70, 71, 72, 73, 74, 86, 87, 88,
                89, 90, 101, 102, 103, 104, 105, 106, 118, 119, 120, 121, 122, 134, 135, 136, 137,
                138, 149, 150, 151, 152, 153, 154, 164, 165, 166, 167, 168, 169, 170, 182, 183,
                184, 185, 186, 196, 197, 198, 199, 200, 201, 202, 212, 213, 214, 215, 216, 217,
                218, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249, 250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [0, 2, 3, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [0, 2, 1, 2, 3, 4, 5, 8, 5, 6, 8, 5, 6, 4, 8, 95],
            vec![
                0, 2, 1, 3, 17, 4, 18, 33, 19, 34, 49, 65, 5, 50, 81, 97, 113, 6, 20, 35, 66, 82,
                129, 145, 240, 98, 114, 161, 177, 193, 21, 51, 130, 146, 209, 225, 7, 67, 83, 162,
                178, 194, 210, 241, 22, 36, 99, 115, 226, 52, 84, 100, 131, 147, 163, 23, 68, 85,
                242, 8, 37, 53, 116, 148, 179, 211, 227, 9, 10, 24, 25, 26, 38, 39, 40, 41, 42, 54,
                55, 56, 57, 58, 69, 70, 71, 72, 73, 74, 86, 87, 88, 89, 90, 101, 102, 103, 104,
                105, 106, 117, 118, 119, 120, 121, 122, 132, 133, 134, 135, 136, 137, 138, 149,
                150, 151, 152, 153, 154, 164, 165, 166, 167, 168, 169, 170, 180, 181, 182, 183,
                184, 185, 186, 195, 196, 197, 198, 199, 200, 201, 202, 212, 213, 214, 215, 216,
                217, 218, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q91() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 0, 7, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 2, 4, 3, 4, 5, 8, 5, 7, 5, 6, 7, 6, 12, 87],
            vec![
                2, 1, 3, 0, 4, 17, 18, 5, 33, 49, 6, 19, 34, 65, 50, 66, 81, 97, 113, 7, 20, 35,
                82, 129, 145, 161, 240, 98, 114, 177, 193, 209, 8, 21, 51, 130, 146, 225, 241, 36,
                67, 83, 162, 178, 22, 52, 99, 115, 194, 210, 37, 68, 84, 131, 147, 179, 226, 23,
                116, 163, 181, 211, 242, 38, 53, 54, 69, 85, 100, 118, 132, 133, 148, 180, 195, 9,
                10, 24, 25, 26, 39, 40, 41, 42, 55, 56, 57, 58, 70, 71, 72, 73, 74, 86, 87, 88, 89,
                90, 101, 102, 103, 104, 105, 106, 117, 119, 120, 121, 122, 134, 135, 136, 137, 138,
                149, 150, 151, 152, 153, 154, 164, 165, 166, 167, 168, 169, 170, 182, 183, 184,
                185, 186, 196, 197, 198, 199, 200, 201, 202, 212, 213, 214, 215, 216, 217, 218,
                227, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249, 250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [0, 1, 3, 2, 2, 6, 4, 9, 7, 6, 5, 7, 5, 5, 79, 21],
            vec![
                0, 1, 2, 3, 17, 18, 4, 33, 5, 19, 34, 49, 65, 81, 50, 66, 97, 113, 6, 20, 35, 82,
                98, 129, 145, 161, 240, 51, 114, 130, 146, 177, 193, 209, 21, 67, 83, 162, 178,
                225, 7, 36, 194, 210, 241, 22, 52, 84, 99, 115, 147, 226, 23, 100, 131, 163, 242,
                37, 68, 85, 211, 227, 8, 9, 10, 24, 25, 26, 38, 39, 40, 41, 42, 53, 54, 55, 56, 57,
                58, 69, 70, 71, 72, 73, 74, 86, 87, 88, 89, 90, 101, 102, 103, 104, 105, 106, 116,
                117, 118, 119, 120, 121, 122, 132, 133, 134, 135, 136, 137, 138, 148, 149, 150,
                151, 152, 153, 154, 164, 165, 166, 167, 168, 169, 170, 179, 180, 181, 182, 183,
                184, 185, 186, 195, 196, 197, 198, 199, 200, 201, 202, 212, 213, 214, 215, 216,
                217, 218, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q92() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 0, 7, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 2, 4, 3, 4, 5, 8, 6, 4, 7, 6, 7, 6, 12, 87],
            vec![
                2, 1, 3, 0, 4, 17, 18, 5, 33, 49, 6, 19, 34, 65, 50, 66, 81, 97, 113, 7, 20, 35,
                82, 129, 145, 161, 240, 51, 98, 114, 177, 193, 209, 21, 130, 146, 225, 8, 36, 67,
                83, 162, 178, 241, 22, 52, 99, 115, 194, 210, 37, 68, 84, 131, 147, 179, 226, 23,
                53, 116, 163, 181, 211, 38, 54, 55, 69, 85, 100, 118, 133, 148, 180, 195, 242, 9,
                10, 24, 25, 26, 39, 40, 41, 42, 56, 57, 58, 70, 71, 72, 73, 74, 86, 87, 88, 89, 90,
                101, 102, 103, 104, 105, 106, 117, 119, 120, 121, 122, 132, 134, 135, 136, 137,
                138, 149, 150, 151, 152, 153, 154, 164, 165, 166, 167, 168, 169, 170, 182, 183,
                184, 185, 186, 196, 197, 198, 199, 200, 201, 202, 212, 213, 214, 215, 216, 217,
                218, 227, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [0, 1, 3, 2, 2, 6, 4, 9, 7, 6, 5, 7, 5, 8, 70, 27],
            vec![
                2, 0, 1, 3, 17, 18, 4, 33, 5, 19, 34, 49, 65, 81, 50, 66, 97, 113, 6, 20, 35, 82,
                98, 129, 145, 161, 240, 51, 114, 130, 146, 177, 193, 209, 21, 67, 83, 162, 178,
                225, 7, 36, 194, 210, 241, 22, 52, 84, 99, 115, 147, 226, 23, 68, 100, 131, 242,
                37, 85, 148, 163, 164, 179, 211, 227, 8, 9, 10, 24, 25, 26, 38, 39, 40, 41, 42, 53,
                54, 55, 56, 57, 58, 69, 70, 71, 72, 73, 74, 86, 87, 88, 89, 90, 101, 102, 103, 104,
                105, 106, 116, 117, 118, 119, 120, 121, 122, 132, 133, 134, 135, 136, 137, 138,
                149, 150, 151, 152, 153, 154, 165, 166, 167, 168, 169, 170, 180, 181, 182, 183,
                184, 185, 186, 195, 196, 197, 198, 199, 200, 201, 202, 212, 213, 214, 215, 216,
                217, 218, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q93() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 0, 7, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 2, 4, 3, 5, 3, 8, 6, 4, 8, 4, 6, 8, 11, 89],
            vec![
                2, 1, 3, 0, 4, 17, 18, 5, 33, 34, 6, 19, 49, 50, 65, 66, 81, 97, 7, 20, 35, 82,
                113, 129, 145, 240, 21, 98, 114, 161, 177, 193, 51, 130, 209, 225, 8, 22, 36, 67,
                146, 162, 178, 241, 52, 83, 194, 210, 37, 84, 99, 115, 131, 147, 23, 53, 68, 148,
                179, 181, 211, 226, 38, 55, 69, 85, 100, 116, 133, 163, 180, 195, 242, 9, 10, 24,
                25, 26, 39, 40, 41, 42, 54, 56, 57, 58, 70, 71, 72, 73, 74, 86, 87, 88, 89, 90,
                101, 102, 103, 104, 105, 106, 117, 118, 119, 120, 121, 122, 132, 134, 135, 136,
                137, 138, 149, 150, 151, 152, 153, 154, 164, 165, 166, 167, 168, 169, 170, 182,
                183, 184, 185, 186, 196, 197, 198, 199, 200, 201, 202, 212, 213, 214, 215, 216,
                217, 218, 227, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248,
                249, 250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [0, 1, 3, 3, 1, 5, 3, 7, 7, 7, 6, 4, 7, 6, 9, 93],
            vec![
                2, 0, 1, 3, 4, 17, 18, 33, 5, 19, 34, 49, 65, 50, 81, 97, 6, 20, 35, 66, 82, 113,
                129, 98, 114, 145, 161, 177, 193, 240, 7, 21, 51, 130, 146, 209, 225, 36, 67, 83,
                162, 178, 241, 22, 99, 194, 210, 8, 23, 52, 84, 115, 147, 226, 37, 68, 85, 131,
                227, 242, 53, 100, 101, 116, 148, 163, 164, 179, 211, 9, 10, 24, 25, 26, 38, 39,
                40, 41, 42, 54, 55, 56, 57, 58, 69, 70, 71, 72, 73, 74, 86, 87, 88, 89, 90, 102,
                103, 104, 105, 106, 117, 118, 119, 120, 121, 122, 132, 133, 134, 135, 136, 137,
                138, 149, 150, 151, 152, 153, 154, 165, 166, 167, 168, 169, 170, 180, 181, 182,
                183, 184, 185, 186, 195, 196, 197, 198, 199, 200, 201, 202, 212, 213, 214, 215,
                216, 217, 218, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248,
                249, 250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q94() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 0, 7, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 2, 4, 3, 4, 5, 7, 8, 3, 7, 4, 8, 5, 101, 0],
            vec![
                2, 1, 3, 0, 4, 17, 18, 5, 33, 34, 6, 19, 49, 65, 7, 50, 66, 81, 97, 20, 35, 82,
                113, 129, 145, 240, 8, 21, 51, 98, 114, 161, 177, 193, 130, 209, 225, 22, 36, 67,
                146, 162, 178, 241, 52, 83, 194, 210, 9, 23, 37, 84, 99, 115, 131, 147, 53, 68,
                116, 179, 226, 10, 24, 25, 26, 38, 39, 40, 41, 42, 54, 55, 56, 57, 58, 69, 70, 71,
                72, 73, 74, 85, 86, 87, 88, 89, 90, 100, 101, 102, 103, 104, 105, 106, 117, 118,
                119, 120, 121, 122, 132, 133, 134, 135, 136, 137, 138, 148, 149, 150, 151, 152,
                153, 154, 163, 164, 165, 166, 167, 168, 169, 170, 180, 181, 182, 183, 184, 185,
                186, 195, 196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217,
                218, 227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248,
                249, 250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [0, 1, 3, 3, 1, 5, 3, 7, 6, 8, 8, 4, 6, 10, 6, 91],
            vec![
                2, 0, 1, 3, 4, 17, 18, 33, 5, 19, 34, 49, 65, 50, 81, 97, 6, 20, 35, 66, 82, 113,
                129, 98, 114, 145, 161, 177, 240, 7, 21, 51, 130, 146, 193, 209, 225, 36, 67, 83,
                162, 178, 194, 210, 241, 22, 52, 99, 115, 8, 23, 84, 131, 147, 226, 37, 53, 68,
                101, 148, 163, 164, 179, 211, 242, 85, 100, 116, 195, 227, 228, 9, 10, 24, 25, 26,
                38, 39, 40, 41, 42, 54, 55, 56, 57, 58, 69, 70, 71, 72, 73, 74, 86, 87, 88, 89, 90,
                102, 103, 104, 105, 106, 117, 118, 119, 120, 121, 122, 132, 133, 134, 135, 136,
                137, 138, 149, 150, 151, 152, 153, 154, 165, 166, 167, 168, 169, 170, 180, 181,
                182, 183, 184, 185, 186, 196, 197, 198, 199, 200, 201, 202, 212, 213, 214, 215,
                216, 217, 218, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q95() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 0, 6, 3, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            vec![3, 4, 5, 6, 7, 8, 0, 2, 9, 1, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 2, 4, 3, 5, 3, 7, 7, 6, 5, 3, 9, 8, 99, 0],
            vec![
                2, 1, 3, 0, 4, 17, 18, 5, 33, 34, 6, 19, 49, 50, 65, 7, 81, 97, 20, 35, 66, 82,
                113, 129, 240, 8, 21, 51, 98, 145, 161, 177, 36, 114, 130, 193, 209, 225, 22, 67,
                146, 162, 241, 52, 83, 178, 9, 23, 37, 99, 115, 131, 147, 194, 210, 53, 68, 84,
                116, 148, 179, 211, 226, 10, 24, 25, 26, 38, 39, 40, 41, 42, 54, 55, 56, 57, 58,
                69, 70, 71, 72, 73, 74, 85, 86, 87, 88, 89, 90, 100, 101, 102, 103, 104, 105, 106,
                117, 118, 119, 120, 121, 122, 132, 133, 134, 135, 136, 137, 138, 149, 150, 151,
                152, 153, 154, 163, 164, 165, 166, 167, 168, 169, 170, 180, 181, 182, 183, 184,
                185, 186, 195, 196, 197, 198, 199, 200, 201, 202, 212, 213, 214, 215, 216, 217,
                218, 227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248,
                249, 250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [0, 1, 3, 3, 1, 4, 5, 7, 7, 7, 5, 6, 7, 7, 8, 91],
            vec![
                2, 0, 1, 3, 4, 17, 18, 33, 5, 19, 34, 49, 6, 50, 65, 81, 97, 20, 35, 66, 82, 113,
                129, 145, 51, 98, 114, 161, 177, 193, 240, 7, 21, 67, 130, 146, 209, 225, 36, 83,
                162, 178, 241, 22, 52, 99, 115, 194, 210, 8, 23, 68, 84, 131, 147, 226, 37, 101,
                163, 164, 179, 211, 242, 24, 53, 69, 85, 100, 116, 148, 227, 9, 10, 25, 26, 38, 39,
                40, 41, 42, 54, 55, 56, 57, 58, 70, 71, 72, 73, 74, 86, 87, 88, 89, 90, 102, 103,
                104, 105, 106, 117, 118, 119, 120, 121, 122, 132, 133, 134, 135, 136, 137, 138,
                149, 150, 151, 152, 153, 154, 165, 166, 167, 168, 169, 170, 180, 181, 182, 183,
                184, 185, 186, 195, 196, 197, 198, 199, 200, 201, 202, 212, 213, 214, 215, 216,
                217, 218, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q96() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 0, 6, 3, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            vec![3, 4, 5, 6, 7, 8, 0, 2, 9, 1, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 2, 4, 3, 4, 5, 7, 7, 7, 3, 4, 7, 7, 101, 0],
            vec![
                2, 1, 3, 0, 4, 17, 18, 5, 33, 34, 6, 19, 49, 65, 7, 20, 50, 81, 97, 35, 66, 82,
                113, 129, 145, 240, 8, 21, 51, 98, 161, 177, 193, 36, 67, 114, 130, 209, 225, 241,
                22, 83, 146, 52, 99, 162, 178, 9, 23, 37, 68, 115, 194, 210, 53, 84, 116, 131, 147,
                148, 179, 10, 24, 25, 26, 38, 39, 40, 41, 42, 54, 55, 56, 57, 58, 69, 70, 71, 72,
                73, 74, 85, 86, 87, 88, 89, 90, 100, 101, 102, 103, 104, 105, 106, 117, 118, 119,
                120, 121, 122, 132, 133, 134, 135, 136, 137, 138, 149, 150, 151, 152, 153, 154,
                163, 164, 165, 166, 167, 168, 169, 170, 180, 181, 182, 183, 184, 185, 186, 195,
                196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217, 218, 226,
                227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [0, 1, 3, 3, 1, 4, 5, 7, 6, 9, 5, 6, 6, 8, 13, 85],
            vec![
                2, 0, 1, 3, 4, 17, 18, 33, 5, 19, 34, 49, 6, 50, 65, 81, 97, 7, 20, 35, 66, 82,
                113, 129, 98, 114, 145, 161, 177, 240, 8, 21, 51, 67, 130, 146, 193, 209, 225, 36,
                83, 162, 178, 241, 22, 52, 99, 115, 194, 210, 9, 37, 84, 131, 147, 226, 23, 24, 68,
                85, 101, 163, 179, 242, 10, 25, 26, 38, 53, 100, 116, 148, 164, 195, 211, 227, 228,
                39, 40, 41, 42, 54, 55, 56, 57, 58, 69, 70, 71, 72, 73, 74, 86, 87, 88, 89, 90,
                102, 103, 104, 105, 106, 117, 118, 119, 120, 121, 122, 132, 133, 134, 135, 136,
                137, 138, 149, 150, 151, 152, 153, 154, 165, 166, 167, 168, 169, 170, 180, 181,
                182, 183, 184, 185, 186, 196, 197, 198, 199, 200, 201, 202, 212, 213, 214, 215,
                216, 217, 218, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q97() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 0, 6, 3, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            vec![3, 4, 5, 6, 7, 8, 0, 2, 9, 1, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 2, 4, 3, 5, 4, 5, 8, 6, 4, 4, 6, 7, 12, 91],
            vec![
                2, 1, 3, 4, 5, 17, 18, 0, 6, 33, 7, 19, 34, 49, 65, 20, 50, 81, 97, 8, 35, 66, 113,
                129, 9, 21, 51, 82, 145, 161, 177, 240, 36, 98, 114, 193, 209, 225, 22, 67, 130,
                241, 52, 83, 146, 162, 23, 37, 99, 115, 178, 194, 10, 53, 68, 84, 131, 147, 210,
                24, 25, 38, 85, 100, 116, 148, 163, 179, 180, 182, 226, 26, 39, 40, 41, 42, 54, 55,
                56, 57, 58, 69, 70, 71, 72, 73, 74, 86, 87, 88, 89, 90, 101, 102, 103, 104, 105,
                106, 117, 118, 119, 120, 121, 122, 132, 133, 134, 135, 136, 137, 138, 149, 150,
                151, 152, 153, 154, 164, 165, 166, 167, 168, 169, 170, 181, 183, 184, 185, 186,
                195, 196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217, 218,
                227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [0, 1, 3, 3, 1, 4, 5, 7, 7, 6, 7, 6, 7, 7, 9, 89],
            vec![
                2, 0, 1, 3, 4, 17, 18, 33, 5, 19, 34, 49, 6, 50, 65, 81, 97, 20, 35, 66, 82, 113,
                129, 240, 7, 51, 98, 114, 145, 161, 177, 21, 130, 146, 193, 209, 225, 8, 36, 67,
                83, 162, 178, 241, 22, 52, 99, 115, 194, 210, 9, 37, 68, 84, 131, 147, 226, 23, 24,
                85, 101, 148, 163, 179, 10, 53, 100, 116, 165, 195, 211, 227, 242, 25, 26, 38, 39,
                40, 41, 42, 54, 55, 56, 57, 58, 69, 70, 71, 72, 73, 74, 86, 87, 88, 89, 90, 102,
                103, 104, 105, 106, 117, 118, 119, 120, 121, 122, 132, 133, 134, 135, 136, 137,
                138, 149, 150, 151, 152, 153, 154, 164, 166, 167, 168, 169, 170, 180, 181, 182,
                183, 184, 185, 186, 196, 197, 198, 199, 200, 201, 202, 212, 213, 214, 215, 216,
                217, 218, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q98() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 0, 6, 3, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            vec![3, 4, 5, 6, 7, 8, 0, 2, 9, 1, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 2, 4, 4, 3, 4, 6, 6, 6, 5, 3, 5, 4, 10, 99],
            vec![
                2, 1, 3, 4, 5, 17, 18, 0, 6, 19, 33, 34, 49, 65, 7, 20, 50, 81, 8, 35, 66, 97, 113,
                129, 21, 51, 82, 145, 161, 240, 9, 36, 98, 177, 193, 209, 22, 67, 114, 225, 241,
                52, 83, 130, 23, 37, 99, 146, 162, 10, 68, 115, 178, 24, 38, 53, 84, 85, 131, 147,
                179, 194, 210, 25, 26, 39, 40, 41, 42, 54, 55, 56, 57, 58, 69, 70, 71, 72, 73, 74,
                86, 87, 88, 89, 90, 100, 101, 102, 103, 104, 105, 106, 116, 117, 118, 119, 120,
                121, 122, 132, 133, 134, 135, 136, 137, 138, 148, 149, 150, 151, 152, 153, 154,
                163, 164, 165, 166, 167, 168, 169, 170, 180, 181, 182, 183, 184, 185, 186, 195,
                196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216, 217, 218, 226,
                227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [0, 1, 2, 4, 3, 4, 4, 9, 7, 7, 6, 4, 7, 6, 13, 85],
            vec![
                2, 1, 3, 0, 4, 17, 18, 5, 33, 49, 6, 19, 34, 65, 20, 50, 81, 97, 7, 35, 66, 82,
                113, 129, 145, 161, 240, 21, 51, 98, 114, 177, 193, 209, 8, 36, 67, 130, 146, 225,
                241, 22, 83, 99, 162, 178, 194, 37, 52, 115, 210, 9, 23, 68, 84, 131, 147, 226, 24,
                53, 102, 163, 179, 242, 10, 25, 26, 38, 69, 85, 100, 116, 132, 148, 165, 195, 228,
                39, 40, 41, 42, 54, 55, 56, 57, 58, 70, 71, 72, 73, 74, 86, 87, 88, 89, 90, 101,
                103, 104, 105, 106, 117, 118, 119, 120, 121, 122, 133, 134, 135, 136, 137, 138,
                149, 150, 151, 152, 153, 154, 164, 166, 167, 168, 169, 170, 180, 181, 182, 183,
                184, 185, 186, 196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216,
                217, 218, 227, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q99() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 0, 6, 3, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            vec![3, 4, 5, 6, 7, 8, 0, 2, 9, 1, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 3, 2, 4, 4, 3, 4, 5, 7, 6, 6, 3, 5, 6, 103],
            vec![
                2, 1, 3, 4, 5, 17, 0, 6, 18, 33, 7, 19, 34, 49, 8, 20, 65, 35, 50, 81, 97, 21, 66,
                113, 129, 240, 9, 36, 51, 82, 145, 161, 177, 22, 67, 98, 193, 209, 225, 23, 52, 83,
                114, 130, 241, 37, 99, 146, 10, 24, 68, 115, 162, 38, 53, 84, 131, 178, 194, 25,
                26, 39, 40, 41, 42, 54, 55, 56, 57, 58, 69, 70, 71, 72, 73, 74, 85, 86, 87, 88, 89,
                90, 100, 101, 102, 103, 104, 105, 106, 116, 117, 118, 119, 120, 121, 122, 132, 133,
                134, 135, 136, 137, 138, 147, 148, 149, 150, 151, 152, 153, 154, 163, 164, 165,
                166, 167, 168, 169, 170, 179, 180, 181, 182, 183, 184, 185, 186, 195, 196, 197,
                198, 199, 200, 201, 202, 210, 211, 212, 213, 214, 215, 216, 217, 218, 226, 227,
                228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248, 249, 250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [0, 1, 2, 4, 3, 4, 5, 8, 6, 5, 6, 5, 5, 6, 9, 93],
            vec![
                2, 1, 3, 0, 4, 17, 18, 5, 33, 49, 6, 19, 34, 65, 20, 50, 81, 97, 113, 7, 35, 66,
                82, 129, 145, 161, 240, 21, 51, 98, 177, 193, 209, 8, 36, 114, 225, 241, 22, 67,
                83, 130, 146, 162, 52, 99, 178, 194, 210, 23, 37, 68, 115, 226, 9, 53, 84, 131,
                147, 179, 24, 38, 69, 100, 116, 148, 163, 211, 242, 10, 25, 26, 39, 40, 41, 42, 54,
                55, 56, 57, 58, 70, 71, 72, 73, 74, 85, 86, 87, 88, 89, 90, 101, 102, 103, 104,
                105, 106, 117, 118, 119, 120, 121, 122, 132, 133, 134, 135, 136, 137, 138, 149,
                150, 151, 152, 153, 154, 164, 165, 166, 167, 168, 169, 170, 180, 181, 182, 183,
                184, 185, 186, 195, 196, 197, 198, 199, 200, 201, 202, 212, 213, 214, 215, 216,
                217, 218, 227, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248,
                249, 250,
            ],
        )
        .unwrap(),
    }
}

pub fn trained_tables_q100() -> HuffmanTableSet {
    HuffmanTableSet {
        dc_luma: OptimizedTable::from_bits_values(
            [0, 0, 6, 3, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            vec![3, 4, 5, 6, 7, 8, 0, 2, 9, 1, 10, 11],
        )
        .unwrap(),
        ac_luma: OptimizedTable::from_bits_values(
            [0, 1, 3, 2, 4, 4, 2, 6, 5, 8, 4, 5, 4, 7, 8, 99],
            vec![
                2, 1, 3, 4, 5, 17, 6, 18, 19, 33, 0, 7, 34, 49, 20, 65, 8, 21, 35, 50, 81, 97, 66,
                113, 129, 145, 240, 9, 22, 36, 51, 82, 161, 177, 193, 98, 209, 225, 241, 23, 37,
                52, 67, 114, 68, 83, 130, 146, 10, 24, 38, 53, 84, 99, 162, 85, 86, 100, 115, 116,
                131, 178, 194, 25, 26, 39, 40, 41, 42, 54, 55, 56, 57, 58, 69, 70, 71, 72, 73, 74,
                87, 88, 89, 90, 101, 102, 103, 104, 105, 106, 117, 118, 119, 120, 121, 122, 132,
                133, 134, 135, 136, 137, 138, 147, 148, 149, 150, 151, 152, 153, 154, 163, 164,
                165, 166, 167, 168, 169, 170, 179, 180, 181, 182, 183, 184, 185, 186, 195, 196,
                197, 198, 199, 200, 201, 202, 210, 211, 212, 213, 214, 215, 216, 217, 218, 226,
                227, 228, 229, 230, 231, 232, 233, 234, 242, 243, 244, 245, 246, 247, 248, 249,
                250,
            ],
        )
        .unwrap(),
        dc_chroma: OptimizedTable::from_bits_values(
            [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        )
        .unwrap(),
        ac_chroma: OptimizedTable::from_bits_values(
            [0, 1, 2, 4, 3, 4, 6, 6, 6, 6, 4, 5, 4, 8, 8, 95],
            vec![
                2, 1, 3, 0, 4, 17, 18, 5, 33, 49, 6, 19, 34, 65, 20, 50, 81, 97, 113, 240, 7, 35,
                66, 129, 145, 161, 21, 82, 177, 193, 209, 225, 8, 36, 51, 98, 114, 241, 22, 67,
                130, 146, 37, 52, 83, 162, 178, 68, 99, 194, 210, 9, 23, 53, 84, 115, 131, 147,
                226, 10, 24, 38, 100, 116, 163, 179, 242, 25, 26, 39, 40, 41, 42, 54, 55, 56, 57,
                58, 69, 70, 71, 72, 73, 74, 85, 86, 87, 88, 89, 90, 101, 102, 103, 104, 105, 106,
                117, 118, 119, 120, 121, 122, 132, 133, 134, 135, 136, 137, 138, 148, 149, 150,
                151, 152, 153, 154, 164, 165, 166, 167, 168, 169, 170, 180, 181, 182, 183, 184,
                185, 186, 195, 196, 197, 198, 199, 200, 201, 202, 211, 212, 213, 214, 215, 216,
                217, 218, 227, 228, 229, 230, 231, 232, 233, 234, 243, 244, 245, 246, 247, 248,
                249, 250,
            ],
        )
        .unwrap(),
    }
}