// This is a generated file. Do not modify directly.
#![allow(non_camel_case_types)]
#![allow(unused)]
#![allow(clippy::eq_op)]
#![allow(clippy::overly_complex_bool_expr)]

use once_cell::sync::Lazy;

use crate::magic::*;
use phf::phf_map;
use regex::bytes::Regex;

pub(super) struct T_x_tga_image;
impl MimeTypeChecker for T_x_tga_image {
    fn get_mime(&self) -> &'static str {
        "image/x-tga"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.tga", "*.icb", "*.vda"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> = Lazy::new(|| {
            Regex::new(".*[\\x54\\x52\\x55\\x45\\x56\\x49\\x53\\x49\\x4F\\x4E\\x2D\\x58\\x46\\x49\\x4C\\x45\\x2E\\x00]").unwrap()
        });

        ((offset(bytes, 1, &[1, 1, 0, 0]) && regex(bytes, 8, &REGEX_PATTERN_0))
            || (offset(bytes, 1, &[0, 2, 0, 0]) && regex(bytes, 8, &REGEX_PATTERN_0))
            || (offset(bytes, 1, &[0, 3, 0, 0]) && regex(bytes, 8, &REGEX_PATTERN_0)))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_tmx_application;
impl MimeTypeChecker for T_x_tmx_application {
    fn get_mime(&self) -> &'static str {
        "application/x-tmx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.tmx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_range(bytes, 0, 256, &[60, 116, 109, 120])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_endnote_refer_application;
impl MimeTypeChecker for T_x_endnote_refer_application {
    fn get_mime(&self) -> &'static str {
        "application/x-endnote-refer"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.enw", "*.enr"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset_range(bytes, 0, 50, &[37, 65, 32])
            && offset_range(bytes, 0, 1000, &[10, 37, 68, 32])
            && offset_range(bytes, 0, 1000, &[10, 37, 84, 32]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_dvd_ifo_application;
impl MimeTypeChecker for T_x_dvd_ifo_application {
    fn get_mime(&self) -> &'static str {
        "application/x-dvd-ifo"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ifo", "*.bup"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[68, 86, 68, 86, 73, 68, 69, 79, 45, 86, 84, 83])
            || offset(bytes, 0, &[68, 86, 68, 86, 73, 68, 69, 79, 45, 86, 77, 71]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ebu_stl_application;
impl MimeTypeChecker for T_x_ebu_stl_application {
    fn get_mime(&self) -> &'static str {
        "application/x-ebu-stl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 3, &[83, 84, 76]) && offset(bytes, 8, &[46, 48, 49]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mbox_application;
impl MimeTypeChecker for T_mbox_application {
    fn get_mime(&self) -> &'static str {
        "application/mbox"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mbox"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[70, 114, 111, 109, 32])
            && (offset_range(bytes, 32, 256, &[10, 70, 114, 111, 109, 58, 32])
                || offset_range(bytes, 32, 256, &[10, 68, 97, 116, 101, 58, 32])
                || offset_range(
                    bytes,
                    32,
                    256,
                    &[10, 83, 117, 98, 106, 101, 99, 116, 58, 32],
                )
                || offset_range(
                    bytes,
                    32,
                    256,
                    &[
                        10, 68, 101, 108, 105, 118, 101, 114, 101, 100, 45, 84, 111, 58, 32,
                    ],
                )
                || offset_range(
                    bytes,
                    32,
                    256,
                    &[
                        10, 82, 101, 99, 101, 105, 118, 101, 100, 58, 32, 98, 121, 32,
                    ],
                )
                || offset_range(
                    bytes,
                    32,
                    256,
                    &[
                        10, 82, 101, 99, 101, 105, 118, 101, 100, 58, 32, 118, 105, 97, 32,
                    ],
                )
                || offset_range(
                    bytes,
                    32,
                    256,
                    &[
                        10, 82, 101, 99, 101, 105, 118, 101, 100, 58, 32, 102, 114, 111, 109, 32,
                    ],
                )
                || offset_range(
                    bytes,
                    32,
                    256,
                    &[
                        10, 77, 105, 109, 101, 45, 86, 101, 114, 115, 105, 111, 110, 58, 32,
                    ],
                )
                || (offset_range_case_insensitive(bytes, 32, 256, &[10, 88, 45])
                    && (offset_range(bytes, 32, 8192, &[10, 70, 114, 111, 109, 58, 32])
                        || offset_range(bytes, 32, 8192, &[10, 68, 97, 116, 101, 58, 32])
                        || offset_range(
                            bytes,
                            32,
                            8192,
                            &[10, 83, 117, 98, 106, 101, 99, 116, 58, 32],
                        )
                        || offset_range(
                            bytes,
                            32,
                            8192,
                            &[
                                10, 68, 101, 108, 105, 118, 101, 114, 101, 100, 45, 84, 111, 58, 32,
                            ],
                        )
                        || offset_range(
                            bytes,
                            32,
                            8192,
                            &[
                                10, 82, 101, 99, 101, 105, 118, 101, 100, 58, 32, 98, 121, 32,
                            ],
                        )
                        || offset_range(
                            bytes,
                            32,
                            8192,
                            &[
                                10, 82, 101, 99, 101, 105, 118, 101, 100, 58, 32, 118, 105, 97, 32,
                            ],
                        )
                        || offset_range(
                            bytes,
                            32,
                            8192,
                            &[
                                10, 82, 101, 99, 101, 105, 118, 101, 100, 58, 32, 102, 114, 111,
                                109, 32,
                            ],
                        )
                        || offset_range(
                            bytes,
                            32,
                            8192,
                            &[
                                10, 77, 105, 109, 101, 45, 86, 101, 114, 115, 105, 111, 110, 58, 32,
                            ],
                        )))))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_emlx_message;
impl MimeTypeChecker for T_x_emlx_message {
    fn get_mime(&self) -> &'static str {
        "message/x-emlx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.emlx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset_range(
            bytes,
            2,
            9,
            &[
                10, 82, 101, 108, 97, 121, 45, 86, 101, 114, 115, 105, 111, 110, 58,
            ],
        ) || offset_range(bytes, 2, 9, &[10, 35, 33, 32, 114, 110, 101, 119, 115])
            || offset_range(bytes, 2, 9, &[10, 78, 35, 33, 32, 114, 110, 101, 119, 115])
            || offset_range(
                bytes,
                2,
                9,
                &[10, 70, 111, 114, 119, 97, 114, 100, 32, 116, 111],
            )
            || offset_range(bytes, 2, 9, &[10, 80, 105, 112, 101, 32, 116, 111])
            || offset_range(
                bytes,
                2,
                9,
                &[10, 82, 101, 116, 117, 114, 110, 45, 80, 97, 116, 104, 58],
            )
            || offset_range(bytes, 2, 9, &[10, 70, 114, 111, 109, 58])
            || offset_range(bytes, 2, 9, &[10, 82, 101, 99, 101, 105, 118, 101, 100, 58])
            || offset_range(
                bytes,
                2,
                9,
                &[10, 77, 101, 115, 115, 97, 103, 101, 45, 73, 68, 58],
            )
            || offset_range(bytes, 2, 9, &[10, 68, 97, 116, 101, 58]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ms_nls_application;
impl MimeTypeChecker for T_x_ms_nls_application {
    fn get_mime(&self) -> &'static str {
        "application/x-ms-nls"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> =
            Lazy::new(|| Regex::new("(?s)^\\x0D.{51}\\x0C\\x00\\x0D\\x00\\x0E").unwrap());
        static REGEX_PATTERN_1: Lazy<Regex> =
            Lazy::new(|| Regex::new("(?s)^\\x44\\x43.\\x01").unwrap());

        (regex(bytes, 0, &REGEX_PATTERN_0) || regex(bytes, 0, &REGEX_PATTERN_1))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mswrite_application;
impl MimeTypeChecker for T_x_mswrite_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mswrite"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wri"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[49, 190, 0, 0]) || offset(bytes, 0, &[50, 190, 0, 0]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pdf_application;
impl MimeTypeChecker for T_pdf_application {
    fn get_mime(&self) -> &'static str {
        "application/pdf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pdf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> = Lazy::new(|| Regex::new("^[ -~]*%%").unwrap());

        (offset(bytes, 0, &[37, 80, 68, 70, 45])
            || offset(bytes, 0, &[239, 187, 191, 37, 80, 68, 70, 45])
            || (regex_range(bytes, 0, 128, &REGEX_PATTERN_0)
                && ((offset_range(bytes, 0, 128, &[37, 37])
                    && offset_range(bytes, 1, 512, &[37, 80, 68, 70, 45, 49, 46]))
                    || (offset_range(bytes, 0, 128, &[37, 37])
                        && offset_range(bytes, 1, 512, &[37, 80, 68, 70, 45, 50, 46]))))
            || (regex_range(bytes, 0, 128, &REGEX_PATTERN_0)
                && (offset_range(bytes, 1, 512, &[37, 80, 68, 70, 45, 49, 46])
                    || offset_range(bytes, 1, 512, &[37, 80, 68, 70, 45, 50, 46]))))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_illustrator_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_bplist_application;
impl MimeTypeChecker for T_x_bplist_application {
    fn get_mime(&self) -> &'static str {
        "application/x-bplist"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[98, 112, 108, 105, 115, 116, 0, 0])
            || offset(bytes, 0, &[98, 112, 108, 105, 115, 116, 0, 1])
            || offset(bytes, 0, &[98, 112, 108, 105, 115, 116, 64, 0])
            || offset(bytes, 0, &[98, 112, 108, 105, 115, 116, 48, 48])
            || offset(bytes, 0, &[98, 112, 108, 105, 115, 116, 48, 49])
            || offset(bytes, 0, &[98, 112, 108, 105, 115, 116, 49, 48])
            || offset(bytes, 0, &[98, 112, 108, 105, 115, 116, 49, 53])
            || offset(bytes, 0, &[98, 112, 108, 105, 115, 116, 49, 54])
            || offset(bytes, 0, &[98, 112, 108, 105, 115, 116]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_x_itunes_bplist_application,
            &T_x_memgraph_application,
            &T_x_webarchive_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_cbor_application;
impl MimeTypeChecker for T_cbor_application {
    fn get_mime(&self) -> &'static str {
        "application/cbor"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cbor"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[217, 217, 247])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_coreldraw_application;
impl MimeTypeChecker for T_coreldraw_application {
    fn get_mime(&self) -> &'static str {
        "application/coreldraw"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cdr"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[82, 73, 70, 70])
            && (offset(bytes, 8, &[67, 68, 82])
                || offset(bytes, 8, &[99, 100, 114])
                || offset(bytes, 8, &[68, 69, 83])
                || offset(bytes, 8, &[100, 101, 115])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_illustrator_ps_application;
impl MimeTypeChecker for T_illustrator_ps_application {
    fn get_mime(&self) -> &'static str {
        "application/illustrator+ps"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> =
            Lazy::new(|| Regex::new("[\r\n]%AI5_FileFormat [1-4][\r\n]").unwrap());

        regex_range(bytes, 0, 8192, &REGEX_PATTERN_0)
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_apple_mpegurl_application;
impl MimeTypeChecker for T_vnd_apple_mpegurl_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.apple.mpegurl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.m3u8"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[35, 69, 88, 84, 77, 51, 85])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_etsi_asic_e_zip_application;
impl MimeTypeChecker for T_vnd_etsi_asic_e_zip_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.etsi.asic-e+zip"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.asice"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75, 3, 4])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 101, 116, 115, 105, 46, 97, 115, 105, 99,
                    45, 101, 43, 122, 105, 112,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_etsi_asic_s_zip_application;
impl MimeTypeChecker for T_vnd_etsi_asic_s_zip_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.etsi.asic-s+zip"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.asics"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75, 3, 4])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 101, 116, 115, 105, 46, 97, 115, 105, 99,
                    45, 115, 43, 122, 105, 112,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_excel_sheet_4_application;
impl MimeTypeChecker for T_vnd_ms_excel_sheet_4_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-excel.sheet.4"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[9, 4, 6, 0])
            && (offset(bytes, 4, &[0, 0, 16, 0])
                || offset(bytes, 4, &[0, 0, 32, 0])
                || offset(bytes, 4, &[0, 0, 64, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_excel_workspace_4_application;
impl MimeTypeChecker for T_vnd_ms_excel_workspace_4_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-excel.workspace.4"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[9, 4, 6, 0]) && offset(bytes, 4, &[0, 0, 0, 1]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_excel_sheet_3_application;
impl MimeTypeChecker for T_vnd_ms_excel_sheet_3_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-excel.sheet.3"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[9, 2, 6, 0])
            && (offset(bytes, 4, &[0, 0, 16, 0])
                || offset(bytes, 4, &[0, 0, 32, 0])
                || offset(bytes, 4, &[0, 0, 64, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_excel_workspace_3_application;
impl MimeTypeChecker for T_vnd_ms_excel_workspace_3_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-excel.workspace.3"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[9, 2, 6, 0]) && offset(bytes, 4, &[0, 0, 0, 1]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_excel_sheet_2_application;
impl MimeTypeChecker for T_vnd_ms_excel_sheet_2_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-excel.sheet.2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[9, 0, 4, 0])
            && (offset(bytes, 4, &[0, 0, 16, 0])
                || offset(bytes, 4, &[0, 0, 32, 0])
                || offset(bytes, 4, &[0, 0, 64, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_tcpdump_pcap_application;
impl MimeTypeChecker for T_vnd_tcpdump_pcap_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.tcpdump.pcap"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pcap", "*.cap", "*.dmp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[161, 178, 195, 212]) || offset(bytes, 0, &[212, 195, 178, 161]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_tcpdump_pcapng_application;
impl MimeTypeChecker for T_vnd_tcpdump_pcapng_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.tcpdump.pcapng"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pcapng"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[10, 13, 13, 10])
            && (offset(bytes, 8, &[161, 178, 195, 212]) || offset(bytes, 8, &[77, 60, 43, 26])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_warc_application;
impl MimeTypeChecker for T_warc_application {
    fn get_mime(&self) -> &'static str {
        "application/warc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.warc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[87, 65, 82, 67, 47])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_activemime_application;
impl MimeTypeChecker for T_x_activemime_application {
    fn get_mime(&self) -> &'static str {
        "application/x-activemime"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[65, 99, 116, 105, 118, 101, 77, 105, 109, 101, 0, 0],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_axcrypt_application;
impl MimeTypeChecker for T_x_axcrypt_application {
    fn get_mime(&self) -> &'static str {
        "application/x-axcrypt"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.axx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                192, 185, 7, 46, 79, 147, 241, 70, 160, 21, 121, 44, 161, 217, 232, 33,
            ],
        ) && offset(bytes, 17, &[0, 0, 0, 2]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_berkeley_db_format_hash_version_2_application;
impl MimeTypeChecker for T_x_berkeley_db_format_hash_version_2_application {
    fn get_mime(&self) -> &'static str {
        "application/x-berkeley-db;format=hash;version=2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 12, &[97, 21, 6, 0]) && offset(bytes, 16, &[5, 0, 0, 0]))
            || (offset(bytes, 12, &[0, 6, 21, 97]) && offset(bytes, 16, &[0, 0, 0, 5]))
            || (offset(bytes, 12, &[97, 21, 6, 0]) && offset(bytes, 16, &[5, 0, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_berkeley_db_format_hash_version_3_application;
impl MimeTypeChecker for T_x_berkeley_db_format_hash_version_3_application {
    fn get_mime(&self) -> &'static str {
        "application/x-berkeley-db;format=hash;version=3"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 12, &[97, 21, 6, 0]) && offset(bytes, 16, &[7, 0, 0, 0]))
            || (offset(bytes, 12, &[0, 6, 21, 97]) && offset(bytes, 16, &[0, 0, 0, 7]))
            || (offset(bytes, 12, &[97, 21, 6, 0]) && offset(bytes, 16, &[7, 0, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_berkeley_db_format_hash_version_4_application;
impl MimeTypeChecker for T_x_berkeley_db_format_hash_version_4_application {
    fn get_mime(&self) -> &'static str {
        "application/x-berkeley-db;format=hash;version=4"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 12, &[97, 21, 6, 0]) && offset(bytes, 16, &[8, 0, 0, 0]))
            || (offset(bytes, 12, &[0, 6, 21, 97]) && offset(bytes, 16, &[0, 0, 0, 8]))
            || (offset(bytes, 12, &[97, 21, 6, 0]) && offset(bytes, 16, &[8, 0, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_berkeley_db_format_hash_version_5_application;
impl MimeTypeChecker for T_x_berkeley_db_format_hash_version_5_application {
    fn get_mime(&self) -> &'static str {
        "application/x-berkeley-db;format=hash;version=5"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 12, &[97, 21, 6, 0]) && offset(bytes, 16, &[9, 0, 0, 0]))
            || (offset(bytes, 12, &[0, 6, 21, 97]) && offset(bytes, 16, &[0, 0, 0, 9]))
            || (offset(bytes, 12, &[97, 21, 6, 0]) && offset(bytes, 16, &[9, 0, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_berkeley_db_format_btree_version_2_application;
impl MimeTypeChecker for T_x_berkeley_db_format_btree_version_2_application {
    fn get_mime(&self) -> &'static str {
        "application/x-berkeley-db;format=btree;version=2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 12, &[98, 49, 5, 0]) && offset(bytes, 16, &[6, 0, 0, 0]))
            || (offset(bytes, 12, &[0, 5, 49, 98]) && offset(bytes, 16, &[0, 0, 0, 6]))
            || (offset(bytes, 12, &[98, 49, 5, 0]) && offset(bytes, 16, &[6, 0, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_berkeley_db_format_btree_version_3_application;
impl MimeTypeChecker for T_x_berkeley_db_format_btree_version_3_application {
    fn get_mime(&self) -> &'static str {
        "application/x-berkeley-db;format=btree;version=3"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 12, &[98, 49, 5, 0]) && offset(bytes, 16, &[8, 0, 0, 0]))
            || (offset(bytes, 12, &[0, 5, 49, 98]) && offset(bytes, 16, &[0, 0, 0, 8]))
            || (offset(bytes, 12, &[98, 49, 5, 0]) && offset(bytes, 16, &[8, 0, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_berkeley_db_format_btree_version_4_application;
impl MimeTypeChecker for T_x_berkeley_db_format_btree_version_4_application {
    fn get_mime(&self) -> &'static str {
        "application/x-berkeley-db;format=btree;version=4"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 12, &[98, 49, 5, 0]) && offset(bytes, 16, &[9, 0, 0, 0]))
            || (offset(bytes, 12, &[0, 5, 49, 98]) && offset(bytes, 16, &[0, 0, 0, 9]))
            || (offset(bytes, 12, &[98, 49, 5, 0]) && offset(bytes, 16, &[9, 0, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_debian_package_application;
impl MimeTypeChecker for T_x_debian_package_application {
    fn get_mime(&self) -> &'static str {
        "application/x-debian-package"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.deb", "*.udeb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                33, 60, 97, 114, 99, 104, 62, 10, 100, 101, 98, 105, 97, 110, 45, 98, 105, 110, 97,
                114, 121,
            ],
        ) || offset(
            bytes,
            0,
            &[
                33, 60, 97, 114, 99, 104, 62, 10, 100, 101, 98, 105, 97, 110, 45, 115, 112, 108,
                105, 116,
            ],
        ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_font_type1_application;
impl MimeTypeChecker for T_x_font_type1_application {
    fn get_mime(&self) -> &'static str {
        "application/x-font-type1"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pfa", "*.pfb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset_mask(
            bytes,
            0,
            &[
                128, 1, 255, 255, 0, 0, 37, 33, 80, 83, 45, 65, 100, 111, 98, 101, 70, 111, 110,
                116,
            ],
            &[
                255, 255, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
                255, 255, 255,
            ],
        ) || offset(
            bytes,
            0,
            &[
                37, 33, 80, 83, 45, 65, 100, 111, 98, 101, 70, 111, 110, 116, 45, 49, 46, 48,
            ],
        ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_foxmail_application;
impl MimeTypeChecker for T_x_foxmail_application {
    fn get_mime(&self) -> &'static str {
        "application/x-foxmail"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 83],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_internet_archive_application;
impl MimeTypeChecker for T_x_internet_archive_application {
    fn get_mime(&self) -> &'static str {
        "application/x-internet-archive"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.arc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[102, 105, 108, 101, 100, 101, 115, 99, 58, 47, 47],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_lz4_application;
impl MimeTypeChecker for T_x_lz4_application {
    fn get_mime(&self) -> &'static str {
        "application/x-lz4"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.lz4"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[4, 34, 77, 24]) || offset(bytes, 0, &[2, 33, 76, 24]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mobipocket_ebook_application;
impl MimeTypeChecker for T_x_mobipocket_ebook_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mobipocket-ebook"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.prc", "*.mobi"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_range(bytes, 0, 60, &[66, 79, 79, 75, 77, 79, 66, 73])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_msaccess_application;
impl MimeTypeChecker for T_x_msaccess_application {
    fn get_mime(&self) -> &'static str {
        "application/x-msaccess"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.accdb", "*.accde", "*.mdb", "*.mde"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[0, 1, 0, 0, 83, 116, 97, 110])
            || offset(
                bytes,
                4,
                &[
                    83, 116, 97, 110, 100, 97, 114, 100, 32, 65, 67, 69, 32, 68, 66,
                ],
            )
            || offset(
                bytes,
                4,
                &[
                    83, 116, 97, 110, 100, 97, 114, 100, 32, 74, 69, 84, 32, 68, 66,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_msdownload_format_pe32_application;
impl MimeTypeChecker for T_x_msdownload_format_pe32_application {
    fn get_mime(&self) -> &'static str {
        "application/x-msdownload;format=pe32"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 128, &[80, 69, 0, 0]) && offset(bytes, 132, &[76, 1]))
            || (offset(bytes, 240, &[80, 69, 0, 0]) && offset(bytes, 244, &[76, 1])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_msdownload_format_pe64_application;
impl MimeTypeChecker for T_x_msdownload_format_pe64_application {
    fn get_mime(&self) -> &'static str {
        "application/x-msdownload;format=pe64"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 128, &[80, 69, 0, 0]) && offset(bytes, 132, &[100, 134]))
            || (offset(bytes, 240, &[80, 69, 0, 0]) && offset(bytes, 244, &[100, 134])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_msdownload_format_pe_itanium_application;
impl MimeTypeChecker for T_x_msdownload_format_pe_itanium_application {
    fn get_mime(&self) -> &'static str {
        "application/x-msdownload;format=pe-itanium"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 128, &[80, 69, 0, 0]) && offset(bytes, 132, &[0, 2]))
            || (offset(bytes, 240, &[80, 69, 0, 0]) && offset(bytes, 244, &[0, 2])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_msdownload_format_pe_armLE_application;
impl MimeTypeChecker for T_x_msdownload_format_pe_armLE_application {
    fn get_mime(&self) -> &'static str {
        "application/x-msdownload;format=pe-armLE"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 128, &[112, 101, 0, 0]) && offset(bytes, 132, &[192, 1]))
            || (offset(bytes, 240, &[112, 101, 0, 0]) && offset(bytes, 244, &[192, 1])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_msdownload_format_pe_arm7_application;
impl MimeTypeChecker for T_x_msdownload_format_pe_arm7_application {
    fn get_mime(&self) -> &'static str {
        "application/x-msdownload;format=pe-arm7"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 128, &[112, 101, 0, 0]) && offset(bytes, 132, &[196, 1]))
            || (offset(bytes, 240, &[112, 101, 0, 0]) && offset(bytes, 244, &[196, 1])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_msmoney_application;
impl MimeTypeChecker for T_x_msmoney_application {
    fn get_mime(&self) -> &'static str {
        "application/x-msmoney"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mny"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                0, 1, 0, 0, 77, 83, 73, 83, 65, 77, 32, 68, 97, 116, 97, 98, 97, 115, 101,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_rar_compressed_version_4_application;
impl MimeTypeChecker for T_x_rar_compressed_version_4_application {
    fn get_mime(&self) -> &'static str {
        "application/x-rar-compressed;version=4"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[82, 97, 114, 33, 26, 7, 0])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_rar_compressed_version_5_application;
impl MimeTypeChecker for T_x_rar_compressed_version_5_application {
    fn get_mime(&self) -> &'static str {
        "application/x-rar-compressed;version=5"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[82, 97, 114, 33, 26, 7, 1, 0])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_shapefile_application;
impl MimeTypeChecker for T_x_shapefile_application {
    fn get_mime(&self) -> &'static str {
        "application/x-shapefile"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.shp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[0, 0, 39, 10])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_geopackage_application;
impl MimeTypeChecker for T_x_geopackage_application {
    fn get_mime(&self) -> &'static str {
        "application/x-geopackage"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gpkg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                83, 81, 76, 105, 116, 101, 32, 102, 111, 114, 109, 97, 116, 32, 51, 0,
            ],
        ) && offset(bytes, 68, &[71, 80, 75, 71]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_geopackage__version_1_1Or1_0_application;
impl MimeTypeChecker for T_x_geopackage__version_1_1Or1_0_application {
    fn get_mime(&self) -> &'static str {
        "application/x-geopackage; version=1.1Or1.0"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gpkg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                83, 81, 76, 105, 116, 101, 32, 102, 111, 114, 109, 97, 116, 32, 51, 0,
            ],
        ) && offset(bytes, 68, &[71, 80, 49, 48]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_fossil_checkout_application;
impl MimeTypeChecker for T_x_fossil_checkout_application {
    fn get_mime(&self) -> &'static str {
        "application/x-fossil-checkout"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                83, 81, 76, 105, 116, 101, 32, 102, 111, 114, 109, 97, 116, 32, 51, 0,
            ],
        ) && offset(bytes, 68, &[15, 5, 81, 18]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_fossil_global_conf_application;
impl MimeTypeChecker for T_x_fossil_global_conf_application {
    fn get_mime(&self) -> &'static str {
        "application/x-fossil-global-conf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                83, 81, 76, 105, 116, 101, 32, 102, 111, 114, 109, 97, 116, 32, 51, 0,
            ],
        ) && offset(bytes, 68, &[15, 5, 81, 19]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_fossil_repository_application;
impl MimeTypeChecker for T_x_fossil_repository_application {
    fn get_mime(&self) -> &'static str {
        "application/x-fossil-repository"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                83, 81, 76, 105, 116, 101, 32, 102, 111, 114, 109, 97, 116, 32, 51, 0,
            ],
        ) && offset(bytes, 68, &[15, 5, 81, 17]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_bentley_besqlite_application;
impl MimeTypeChecker for T_x_bentley_besqlite_application {
    fn get_mime(&self) -> &'static str {
        "application/x-bentley-besqlite"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                83, 81, 76, 105, 116, 101, 32, 102, 111, 114, 109, 97, 116, 32, 51, 0,
            ],
        ) && offset(bytes, 68, &[66, 101, 68, 98]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_bentley_localization_application;
impl MimeTypeChecker for T_x_bentley_localization_application {
    fn get_mime(&self) -> &'static str {
        "application/x-bentley-localization"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                83, 81, 76, 105, 116, 101, 32, 102, 111, 114, 109, 97, 116, 32, 51, 0,
            ],
        ) && offset(bytes, 68, &[66, 101, 76, 110]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_monotone_source_repo_application;
impl MimeTypeChecker for T_x_monotone_source_repo_application {
    fn get_mime(&self) -> &'static str {
        "application/x-monotone-source-repo"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                83, 81, 76, 105, 116, 101, 32, 102, 111, 114, 109, 97, 116, 32, 51, 0,
            ],
        ) && offset(bytes, 68, &[95, 77, 84, 78]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_esri_spatially_enabled_db_application;
impl MimeTypeChecker for T_x_esri_spatially_enabled_db_application {
    fn get_mime(&self) -> &'static str {
        "application/x-esri-spatially-enabled-db"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                83, 81, 76, 105, 116, 101, 32, 102, 111, 114, 109, 97, 116, 32, 51, 0,
            ],
        ) && offset(bytes, 68, &[69, 115, 114, 105]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mbtiles_application;
impl MimeTypeChecker for T_x_mbtiles_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mbtiles"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                83, 81, 76, 105, 116, 101, 32, 102, 111, 114, 109, 97, 116, 32, 51, 0,
            ],
        ) && offset(bytes, 68, &[77, 80, 66, 88]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_texnicard_application;
impl MimeTypeChecker for T_x_texnicard_application {
    fn get_mime(&self) -> &'static str {
        "application/x-texnicard"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                83, 81, 76, 105, 116, 101, 32, 102, 111, 114, 109, 97, 116, 32, 51, 0,
            ],
        ) && offset(bytes, 68, &[106, 3, 87, 68]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_stata_dta_version_14_application;
impl MimeTypeChecker for T_x_stata_dta_version_14_application {
    fn get_mime(&self) -> &'static str {
        "application/x-stata-dta;version=14"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                60, 115, 116, 97, 116, 97, 95, 100, 116, 97, 62, 60, 104, 101, 97, 100, 101, 114,
                62, 60, 114, 101, 108, 101, 97, 115, 101, 62, 49, 49, 56, 60, 47, 114, 101, 108,
                101, 97, 115, 101, 62,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_stata_dta_version_13_application;
impl MimeTypeChecker for T_x_stata_dta_version_13_application {
    fn get_mime(&self) -> &'static str {
        "application/x-stata-dta;version=13"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                60, 115, 116, 97, 116, 97, 95, 100, 116, 97, 62, 60, 104, 101, 97, 100, 101, 114,
                62, 60, 114, 101, 108, 101, 97, 115, 101, 62, 49, 49, 55, 60, 47, 114, 101, 108,
                101, 97, 115, 101, 62,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_stata_dta_version_12_application;
impl MimeTypeChecker for T_x_stata_dta_version_12_application {
    fn get_mime(&self) -> &'static str {
        "application/x-stata-dta;version=12"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                60, 115, 116, 97, 116, 97, 95, 100, 116, 97, 62, 60, 104, 101, 97, 100, 101, 114,
                62, 60, 114, 101, 108, 101, 97, 115, 101, 62, 49, 49, 53, 60, 47, 114, 101, 108,
                101, 97, 115, 101, 62,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_stata_dta_version_10_application;
impl MimeTypeChecker for T_x_stata_dta_version_10_application {
    fn get_mime(&self) -> &'static str {
        "application/x-stata-dta;version=10"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                60, 115, 116, 97, 116, 97, 95, 100, 116, 97, 62, 60, 104, 101, 97, 100, 101, 114,
                62, 60, 114, 101, 108, 101, 97, 115, 101, 62, 49, 49, 52, 60, 47, 114, 101, 108,
                101, 97, 115, 101, 62,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_stata_dta_version_8_application;
impl MimeTypeChecker for T_x_stata_dta_version_8_application {
    fn get_mime(&self) -> &'static str {
        "application/x-stata-dta;version=8"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                60, 115, 116, 97, 116, 97, 95, 100, 116, 97, 62, 60, 104, 101, 97, 100, 101, 114,
                62, 60, 114, 101, 108, 101, 97, 115, 101, 62, 49, 49, 51, 60, 47, 114, 101, 108,
                101, 97, 115, 101, 62,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mp4_audio;
impl MimeTypeChecker for T_mp4_audio {
    fn get_mime(&self) -> &'static str {
        "audio/mp4"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mp4a", "*.m4a", "*.m4b"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 4, &[102, 116, 121, 112, 77, 52, 65, 32])
            || offset(bytes, 4, &[102, 116, 121, 112, 77, 52, 66, 32])
            || offset(bytes, 4, &[102, 116, 121, 112, 77, 52, 80, 32])
            || offset(bytes, 4, &[102, 116, 121, 112, 70, 52, 65, 32])
            || offset(bytes, 4, &[102, 116, 121, 112, 70, 52, 66, 32])
            || offset(bytes, 4, &[102, 116, 121, 112, 78, 68, 65, 83])
            || offset(bytes, 4, &[102, 116, 121, 112, 77, 83, 78, 86]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vorbis_audio;
impl MimeTypeChecker for T_vorbis_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vorbis"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ogg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[79, 103, 103, 83, 0])
            && offset(bytes, 28, &[1, 118, 111, 114, 98, 105, 115]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_oggflac_audio;
impl MimeTypeChecker for T_x_oggflac_audio {
    fn get_mime(&self) -> &'static str {
        "audio/x-oggflac"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_mask(
            bytes,
            0,
            &[
                79, 103, 103, 83, 0, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
                46, 46, 46, 46, 46, 46, 46, 46, 70, 76, 65, 67,
            ],
            &[
                255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                0, 0, 0, 0, 255, 255, 255,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_oggpcm_audio;
impl MimeTypeChecker for T_x_oggpcm_audio {
    fn get_mime(&self) -> &'static str {
        "audio/x-oggpcm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_mask(
            bytes,
            0,
            &[
                79, 103, 103, 83, 0, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
                46, 46, 46, 46, 46, 46, 46, 46, 80, 67, 77, 32, 32, 32, 32, 32,
            ],
            &[
                255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_opus_audio;
impl MimeTypeChecker for T_opus_audio {
    fn get_mime(&self) -> &'static str {
        "audio/opus"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.opus"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[79, 103, 103, 83, 0])
            && offset(bytes, 28, &[79, 112, 117, 115, 72, 101, 97, 100]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_speex_audio;
impl MimeTypeChecker for T_speex_audio {
    fn get_mime(&self) -> &'static str {
        "audio/speex"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.spx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[79, 103, 103, 83, 0])
            && offset(bytes, 28, &[83, 112, 101, 101, 120, 32, 32, 32]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_caf_audio;
impl MimeTypeChecker for T_x_caf_audio {
    fn get_mime(&self) -> &'static str {
        "audio/x-caf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.caf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[99, 97, 102, 102, 0, 0])
            || offset(bytes, 0, &[99, 97, 102, 102, 0, 1])
            || offset(bytes, 0, &[99, 97, 102, 102, 0, 2])
            || offset(bytes, 0, &[99, 97, 102, 102, 64, 0])
            || offset(bytes, 0, &[99, 97, 102, 102, 128, 0]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_avif_image;
impl MimeTypeChecker for T_avif_image {
    fn get_mime(&self) -> &'static str {
        "image/avif"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.avif"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 4, &[102, 116, 121, 112, 97, 118, 105, 102])
            || offset(bytes, 4, &[102, 116, 121, 112, 97, 118, 105, 115]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_heic_image;
impl MimeTypeChecker for T_heic_image {
    fn get_mime(&self) -> &'static str {
        "image/heic"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.heic"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 4, &[102, 116, 121, 112, 104, 101, 105, 99])
            || offset(bytes, 4, &[102, 116, 121, 112, 104, 101, 105, 120]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_heic_sequence_image;
impl MimeTypeChecker for T_heic_sequence_image {
    fn get_mime(&self) -> &'static str {
        "image/heic-sequence"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 4, &[102, 116, 121, 112, 104, 101, 118, 99])
            || offset(bytes, 4, &[102, 116, 121, 112, 104, 101, 118, 120]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_canon_cr2_image;
impl MimeTypeChecker for T_x_canon_cr2_image {
    fn get_mime(&self) -> &'static str {
        "image/x-canon-cr2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cr2"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 0, &[77, 77, 0, 42]) && offset(bytes, 8, &[67, 82]))
            || (offset(bytes, 0, &[73, 73, 42, 0]) && offset(bytes, 8, &[67, 82]))
            || (offset(bytes, 0, &[77, 77, 0, 43]) && offset(bytes, 8, &[67, 82])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_canon_cr3_image;
impl MimeTypeChecker for T_x_canon_cr3_image {
    fn get_mime(&self) -> &'static str {
        "image/x-canon-cr3"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cr3"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 4, &[102, 116, 121, 112, 99, 114, 120, 32])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_news_message;
impl MimeTypeChecker for T_news_message {
    fn get_mime(&self) -> &'static str {
        "message/news"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 97, 116, 104, 58])
            || offset(bytes, 0, &[88, 114, 101, 102, 58])
            || offset(bytes, 0, &[65, 114, 116, 105, 99, 108, 101]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_httpresponse_application;
impl MimeTypeChecker for T_x_httpresponse_application {
    fn get_mime(&self) -> &'static str {
        "application/x-httpresponse"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[72, 84, 84, 80, 47])
            && (offset_range(
                bytes,
                0,
                1000,
                &[
                    10, 67, 97, 99, 104, 101, 45, 67, 111, 110, 116, 114, 111, 108, 58,
                ],
            ) || offset_range(
                bytes,
                0,
                1000,
                &[
                    10, 67, 111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58,
                ],
            ) || offset_range(
                bytes,
                0,
                1000,
                &[
                    10, 67, 111, 110, 116, 101, 110, 116, 45, 76, 101, 110, 103, 116, 104, 58,
                ],
            ) || offset_range(
                bytes,
                0,
                1000,
                &[
                    10, 67, 111, 110, 116, 101, 110, 116, 45, 68, 105, 115, 112, 111, 115, 105,
                    116, 105, 111, 110, 58,
                ],
            ) || offset_range(bytes, 0, 1000, &[10, 68, 97, 116, 101, 58])
                || offset_range(bytes, 0, 1000, &[10, 83, 101, 114, 118, 101, 114, 58])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_related_multipart;
impl MimeTypeChecker for T_related_multipart {
    fn get_mime(&self) -> &'static str {
        "multipart/related"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mht", "*.mhtml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset_case_insensitive(
            bytes,
            0,
            &[
                70, 114, 111, 109, 58, 32, 60, 83, 97, 118, 101, 100, 32, 98, 121, 32, 87, 105,
                110, 100, 111, 119, 115, 32, 73, 110, 116, 101, 114, 110, 101, 116, 32, 69, 120,
                112, 108, 111, 114, 101, 114, 32, 56, 62,
            ],
        ) || offset_case_insensitive(
            bytes,
            0,
            &[
                70, 114, 111, 109, 58, 32, 34, 83, 97, 118, 101, 100, 32, 98, 121, 32, 73, 110,
                116, 101, 114, 110, 101, 116, 32, 69, 120, 112, 108, 111, 114, 101, 114, 32, 49,
                49, 34,
            ],
        ) || (offset(
            bytes,
            0,
            &[
                77, 73, 77, 69, 45, 86, 101, 114, 115, 105, 111, 110, 58, 32, 49, 46, 48,
            ],
        ) && offset_range(
            bytes,
            16,
            512,
            &[
                10, 67, 111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 32, 109, 117, 108,
                116, 105, 112, 97, 114, 116, 47, 114, 101, 108, 97, 116, 101, 100,
            ],
        )))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_e57_model;
impl MimeTypeChecker for T_e57_model {
    fn get_mime(&self) -> &'static str {
        "model/e57"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.e57"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[65, 83, 84, 77, 45, 69, 53, 55])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_stl_ascii_model;
impl MimeTypeChecker for T_x_stl_ascii_model {
    fn get_mime(&self) -> &'static str {
        "model/x.stl-ascii"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[115, 111, 108, 105, 100, 32])
            && offset_range(bytes, 7, 256, &[102, 97, 99, 101, 116, 32]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dwf_version_6_model;
impl MimeTypeChecker for T_vnd_dwf_version_6_model {
    fn get_mime(&self) -> &'static str {
        "model/vnd.dwf;version=6"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[40, 68, 87, 70, 32, 86, 48, 54, 46])
            && offset(bytes, 11, &[41, 80, 75]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dwf_version_5_model;
impl MimeTypeChecker for T_vnd_dwf_version_5_model {
    fn get_mime(&self) -> &'static str {
        "model/vnd.dwf;version=5"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[40, 68, 87, 70, 32, 86, 48, 48, 46, 53, 53, 41])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dwf_version_2_model;
impl MimeTypeChecker for T_vnd_dwf_version_2_model {
    fn get_mime(&self) -> &'static str {
        "model/vnd.dwf;version=2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[40, 68, 87, 70, 32, 86, 48, 48, 46, 50, 50, 41])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_php_text;
impl MimeTypeChecker for T_x_php_text {
    fn get_mime(&self) -> &'static str {
        "text/x-php"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.php", "*.php3", "*.php4"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[60, 63, 112, 104, 112])
            || offset(
                bytes,
                0,
                &[
                    35, 33, 47, 117, 115, 114, 47, 98, 105, 110, 47, 112, 104, 112,
                ],
            )
            || offset(
                bytes,
                0,
                &[
                    35, 33, 47, 117, 115, 114, 47, 98, 105, 110, 47, 101, 110, 118, 32, 112, 104,
                    112,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_3gpp_video;
impl MimeTypeChecker for T_3gpp_video {
    fn get_mime(&self) -> &'static str {
        "video/3gpp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.3gp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 4, &[102, 116, 121, 112, 51, 103, 101, 54])
            || offset(bytes, 4, &[102, 116, 121, 112, 51, 103, 101, 55])
            || offset(bytes, 4, &[102, 116, 121, 112, 51, 103, 103, 54])
            || offset(bytes, 4, &[102, 116, 121, 112, 51, 103, 112, 49])
            || offset(bytes, 4, &[102, 116, 121, 112, 51, 103, 112, 50])
            || offset(bytes, 4, &[102, 116, 121, 112, 51, 103, 112, 51])
            || offset(bytes, 4, &[102, 116, 121, 112, 51, 103, 112, 52])
            || offset(bytes, 4, &[102, 116, 121, 112, 51, 103, 112, 53])
            || offset(bytes, 4, &[102, 116, 121, 112, 51, 103, 112, 54])
            || offset(bytes, 4, &[102, 116, 121, 112, 51, 103, 112, 55])
            || offset(bytes, 4, &[102, 116, 121, 112, 51, 103, 115, 55]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_3gpp2_video;
impl MimeTypeChecker for T_3gpp2_video {
    fn get_mime(&self) -> &'static str {
        "video/3gpp2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.3g2"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 4, &[102, 116, 121, 112, 51, 103, 50, 52])
            || offset(bytes, 4, &[102, 116, 121, 112, 51, 103, 50, 53])
            || offset(bytes, 4, &[102, 116, 121, 112, 51, 103, 50, 54])
            || offset(bytes, 4, &[102, 116, 121, 112, 51, 103, 50, 97])
            || offset(bytes, 4, &[102, 116, 121, 112, 51, 103, 50, 98])
            || offset(bytes, 4, &[102, 116, 121, 112, 51, 103, 50, 99])
            || offset(bytes, 4, &[102, 116, 121, 112, 75, 68, 68, 73]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_daala_video;
impl MimeTypeChecker for T_daala_video {
    fn get_mime(&self) -> &'static str {
        "video/daala"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_mask(
            bytes,
            0,
            &[
                79, 103, 103, 83, 0, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
                46, 46, 46, 46, 46, 46, 46, 46, 128, 100, 97, 97, 108, 97,
            ],
            &[
                255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                0, 0, 0, 0, 255, 255, 255, 255, 255, 255,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_theora_video;
impl MimeTypeChecker for T_theora_video {
    fn get_mime(&self) -> &'static str {
        "video/theora"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_mask(
            bytes,
            0,
            &[
                79, 103, 103, 83, 0, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
                46, 46, 46, 46, 46, 46, 46, 46, 128, 116, 104, 101, 111, 114, 97,
            ],
            &[
                255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_dirac_video;
impl MimeTypeChecker for T_x_dirac_video {
    fn get_mime(&self) -> &'static str {
        "video/x-dirac"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.drc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_mask(
            bytes,
            0,
            &[
                79, 103, 103, 83, 0, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
                46, 46, 46, 46, 46, 46, 46, 46, 66, 66, 67, 68,
            ],
            &[
                255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                0, 0, 0, 0, 255, 255, 255, 255,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ogm_video;
impl MimeTypeChecker for T_x_ogm_video {
    fn get_mime(&self) -> &'static str {
        "video/x-ogm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ogm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_mask(
            bytes,
            0,
            &[
                79, 103, 103, 83, 0, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
                46, 46, 46, 46, 46, 46, 46, 46, 118, 105, 100, 101, 111,
            ],
            &[
                255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                0, 0, 0, 0, 255, 255, 255, 255, 255,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ogguvs_video;
impl MimeTypeChecker for T_x_ogguvs_video {
    fn get_mime(&self) -> &'static str {
        "video/x-ogguvs"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_mask(
            bytes,
            0,
            &[
                79, 103, 103, 83, 0, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
                46, 46, 46, 46, 46, 46, 46, 46, 85, 86, 83, 32,
            ],
            &[
                255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                0, 0, 0, 0, 255, 255, 255, 255,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_oggyuv_video;
impl MimeTypeChecker for T_x_oggyuv_video {
    fn get_mime(&self) -> &'static str {
        "video/x-oggyuv"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_mask(
            bytes,
            0,
            &[
                79, 103, 103, 83, 0, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
                46, 46, 46, 46, 46, 46, 46, 46, 1, 89, 85, 86,
            ],
            &[
                255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                0, 0, 0, 0, 255, 255, 255, 255,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_oggrgb_video;
impl MimeTypeChecker for T_x_oggrgb_video {
    fn get_mime(&self) -> &'static str {
        "video/x-oggrgb"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_mask(
            bytes,
            0,
            &[
                79, 103, 103, 83, 0, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
                46, 46, 46, 46, 46, 46, 46, 46, 1, 82, 71, 66,
            ],
            &[
                255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                0, 0, 0, 0, 255, 255, 255, 255,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_m4v_video;
impl MimeTypeChecker for T_x_m4v_video {
    fn get_mime(&self) -> &'static str {
        "video/x-m4v"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.m4v"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 4, &[102, 116, 121, 112, 77, 52, 86, 32])
            || offset(bytes, 4, &[102, 116, 121, 112, 77, 52, 86, 72])
            || offset(bytes, 4, &[102, 116, 121, 112, 77, 52, 86, 80]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ms_wmv_video;
impl MimeTypeChecker for T_x_ms_wmv_video {
    fn get_mime(&self) -> &'static str {
        "video/x-ms-wmv"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wmv"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (unicode_le_range(
            bytes,
            0,
            8192,
            &[
                87, 105, 110, 100, 111, 119, 115, 32, 77, 101, 100, 105, 97, 32, 86, 105, 100, 101,
                111,
            ],
        ) || unicode_le_range(
            bytes,
            0,
            8192,
            &[
                86, 67, 45, 49, 32, 65, 100, 118, 97, 110, 99, 101, 100, 32, 80, 114, 111, 102,
                105, 108, 101,
            ],
        ) || unicode_le_range(bytes, 0, 8192, &[119, 109, 118, 50]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mach_o_universal_application;
impl MimeTypeChecker for T_x_mach_o_universal_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mach-o-universal"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 0, &[202, 254, 186, 190])
            && (offset(bytes, 4, &[0, 0, 0, 1])
                || offset(bytes, 4, &[0, 0, 0, 2])
                || offset(bytes, 4, &[0, 0, 0, 3])
                || offset(bytes, 4, &[0, 0, 0, 4])
                || offset(bytes, 4, &[0, 0, 0, 5])
                || offset(bytes, 4, &[0, 0, 0, 6])
                || offset(bytes, 4, &[0, 0, 0, 7])
                || offset(bytes, 4, &[0, 0, 0, 8])
                || offset(bytes, 4, &[0, 0, 0, 9])
                || offset(bytes, 4, &[0, 0, 0, 10])
                || offset(bytes, 4, &[0, 0, 0, 11])
                || offset(bytes, 4, &[0, 0, 0, 12])
                || offset(bytes, 4, &[0, 0, 0, 13])
                || offset(bytes, 4, &[0, 0, 0, 14])
                || offset(bytes, 4, &[0, 0, 0, 15])
                || offset(bytes, 4, &[0, 0, 0, 16])
                || offset(bytes, 4, &[0, 0, 0, 17])
                || offset(bytes, 4, &[0, 0, 0, 18])
                || offset(bytes, 4, &[0, 0, 0, 19])))
            || (offset(bytes, 0, &[190, 186, 254, 202])
                && (offset(bytes, 4, &[1, 0, 0, 0])
                    || offset(bytes, 4, &[2, 0, 0, 0])
                    || offset(bytes, 4, &[3, 0, 0, 0])
                    || offset(bytes, 4, &[4, 0, 0, 0])
                    || offset(bytes, 4, &[5, 0, 0, 0])
                    || offset(bytes, 4, &[6, 0, 0, 0])
                    || offset(bytes, 4, &[7, 0, 0, 0])
                    || offset(bytes, 4, &[8, 0, 0, 0])
                    || offset(bytes, 4, &[9, 0, 0, 0])
                    || offset(bytes, 4, &[10, 0, 0, 0])
                    || offset(bytes, 4, &[11, 0, 0, 0])
                    || offset(bytes, 4, &[12, 0, 0, 0])
                    || offset(bytes, 4, &[13, 0, 0, 0])
                    || offset(bytes, 4, &[14, 0, 0, 0])
                    || offset(bytes, 4, &[15, 0, 0, 0])
                    || offset(bytes, 4, &[16, 0, 0, 0])
                    || offset(bytes, 4, &[17, 0, 0, 0])
                    || offset(bytes, 4, &[18, 0, 0, 0])
                    || offset(bytes, 4, &[19, 0, 0, 0])))
            || (offset(bytes, 0, &[202, 254, 186, 191])
                && (offset(bytes, 4, &[0, 0, 0, 1])
                    || offset(bytes, 4, &[0, 0, 0, 2])
                    || offset(bytes, 4, &[0, 0, 0, 3])
                    || offset(bytes, 4, &[0, 0, 0, 4])
                    || offset(bytes, 4, &[0, 0, 0, 5])
                    || offset(bytes, 4, &[0, 0, 0, 6])
                    || offset(bytes, 4, &[0, 0, 0, 7])
                    || offset(bytes, 4, &[0, 0, 0, 8])
                    || offset(bytes, 4, &[0, 0, 0, 9])
                    || offset(bytes, 4, &[0, 0, 0, 10])
                    || offset(bytes, 4, &[0, 0, 0, 11])
                    || offset(bytes, 4, &[0, 0, 0, 12])
                    || offset(bytes, 4, &[0, 0, 0, 13])
                    || offset(bytes, 4, &[0, 0, 0, 14])
                    || offset(bytes, 4, &[0, 0, 0, 15])
                    || offset(bytes, 4, &[0, 0, 0, 16])
                    || offset(bytes, 4, &[0, 0, 0, 17])
                    || offset(bytes, 4, &[0, 0, 0, 18])
                    || offset(bytes, 4, &[0, 0, 0, 19])))
            || (offset(bytes, 0, &[191, 186, 254, 202])
                && (offset(bytes, 4, &[1, 0, 0, 0])
                    || offset(bytes, 4, &[2, 0, 0, 0])
                    || offset(bytes, 4, &[3, 0, 0, 0])
                    || offset(bytes, 4, &[4, 0, 0, 0])
                    || offset(bytes, 4, &[5, 0, 0, 0])
                    || offset(bytes, 4, &[6, 0, 0, 0])
                    || offset(bytes, 4, &[7, 0, 0, 0])
                    || offset(bytes, 4, &[8, 0, 0, 0])
                    || offset(bytes, 4, &[9, 0, 0, 0])
                    || offset(bytes, 4, &[10, 0, 0, 0])
                    || offset(bytes, 4, &[11, 0, 0, 0])
                    || offset(bytes, 4, &[12, 0, 0, 0])
                    || offset(bytes, 4, &[13, 0, 0, 0])
                    || offset(bytes, 4, &[14, 0, 0, 0])
                    || offset(bytes, 4, &[15, 0, 0, 0])
                    || offset(bytes, 4, &[16, 0, 0, 0])
                    || offset(bytes, 4, &[17, 0, 0, 0])
                    || offset(bytes, 4, &[18, 0, 0, 0])
                    || offset(bytes, 4, &[19, 0, 0, 0]))))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_x_java_jnilib_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_heif_image;
impl MimeTypeChecker for T_heif_image {
    fn get_mime(&self) -> &'static str {
        "image/heif"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.heif"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 4, &[102, 116, 121, 112, 109, 105, 102, 49])
            || offset(bytes, 4, &[102, 116, 121, 112, 104, 101, 105, 109])
            || offset(bytes, 4, &[102, 116, 121, 112, 104, 101, 105, 115])
            || offset(bytes, 4, &[102, 116, 121, 112, 97, 118, 105, 99]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_heic_image]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_heif_sequence_image;
impl MimeTypeChecker for T_heif_sequence_image {
    fn get_mime(&self) -> &'static str {
        "image/heif-sequence"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 4, &[102, 116, 121, 112, 109, 115, 102, 49])
            || offset(bytes, 4, &[102, 116, 121, 112, 104, 101, 118, 109])
            || offset(bytes, 4, &[102, 116, 121, 112, 104, 101, 118, 115])
            || offset(bytes, 4, &[102, 116, 121, 112, 97, 118, 99, 115]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_heic_sequence_image]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_mp4_video;
impl MimeTypeChecker for T_mp4_video {
    fn get_mime(&self) -> &'static str {
        "video/mp4"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mp4", "*.mp4v", "*.mpg4"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 4, &[102, 116, 121, 112, 109, 112, 52, 49])
            || offset(bytes, 4, &[102, 116, 121, 112, 109, 112, 52, 50])
            || offset(bytes, 4, &[102, 116, 121, 112, 97, 118, 99, 49])
            || offset(bytes, 4, &[102, 116, 121, 112, 105, 115, 111, 50])
            || offset(bytes, 4, &[102, 116, 121, 112, 105, 115, 111, 109])
            || offset(bytes, 4, &[102, 116, 121, 112, 109, 109, 112, 52])
            || offset(bytes, 4, &[102, 116, 121, 112, 70, 52, 86, 32])
            || offset(bytes, 4, &[102, 116, 121, 112, 70, 52, 80, 32])
            || offset(bytes, 4, &[102, 116, 121, 112, 77, 52, 66, 32])
            || offset(bytes, 4, &[102, 116, 121, 112, 77, 83, 86, 32])
            || offset(bytes, 4, &[102, 116, 121, 112, 48, 48, 48, 48]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_x_m4v_video]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_robots_text;
impl MimeTypeChecker for T_x_robots_text {
    fn get_mime(&self) -> &'static str {
        "text/x-robots"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (false
            && (offset_case_insensitive(
                bytes,
                0,
                &[117, 115, 101, 114, 45, 97, 103, 101, 110, 116, 58],
            ) || offset_case_insensitive(bytes, 0, &[97, 108, 108, 111, 119, 58])
                || offset_case_insensitive(bytes, 0, &[100, 105, 115, 97, 108, 108, 111, 119, 58])
                || offset_case_insensitive(bytes, 0, &[115, 105, 116, 101, 109, 97, 112, 58])
                || offset_range_case_insensitive(
                    bytes,
                    0,
                    1000,
                    &[10, 117, 115, 101, 114, 45, 97, 103, 101, 110, 116, 58],
                )
                || offset_range_case_insensitive(
                    bytes,
                    0,
                    1000,
                    &[10, 97, 108, 108, 111, 119, 58],
                )
                || offset_range_case_insensitive(
                    bytes,
                    0,
                    1000,
                    &[10, 100, 105, 115, 97, 108, 108, 111, 119, 58],
                )
                || offset_range_case_insensitive(
                    bytes,
                    0,
                    1000,
                    &[10, 115, 105, 116, 101, 109, 97, 112, 58],
                )))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mach_o_object_application;
impl MimeTypeChecker for T_x_mach_o_object_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mach-o-object"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 0, &[254, 237, 250, 206]) && offset(bytes, 12, &[0, 0, 0, 1]))
            || (offset(bytes, 0, &[206, 250, 237, 254]) && offset(bytes, 12, &[1, 0, 0, 0]))
            || (offset(bytes, 0, &[254, 237, 250, 207]) && offset(bytes, 12, &[0, 0, 0, 1]))
            || (offset(bytes, 0, &[207, 250, 237, 254]) && offset(bytes, 12, &[1, 0, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mach_o_executable_application;
impl MimeTypeChecker for T_x_mach_o_executable_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mach-o-executable"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 0, &[254, 237, 250, 206]) && offset(bytes, 12, &[0, 0, 0, 2]))
            || (offset(bytes, 0, &[206, 250, 237, 254]) && offset(bytes, 12, &[2, 0, 0, 0]))
            || (offset(bytes, 0, &[254, 237, 250, 207]) && offset(bytes, 12, &[0, 0, 0, 2]))
            || (offset(bytes, 0, &[207, 250, 237, 254]) && offset(bytes, 12, &[2, 0, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mach_o_fvmlib_application;
impl MimeTypeChecker for T_x_mach_o_fvmlib_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mach-o-fvmlib"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 0, &[254, 237, 250, 206]) && offset(bytes, 12, &[0, 0, 0, 3]))
            || (offset(bytes, 0, &[206, 250, 237, 254]) && offset(bytes, 12, &[3, 0, 0, 0]))
            || (offset(bytes, 0, &[254, 237, 250, 207]) && offset(bytes, 12, &[0, 0, 0, 3]))
            || (offset(bytes, 0, &[207, 250, 237, 254]) && offset(bytes, 12, &[3, 0, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mach_o_core_application;
impl MimeTypeChecker for T_x_mach_o_core_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mach-o-core"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 0, &[254, 237, 250, 206]) && offset(bytes, 12, &[0, 0, 0, 4]))
            || (offset(bytes, 0, &[206, 250, 237, 254]) && offset(bytes, 12, &[4, 0, 0, 0]))
            || (offset(bytes, 0, &[254, 237, 250, 207]) && offset(bytes, 12, &[0, 0, 0, 4]))
            || (offset(bytes, 0, &[207, 250, 237, 254]) && offset(bytes, 12, &[4, 0, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mach_o_preload_application;
impl MimeTypeChecker for T_x_mach_o_preload_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mach-o-preload"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 0, &[254, 237, 250, 206]) && offset(bytes, 12, &[0, 0, 0, 5]))
            || (offset(bytes, 0, &[206, 250, 237, 254]) && offset(bytes, 12, &[5, 0, 0, 0]))
            || (offset(bytes, 0, &[254, 237, 250, 207]) && offset(bytes, 12, &[0, 0, 0, 5]))
            || (offset(bytes, 0, &[207, 250, 237, 254]) && offset(bytes, 12, &[5, 0, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mach_o_dylib_application;
impl MimeTypeChecker for T_x_mach_o_dylib_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mach-o-dylib"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 0, &[254, 237, 250, 206]) && offset(bytes, 12, &[0, 0, 0, 6]))
            || (offset(bytes, 0, &[206, 250, 237, 254]) && offset(bytes, 12, &[6, 0, 0, 0]))
            || (offset(bytes, 0, &[254, 237, 250, 207]) && offset(bytes, 12, &[0, 0, 0, 6]))
            || (offset(bytes, 0, &[207, 250, 237, 254]) && offset(bytes, 12, &[6, 0, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mach_o_dylinker_application;
impl MimeTypeChecker for T_x_mach_o_dylinker_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mach-o-dylinker"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 0, &[254, 237, 250, 206]) && offset(bytes, 12, &[0, 0, 0, 7]))
            || (offset(bytes, 0, &[206, 250, 237, 254]) && offset(bytes, 12, &[7, 0, 0, 0]))
            || (offset(bytes, 0, &[254, 237, 250, 207]) && offset(bytes, 12, &[0, 0, 0, 7]))
            || (offset(bytes, 0, &[207, 250, 237, 254]) && offset(bytes, 12, &[7, 0, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mach_o_bundle_application;
impl MimeTypeChecker for T_x_mach_o_bundle_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mach-o-bundle"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 0, &[254, 237, 250, 206]) && offset(bytes, 12, &[0, 0, 0, 8]))
            || (offset(bytes, 0, &[206, 250, 237, 254]) && offset(bytes, 12, &[8, 0, 0, 0]))
            || (offset(bytes, 0, &[254, 237, 250, 207]) && offset(bytes, 12, &[0, 0, 0, 8]))
            || (offset(bytes, 0, &[207, 250, 237, 254]) && offset(bytes, 12, &[8, 0, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mach_o_dylib_stub_application;
impl MimeTypeChecker for T_x_mach_o_dylib_stub_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mach-o-dylib-stub"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 0, &[254, 237, 250, 206]) && offset(bytes, 12, &[0, 0, 0, 9]))
            || (offset(bytes, 0, &[206, 250, 237, 254]) && offset(bytes, 12, &[9, 0, 0, 0]))
            || (offset(bytes, 0, &[254, 237, 250, 207]) && offset(bytes, 12, &[0, 0, 0, 9]))
            || (offset(bytes, 0, &[207, 250, 237, 254]) && offset(bytes, 12, &[9, 0, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mach_o_dsym_application;
impl MimeTypeChecker for T_x_mach_o_dsym_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mach-o-dsym"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 0, &[254, 237, 250, 206]) && offset(bytes, 12, &[0, 0, 0, 10]))
            || (offset(bytes, 0, &[206, 250, 237, 254]) && offset(bytes, 12, &[10, 0, 0, 0]))
            || (offset(bytes, 0, &[254, 237, 250, 207]) && offset(bytes, 12, &[0, 0, 0, 10]))
            || (offset(bytes, 0, &[207, 250, 237, 254]) && offset(bytes, 12, &[10, 0, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mach_o_kext_bundle_application;
impl MimeTypeChecker for T_x_mach_o_kext_bundle_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mach-o-kext-bundle"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 0, &[254, 237, 250, 206]) && offset(bytes, 12, &[0, 0, 0, 11]))
            || (offset(bytes, 0, &[206, 250, 237, 254]) && offset(bytes, 12, &[11, 0, 0, 0]))
            || (offset(bytes, 0, &[254, 237, 250, 207]) && offset(bytes, 12, &[0, 0, 0, 11]))
            || (offset(bytes, 0, &[207, 250, 237, 254]) && offset(bytes, 12, &[11, 0, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_msdownload_format_pe_application;
impl MimeTypeChecker for T_x_msdownload_format_pe_application {
    fn get_mime(&self) -> &'static str {
        "application/x-msdownload;format=pe"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[77, 90])
            && (offset(bytes, 128, &[80, 69, 0, 0])
                || offset(bytes, 176, &[80, 69, 0, 0])
                || offset(bytes, 208, &[80, 69, 0, 0])
                || offset(bytes, 240, &[80, 69, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_x_msdownload_format_pe32_application,
            &T_x_msdownload_format_pe64_application,
            &T_x_msdownload_format_pe_itanium_application,
            &T_x_msdownload_format_pe_armLE_application,
            &T_x_msdownload_format_pe_arm7_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_applefile_application;
impl MimeTypeChecker for T_applefile_application {
    fn get_mime(&self) -> &'static str {
        "application/applefile"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[0, 5, 22, 0])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_bat_application;
impl MimeTypeChecker for T_x_bat_application {
    fn get_mime(&self) -> &'static str {
        "application/x-bat"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.bat", "*.cmd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset_case_insensitive(bytes, 0, &[64, 101, 99, 104, 111, 32, 111, 102, 102])
            || offset_case_insensitive(bytes, 0, &[114, 101, 109, 32]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dicom_application;
impl MimeTypeChecker for T_dicom_application {
    fn get_mime(&self) -> &'static str {
        "application/dicom"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dcm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 128, &[68, 73, 67, 77])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_java_vm_application;
impl MimeTypeChecker for T_java_vm_application {
    fn get_mime(&self) -> &'static str {
        "application/java-vm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.class"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[202, 254, 186, 190])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_java_hprof__application;
impl MimeTypeChecker for T_vnd_java_hprof__application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.java.hprof "
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.hprof"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> =
            Lazy::new(|| Regex::new("JAVA PROFILE \\d\\.\\d\\.\\d\\u0000").unwrap());

        regex(bytes, 0, &REGEX_PATTERN_0)
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_java_hprof_text_application;
impl MimeTypeChecker for T_vnd_java_hprof_text_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.java.hprof.text"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.hprof.txt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> =
            Lazy::new(|| Regex::new("JAVA PROFILE \\d\\.\\d\\.\\d,").unwrap());

        regex(bytes, 0, &REGEX_PATTERN_0)
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mac_binhex40_application;
impl MimeTypeChecker for T_mac_binhex40_application {
    fn get_mime(&self) -> &'static str {
        "application/mac-binhex40"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.hqx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            11,
            &[
                109, 117, 115, 116, 32, 98, 101, 32, 99, 111, 110, 118, 101, 114, 116, 101, 100,
                32, 119, 105, 116, 104, 32, 66, 105, 110, 72, 101, 120,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_marc_application;
impl MimeTypeChecker for T_marc_application {
    fn get_mime(&self) -> &'static str {
        "application/marc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mrc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> = Lazy::new(|| Regex::new("[0-9]{5,5}").unwrap());
        static REGEX_PATTERN_1: Lazy<Regex> =
            Lazy::new(|| Regex::new("[acdnp][acdefgijkmoprt][abcdims]").unwrap());
        static REGEX_PATTERN_2: Lazy<Regex> = Lazy::new(|| Regex::new("[acdnosx]z").unwrap());
        static REGEX_PATTERN_3: Lazy<Regex> = Lazy::new(|| Regex::new("[cdn][uvxy]").unwrap());
        static REGEX_PATTERN_4: Lazy<Regex> = Lazy::new(|| Regex::new("[acdn]w").unwrap());
        static REGEX_PATTERN_5: Lazy<Regex> = Lazy::new(|| Regex::new("[cdn]q").unwrap());

        (regex(bytes, 0, &REGEX_PATTERN_0)
            && offset(bytes, 20, &[52, 53])
            && (regex(bytes, 5, &REGEX_PATTERN_1)
                || regex(bytes, 5, &REGEX_PATTERN_2)
                || regex(bytes, 5, &REGEX_PATTERN_3)
                || regex(bytes, 5, &REGEX_PATTERN_4)
                || regex(bytes, 5, &REGEX_PATTERN_5)))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wolfram_wl_application;
impl MimeTypeChecker for T_vnd_wolfram_wl_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wolfram.wl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                35, 33, 47, 117, 115, 114, 47, 98, 105, 110, 47, 101, 110, 118, 32, 119, 111, 108,
                102, 114, 97, 109, 115, 99, 114, 105, 112, 116,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_msword_application;
impl MimeTypeChecker for T_msword_application {
    fn get_mime(&self) -> &'static str {
        "application/msword"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.doc", "*.dot"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            2080,
            &[
                77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 87, 111, 114, 100, 32, 54, 46, 48,
                32, 68, 111, 99, 117, 109, 101, 110, 116,
            ],
        ) || offset(
            bytes,
            2080,
            &[
                68, 111, 99, 117, 109, 101, 110, 116, 111, 32, 77, 105, 99, 114, 111, 115, 111,
                102, 116, 32, 87, 111, 114, 100, 32, 54,
            ],
        ) || offset(bytes, 2112, &[77, 83, 87, 111, 114, 100, 68, 111, 99])
            || offset(bytes, 0, &[49, 190, 0, 0])
            || offset(bytes, 0, &[80, 79, 94, 81, 96])
            || offset(bytes, 0, &[254, 55, 0, 35])
            || offset(bytes, 0, &[219, 165, 45, 0, 0, 0])
            || offset(bytes, 0, &[148, 166, 46])
            || (offset_range(bytes, 0, 8, &[208, 207, 17, 224, 161, 177, 26, 225])
                && offset_range(
                    bytes,
                    1152,
                    4096,
                    &[
                        87, 0, 111, 0, 114, 0, 100, 0, 68, 0, 111, 0, 99, 0, 117, 0, 109, 0, 101,
                        0, 110, 0, 116,
                    ],
                ))
            || (offset_range(bytes, 0, 8, &[208, 207, 17, 224, 161, 177, 26, 225])
                && (offset(bytes, 546, &[106, 98, 106, 98])
                    || offset(bytes, 546, &[98, 106, 98, 106]))))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_msword2_application;
impl MimeTypeChecker for T_msword2_application {
    fn get_mime(&self) -> &'static str {
        "application/msword2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[155, 165]) || offset(bytes, 0, &[219, 165]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_msword5_application;
impl MimeTypeChecker for T_msword5_application {
    fn get_mime(&self) -> &'static str {
        "application/msword5"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[254, 55])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_octet_stream_application;
impl MimeTypeChecker for T_octet_stream_application {
    fn get_mime(&self) -> &'static str {
        "application/octet-stream"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[
            "*.bin", "*.dms", "*.lha", "*.lrf", "*.lzh", "*.so", "*.dist", "*.distz", "*.pkg",
            "*.bpk", "*.dump", "*.elc", "*.deploy", "*.aaf",
        ]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            10,
            &[
                35, 32, 84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 115, 104, 101, 108, 108, 32,
                97, 114, 99, 104, 105, 118, 101,
            ],
        ) || offset(bytes, 0, &[31, 30])
            || offset(bytes, 0, &[31, 31])
            || offset(bytes, 0, &[255, 31])
            || offset(bytes, 0, &[255, 31])
            || offset(bytes, 0, &[5, 203])
            || (offset(bytes, 8, &[65, 65, 70, 66, 13, 0, 79, 77])
                && (offset(bytes, 30, &[0, 120, 48, 57]) || offset(bytes, 30, &[0, 120, 48, 99]))))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_onenote_format_one_application;
impl MimeTypeChecker for T_onenote_format_one_application {
    fn get_mime(&self) -> &'static str {
        "application/onenote;format=one"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.one"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[228, 82, 92, 123])
            && offset(bytes, 4, &[140, 216])
            && offset(bytes, 6, &[167, 77])
            && offset(bytes, 8, &[174, 177, 83, 120, 208, 41, 150, 211]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_onenote_format_onetoc2_application;
impl MimeTypeChecker for T_onenote_format_onetoc2_application {
    fn get_mime(&self) -> &'static str {
        "application/onenote;format=onetoc2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.onetoc", "*.onetoc2"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[161, 47, 255, 67])
            && offset(bytes, 4, &[217, 239])
            && offset(bytes, 6, &[118, 76])
            && offset(bytes, 8, &[158, 226, 16, 234, 87, 34, 118, 95]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pkcs7_signature_application;
impl MimeTypeChecker for T_pkcs7_signature_application {
    fn get_mime(&self) -> &'static str {
        "application/pkcs7-signature"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.p7s"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                45, 45, 45, 45, 45, 66, 69, 71, 73, 78, 32, 80, 75, 67, 83, 55,
            ],
        ) || (offset(bytes, 0, &[48, 128])
            && offset_mask(
                bytes,
                2,
                &[6, 9, 42, 134, 72, 134, 247, 13, 1, 7, 255, 160],
                &[255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 255],
            ))
            || (offset(bytes, 0, &[48, 129])
                && offset_mask(
                    bytes,
                    3,
                    &[6, 9, 42, 134, 72, 134, 247, 13, 1, 7, 255, 160],
                    &[255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 255],
                ))
            || (offset(bytes, 0, &[48, 130])
                && offset_mask(
                    bytes,
                    4,
                    &[6, 9, 42, 134, 72, 134, 247, 13, 1, 7, 255, 160],
                    &[255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 255],
                ))
            || (offset(bytes, 0, &[48, 131])
                && offset_mask(
                    bytes,
                    5,
                    &[6, 9, 42, 134, 72, 134, 247, 13, 1, 7, 255, 160],
                    &[255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 255],
                ))
            || (offset(bytes, 0, &[48, 132])
                && offset_mask(
                    bytes,
                    6,
                    &[6, 9, 42, 134, 72, 134, 247, 13, 1, 7, 255, 160],
                    &[255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 255],
                )))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_timestamped_data_application;
impl MimeTypeChecker for T_timestamped_data_application {
    fn get_mime(&self) -> &'static str {
        "application/timestamped-data"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.tsd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[48, 128, 6, 11, 42, 134, 72, 134, 247])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_rtf_application;
impl MimeTypeChecker for T_rtf_application {
    fn get_mime(&self) -> &'static str {
        "application/rtf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rtf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[123, 92, 114, 116, 102])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_sereal_version_1_application;
impl MimeTypeChecker for T_sereal_version_1_application {
    fn get_mime(&self) -> &'static str {
        "application/sereal;version=1"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[61, 115, 114, 108]) && offset_mask(bytes, 4, &[1], &[15]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_sereal_version_2_application;
impl MimeTypeChecker for T_sereal_version_2_application {
    fn get_mime(&self) -> &'static str {
        "application/sereal;version=2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[61, 115, 114, 108]) && offset_mask(bytes, 4, &[2], &[15]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_sereal_version_3_application;
impl MimeTypeChecker for T_sereal_version_3_application {
    fn get_mime(&self) -> &'static str {
        "application/sereal;version=3"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[61, 243, 114, 108]) && offset_mask(bytes, 4, &[3], &[15]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_digilite_prolights_application;
impl MimeTypeChecker for T_vnd_digilite_prolights_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.digilite.prolights"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[127, 12, 68, 43])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fdf_application;
impl MimeTypeChecker for T_vnd_fdf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.fdf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fdf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[37, 70, 68, 70, 45])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_iccprofile_application;
impl MimeTypeChecker for T_vnd_iccprofile_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.iccprofile"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.icc", "*.icm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 36, &[97, 99, 115, 112])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_lotus_1_2_3_version_1_application;
impl MimeTypeChecker for T_vnd_lotus_1_2_3_version_1_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.lotus-1-2-3;version=1"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[0, 0, 2, 0, 4, 4])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_lotus_1_2_3_version_2_application;
impl MimeTypeChecker for T_vnd_lotus_1_2_3_version_2_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.lotus-1-2-3;version=2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wk1", "*.wk2"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[0, 0, 2, 0, 6, 4, 6, 0, 8, 0])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_lotus_1_2_3_version_3_application;
impl MimeTypeChecker for T_vnd_lotus_1_2_3_version_3_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.lotus-1-2-3;version=3"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wk3"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[0, 0, 26, 0, 0, 16, 4, 0])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_lotus_1_2_3_version_4_application;
impl MimeTypeChecker for T_vnd_lotus_1_2_3_version_4_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.lotus-1-2-3;version=4"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wk4"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[0, 0, 26, 0, 2, 16, 4, 0])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_lotus_1_2_3_version_97_9_x_application;
impl MimeTypeChecker for T_vnd_lotus_1_2_3_version_97_9_x_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.lotus-1-2-3;version=97+9.x"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.123"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[0, 0, 26, 0, 3, 16, 4, 0])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_lotus_wordpro_application;
impl MimeTypeChecker for T_vnd_lotus_wordpro_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.lotus-wordpro"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.lwp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[87, 111, 114, 100, 80, 114, 111, 0])
            || offset(bytes, 0, &[87, 111, 114, 100, 80, 114, 111, 13, 251]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mif_application;
impl MimeTypeChecker for T_vnd_mif_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.mif"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mif"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[60, 77, 97, 107, 101, 114, 70, 105, 108, 101])
            || offset(bytes, 0, &[60, 77, 73, 70, 70, 105, 108, 101])
            || offset(
                bytes,
                0,
                &[
                    60, 77, 97, 107, 101, 114, 68, 105, 99, 116, 105, 111, 110, 97, 114, 121,
                ],
            )
            || offset(
                bytes,
                0,
                &[
                    60, 77, 97, 107, 101, 114, 83, 99, 114, 101, 101, 110, 70, 111, 110, 116,
                ],
            )
            || offset(bytes, 0, &[60, 77, 77, 76])
            || offset(bytes, 0, &[60, 66, 111, 111, 107])
            || offset(bytes, 0, &[60, 77, 97, 107, 101, 114]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_excel_application;
impl MimeTypeChecker for T_vnd_ms_excel_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-excel"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[
            "*.xls", "*.xlm", "*.xla", "*.xlc", "*.xlt", "*.xlw", "*.xll", "*.xld",
        ]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            2080,
            &[
                77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 69, 120, 99, 101, 108, 32, 53, 46,
                48, 32, 87, 111, 114, 107, 115, 104, 101, 101, 116,
            ],
        ) || offset(
            bytes,
            2080,
            &[
                70, 111, 103, 108, 105, 111, 32, 100, 105, 32, 108, 97, 118, 111, 114, 111, 32, 77,
                105, 99, 114, 111, 115, 111, 102, 116, 32, 69, 120, 99, 101,
            ],
        ) || offset(bytes, 2114, &[66, 105, 102, 102, 53])
            || offset(bytes, 2121, &[66, 105, 102, 102, 53])
            || (offset_range(bytes, 0, 8, &[208, 207, 17, 224, 161, 177, 26, 225])
                && offset_range(
                    bytes,
                    1152,
                    4096,
                    &[87, 0, 111, 0, 114, 0, 107, 0, 98, 0, 111, 0, 111, 0, 107],
                )))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_fontobject_application;
impl MimeTypeChecker for T_vnd_ms_fontobject_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-fontobject"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.eot"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 8, &[2, 0, 2, 0]) && offset(bytes, 34, &[76, 80]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_htmlhelp_application;
impl MimeTypeChecker for T_vnd_ms_htmlhelp_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-htmlhelp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.chm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[73, 84, 83, 70])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_outlook_pst_application;
impl MimeTypeChecker for T_vnd_ms_outlook_pst_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-outlook-pst"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pst", "*.ost"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_mask(
            bytes,
            0,
            &[33, 66, 68, 78, 46, 46, 46, 46, 83, 77],
            &[255, 255, 255, 255, 0, 0, 0, 0, 255, 255],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_powerpoint_application;
impl MimeTypeChecker for T_vnd_ms_powerpoint_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-powerpoint"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ppt", "*.ppz", "*.pps", "*.pot", "*.ppa"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset_range(bytes, 0, 8, &[208, 207, 17, 224, 161, 177, 26, 225])
            && offset_range(
                bytes,
                1152,
                4096,
                &[
                    80, 0, 111, 0, 119, 0, 101, 0, 114, 0, 80, 0, 111, 0, 105, 0, 110, 0, 116, 0,
                    32, 68, 0, 111, 0, 99, 0, 117, 0, 109, 0, 101, 0, 110, 0, 116,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_project_application;
impl MimeTypeChecker for T_x_project_application {
    fn get_mime(&self) -> &'static str {
        "application/x-project"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mpx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                77, 80, 88, 44, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 80, 114, 111, 106,
                101, 99, 116, 32, 102, 111, 114, 32, 87, 105, 110, 100, 111, 119, 115, 44,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_tnef_application;
impl MimeTypeChecker for T_vnd_ms_tnef_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-tnef"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[120, 159, 62, 34])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_works_application;
impl MimeTypeChecker for T_vnd_ms_works_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-works"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wps", "*.wks", "*.wcm", "*.wdb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset_range(bytes, 0, 8, &[208, 207, 17, 224, 161, 177, 26, 225])
            && offset_range(bytes, 1152, 4096, &[77, 0, 97, 0, 116, 0, 79, 0, 83, 0, 84]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oasis_opendocument_chart_template_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_chart_template_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.chart-template"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.otc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 111, 97, 115, 105, 115, 46, 111, 112,
                    101, 110, 100, 111, 99, 117, 109, 101, 110, 116, 46, 99, 104, 97, 114, 116, 45,
                    116, 101, 109, 112, 108, 97, 116, 101,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oasis_opendocument_base_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_base_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.base"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.odb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 111, 97, 115, 105, 115, 46, 111, 112,
                    101, 110, 100, 111, 99, 117, 109, 101, 110, 116, 46, 98, 97, 115, 101,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oasis_opendocument_formula_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_formula_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.formula"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.odf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    97, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 47, 118, 110, 100, 46, 111,
                    97, 115, 105, 115, 46, 111, 112, 101, 110, 100, 111, 99, 117, 109, 101, 110,
                    116, 46, 102, 111, 114, 109, 117, 108, 97,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oasis_opendocument_flat_text_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_flat_text_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.flat.text"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fodt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_range(
            bytes,
            0,
            4096,
            &[
                111, 102, 102, 105, 99, 101, 58, 109, 105, 109, 101, 116, 121, 112, 101, 61, 34,
                97, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 47, 118, 110, 100, 46, 111, 97,
                115, 105, 115, 46, 111, 112, 101, 110, 100, 111, 99, 117, 109, 101, 110, 116, 46,
                116, 101, 120, 116,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oasis_opendocument_flat_presentation_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_flat_presentation_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.flat.presentation"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fodp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_range(
            bytes,
            0,
            4096,
            &[
                111, 102, 102, 105, 99, 101, 58, 109, 105, 109, 101, 116, 121, 112, 101, 61, 34,
                97, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 47, 118, 110, 100, 46, 111, 97,
                115, 105, 115, 46, 111, 112, 101, 110, 100, 111, 99, 117, 109, 101, 110, 116, 46,
                112, 114, 101, 115, 101, 110, 116, 97, 116, 105, 111, 110,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oasis_opendocument_flat_spreadsheet_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_flat_spreadsheet_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.flat.spreadsheet"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fods"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_range(
            bytes,
            0,
            4096,
            &[
                111, 102, 102, 105, 99, 101, 58, 109, 105, 109, 101, 116, 121, 112, 101, 61, 34,
                97, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 47, 118, 110, 100, 46, 111, 97,
                115, 105, 115, 46, 111, 112, 101, 110, 100, 111, 99, 117, 109, 101, 110, 116, 46,
                115, 112, 114, 101, 97, 100, 115, 104, 101, 101, 116,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oasis_opendocument_text_master_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_text_master_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.text-master"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.otm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 111, 97, 115, 105, 115, 46, 111, 112,
                    101, 110, 100, 111, 99, 117, 109, 101, 110, 116, 46, 116, 101, 120, 116, 45,
                    109, 97, 115, 116, 101, 114,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_openxmlformats_officedocument_presentationml_presentation_application;
impl MimeTypeChecker
    for T_vnd_openxmlformats_officedocument_presentationml_presentation_application
{
    fn get_mime(&self) -> &'static str {
        "application/vnd.openxmlformats-officedocument.presentationml.presentation"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pptx", "*.thmx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75, 3, 4])
            && ((offset_range(
                bytes,
                30,
                65536,
                &[
                    91, 67, 111, 110, 116, 101, 110, 116, 95, 84, 121, 112, 101, 115, 93, 46, 120,
                    109, 108,
                ],
            ) && offset_range(bytes, 0, 4096, &[112, 112, 116, 47]))
                || (offset(
                    bytes,
                    30,
                    &[95, 114, 101, 108, 115, 47, 46, 114, 101, 108, 115],
                ) && offset_range(bytes, 0, 4096, &[112, 112, 116, 47]))))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_openxmlformats_officedocument_spreadsheetml_sheet_application;
impl MimeTypeChecker for T_vnd_openxmlformats_officedocument_spreadsheetml_sheet_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xlsx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75, 3, 4])
            && ((offset_range(
                bytes,
                30,
                65536,
                &[
                    91, 67, 111, 110, 116, 101, 110, 116, 95, 84, 121, 112, 101, 115, 93, 46, 120,
                    109, 108,
                ],
            ) && offset_range(bytes, 0, 4096, &[120, 108, 47]))
                || (offset(
                    bytes,
                    30,
                    &[95, 114, 101, 108, 115, 47, 46, 114, 101, 108, 115],
                ) && offset_range(bytes, 0, 4096, &[120, 108, 47]))))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_openxmlformats_officedocument_wordprocessingml_document_application;
impl MimeTypeChecker for T_vnd_openxmlformats_officedocument_wordprocessingml_document_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.docx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75, 3, 4])
            && ((offset_range(
                bytes,
                30,
                65536,
                &[
                    91, 67, 111, 110, 116, 101, 110, 116, 95, 84, 121, 112, 101, 115, 93, 46, 120,
                    109, 108,
                ],
            ) && offset_range(bytes, 0, 4096, &[119, 111, 114, 100, 47]))
                || (offset(
                    bytes,
                    30,
                    &[95, 114, 101, 108, 115, 47, 46, 114, 101, 108, 115],
                ) && offset_range(bytes, 0, 4096, &[119, 111, 114, 100, 47]))))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_rn_realmedia_application;
impl MimeTypeChecker for T_vnd_rn_realmedia_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.rn-realmedia"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[46, 82, 77, 70])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_stardivision_calc_application;
impl MimeTypeChecker for T_vnd_stardivision_calc_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.stardivision.calc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sdc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset_range(bytes, 0, 8, &[208, 207, 17, 224, 161, 177, 26, 225])
            && offset_range(bytes, 2048, 2207, &[83, 116, 97, 114, 67, 97, 108, 99]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_stardivision_draw_application;
impl MimeTypeChecker for T_vnd_stardivision_draw_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.stardivision.draw"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sda"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset_range(bytes, 0, 8, &[208, 207, 17, 224, 161, 177, 26, 225])
            && offset_range(bytes, 2048, 2207, &[83, 116, 97, 114, 68, 114, 97, 119]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_stardivision_impress_application;
impl MimeTypeChecker for T_vnd_stardivision_impress_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.stardivision.impress"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sdd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset_range(bytes, 0, 8, &[208, 207, 17, 224, 161, 177, 26, 225])
            && offset_range(
                bytes,
                2048,
                2207,
                &[83, 116, 97, 114, 73, 109, 112, 114, 101, 115, 115],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_stardivision_writer_application;
impl MimeTypeChecker for T_vnd_stardivision_writer_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.stardivision.writer"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sdw"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset_range(bytes, 0, 8, &[208, 207, 17, 224, 161, 177, 26, 225])
            && offset_range(
                bytes,
                2048,
                2207,
                &[83, 116, 97, 114, 87, 114, 105, 116, 101, 114],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_subrip_application;
impl MimeTypeChecker for T_x_subrip_application {
    fn get_mime(&self) -> &'static str {
        "application/x-subrip"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.srt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[49, 10, 48, 48])
            || offset(bytes, 0, &[49, 13, 48, 48])
            || offset(bytes, 0, &[3, 16, 208, 161, 48, 48])
            || offset(bytes, 0, &[239, 187, 191, 49, 10, 48, 48])
            || offset(bytes, 0, &[239, 187, 191, 49, 13, 48, 48])
            || offset(bytes, 0, &[14, 251, 187, 243, 16, 208, 161, 48, 48]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_symbian_install_application;
impl MimeTypeChecker for T_vnd_symbian_install_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.symbian.install"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sis", "*.sisx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 8, &[25, 4, 0, 16])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wordperfect_version_4_2_application;
impl MimeTypeChecker for T_vnd_wordperfect_version_4_2_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wordperfect;version=4.2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[203, 10, 1]) && offset(bytes, 5, &[203]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wordperfect_version_5_0_application;
impl MimeTypeChecker for T_vnd_wordperfect_version_5_0_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wordperfect;version=5.0"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[255, 87, 80, 67]) && offset(bytes, 10, &[0, 0]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wordperfect_version_5_1_application;
impl MimeTypeChecker for T_vnd_wordperfect_version_5_1_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wordperfect;version=5.1"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[255, 87, 80, 67]) && offset(bytes, 10, &[0, 1]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wordperfect_version_6_x_application;
impl MimeTypeChecker for T_vnd_wordperfect_version_6_x_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wordperfect;version=6.x"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[255, 87, 80, 67]) && offset(bytes, 10, &[2, 1]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_xara_application;
impl MimeTypeChecker for T_vnd_xara_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.xara"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xar"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[120, 97, 114, 33])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_wasm_application;
impl MimeTypeChecker for T_wasm_application {
    fn get_mime(&self) -> &'static str {
        "application/wasm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wasm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[0, 97, 115, 109]) || offset(bytes, 0, &[109, 115, 97, 0]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_atari_floppy_disk_image_application;
impl MimeTypeChecker for T_x_atari_floppy_disk_image_application {
    fn get_mime(&self) -> &'static str {
        "application/x-atari-floppy-disk-image"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[150, 2])
            && ((offset(bytes, 4, &[128, 0]) && offset(bytes, 11, &[0, 0, 0, 0]))
                || (offset(bytes, 4, &[0, 1]) && offset(bytes, 11, &[0, 0, 0, 0]))))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_adobe_indesign_application;
impl MimeTypeChecker for T_x_adobe_indesign_application {
    fn get_mime(&self) -> &'static str {
        "application/x-adobe-indesign"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.indd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                6, 6, 237, 245, 216, 29, 70, 229, 189, 49, 239, 231, 254, 116, 183, 29,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_isac_fcs_application;
impl MimeTypeChecker for T_vnd_isac_fcs_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.isac.fcs"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fcs"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> =
            Lazy::new(|| Regex::new("FCS[1-3]\\.[0-9]    ").unwrap());

        regex(bytes, 0, &REGEX_PATTERN_0)
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_adobe_indesign_idml_package_application;
impl MimeTypeChecker for T_vnd_adobe_indesign_idml_package_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.adobe.indesign-idml-package"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.idml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75, 3, 4])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 97, 100, 111, 98, 101, 46, 105, 110, 100,
                    101, 115, 105, 103, 110, 45, 105, 100, 109, 108, 45, 112, 97, 99, 107, 97, 103,
                    101,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_adobe_indesign_interchange_application;
impl MimeTypeChecker for T_x_adobe_indesign_interchange_application {
    fn get_mime(&self) -> &'static str {
        "application/x-adobe-indesign-interchange"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.inx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_range(bytes, 0, 100, &[60, 63, 97, 105, 100])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_arj_application;
impl MimeTypeChecker for T_x_arj_application {
    fn get_mime(&self) -> &'static str {
        "application/x-arj"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.arj"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[96, 234])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_asprs_application;
impl MimeTypeChecker for T_x_asprs_application {
    fn get_mime(&self) -> &'static str {
        "application/x-asprs"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.las", "*.laz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[76, 65, 83, 70])
            && (offset(bytes, 24, &[1, 1]) || offset(bytes, 24, &[1, 2])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_berkeley_db_format_queue_application;
impl MimeTypeChecker for T_x_berkeley_db_format_queue_application {
    fn get_mime(&self) -> &'static str {
        "application/x-berkeley-db;format=queue"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 12, &[83, 34, 4, 0])
            || offset(bytes, 12, &[0, 4, 34, 83])
            || offset(bytes, 12, &[83, 34, 4, 0]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_berkeley_db_format_log_application;
impl MimeTypeChecker for T_x_berkeley_db_format_log_application {
    fn get_mime(&self) -> &'static str {
        "application/x-berkeley-db;format=log"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 12, &[136, 9, 4, 0])
            || offset(bytes, 12, &[136, 9, 4, 0])
            || offset(bytes, 12, &[0, 4, 9, 136]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_bibtex_text_file_application;
impl MimeTypeChecker for T_x_bibtex_text_file_application {
    fn get_mime(&self) -> &'static str {
        "application/x-bibtex-text-file"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.bib", "*.bibtex"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[37, 32, 66, 105, 98, 84, 101, 88, 32, 96])
            || offset(bytes, 73, &[37, 37, 37, 32, 32])
            || offset(
                bytes,
                0,
                &[
                    37, 32, 66, 105, 98, 84, 101, 88, 32, 115, 116, 97, 110, 100, 97, 114, 100, 32,
                    98, 105, 98, 108, 105, 111, 103, 114, 97, 112, 104, 121, 32,
                ],
            )
            || offset(
                bytes,
                73,
                &[
                    37, 37, 37, 32, 32, 64, 66, 105, 98, 84, 101, 88, 45, 115, 116, 121, 108, 101,
                    45, 102, 105, 108, 101, 123,
                ],
            )
            || offset_case_insensitive(bytes, 0, &[64, 97, 114, 116, 105, 99, 108, 101, 123])
            || offset_case_insensitive(bytes, 0, &[64, 98, 111, 111, 107, 123])
            || offset_case_insensitive(bytes, 0, &[64, 105, 110, 98, 111, 111, 107, 123])
            || offset_case_insensitive(
                bytes,
                0,
                &[
                    64, 105, 110, 99, 111, 108, 108, 101, 99, 116, 105, 111, 110, 123,
                ],
            )
            || offset_case_insensitive(
                bytes,
                0,
                &[
                    64, 105, 110, 112, 114, 111, 99, 101, 101, 100, 105, 110, 103, 115, 123,
                ],
            )
            || offset_case_insensitive(bytes, 0, &[64, 109, 97, 110, 117, 97, 108, 123])
            || offset_case_insensitive(bytes, 0, &[64, 109, 105, 115, 99, 123])
            || offset_case_insensitive(bytes, 0, &[64, 112, 114, 101, 97, 109, 98, 108, 101, 123])
            || offset_case_insensitive(
                bytes,
                0,
                &[64, 112, 104, 100, 116, 104, 101, 115, 105, 115, 123],
            )
            || offset_case_insensitive(bytes, 0, &[64, 115, 116, 114, 105, 110, 103, 123])
            || offset_case_insensitive(
                bytes,
                0,
                &[64, 116, 101, 99, 104, 114, 101, 112, 111, 114, 116, 123],
            )
            || offset_case_insensitive(
                bytes,
                0,
                &[
                    64, 117, 110, 112, 117, 98, 108, 105, 115, 104, 101, 100, 123,
                ],
            )
            || (offset(bytes, 0, &[37])
                && (offset_range_case_insensitive(
                    bytes,
                    2,
                    128,
                    &[10, 64, 97, 114, 116, 105, 99, 108, 101, 123],
                ) || offset_range_case_insensitive(
                    bytes,
                    2,
                    128,
                    &[10, 64, 98, 111, 111, 107, 123],
                ) || offset_range_case_insensitive(
                    bytes,
                    2,
                    128,
                    &[10, 64, 105, 110, 98, 111, 111, 107, 123],
                ) || offset_range_case_insensitive(
                    bytes,
                    2,
                    128,
                    &[
                        10, 64, 105, 110, 99, 111, 108, 108, 101, 99, 116, 105, 111, 110, 123,
                    ],
                ) || offset_range_case_insensitive(
                    bytes,
                    2,
                    128,
                    &[
                        10, 64, 105, 110, 112, 114, 111, 99, 101, 101, 100, 105, 110, 103, 115, 123,
                    ],
                ) || offset_range_case_insensitive(
                    bytes,
                    2,
                    128,
                    &[10, 64, 109, 97, 110, 117, 97, 108, 123],
                ) || offset_range_case_insensitive(
                    bytes,
                    2,
                    128,
                    &[10, 64, 109, 105, 115, 99, 123],
                ) || offset_range_case_insensitive(
                    bytes,
                    2,
                    128,
                    &[10, 64, 112, 114, 101, 97, 109, 98, 108, 101, 123],
                ) || offset_range_case_insensitive(
                    bytes,
                    2,
                    128,
                    &[10, 64, 112, 104, 100, 116, 104, 101, 115, 105, 115, 123],
                ) || offset_range_case_insensitive(
                    bytes,
                    2,
                    128,
                    &[10, 64, 115, 116, 114, 105, 110, 103, 123],
                ) || offset_range_case_insensitive(
                    bytes,
                    2,
                    128,
                    &[10, 64, 116, 101, 99, 104, 114, 101, 112, 111, 114, 116, 123],
                ) || offset_range_case_insensitive(
                    bytes,
                    2,
                    128,
                    &[
                        10, 64, 117, 110, 112, 117, 98, 108, 105, 115, 104, 101, 100, 123,
                    ],
                ))))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_bittorrent_application;
impl MimeTypeChecker for T_x_bittorrent_application {
    fn get_mime(&self) -> &'static str {
        "application/x-bittorrent"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.torrent"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[100, 56, 58, 97, 110, 110, 111, 117, 110, 99, 101],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_cdf_application;
impl MimeTypeChecker for T_x_cdf_application {
    fn get_mime(&self) -> &'static str {
        "application/x-cdf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                82, 73, 70, 70, 36, 0, 0, 0, 67, 68, 68, 65, 102, 109, 116, 32, 24,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_gtar_application;
impl MimeTypeChecker for T_x_gtar_application {
    fn get_mime(&self) -> &'static str {
        "application/x-gtar"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gtar"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 257, &[117, 115, 116, 97, 114, 32, 32, 0])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_guitar_pro_application;
impl MimeTypeChecker for T_x_guitar_pro_application {
    fn get_mime(&self) -> &'static str {
        "application/x-guitar-pro"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gp4"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            1,
            &[
                70, 73, 67, 72, 73, 69, 82, 32, 71, 85, 73, 84, 65, 82, 69, 32, 80, 82, 79, 32,
            ],
        ) || offset(
            bytes,
            1,
            &[
                70, 73, 67, 72, 73, 69, 82, 32, 71, 85, 73, 84, 65, 82, 32, 80, 82, 79, 32,
            ],
        ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_amiga_disk_format_application;
impl MimeTypeChecker for T_x_amiga_disk_format_application {
    fn get_mime(&self) -> &'static str {
        "application/x-amiga-disk-format"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.adf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[68, 79, 83])
            && (offset(bytes, 4, &[0])
                || offset(bytes, 4, &[1])
                || offset(bytes, 4, &[2])
                || offset(bytes, 4, &[3])
                || offset(bytes, 4, &[4])
                || offset(bytes, 4, &[5])
                || offset(bytes, 4, &[6])
                || offset(bytes, 4, &[7])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_chrome_package_application;
impl MimeTypeChecker for T_x_chrome_package_application {
    fn get_mime(&self) -> &'static str {
        "application/x-chrome-package"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.crx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[67, 114, 50, 52])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_compress_application;
impl MimeTypeChecker for T_x_compress_application {
    fn get_mime(&self) -> &'static str {
        "application/x-compress"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.z"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[31, 157])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_cpio_application;
impl MimeTypeChecker for T_x_cpio_application {
    fn get_mime(&self) -> &'static str {
        "application/x-cpio"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cpio"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[199, 113])
            || offset(bytes, 0, &[113, 199])
            || offset(bytes, 0, &[48, 55, 48, 55, 48, 55])
            || offset(bytes, 0, &[48, 55, 48, 55, 48, 49])
            || offset(bytes, 0, &[48, 55, 48, 55, 48, 50]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_dex_application;
impl MimeTypeChecker for T_x_dex_application {
    fn get_mime(&self) -> &'static str {
        "application/x-dex"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dex"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[100, 101, 120, 10]) && offset(bytes, 7, &[0]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_dvi_application;
impl MimeTypeChecker for T_x_dvi_application {
    fn get_mime(&self) -> &'static str {
        "application/x-dvi"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dvi"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[247, 2])
            || offset(bytes, 0, &[247, 2])
            || offset(
                bytes,
                14,
                &[27, 32, 84, 101, 88, 32, 111, 117, 116, 112, 117, 116, 32],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_elc_application;
impl MimeTypeChecker for T_x_elc_application {
    fn get_mime(&self) -> &'static str {
        "application/x-elc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.elc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[10, 40]) || offset(bytes, 0, &[59, 69, 76, 67, 19, 0, 0, 0]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_endnote_style_application;
impl MimeTypeChecker for T_x_endnote_style_application {
    fn get_mime(&self) -> &'static str {
        "application/x-endnote-style"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ens"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[0, 8])
            && offset(bytes, 4, &[0, 0])
            && (offset(bytes, 8, &[82, 83, 70, 84, 83, 84, 89, 76])
                || offset(bytes, 8, &[69, 78, 68, 78, 69, 78, 70, 84])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_fat_diskimage_application;
impl MimeTypeChecker for T_x_fat_diskimage_application {
    fn get_mime(&self) -> &'static str {
        "application/x-fat-diskimage"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> =
            Lazy::new(|| Regex::new("(\x01|\x02|\x04|\x08|\x10|\x20\x40|x80)").unwrap());

        (offset(bytes, 0, &[235]) && offset(bytes, 2, &[144]) && regex(bytes, 14, &REGEX_PATTERN_0))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_object_application;
impl MimeTypeChecker for T_x_object_application {
    fn get_mime(&self) -> &'static str {
        "application/x-object"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[127, 69, 76, 70])
            && (offset(bytes, 16, &[1, 0]) || offset(bytes, 16, &[0, 1])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_executable_application;
impl MimeTypeChecker for T_x_executable_application {
    fn get_mime(&self) -> &'static str {
        "application/x-executable"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[127, 69, 76, 70])
            && (offset(bytes, 16, &[2, 0]) || offset(bytes, 16, &[0, 2])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sharedlib_application;
impl MimeTypeChecker for T_x_sharedlib_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sharedlib"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[127, 69, 76, 70])
            && (offset(bytes, 16, &[3, 0]) || offset(bytes, 16, &[0, 3])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_coredump_application;
impl MimeTypeChecker for T_x_coredump_application {
    fn get_mime(&self) -> &'static str {
        "application/x-coredump"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[127, 69, 76, 70])
            && (offset(bytes, 16, &[4, 0]) || offset(bytes, 16, &[0, 4])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mmm_digisonde_application;
impl MimeTypeChecker for T_x_mmm_digisonde_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mmm-digisonde"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[9, 60, 0]) && offset(bytes, 24, &[0, 0]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_erdas_hfa_application;
impl MimeTypeChecker for T_x_erdas_hfa_application {
    fn get_mime(&self) -> &'static str {
        "application/x-erdas-hfa"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.hfa"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[69, 72, 70, 65, 95, 72, 69, 65, 68, 69, 82, 95, 84, 65, 71],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_filemaker_application;
impl MimeTypeChecker for T_x_filemaker_application {
    fn get_mime(&self) -> &'static str {
        "application/x-filemaker"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fp7"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 14, &[192, 72, 66, 65, 77, 55])
            && offset(
                bytes,
                525,
                &[
                    72, 66, 65, 77, 50, 49, 48, 49, 79, 67, 84, 57, 57, 193, 2, 72, 7, 80, 114,
                    111, 32, 55, 46, 48, 192, 192,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_gnumeric_application;
impl MimeTypeChecker for T_x_gnumeric_application {
    fn get_mime(&self) -> &'static str {
        "application/x-gnumeric"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gnumeric"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            39,
            &[
                61, 60, 103, 109, 114, 58, 87, 111, 114, 107, 98, 111, 111, 107,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_grib_application;
impl MimeTypeChecker for T_x_grib_application {
    fn get_mime(&self) -> &'static str {
        "application/x-grib"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.grb", "*.grb1", "*.grb2"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[71, 82, 73, 66])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_zstd_application;
impl MimeTypeChecker for T_zstd_application {
    fn get_mime(&self) -> &'static str {
        "application/zstd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.zst"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[40, 181, 47, 253])
            || offset(bytes, 0, &[39, 181, 47, 253])
            || offset(bytes, 0, &[38, 181, 47, 253])
            || offset(bytes, 0, &[37, 181, 47, 253])
            || offset(bytes, 0, &[36, 181, 47, 253])
            || offset(bytes, 0, &[35, 181, 47, 253])
            || offset(bytes, 0, &[34, 181, 47, 253])
            || offset(bytes, 0, &[80, 42, 77, 24])
            || offset(bytes, 0, &[81, 42, 77, 24])
            || offset(bytes, 0, &[82, 42, 77, 24])
            || offset(bytes, 0, &[83, 42, 77, 24])
            || offset(bytes, 0, &[84, 42, 77, 24])
            || offset(bytes, 0, &[85, 42, 77, 24])
            || offset(bytes, 0, &[86, 42, 77, 24])
            || offset(bytes, 0, &[87, 42, 77, 24])
            || offset(bytes, 0, &[88, 42, 77, 24])
            || offset(bytes, 0, &[89, 42, 77, 24])
            || offset(bytes, 0, &[90, 42, 77, 24])
            || offset(bytes, 0, &[91, 42, 77, 24])
            || offset(bytes, 0, &[92, 42, 77, 24])
            || offset(bytes, 0, &[93, 42, 77, 24])
            || offset(bytes, 0, &[94, 42, 77, 24])
            || offset(bytes, 0, &[95, 42, 77, 24]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_hdf_application;
impl MimeTypeChecker for T_x_hdf_application {
    fn get_mime(&self) -> &'static str {
        "application/x-hdf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.hdf", "*.he5", "*.h5"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[14, 3, 19, 1]) || offset(bytes, 0, &[137, 72, 68, 70, 13, 10, 26]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_hwp_application;
impl MimeTypeChecker for T_x_hwp_application {
    fn get_mime(&self) -> &'static str {
        "application/x-hwp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                72, 87, 80, 32, 68, 111, 99, 117, 109, 101, 110, 116, 32, 70, 105, 108, 101, 32, 86,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ibooks_zip_application;
impl MimeTypeChecker for T_x_ibooks_zip_application {
    fn get_mime(&self) -> &'static str {
        "application/x-ibooks+zip"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ibooks"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75, 3, 4])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 120, 45, 105, 98, 111, 111, 107, 115, 43, 122, 105, 112,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_idl_save_file_application;
impl MimeTypeChecker for T_x_idl_save_file_application {
    fn get_mime(&self) -> &'static str {
        "application/x-idl-save-file"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[83, 82, 0, 4, 0, 0, 0, 10, 0, 0, 4])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_isatab_investigation_application;
impl MimeTypeChecker for T_x_isatab_investigation_application {
    fn get_mime(&self) -> &'static str {
        "application/x-isatab-investigation"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["i_*.txt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                79, 78, 84, 79, 76, 79, 71, 89, 32, 83, 79, 85, 82, 67, 69, 32, 82, 69, 70, 69, 82,
                69, 78, 67, 69,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_isatab_application;
impl MimeTypeChecker for T_x_isatab_application {
    fn get_mime(&self) -> &'static str {
        "application/x-isatab"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["s_*.txt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            1,
            &[83, 111, 117, 114, 99, 101, 32, 78, 97, 109, 101],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_isatab_assay_application;
impl MimeTypeChecker for T_x_isatab_assay_application {
    fn get_mime(&self) -> &'static str {
        "application/x-isatab-assay"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["a_*.txt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            1,
            &[83, 97, 109, 112, 108, 101, 32, 78, 97, 109, 101],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_jeol_jdf_application;
impl MimeTypeChecker for T_x_jeol_jdf_application {
    fn get_mime(&self) -> &'static str {
        "application/x-jeol-jdf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jdf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[74, 69, 79, 76, 46, 78, 77, 82])
            || offset(bytes, 0, &[82, 77, 78, 46, 76, 79, 69, 74]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_jigdo_application;
impl MimeTypeChecker for T_x_jigdo_application {
    fn get_mime(&self) -> &'static str {
        "application/x-jigdo"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                74, 105, 103, 115, 97, 119, 68, 111, 119, 110, 108, 111, 97, 100, 32, 116, 101,
                109, 112, 108, 97, 116, 101,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_kdelnk_application;
impl MimeTypeChecker for T_x_kdelnk_application {
    fn get_mime(&self) -> &'static str {
        "application/x-kdelnk"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                91, 75, 68, 69, 32, 68, 101, 115, 107, 116, 111, 112, 32, 69, 110, 116, 114, 121,
                93,
            ],
        ) || offset(
            bytes,
            0,
            &[
                35, 32, 75, 68, 69, 32, 67, 111, 110, 102, 105, 103, 32, 70, 105, 108, 101,
            ],
        ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_latex_application;
impl MimeTypeChecker for T_x_latex_application {
    fn get_mime(&self) -> &'static str {
        "application/x-latex"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.latex"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[37, 32, 45, 42, 45, 108, 97, 116, 101, 120, 45, 42, 45],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_lha_application;
impl MimeTypeChecker for T_x_lha_application {
    fn get_mime(&self) -> &'static str {
        "application/x-lha"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 2, &[45, 108, 122, 115, 45])
            || offset(bytes, 2, &[45, 108, 104, 32, 45])
            || offset(bytes, 2, &[45, 108, 104, 100, 45])
            || offset(bytes, 2, &[45, 108, 104, 50, 45])
            || offset(bytes, 2, &[45, 108, 104, 51, 45])
            || offset(bytes, 2, &[45, 108, 104, 52, 45])
            || offset(bytes, 2, &[45, 108, 104, 53, 45])
            || offset(bytes, 2, &[45, 108, 104, 54, 45])
            || offset(bytes, 2, &[45, 108, 104, 55, 45]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_lharc_application;
impl MimeTypeChecker for T_x_lharc_application {
    fn get_mime(&self) -> &'static str {
        "application/x-lharc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 2, &[45, 108, 104, 48, 45])
            || offset(bytes, 2, &[45, 108, 104, 49, 45])
            || offset(bytes, 2, &[45, 108, 122, 52, 45])
            || offset(bytes, 2, &[45, 108, 122, 53, 45]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_lzip_application;
impl MimeTypeChecker for T_x_lzip_application {
    fn get_mime(&self) -> &'static str {
        "application/x-lzip"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.lz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[76, 90, 73, 80])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mach_o_application;
impl MimeTypeChecker for T_x_mach_o_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mach-o"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[254, 237, 250, 206])
            || offset(bytes, 0, &[206, 250, 237, 254])
            || offset(bytes, 0, &[254, 237, 250, 207])
            || offset(bytes, 0, &[207, 250, 237, 254]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ms_compress_szdd_application;
impl MimeTypeChecker for T_x_ms_compress_szdd_application {
    fn get_mime(&self) -> &'static str {
        "application/x-ms-compress-szdd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[83, 90, 68, 68, 136, 240, 39, 51, 65])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_nesrom_application;
impl MimeTypeChecker for T_x_nesrom_application {
    fn get_mime(&self) -> &'static str {
        "application/x-nesrom"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.nes"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[78, 69, 83, 26])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_netcdf_application;
impl MimeTypeChecker for T_x_netcdf_application {
    fn get_mime(&self) -> &'static str {
        "application/x-netcdf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.nc", "*.cdf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[67, 68, 70, 1])
            || offset(bytes, 0, &[67, 68, 70, 2])
            || offset(bytes, 0, &[67, 68, 70, 1]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_parquet_application;
impl MimeTypeChecker for T_x_parquet_application {
    fn get_mime(&self) -> &'static str {
        "application/x-parquet"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.parquet"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[80, 65, 82, 49])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_prt_application;
impl MimeTypeChecker for T_x_prt_application {
    fn get_mime(&self) -> &'static str {
        "application/x-prt"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.prt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 8, &[48, 77, 51, 67])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_quattro_pro_version_1_4_application;
impl MimeTypeChecker for T_x_quattro_pro_version_1_4_application {
    fn get_mime(&self) -> &'static str {
        "application/x-quattro-pro;version=1-4"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wq1", "*.wkq"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[0, 0, 2, 0, 32, 81])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_quattro_pro_version_5_application;
impl MimeTypeChecker for T_x_quattro_pro_version_5_application {
    fn get_mime(&self) -> &'static str {
        "application/x-quattro-pro;version=5"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wq2", "*.wkq"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[0, 0, 2, 0, 33, 81])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_quattro_pro_version_1_5_application;
impl MimeTypeChecker for T_x_quattro_pro_version_1_5_application {
    fn get_mime(&self) -> &'static str {
        "application/x-quattro-pro;version=1+5"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wb1"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[0, 0, 2, 0, 1, 16])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_quattro_pro_version_6_application;
impl MimeTypeChecker for T_x_quattro_pro_version_6_application {
    fn get_mime(&self) -> &'static str {
        "application/x-quattro-pro;version=6"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wb2"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[0, 0, 2, 0, 2, 16])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_rpm_application;
impl MimeTypeChecker for T_x_rpm_application {
    fn get_mime(&self) -> &'static str {
        "application/x-rpm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rpm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[237, 171, 238, 219]) || offset(bytes, 0, &[100, 114, 112, 109]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_spss_sav_application;
impl MimeTypeChecker for T_x_spss_sav_application {
    fn get_mime(&self) -> &'static str {
        "application/x-spss-sav"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sav"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[36, 70, 76, 50, 64, 40, 35, 41])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sc_application;
impl MimeTypeChecker for T_x_sc_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            38,
            &[83, 112, 114, 101, 97, 100, 115, 104, 101, 101, 116],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_shockwave_flash_application;
impl MimeTypeChecker for T_x_shockwave_flash_application {
    fn get_mime(&self) -> &'static str {
        "application/x-shockwave-flash"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.swf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[70, 87, 83])
            || offset(bytes, 0, &[67, 87, 83])
            || offset(bytes, 0, &[90, 87, 83]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sibelius_application;
impl MimeTypeChecker for T_x_sibelius_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sibelius"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sib"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[15, 83, 73, 66, 69, 76, 73, 85, 83])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_snappy_framed_application;
impl MimeTypeChecker for T_x_snappy_framed_application {
    fn get_mime(&self) -> &'static str {
        "application/x-snappy-framed"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_range(bytes, 0, 16, &[115, 78, 97, 80, 112, 89])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_spectrum_tzx_application;
impl MimeTypeChecker for T_x_spectrum_tzx_application {
    fn get_mime(&self) -> &'static str {
        "application/x-spectrum-tzx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.tzx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[90, 88, 84, 97, 112, 101, 33, 26])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_stuffit_application;
impl MimeTypeChecker for T_x_stuffit_application {
    fn get_mime(&self) -> &'static str {
        "application/x-stuffit"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sit"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[83, 116, 117, 102, 102, 73, 116])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_texinfo_application;
impl MimeTypeChecker for T_x_texinfo_application {
    fn get_mime(&self) -> &'static str {
        "application/x-texinfo"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.texinfo", "*.texi"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                92, 105, 110, 112, 117, 116, 32, 116, 101, 120, 105, 110, 102, 111,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_tex_virtual_font_application;
impl MimeTypeChecker for T_x_tex_virtual_font_application {
    fn get_mime(&self) -> &'static str {
        "application/x-tex-virtual-font"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[247, 202])
            && offset(bytes, 11, &[243, 0])
            && offset(bytes, 17, &[0, 16]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_touhou_application;
impl MimeTypeChecker for T_x_touhou_application {
    fn get_mime(&self) -> &'static str {
        "application/x-touhou"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> =
            Lazy::new(|| Regex::new("[\x72|\x33|\x36|\x35]").unwrap());

        (offset(bytes, 0, &[116, 49])
            && regex(bytes, 3, &REGEX_PATTERN_0)
            && offset(bytes, 5, &[0, 0, 0, 0, 0, 0, 0]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_uc2_compressed_application;
impl MimeTypeChecker for T_x_uc2_compressed_application {
    fn get_mime(&self) -> &'static str {
        "application/x-uc2-compressed"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.uc2"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[85, 67, 50, 26])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_vhd_application;
impl MimeTypeChecker for T_x_vhd_application {
    fn get_mime(&self) -> &'static str {
        "application/x-vhd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[99, 111, 110, 101, 99, 116, 105, 120])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_x509_cert_format_pem_application;
impl MimeTypeChecker for T_x_x509_cert_format_pem_application {
    fn get_mime(&self) -> &'static str {
        "application/x-x509-cert;format=pem"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pem"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                45, 45, 45, 45, 45, 66, 69, 71, 73, 78, 32, 67, 69, 82, 84, 73, 70, 73, 67, 65, 84,
                69, 45, 45, 45, 45, 45,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_x509_cert_format_der_application;
impl MimeTypeChecker for T_x_x509_cert_format_der_application {
    fn get_mime(&self) -> &'static str {
        "application/x-x509-cert;format=der"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.der"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset_mask(bytes, 0, &[48, 128], &[255, 248])
            && (offset_mask_range(
                bytes,
                10,
                50,
                &[48, 13, 6, 9, 42, 134, 72, 134, 247, 13, 1, 1, 11, 5, 0],
                &[
                    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 255, 255,
                ],
            ) || offset_mask_range(
                bytes,
                10,
                50,
                &[48, 11, 6, 9, 96, 134, 72, 1, 101, 3, 4, 3, 1],
                &[
                    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0,
                ],
            ) || offset_mask_range(
                bytes,
                10,
                50,
                &[48, 10, 6, 8, 42, 134, 72, 206, 61, 4, 3, 1],
                &[255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0],
            )))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_x509_key_format_pem_application;
impl MimeTypeChecker for T_x_x509_key_format_pem_application {
    fn get_mime(&self) -> &'static str {
        "application/x-x509-key;format=pem"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                45, 45, 45, 45, 45, 66, 69, 71, 73, 78, 32, 80, 82, 73, 86, 65, 84, 69, 32, 75, 69,
                89, 45, 45, 45, 45, 45,
            ],
        ) || offset(
            bytes,
            0,
            &[
                45, 45, 45, 45, 45, 66, 69, 71, 73, 78, 32, 80, 85, 66, 76, 73, 67, 32, 75, 69, 89,
                45, 45, 45, 45, 45,
            ],
        ) || offset(
            bytes,
            0,
            &[
                45, 45, 45, 45, 45, 66, 69, 71, 73, 78, 32, 75, 69, 89, 45, 45, 45, 45, 45,
            ],
        ) || offset(
            bytes,
            0,
            &[
                45, 45, 45, 45, 45, 66, 69, 71, 73, 78, 32, 82, 83, 65, 32, 75, 69, 89, 45, 45, 45,
                45, 45,
            ],
        ) || offset(
            bytes,
            0,
            &[
                45, 45, 45, 45, 45, 66, 69, 71, 73, 78, 32, 82, 83, 65, 32, 80, 82, 73, 86, 65, 84,
                69, 32, 75, 69, 89, 45, 45, 45, 45, 45,
            ],
        ) || offset(
            bytes,
            0,
            &[
                45, 45, 45, 45, 45, 66, 69, 71, 73, 78, 32, 68, 83, 65, 32, 75, 69, 89, 45, 45, 45,
                45, 45,
            ],
        ) || offset(
            bytes,
            0,
            &[
                45, 45, 45, 45, 45, 66, 69, 71, 73, 78, 32, 68, 83, 65, 32, 80, 82, 73, 86, 65, 84,
                69, 32, 75, 69, 89, 45, 45, 45, 45, 45,
            ],
        ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_x509_dsa_parameters_application;
impl MimeTypeChecker for T_x_x509_dsa_parameters_application {
    fn get_mime(&self) -> &'static str {
        "application/x-x509-dsa-parameters"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                45, 45, 45, 45, 45, 66, 69, 71, 73, 78, 32, 68, 83, 65, 32, 80, 65, 82, 65, 77, 69,
                84, 69, 82, 83, 45, 45, 45, 45, 45,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_x509_ec_parameters_application;
impl MimeTypeChecker for T_x_x509_ec_parameters_application {
    fn get_mime(&self) -> &'static str {
        "application/x-x509-ec-parameters"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                45, 45, 45, 45, 45, 66, 69, 71, 73, 78, 32, 69, 67, 32, 80, 65, 82, 65, 77, 69, 84,
                69, 82, 83, 45, 45, 45, 45, 45,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_java_keystore_application;
impl MimeTypeChecker for T_x_java_keystore_application {
    fn get_mime(&self) -> &'static str {
        "application/x-java-keystore"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jks"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_range(bytes, 0, 4, &[254, 237, 254, 237])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_xz_application;
impl MimeTypeChecker for T_x_xz_application {
    fn get_mime(&self) -> &'static str {
        "application/x-xz"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[253, 55, 122, 88, 90, 0])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_zim_application;
impl MimeTypeChecker for T_x_zim_application {
    fn get_mime(&self) -> &'static str {
        "application/x-zim"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[90, 73, 77, 4])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_zoo_application;
impl MimeTypeChecker for T_x_zoo_application {
    fn get_mime(&self) -> &'static str {
        "application/x-zoo"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.zoo"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 20, &[220, 167, 196, 253])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_7z_compressed_application;
impl MimeTypeChecker for T_x_7z_compressed_application {
    fn get_mime(&self) -> &'static str {
        "application/x-7z-compressed"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.7z"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset_range(bytes, 0, 1, &[55, 122]) && offset_range(bytes, 2, 5, &[188, 175, 39, 28]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_eac3_audio;
impl MimeTypeChecker for T_eac3_audio {
    fn get_mime(&self) -> &'static str {
        "audio/eac3"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[11, 119])
            && (offset_mask(bytes, 5, &[88], &[248])
                || offset_mask(bytes, 5, &[96], &[248])
                || offset_mask(bytes, 5, &[104], &[248])
                || offset_mask(bytes, 5, &[112], &[248])
                || offset_mask(bytes, 5, &[120], &[248])
                || offset_mask(bytes, 5, &[128], &[248])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_amr_wb_audio;
impl MimeTypeChecker for T_amr_wb_audio {
    fn get_mime(&self) -> &'static str {
        "audio/amr-wb"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[35, 33, 65, 77, 82, 45, 87, 66, 10])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_psf_audio;
impl MimeTypeChecker for T_x_psf_audio {
    fn get_mime(&self) -> &'static str {
        "audio/x-psf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[
            "*.psf1",
            "*.psflib",
            "*.minipsf",
            "*.minipsf1",
            "*.gslib",
            "*.minigsf",
        ]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 83, 70])
            && (offset(bytes, 3, &[1])
                || offset(bytes, 3, &[2])
                || offset(bytes, 3, &[17])
                || offset(bytes, 3, &[18])
                || offset(bytes, 3, &[19])
                || offset(bytes, 3, &[33])
                || offset(bytes, 3, &[34])
                || offset(bytes, 3, &[35])
                || offset(bytes, 3, &[65])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sap_audio;
impl MimeTypeChecker for T_x_sap_audio {
    fn get_mime(&self) -> &'static str {
        "audio/x-sap"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sap"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[83, 65, 80, 13, 10])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_prs_sid_audio;
impl MimeTypeChecker for T_prs_sid_audio {
    fn get_mime(&self) -> &'static str {
        "audio/prs.sid"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[80, 83, 73, 68])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_qcelp_audio;
impl MimeTypeChecker for T_qcelp_audio {
    fn get_mime(&self) -> &'static str {
        "audio/qcelp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.qcp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[82, 73, 70, 70]) && offset(bytes, 8, &[81, 76, 67, 77]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_flac_audio;
impl MimeTypeChecker for T_x_flac_audio {
    fn get_mime(&self) -> &'static str {
        "audio/x-flac"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.flac"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[102, 76, 97, 67])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mod_audio;
impl MimeTypeChecker for T_x_mod_audio {
    fn get_mime(&self) -> &'static str {
        "audio/x-mod"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mod"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                69, 120, 116, 101, 110, 100, 101, 100, 32, 77, 111, 100, 117, 108, 101, 58,
            ],
        ) || offset(bytes, 21, &[66, 77, 79, 68, 50, 83, 84, 77])
            || offset(bytes, 1080, &[77, 46, 75, 46])
            || offset(bytes, 1080, &[77, 33, 75, 33])
            || offset(bytes, 1080, &[70, 76, 84, 52])
            || offset(bytes, 1080, &[70, 76, 84, 56])
            || offset(bytes, 1080, &[52, 67, 72, 78])
            || offset(bytes, 1080, &[54, 67, 72, 78])
            || offset(bytes, 1080, &[56, 67, 72, 78])
            || offset(bytes, 1080, &[67, 68, 56, 49])
            || offset(bytes, 1080, &[79, 75, 84, 65])
            || offset(bytes, 1080, &[49, 54, 67, 78])
            || offset(bytes, 1080, &[51, 50, 67, 78])
            || offset(bytes, 0, &[73, 77, 80, 77]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mpegurl_audio;
impl MimeTypeChecker for T_x_mpegurl_audio {
    fn get_mime(&self) -> &'static str {
        "audio/x-mpegurl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.m3u"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[35, 69, 88, 84, 77, 51, 85, 13, 10])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ms_wma_audio;
impl MimeTypeChecker for T_x_ms_wma_audio {
    fn get_mime(&self) -> &'static str {
        "audio/x-ms-wma"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wma"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        unicode_le_range(
            bytes,
            0,
            8192,
            &[
                87, 105, 110, 100, 111, 119, 115, 32, 77, 101, 100, 105, 97, 32, 65, 117, 100, 105,
                111,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_pn_realaudio_audio;
impl MimeTypeChecker for T_x_pn_realaudio_audio {
    fn get_mime(&self) -> &'static str {
        "audio/x-pn-realaudio"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ram", "*.ra"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[46, 114, 97, 253])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_cdx_chemical;
impl MimeTypeChecker for T_x_cdx_chemical {
    fn get_mime(&self) -> &'static str {
        "chemical/x-cdx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cdx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[86, 106, 67, 68, 48, 49, 48, 48])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_3ds_image;
impl MimeTypeChecker for T_x_3ds_image {
    fn get_mime(&self) -> &'static str {
        "image/x-3ds"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.3ds"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[77, 77])
            && offset(bytes, 6, &[2, 0, 10, 0, 0, 0])
            && offset(bytes, 16, &[61, 61]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_aces_image;
impl MimeTypeChecker for T_aces_image {
    fn get_mime(&self) -> &'static str {
        "image/aces"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.exr"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[118, 47, 49, 1, 2, 0, 0, 0])
            || offset(bytes, 0, &[118, 47, 49, 1, 2, 4, 0, 0]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_os2_graphics__charset_binary_image;
impl MimeTypeChecker for T_x_os2_graphics__charset_binary_image {
    fn get_mime(&self) -> &'static str {
        "image/x-os2-graphics; charset=binary"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[66, 65])
            && (offset(bytes, 14, &[66, 77])
                || offset(bytes, 14, &[67, 73])
                || offset(bytes, 14, &[73, 67])
                || offset(bytes, 14, &[67, 80])
                || offset(bytes, 14, &[80, 84])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_bmp_image;
impl MimeTypeChecker for T_bmp_image {
    fn get_mime(&self) -> &'static str {
        "image/bmp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.bmp", "*.dib"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[66, 77])
            && offset(bytes, 26, &[1, 0])
            && (offset(bytes, 28, &[0, 0])
                || offset(bytes, 28, &[1, 0])
                || offset(bytes, 28, &[4, 0])
                || offset(bytes, 28, &[8, 0])
                || offset(bytes, 28, &[16, 0])
                || offset(bytes, 28, &[24, 0])
                || offset(bytes, 28, &[32, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_bpg_image;
impl MimeTypeChecker for T_x_bpg_image {
    fn get_mime(&self) -> &'static str {
        "image/x-bpg"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.bpg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[66, 80, 71, 251])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_cgm_image;
impl MimeTypeChecker for T_cgm_image {
    fn get_mime(&self) -> &'static str {
        "image/cgm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cgm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[66, 69, 71, 77, 70])
            || (offset_mask(bytes, 0, &[0, 32], &[255, 224])
                && (offset_range(bytes, 2, 64, &[16, 34, 0, 1])
                    || offset_range(bytes, 2, 64, &[16, 34, 0, 2])
                    || offset_range(bytes, 2, 64, &[16, 34, 0, 3])
                    || offset_range(bytes, 2, 64, &[16, 34, 0, 4]))))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_dpx_image;
impl MimeTypeChecker for T_x_dpx_image {
    fn get_mime(&self) -> &'static str {
        "image/x-dpx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dpx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[83, 68, 80, 88]) || offset(bytes, 0, &[88, 80, 68, 83]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_emf_image;
impl MimeTypeChecker for T_emf_image {
    fn get_mime(&self) -> &'static str {
        "image/emf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.emf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[1, 0, 0, 0]) && offset(bytes, 40, &[32, 69, 77, 70]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_fits_image;
impl MimeTypeChecker for T_fits_image {
    fn get_mime(&self) -> &'static str {
        "image/fits"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[83, 73, 77, 80, 76, 69, 32, 32, 61, 32, 32])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_gif_image;
impl MimeTypeChecker for T_gif_image {
    fn get_mime(&self) -> &'static str {
        "image/gif"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gif"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[71, 73, 70, 56, 55, 97]) || offset(bytes, 0, &[71, 73, 70, 56, 57, 97]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_icns_image;
impl MimeTypeChecker for T_icns_image {
    fn get_mime(&self) -> &'static str {
        "image/icns"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.icns"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[105, 99, 110, 115])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_jp2_image;
impl MimeTypeChecker for T_jp2_image {
    fn get_mime(&self) -> &'static str {
        "image/jp2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jp2"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[0, 0, 0, 12, 106, 80, 32, 32, 13, 10, 135, 10])
            && offset(bytes, 20, &[106, 112, 50, 32]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_jpeg_image;
impl MimeTypeChecker for T_jpeg_image {
    fn get_mime(&self) -> &'static str {
        "image/jpeg"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jpg", "*.jpeg", "*.jpe", "*.jif", "*.jfif", "*.jfi"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[255, 216, 255])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_jpm_image;
impl MimeTypeChecker for T_jpm_image {
    fn get_mime(&self) -> &'static str {
        "image/jpm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jpm", "*.jpgm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[0, 0, 0, 12, 106, 80, 32, 32, 13, 10, 135, 10])
            && offset(bytes, 20, &[106, 112, 109, 32]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_jpx_image;
impl MimeTypeChecker for T_jpx_image {
    fn get_mime(&self) -> &'static str {
        "image/jpx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jpf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[0, 0, 0, 12, 106, 80, 32, 32, 13, 10, 135, 10])
            && offset(bytes, 20, &[106, 112, 120, 32]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_nitf_image;
impl MimeTypeChecker for T_nitf_image {
    fn get_mime(&self) -> &'static str {
        "image/nitf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ntf", "*.nitf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[78, 73, 84, 70, 48, 49, 46, 49, 48])
            || offset(bytes, 0, &[78, 73, 84, 70, 48, 50, 46, 48, 48, 48])
            || offset(bytes, 0, &[78, 73, 84, 70, 48, 50, 46, 49, 48, 48]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_svg_xml_image;
impl MimeTypeChecker for T_svg_xml_image {
    fn get_mime(&self) -> &'static str {
        "image/svg+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.svg", "*.svgz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml(bytes, "svg", "http://www.w3.org/2000/svg")
            || (offset_range(bytes, 0, 256, &[60, 115, 118, 103])
                && offset_range(
                    bytes,
                    5,
                    256,
                    &[
                        104, 116, 116, 112, 58, 47, 47, 119, 119, 119, 46, 119, 51, 46, 111, 114,
                        103, 47, 50, 48, 48, 48, 47, 115, 118, 103,
                    ],
                ))
            || offset(bytes, 0, &[60, 115, 118, 103]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_adobe_photoshop_image;
impl MimeTypeChecker for T_vnd_adobe_photoshop_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.adobe.photoshop"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.psd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[56, 66, 80, 83, 0, 1]) || offset(bytes, 0, &[56, 66, 80, 83, 0, 2]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dgn_version_7_image;
impl MimeTypeChecker for T_vnd_dgn_version_7_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.dgn;version=7"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_mask(bytes, 0, &[8, 9, 254, 2], &[15, 255, 255, 255])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_djvu_image;
impl MimeTypeChecker for T_vnd_djvu_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.djvu"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.djvu", "*.djv"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[65, 84, 38, 84, 70, 79, 82, 77])
            && (offset(bytes, 12, &[68, 74, 86, 77])
                || offset(bytes, 12, &[68, 74, 86, 85])
                || offset(bytes, 12, &[68, 74, 86, 73])
                || offset(bytes, 12, &[84, 72, 85, 77])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dwg_image;
impl MimeTypeChecker for T_vnd_dwg_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.dwg"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dwg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[77, 67, 48, 46, 48])
            || offset(bytes, 0, &[65, 67, 49, 46, 50])
            || offset(bytes, 0, &[65, 67, 49, 46, 52, 48])
            || offset(bytes, 0, &[65, 67, 49, 46, 53, 48])
            || offset(bytes, 0, &[65, 67, 50, 46, 49, 48])
            || offset(bytes, 0, &[65, 67, 50, 46, 50, 49])
            || offset(bytes, 0, &[65, 67, 50, 46, 50, 50])
            || offset_mask(
                bytes,
                0,
                &[65, 67, 48, 48, 48, 48],
                &[255, 255, 240, 240, 240, 240],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dxb_image;
impl MimeTypeChecker for T_vnd_dxb_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.dxb"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dxb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                65, 117, 116, 111, 67, 65, 68, 32, 68, 88, 66, 32, 49, 46, 48, 13, 10, 48, 120, 49,
                65, 48, 48,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dxf_format_binary_image;
impl MimeTypeChecker for T_vnd_dxf_format_binary_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.dxf;format=binary"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                65, 117, 116, 111, 67, 65, 68, 32, 66, 105, 110, 97, 114, 121, 32, 68, 88, 70, 13,
                10, 48, 120, 49, 65, 48, 48,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dxf_format_ascii_image;
impl MimeTypeChecker for T_vnd_dxf_format_ascii_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.dxf;format=ascii"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> =
            Lazy::new(|| Regex::new("(999\r?\n[^\r\n]{0,64}\\s+)?0\r?\nSECTION\r?\n").unwrap());
        static REGEX_PATTERN_1: Lazy<Regex> =
            Lazy::new(|| Regex::new("2\r?\n(?:HEADER|ENTITIES)\r?\n").unwrap());

        (regex_range(bytes, 0, 32, &REGEX_PATTERN_0)
            && regex_range(bytes, 12, 60, &REGEX_PATTERN_1))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_microsoft_icon_image;
impl MimeTypeChecker for T_vnd_microsoft_icon_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.microsoft.icon"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ico"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[66, 65, 40, 0, 0, 0, 46, 0, 0, 0, 0, 0, 0, 0])
            || offset(bytes, 0, &[0, 0, 1, 0])
            || offset(bytes, 0, &[0, 0, 2, 0]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_modi_image;
impl MimeTypeChecker for T_vnd_ms_modi_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.ms-modi"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mdi"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[69, 80, 42, 0])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_radiance_image;
impl MimeTypeChecker for T_vnd_radiance_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.radiance"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.hdr"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[35, 63, 82, 65, 68, 73, 65, 78, 67, 69])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_zbrush_dcx_image;
impl MimeTypeChecker for T_vnd_zbrush_dcx_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.zbrush.dcx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dcx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[177, 104, 222, 58])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_webp_image;
impl MimeTypeChecker for T_webp_image {
    fn get_mime(&self) -> &'static str {
        "image/webp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.webp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_mask(
            bytes,
            0,
            &[82, 73, 70, 70, 46, 46, 46, 46, 87, 69, 66, 80],
            &[255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_wmf_image;
impl MimeTypeChecker for T_wmf_image {
    fn get_mime(&self) -> &'static str {
        "image/wmf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wmf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[215, 205, 198, 154, 0, 0]) || offset(bytes, 0, &[1, 0, 9, 0, 0, 3]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_freehand_image;
impl MimeTypeChecker for T_x_freehand_image {
    fn get_mime(&self) -> &'static str {
        "image/x-freehand"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[
            "*.fh", "*.fhc", "*.fh4", "*.fh40", "*.fh5", "*.fh50", "*.fh7", "*.fh8", "*.fh9",
            "*.fh10", "*.fh11", "*.fh12", "*.ft7", "*.ft8", "*.ft9", "*.ft10", "*.ft11", "*.ft12",
        ]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[65, 71, 68, 50])
            || offset(bytes, 0, &[65, 71, 68, 51])
            || offset(bytes, 0, &[65, 71, 68, 52])
            || offset_range(bytes, 0, 24, &[70, 114, 101, 101, 72, 97, 110, 100, 49, 48])
            || offset_range(bytes, 0, 24, &[70, 114, 101, 101, 72, 97, 110, 100, 49, 49])
            || offset_range(bytes, 0, 24, &[70, 114, 101, 101, 72, 97, 110, 100, 49, 50]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_jbig2_image;
impl MimeTypeChecker for T_x_jbig2_image {
    fn get_mime(&self) -> &'static str {
        "image/x-jbig2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jb2", "*.jbig2"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[151, 74, 66, 50, 13, 10, 26, 10])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_jxl_image;
impl MimeTypeChecker for T_jxl_image {
    fn get_mime(&self) -> &'static str {
        "image/jxl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jxl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[255, 10])
            || offset(bytes, 0, &[0, 0, 0, 12, 74, 88, 76, 32, 13, 10, 135, 10]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_niff_image;
impl MimeTypeChecker for T_x_niff_image {
    fn get_mime(&self) -> &'static str {
        "image/x-niff"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[73, 73, 78, 49])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_pict_image;
impl MimeTypeChecker for T_x_pict_image {
    fn get_mime(&self) -> &'static str {
        "image/x-pict"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pic", "*.pct", "*.pict"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 522, &[0, 17, 2, 255, 12, 0])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_portable_bitmap_image;
impl MimeTypeChecker for T_x_portable_bitmap_image {
    fn get_mime(&self) -> &'static str {
        "image/x-portable-bitmap"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pbm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> = Lazy::new(|| Regex::new("P4").unwrap());

        ((offset(bytes, 0, &[80, 49])
            && (offset(bytes, 2, &[10]) || offset(bytes, 2, &[13]) || offset(bytes, 2, &[32])))
            || (regex(bytes, 0, &REGEX_PATTERN_0)
                && (offset(bytes, 2, &[10]) || offset(bytes, 2, &[13]) || offset(bytes, 2, &[32]))))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_portable_graymap_image;
impl MimeTypeChecker for T_x_portable_graymap_image {
    fn get_mime(&self) -> &'static str {
        "image/x-portable-graymap"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pgm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> = Lazy::new(|| Regex::new("P5").unwrap());

        ((offset(bytes, 0, &[80, 50])
            && (offset(bytes, 2, &[10]) || offset(bytes, 2, &[13]) || offset(bytes, 2, &[32])))
            || (regex(bytes, 0, &REGEX_PATTERN_0)
                && (offset(bytes, 2, &[10]) || offset(bytes, 2, &[13]) || offset(bytes, 2, &[32]))))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_portable_pixmap_image;
impl MimeTypeChecker for T_x_portable_pixmap_image {
    fn get_mime(&self) -> &'static str {
        "image/x-portable-pixmap"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ppm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> = Lazy::new(|| Regex::new("P6").unwrap());

        ((offset(bytes, 0, &[80, 51])
            && (offset(bytes, 2, &[10]) || offset(bytes, 2, &[13]) || offset(bytes, 2, &[32])))
            || (regex(bytes, 0, &REGEX_PATTERN_0)
                && (offset(bytes, 2, &[10]) || offset(bytes, 2, &[13]) || offset(bytes, 2, &[32]))))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_portable_arbitrarymap_image;
impl MimeTypeChecker for T_x_portable_arbitrarymap_image {
    fn get_mime(&self) -> &'static str {
        "image/x-portable-arbitrarymap"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pam"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 55])
            && (offset(bytes, 2, &[10]) || offset(bytes, 2, &[13]) || offset(bytes, 2, &[32])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_canon_image;
impl MimeTypeChecker for T_x_raw_canon_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-canon"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.crw"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[73, 73, 26, 0, 0, 0, 72, 69, 65, 80, 67, 67, 68, 82],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_olympus_image;
impl MimeTypeChecker for T_x_raw_olympus_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-olympus"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.orf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[73, 73, 82, 79])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_rgb_image;
impl MimeTypeChecker for T_x_rgb_image {
    fn get_mime(&self) -> &'static str {
        "image/x-rgb"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rgb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[1, 218, 1, 1, 0, 3])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_xcf_image;
impl MimeTypeChecker for T_x_xcf_image {
    fn get_mime(&self) -> &'static str {
        "image/x-xcf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xcf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[103, 105, 109, 112, 32, 120, 99, 102, 32])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_xpixmap_image;
impl MimeTypeChecker for T_x_xpixmap_image {
    fn get_mime(&self) -> &'static str {
        "image/x-xpixmap"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xpm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[47, 42, 32, 88, 80, 77, 32, 42, 47])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_appledouble_multipart;
impl MimeTypeChecker for T_appledouble_multipart {
    fn get_mime(&self) -> &'static str {
        "multipart/appledouble"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[0, 5, 22, 7])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_calendar_text;
impl MimeTypeChecker for T_calendar_text {
    fn get_mime(&self) -> &'static str {
        "text/calendar"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ics", "*.ifb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[66, 69, 71, 73, 78, 58, 86, 67, 65, 76, 69, 78, 68, 65, 82],
        ) && offset_range(
            bytes,
            15,
            360,
            &[10, 86, 69, 82, 83, 73, 79, 78, 58, 50, 46, 48],
        ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_troff_text;
impl MimeTypeChecker for T_troff_text {
    fn get_mime(&self) -> &'static str {
        "text/troff"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.t", "*.tr", "*.roff", "*.nroff", "*.man", "*.me", "*.ms"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[46, 92, 34])
            || offset(bytes, 0, &[39, 92, 34])
            || offset(bytes, 0, &[39, 46, 92, 34])
            || offset(bytes, 0, &[92, 34])
            || offset(bytes, 0, &[39, 39, 39]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_graphviz_text;
impl MimeTypeChecker for T_vnd_graphviz_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.graphviz"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gv"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> =
            Lazy::new(|| Regex::new("(?s)^\\s*(?:strict\\s+)?(?:di)?graph\\b").unwrap());
        static REGEX_PATTERN_1: Lazy<Regex> = Lazy::new(|| {
            Regex::new("(?s)^(?:\\s*//[^\\n]*\n){1,10}\\s*(?:strict\\s+)?(?:di)?graph\\b").unwrap()
        });
        static REGEX_PATTERN_2: Lazy<Regex> = Lazy::new(|| {
            Regex::new("(?s)^\\s*/\\*.{0,1024}?\\*/\\s*(?:strict\\s+)?(?:di)?graph\\b").unwrap()
        });

        (regex(bytes, 0, &REGEX_PATTERN_0)
            || regex(bytes, 0, &REGEX_PATTERN_1)
            || regex(bytes, 0, &REGEX_PATTERN_2))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_iptc_anpa_text;
impl MimeTypeChecker for T_vnd_iptc_anpa_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.iptc.anpa"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.anpa"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[22, 22, 1])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_awk_text;
impl MimeTypeChecker for T_x_awk_text {
    fn get_mime(&self) -> &'static str {
        "text/x-awk"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.awk"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[35, 33, 47, 98, 105, 110, 47, 103, 97, 119, 107])
            || offset(
                bytes,
                0,
                &[35, 33, 32, 47, 98, 105, 110, 47, 103, 97, 119, 107],
            )
            || offset(
                bytes,
                0,
                &[
                    35, 33, 47, 117, 115, 114, 47, 98, 105, 110, 47, 103, 97, 119, 107,
                ],
            )
            || offset(
                bytes,
                0,
                &[
                    35, 33, 32, 47, 117, 115, 114, 47, 98, 105, 110, 47, 103, 97, 119, 107,
                ],
            )
            || offset(
                bytes,
                0,
                &[
                    35, 33, 47, 117, 115, 114, 47, 108, 111, 99, 97, 108, 47, 98, 105, 110, 47,
                    103, 97, 119, 107,
                ],
            )
            || offset(
                bytes,
                0,
                &[
                    35, 33, 32, 47, 117, 115, 114, 47, 108, 111, 99, 97, 108, 47, 98, 105, 110, 47,
                    103, 97, 119, 107,
                ],
            )
            || offset(bytes, 0, &[35, 33, 47, 98, 105, 110, 47, 97, 119, 107])
            || offset(bytes, 0, &[35, 33, 32, 47, 98, 105, 110, 47, 97, 119, 107])
            || offset(
                bytes,
                0,
                &[
                    35, 33, 47, 117, 115, 114, 47, 98, 105, 110, 47, 97, 119, 107,
                ],
            )
            || offset(
                bytes,
                0,
                &[
                    35, 33, 32, 47, 117, 115, 114, 47, 98, 105, 110, 47, 97, 119, 107,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_diff_text;
impl MimeTypeChecker for T_x_diff_text {
    fn get_mime(&self) -> &'static str {
        "text/x-diff"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.diff", "*.patch"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[100, 105, 102, 102, 32])
            || offset(bytes, 0, &[42, 42, 42, 32])
            || offset(bytes, 0, &[79, 110, 108, 121, 32, 105, 110, 32])
            || offset(
                bytes,
                0,
                &[
                    67, 111, 109, 109, 111, 110, 32, 115, 117, 98, 100, 105, 114, 101, 99, 116,
                    111, 114, 105, 101, 115, 58, 32,
                ],
            )
            || offset(bytes, 0, &[73, 110, 100, 101, 120, 58]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_jsp_text;
impl MimeTypeChecker for T_x_jsp_text {
    fn get_mime(&self) -> &'static str {
        "text/x-jsp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jsp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[60, 37, 64]) || offset(bytes, 0, &[60, 37, 45, 45]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_lua_text;
impl MimeTypeChecker for T_x_lua_text {
    fn get_mime(&self) -> &'static str {
        "text/x-lua"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.lua"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[35, 33])
            && (offset_range_case_insensitive(
                bytes,
                2,
                15,
                &[47, 117, 115, 114, 47, 98, 105, 110, 47, 108, 117, 97],
            ) || offset_range_case_insensitive(
                bytes,
                2,
                11,
                &[47, 98, 105, 110, 47, 108, 117, 97],
            ) || offset_case_insensitive(
                bytes,
                2,
                &[
                    47, 117, 115, 114, 47, 98, 105, 110, 47, 101, 110, 118, 32, 108, 117, 97,
                ],
            )))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_matlab_text;
impl MimeTypeChecker for T_x_matlab_text {
    fn get_mime(&self) -> &'static str {
        "text/x-matlab"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> =
            Lazy::new(|| Regex::new("function [a-zA-Z][A-Za-z0-9_]{0,62}\\s*=").unwrap());
        static REGEX_PATTERN_1: Lazy<Regex> =
            Lazy::new(|| Regex::new("function [a-zA-Z][A-Za-z0-9_]{0,62}[\\r\\n]").unwrap());
        static REGEX_PATTERN_2: Lazy<Regex> = Lazy::new(|| Regex::new("^%[ -~]+\n%").unwrap());
        static REGEX_PATTERN_3: Lazy<Regex> = Lazy::new(|| Regex::new("^%[ -~]+\r%").unwrap());
        static REGEX_PATTERN_4: Lazy<Regex> = Lazy::new(|| Regex::new("^%%[ -~]+$").unwrap());

        (offset(bytes, 0, &[102, 117, 110, 99, 116, 105, 111, 110, 32, 91])
            || regex(bytes, 0, &REGEX_PATTERN_0)
            || regex(bytes, 0, &REGEX_PATTERN_1)
            || regex_range(bytes, 0, 120, &REGEX_PATTERN_2)
            || regex_range(bytes, 0, 120, &REGEX_PATTERN_3)
            || regex_range(bytes, 0, 120, &REGEX_PATTERN_4)
            || offset(bytes, 0, &[37, 123, 10]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_matlab_data_application;
impl MimeTypeChecker for T_x_matlab_data_application {
    fn get_mime(&self) -> &'static str {
        "application/x-matlab-data"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mat"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[77, 65, 84, 76, 65, 66])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_perl_text;
impl MimeTypeChecker for T_x_perl_text {
    fn get_mime(&self) -> &'static str {
        "text/x-perl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pl", "*.pm", "*.al", "*.perl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                101, 118, 97, 108, 32, 34, 101, 120, 101, 99, 32, 47, 117, 115, 114, 47, 108, 111,
                99, 97, 108, 47, 98, 105, 110, 47, 112, 101, 114, 108,
            ],
        ) || offset(
            bytes,
            0,
            &[35, 33, 47, 98, 105, 110, 47, 112, 101, 114, 108],
        ) || offset(
            bytes,
            0,
            &[
                35, 33, 47, 98, 105, 110, 47, 101, 110, 118, 32, 112, 101, 114, 108,
            ],
        ) || offset(
            bytes,
            0,
            &[
                35, 33, 47, 117, 115, 114, 47, 98, 105, 110, 47, 112, 101, 114, 108,
            ],
        ) || offset(
            bytes,
            0,
            &[
                35, 33, 47, 117, 115, 114, 47, 108, 111, 99, 97, 108, 47, 98, 105, 110, 47, 112,
                101, 114, 108,
            ],
        ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_python_text;
impl MimeTypeChecker for T_x_python_text {
    fn get_mime(&self) -> &'static str {
        "text/x-python"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.py"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[35, 33, 47, 98, 105, 110, 47, 112, 121, 116, 104, 111, 110],
        ) || offset(
            bytes,
            0,
            &[
                35, 33, 32, 47, 98, 105, 110, 47, 112, 121, 116, 104, 111, 110,
            ],
        ) || offset(
            bytes,
            0,
            &[
                101, 118, 97, 108, 32, 34, 101, 120, 101, 99, 32, 47, 98, 105, 110, 47, 112, 121,
                116, 104, 111, 110,
            ],
        ) || offset(
            bytes,
            0,
            &[
                35, 33, 47, 117, 115, 114, 47, 98, 105, 110, 47, 112, 121, 116, 104, 111, 110,
            ],
        ) || offset(
            bytes,
            0,
            &[
                35, 33, 32, 47, 117, 115, 114, 47, 98, 105, 110, 47, 112, 121, 116, 104, 111, 110,
            ],
        ) || offset(
            bytes,
            0,
            &[
                101, 118, 97, 108, 32, 34, 101, 120, 101, 99, 32, 47, 117, 115, 114, 47, 98, 105,
                110, 47, 112, 121, 116, 104, 111, 110,
            ],
        ) || offset(
            bytes,
            0,
            &[
                35, 33, 47, 117, 115, 114, 47, 108, 111, 99, 97, 108, 47, 98, 105, 110, 47, 112,
                121, 116, 104, 111, 110,
            ],
        ) || offset(
            bytes,
            0,
            &[
                35, 33, 32, 47, 117, 115, 114, 47, 108, 111, 99, 97, 108, 47, 98, 105, 110, 47,
                112, 121, 116, 104, 111, 110,
            ],
        ) || offset(
            bytes,
            0,
            &[
                101, 118, 97, 108, 32, 34, 101, 120, 101, 99, 32, 47, 117, 115, 114, 47, 108, 111,
                99, 97, 108, 47, 98, 105, 110, 47, 112, 121, 116, 104, 111, 110,
            ],
        ) || offset(
            bytes,
            1,
            &[
                47, 98, 105, 110, 47, 101, 110, 118, 32, 112, 121, 116, 104, 111, 110,
            ],
        ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_tcl_text;
impl MimeTypeChecker for T_x_tcl_text {
    fn get_mime(&self) -> &'static str {
        "text/x-tcl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.itk", "*.tcl", "*.tk"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                35, 33, 47, 117, 115, 114, 47, 98, 105, 110, 47, 101, 110, 118, 32, 116, 99, 108,
            ],
        ) || offset(
            bytes,
            0,
            &[
                35, 33, 47, 117, 115, 114, 47, 98, 105, 110, 47, 116, 99, 108,
            ],
        ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_uuencode_text;
impl MimeTypeChecker for T_x_uuencode_text {
    fn get_mime(&self) -> &'static str {
        "text/x-uuencode"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.uu", "*.uue"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> = Lazy::new(|| Regex::new("^begin [0-9]{3} ").unwrap());

        regex(bytes, 0, &REGEX_PATTERN_0)
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_vcalendar_text;
impl MimeTypeChecker for T_x_vcalendar_text {
    fn get_mime(&self) -> &'static str {
        "text/x-vcalendar"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vcs"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[66, 69, 71, 73, 78, 58, 86, 67, 65, 76, 69, 78, 68, 65, 82],
        ) && offset_range(bytes, 15, 30, &[86, 69, 82, 83, 73, 79, 78, 58, 49, 46, 48]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_vcard_text;
impl MimeTypeChecker for T_x_vcard_text {
    fn get_mime(&self) -> &'static str {
        "text/x-vcard"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vcf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[66, 69, 71, 73, 78, 58, 86, 67, 65, 82, 68])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mj2_video;
impl MimeTypeChecker for T_mj2_video {
    fn get_mime(&self) -> &'static str {
        "video/mj2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mj2", "*.mjp2"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[0, 0, 0, 12, 106, 80, 32, 32, 13, 10, 135, 10])
            && offset(bytes, 20, &[109, 106, 112, 50]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mpeg_video;
impl MimeTypeChecker for T_mpeg_video {
    fn get_mime(&self) -> &'static str {
        "video/mpeg"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mpeg", "*.mpg", "*.mpe", "*.m1v", "*.m2v"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[0, 0, 1, 179]) || offset(bytes, 0, &[0, 0, 1, 186]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_flv_video;
impl MimeTypeChecker for T_x_flv_video {
    fn get_mime(&self) -> &'static str {
        "video/x-flv"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.flv"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[70, 76, 86])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_jng_video;
impl MimeTypeChecker for T_x_jng_video {
    fn get_mime(&self) -> &'static str {
        "video/x-jng"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jng"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[139, 74, 78, 71])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mng_video;
impl MimeTypeChecker for T_x_mng_video {
    fn get_mime(&self) -> &'static str {
        "video/x-mng"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mng"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[138, 77, 78, 71])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_msvideo_video;
impl MimeTypeChecker for T_x_msvideo_video {
    fn get_mime(&self) -> &'static str {
        "video/x-msvideo"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.avi"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset_mask(
            bytes,
            0,
            &[82, 73, 70, 70, 46, 46, 46, 46, 65, 86, 73, 32],
            &[255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255],
        ) || offset(bytes, 8, &[65, 86, 73, 32]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sgi_movie_video;
impl MimeTypeChecker for T_x_sgi_movie_video {
    fn get_mime(&self) -> &'static str {
        "video/x-sgi-movie"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.movie"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[77, 79, 86, 73, 0])
            || offset(bytes, 0, &[77, 79, 86, 73, 1])
            || offset(bytes, 0, &[77, 79, 86, 73, 2])
            || offset(bytes, 0, &[77, 79, 86, 73, 254])
            || offset(bytes, 0, &[77, 79, 86, 73, 255]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_matroska_video;
impl MimeTypeChecker for T_x_matroska_video {
    fn get_mime(&self) -> &'static str {
        "video/x-matroska"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mkv"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                26, 69, 223, 163, 147, 66, 130, 136, 109, 97, 116, 114, 111, 115, 107, 97,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_webm_video;
impl MimeTypeChecker for T_webm_video {
    fn get_mime(&self) -> &'static str {
        "video/webm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.webm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[26, 69, 223, 163])
            && offset_range(bytes, 4, 4096, &[66, 130])
            && offset_range(bytes, 4, 4096, &[119, 101, 98, 109]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ole_storage_application;
impl MimeTypeChecker for T_x_ole_storage_application {
    fn get_mime(&self) -> &'static str {
        "application/x-ole-storage"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_range(bytes, 0, 8, &[208, 207, 17, 224, 161, 177, 26, 225])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_webm_audio;
impl MimeTypeChecker for T_webm_audio {
    fn get_mime(&self) -> &'static str {
        "audio/webm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[26, 69, 223, 163])
            && offset_range(bytes, 4, 4096, &[66, 130])
            && offset_range(bytes, 4, 4096, &[119, 101, 98, 109])
            && (offset_range(bytes, 4, 4096, &[65, 95, 86, 79, 82, 66, 73, 83])
                || offset_range(bytes, 4, 4096, &[65, 95, 79, 80, 85, 83])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_woff_font;
impl MimeTypeChecker for T_woff_font {
    fn get_mime(&self) -> &'static str {
        "font/woff"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.woff"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[119, 79, 70, 70])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_woff2_font;
impl MimeTypeChecker for T_woff2_font {
    fn get_mime(&self) -> &'static str {
        "font/woff2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.woff2"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[119, 79, 70, 50])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_xar_application;
impl MimeTypeChecker for T_x_xar_application {
    fn get_mime(&self) -> &'static str {
        "application/x-xar"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xar"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[120, 97, 114, 33])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_lzip_application;
impl MimeTypeChecker for T_lzip_application {
    fn get_mime(&self) -> &'static str {
        "application/lzip"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.lz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[76, 90, 73, 80])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_installshield_application;
impl MimeTypeChecker for T_x_installshield_application {
    fn get_mime(&self) -> &'static str {
        "application/x-installshield"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[73, 83, 99, 40])
            && offset(bytes, 6, &[0])
            && (offset(bytes, 7, &[1]) || offset(bytes, 7, &[2]) || offset(bytes, 7, &[4])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_chrome_extension_application;
impl MimeTypeChecker for T_x_chrome_extension_application {
    fn get_mime(&self) -> &'static str {
        "application/x-chrome-extension"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.crx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[67, 114, 50, 52])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_ape_audio;
impl MimeTypeChecker for T_ape_audio {
    fn get_mime(&self) -> &'static str {
        "audio/ape"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ape"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                77, 65, 67, 32, 150, 15, 0, 0, 52, 0, 0, 0, 24, 0, 0, 0, 144, 227,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_musepack_audio;
impl MimeTypeChecker for T_musepack_audio {
    fn get_mime(&self) -> &'static str {
        "audio/musepack"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mpc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[77, 80, 67, 75])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_unknown_audio;
impl MimeTypeChecker for T_x_unknown_audio {
    fn get_mime(&self) -> &'static str {
        "audio/x-unknown"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.voc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                67, 114, 101, 97, 116, 105, 118, 101, 32, 86, 111, 105, 99, 101, 32, 70, 105, 108,
                101,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ms_shortcut_application;
impl MimeTypeChecker for T_x_ms_shortcut_application {
    fn get_mime(&self) -> &'static str {
        "application/x-ms-shortcut"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.lnk"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[76, 0, 0, 0, 1, 20, 2, 0])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_gltf_binary_model;
impl MimeTypeChecker for T_gltf_binary_model {
    fn get_mime(&self) -> &'static str {
        "model/gltf-binary"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.glb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[103, 108, 84, 70])
            && (offset(bytes, 4, &[1, 0, 0, 0]) || offset(bytes, 4, &[2, 0, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_tzif_application;
impl MimeTypeChecker for T_tzif_application {
    fn get_mime(&self) -> &'static str {
        "application/tzif"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["tzfile"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[84, 90, 105, 102])
            && (offset(bytes, 4, &[0]) || offset(bytes, 4, &[50]) || offset(bytes, 4, &[51])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_collection_font;
impl MimeTypeChecker for T_collection_font {
    fn get_mime(&self) -> &'static str {
        "font/collection"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ttc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[116, 116, 99, 102])
            && (offset(bytes, 4, &[0, 1, 0, 0]) || offset(bytes, 4, &[0, 2, 0, 0])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dvb_file_video;
impl MimeTypeChecker for T_vnd_dvb_file_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.dvb.file"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dvb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 4, &[102, 116, 121, 112])
            && (offset(bytes, 8, &[100, 98, 121, 49])
                || offset(bytes, 8, &[100, 115, 109, 115])
                || offset(bytes, 8, &[100, 116, 115, 49])
                || offset(bytes, 8, &[100, 116, 115, 50])
                || offset(bytes, 8, &[100, 116, 115, 51])
                || offset(bytes, 8, &[100, 120, 111, 32])
                || offset(bytes, 8, &[100, 109, 98, 49])
                || offset(bytes, 8, &[100, 109, 112, 102])
                || offset(bytes, 8, &[100, 114, 99, 49])
                || offset(bytes, 8, &[100, 118, 49, 97])
                || offset(bytes, 8, &[100, 118, 49, 98])
                || offset(bytes, 8, &[100, 118, 50, 97])
                || offset(bytes, 8, &[100, 118, 50, 98])
                || offset(bytes, 8, &[100, 118, 51, 97])
                || offset(bytes, 8, &[100, 118, 51, 98])
                || offset(bytes, 8, &[100, 118, 114, 49])
                || offset(bytes, 8, &[100, 118, 116, 49])
                || offset(bytes, 8, &[101, 109, 115, 103])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mozilla_apng_image;
impl MimeTypeChecker for T_vnd_mozilla_apng_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.mozilla.apng"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[137, 80, 78, 71, 13, 10, 26, 10])
            && offset(bytes, 37, &[97, 99, 84, 76]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_bpg_image;
impl MimeTypeChecker for T_bpg_image {
    fn get_mime(&self) -> &'static str {
        "image/bpg"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.bpg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[66, 80, 71, 251])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_jxs_image;
impl MimeTypeChecker for T_jxs_image {
    fn get_mime(&self) -> &'static str {
        "image/jxs"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jxs"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[0, 0, 0, 12, 74, 88, 83, 32, 13, 10, 135, 10])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_jxr_image;
impl MimeTypeChecker for T_jxr_image {
    fn get_mime(&self) -> &'static str {
        "image/jxr"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jxr"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[73, 73, 188, 1])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ms_reader_application;
impl MimeTypeChecker for T_x_ms_reader_application {
    fn get_mime(&self) -> &'static str {
        "application/x-ms-reader"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.lit"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[73, 84, 79, 76, 73, 84, 76, 83])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_epub_zip_application;
impl MimeTypeChecker for T_epub_zip_application {
    fn get_mime(&self) -> &'static str {
        "application/epub+zip"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.epub"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75, 3, 4])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 101, 112, 117, 98, 43, 122, 105, 112,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_x_ibooks_zip_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_fits_application;
impl MimeTypeChecker for T_fits_application {
    fn get_mime(&self) -> &'static str {
        "application/fits"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fits", "*.fit", "*.fts"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                83, 73, 77, 80, 76, 69, 32, 32, 61, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
                32, 32, 32, 32, 32, 32, 32, 32, 84,
            ],
        ) || offset(
            bytes,
            0,
            &[
                83, 73, 77, 80, 76, 69, 32, 32, 61, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
                32, 32, 32, 32, 84,
            ],
        ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_fits_image]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_javascript_text;
impl MimeTypeChecker for T_javascript_text {
    fn get_mime(&self) -> &'static str {
        "text/javascript"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.js", "*.mjs"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[47, 42, 32, 106, 81, 117, 101, 114, 121, 32])
            || offset(bytes, 0, &[47, 42, 33, 32, 106, 81, 117, 101, 114, 121, 32])
            || (offset(bytes, 0, &[47, 42, 33])
                && offset_range(bytes, 4, 8, &[42, 32, 106, 81, 117, 101, 114, 121, 32]))
            || offset(
                bytes,
                0,
                &[
                    40, 102, 117, 110, 99, 116, 105, 111, 110, 40, 101, 44, 117, 110, 100, 101,
                    102, 105, 110, 101, 100, 41, 123,
                ],
            )
            || offset(
                bytes,
                0,
                &[
                    33, 102, 117, 110, 99, 116, 105, 111, 110, 40, 119, 105, 110, 100, 111, 119,
                    44, 117, 110, 100, 101, 102, 105, 110, 101, 100, 41, 123,
                ],
            )
            || offset(
                bytes,
                0,
                &[
                    47, 42, 32, 32, 80, 114, 111, 116, 111, 116, 121, 112, 101, 32, 74, 97, 118,
                    97, 83, 99, 114, 105, 112, 116, 32,
                ],
            )
            || offset(
                bytes,
                0,
                &[
                    118, 97, 114, 32, 80, 114, 111, 116, 111, 116, 121, 112, 101, 61, 123,
                ],
            )
            || offset(
                bytes,
                0,
                &[
                    102, 117, 110, 99, 116, 105, 111, 110, 32, 36, 119, 40, 116, 41, 123,
                ],
            )
            || offset(
                bytes,
                0,
                &[
                    47, 42, 42, 32, 64, 108, 105, 99, 101, 110, 115, 101, 32, 82, 101, 97, 99, 116,
                ],
            )
            || (offset(bytes, 0, &[47, 42, 42])
                && offset_range(bytes, 4, 8, &[42, 32, 82, 101, 97, 99, 116, 32]))
            || (offset(bytes, 0, &[35, 33])
                && (offset_case_insensitive(
                    bytes,
                    2,
                    &[47, 98, 105, 110, 47, 110, 111, 100, 101],
                ) || offset_case_insensitive(
                    bytes,
                    2,
                    &[47, 117, 115, 114, 47, 98, 105, 110, 47, 110, 111, 100, 101],
                ) || offset_case_insensitive(
                    bytes,
                    2,
                    &[47, 98, 105, 110, 47, 110, 111, 100, 101, 106, 115],
                ) || offset_case_insensitive(
                    bytes,
                    2,
                    &[
                        47, 117, 115, 114, 47, 98, 105, 110, 47, 101, 110, 118, 32, 110, 111, 100,
                        101,
                    ],
                ) || offset_case_insensitive(
                    bytes,
                    2,
                    &[
                        47, 117, 115, 114, 47, 98, 105, 110, 47, 101, 110, 118, 32, 110, 111, 100,
                        101, 106, 115,
                    ],
                ))))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_json_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_mathematica_application;
impl MimeTypeChecker for T_mathematica_application {
    fn get_mime(&self) -> &'static str {
        "application/mathematica"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ma", "*.nb", "*.mb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[40, 42, 42]) || offset(bytes, 0, &[40, 42, 32]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_vnd_wolfram_wl_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_postscript_application;
impl MimeTypeChecker for T_postscript_application {
    fn get_mime(&self) -> &'static str {
        "application/postscript"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ps", "*.eps", "*.epsf", "*.epsi"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[37, 33])
            || offset(bytes, 0, &[4, 37, 33])
            || offset(bytes, 0, &[197, 208, 211, 198])
            || offset(bytes, 0, &[37, 33, 80, 83, 45, 65, 100, 111, 98, 101, 45]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_illustrator_ps_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_vnd_ms_cab_compressed_application;
impl MimeTypeChecker for T_vnd_ms_cab_compressed_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-cab-compressed"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cab"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[77, 83, 67, 70, 0, 0, 0, 0]) || offset(bytes, 0, &[77, 83, 67, 70]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_onenote__format_package_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_archive_application;
impl MimeTypeChecker for T_x_archive_application {
    fn get_mime(&self) -> &'static str {
        "application/x-archive"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ar", "*.a"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[61, 60, 97, 114, 62])
            || offset(bytes, 0, &[33, 60, 97, 114, 99, 104, 62]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_x_debian_package_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_iso9660_image_application;
impl MimeTypeChecker for T_x_iso9660_image_application {
    fn get_mime(&self) -> &'static str {
        "application/x-iso9660-image"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.iso"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 32769, &[67, 68, 48, 48, 49])
            || offset(bytes, 34817, &[67, 68, 48, 48, 49])
            || offset(bytes, 36865, &[67, 68, 48, 48, 49]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_x_roxio_toast_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_tex_application;
impl MimeTypeChecker for T_x_tex_application {
    fn get_mime(&self) -> &'static str {
        "application/x-tex"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.tex"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[92, 105, 110, 112, 117, 116])
            || offset(bytes, 0, &[92, 115, 101, 99, 116, 105, 111, 110])
            || offset(bytes, 0, &[92, 115, 101, 116, 108, 101, 110, 103, 116, 104])
            || offset(
                bytes,
                0,
                &[
                    92, 100, 111, 99, 117, 109, 101, 110, 116, 115, 116, 121, 108, 101,
                ],
            )
            || offset(bytes, 0, &[92, 99, 104, 97, 112, 116, 101, 114])
            || offset(
                bytes,
                0,
                &[
                    92, 100, 111, 99, 117, 109, 101, 110, 116, 99, 108, 97, 115, 115,
                ],
            )
            || offset(bytes, 0, &[92, 114, 101, 108, 97, 120])
            || offset(
                bytes,
                0,
                &[
                    92, 99, 111, 110, 116, 101, 110, 116, 115, 108, 105, 110, 101,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_x_latex_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_ac3_audio;
impl MimeTypeChecker for T_ac3_audio {
    fn get_mime(&self) -> &'static str {
        "audio/ac3"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ac3"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[11, 119])
            || (offset(bytes, 0, &[11, 119])
                && (offset_mask(bytes, 5, &[0], &[248])
                    || offset_mask(bytes, 5, &[8], &[248])
                    || offset_mask(bytes, 5, &[16], &[248])
                    || offset_mask(bytes, 5, &[24], &[248])
                    || offset_mask(bytes, 5, &[32], &[248])
                    || offset_mask(bytes, 5, &[40], &[248])
                    || offset_mask(bytes, 5, &[48], &[248])
                    || offset_mask(bytes, 5, &[56], &[248])
                    || offset_mask(bytes, 5, &[64], &[248]))))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_eac3_audio]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_png_image;
impl MimeTypeChecker for T_png_image {
    fn get_mime(&self) -> &'static str {
        "image/png"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.png"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[137, 80, 78, 71, 13, 10, 26, 10])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_vnd_mozilla_apng_image]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_tiff_image;
impl MimeTypeChecker for T_tiff_image {
    fn get_mime(&self) -> &'static str {
        "image/tiff"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.tiff", "*.tif"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[77, 77, 0, 42])
            || offset(bytes, 0, &[73, 73, 42, 0])
            || offset(bytes, 0, &[77, 77, 0, 43]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_x_canon_cr2_image]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_xbitmap_image;
impl MimeTypeChecker for T_x_xbitmap_image {
    fn get_mime(&self) -> &'static str {
        "image/x-xbitmap"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xbm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[47, 42, 32, 88, 80, 77])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_x_xpixmap_image]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_rfc822_message;
impl MimeTypeChecker for T_rfc822_message {
    fn get_mime(&self) -> &'static str {
        "message/rfc822"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.eml", "*.mime"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> = Lazy::new(|| Regex::new("(X|DKIM|ARC)-").unwrap());

        (offset_case_insensitive(
            bytes,
            0,
            &[
                82, 101, 108, 97, 121, 45, 86, 101, 114, 115, 105, 111, 110, 58,
            ],
        ) || offset(bytes, 0, &[35, 33, 32, 114, 110, 101, 119, 115])
            || offset(bytes, 0, &[78, 35, 33, 32, 114, 110, 101, 119, 115])
            || offset(bytes, 0, &[70, 111, 114, 119, 97, 114, 100, 32, 116, 111])
            || offset(bytes, 0, &[80, 105, 112, 101, 32, 116, 111])
            || offset_case_insensitive(
                bytes,
                0,
                &[82, 101, 116, 117, 114, 110, 45, 80, 97, 116, 104, 58],
            )
            || offset_case_insensitive(
                bytes,
                0,
                &[77, 101, 115, 115, 97, 103, 101, 45, 73, 68, 58],
            )
            || offset(bytes, 0, &[88, 45, 77, 97, 105, 108, 101, 114, 58])
            || (offset(
                bytes,
                0,
                &[88, 45, 78, 111, 116, 101, 115, 45, 73, 116, 101, 109, 58],
            ) && offset_range(
                bytes,
                0,
                8192,
                &[77, 101, 115, 115, 97, 103, 101, 45, 73, 68, 58],
            ))
            || (regex(bytes, 0, &REGEX_PATTERN_0)
                && (offset_range_case_insensitive(bytes, 0, 8192, &[10, 68, 97, 116, 101, 58])
                    || offset_range(
                        bytes,
                        0,
                        8192,
                        &[
                            10, 68, 101, 108, 105, 118, 101, 114, 101, 100, 45, 84, 111, 58,
                        ],
                    )
                    || offset_range_case_insensitive(
                        bytes,
                        0,
                        8192,
                        &[10, 70, 114, 111, 109, 58],
                    )
                    || offset_range_case_insensitive(
                        bytes,
                        0,
                        8192,
                        &[10, 77, 101, 115, 115, 97, 103, 101, 45, 73, 68, 58],
                    )
                    || offset_range_case_insensitive(
                        bytes,
                        0,
                        8192,
                        &[10, 77, 73, 77, 69, 45, 86, 101, 114, 115, 105, 111, 110, 58],
                    )
                    || offset_range_case_insensitive(
                        bytes,
                        0,
                        8192,
                        &[10, 82, 101, 99, 101, 105, 118, 101, 100, 58],
                    )
                    || offset_range_case_insensitive(
                        bytes,
                        0,
                        8192,
                        &[
                            10, 82, 101, 108, 97, 121, 45, 86, 101, 114, 115, 105, 111, 110, 58,
                        ],
                    )
                    || offset_range_case_insensitive(
                        bytes,
                        0,
                        8192,
                        &[10, 82, 101, 116, 117, 114, 110, 45, 80, 97, 116, 104, 58],
                    )
                    || offset_range(bytes, 0, 8192, &[10, 83, 116, 97, 116, 117, 115, 58])
                    || offset_range(
                        bytes,
                        0,
                        8192,
                        &[10, 85, 115, 101, 114, 45, 65, 103, 101, 110, 116, 58],
                    )
                    || offset_range(
                        bytes,
                        0,
                        8192,
                        &[10, 88, 45, 77, 97, 105, 108, 101, 114, 58],
                    )
                    || offset_range_case_insensitive(
                        bytes,
                        0,
                        8192,
                        &[
                            10, 88, 45, 79, 114, 105, 103, 105, 110, 97, 116, 105, 110, 103, 45,
                            73, 80, 58,
                        ],
                    )))
            || (false
                && ((false
                    && (offset_case_insensitive(
                        bytes,
                        0,
                        &[67, 111, 110, 116, 101, 110, 116, 45, 73, 68, 58],
                    ) || offset_case_insensitive(
                        bytes,
                        0,
                        &[
                            67, 111, 110, 116, 101, 110, 116, 45, 76, 111, 99, 97, 116, 105, 111,
                            110, 58,
                        ],
                    ) || offset_case_insensitive(
                        bytes,
                        0,
                        &[
                            67, 111, 110, 116, 101, 110, 116, 45, 84, 114, 97, 110, 115, 102, 101,
                            114, 45, 69, 110, 99, 111, 100, 105, 110, 103, 58,
                        ],
                    ) || offset_case_insensitive(
                        bytes,
                        0,
                        &[67, 111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58],
                    ) || offset_case_insensitive(bytes, 0, &[68, 97, 116, 101, 58])
                        || offset(
                            bytes,
                            0,
                            &[68, 101, 108, 105, 118, 101, 114, 101, 100, 45, 84, 111, 58],
                        )
                        || offset_case_insensitive(bytes, 0, &[70, 114, 111, 109, 58])
                        || offset_case_insensitive(
                            bytes,
                            0,
                            &[77, 101, 115, 115, 97, 103, 101, 45, 73, 68, 58],
                        )
                        || offset_case_insensitive(
                            bytes,
                            0,
                            &[77, 73, 77, 69, 45, 86, 101, 114, 115, 105, 111, 110, 58],
                        )
                        || offset_case_insensitive(
                            bytes,
                            0,
                            &[82, 101, 99, 101, 105, 118, 101, 100, 58],
                        )
                        || offset_case_insensitive(
                            bytes,
                            0,
                            &[
                                82, 101, 108, 97, 121, 45, 86, 101, 114, 115, 105, 111, 110, 58,
                            ],
                        )
                        || offset_case_insensitive(
                            bytes,
                            0,
                            &[82, 101, 116, 117, 114, 110, 45, 80, 97, 116, 104, 58],
                        )
                        || offset(bytes, 0, &[83, 101, 110, 116, 58])
                        || offset(bytes, 0, &[83, 116, 97, 116, 117, 115, 58])
                        || offset(bytes, 0, &[83, 117, 98, 106, 101, 99, 116, 58])
                        || offset(bytes, 0, &[84, 111, 58])
                        || offset(
                            bytes,
                            0,
                            &[85, 115, 101, 114, 45, 65, 103, 101, 110, 116, 58],
                        )
                        || offset(bytes, 0, &[88, 45, 77, 97, 105, 108, 101, 114, 58])
                        || offset_case_insensitive(
                            bytes,
                            0,
                            &[
                                88, 45, 79, 114, 105, 103, 105, 110, 97, 116, 105, 110, 103, 45,
                                73, 80, 58,
                            ],
                        )
                        || (offset(bytes, 0, &[239, 187, 191])
                            && (offset_case_insensitive(
                                bytes,
                                3,
                                &[67, 111, 110, 116, 101, 110, 116, 45, 73, 68, 58],
                            ) || offset_case_insensitive(
                                bytes,
                                3,
                                &[
                                    67, 111, 110, 116, 101, 110, 116, 45, 76, 111, 99, 97, 116,
                                    105, 111, 110, 58,
                                ],
                            ) || offset_case_insensitive(
                                bytes,
                                3,
                                &[
                                    67, 111, 110, 116, 101, 110, 116, 45, 84, 114, 97, 110, 115,
                                    102, 101, 114, 45, 69, 110, 99, 111, 100, 105, 110, 103, 58,
                                ],
                            ) || offset_case_insensitive(
                                bytes,
                                3,
                                &[67, 111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58],
                            ) || offset_case_insensitive(
                                bytes,
                                3,
                                &[68, 97, 116, 101, 58],
                            ) || offset(
                                bytes,
                                3,
                                &[68, 101, 108, 105, 118, 101, 114, 101, 100, 45, 84, 111, 58],
                            ) || offset_case_insensitive(
                                bytes,
                                3,
                                &[70, 114, 111, 109, 58],
                            ) || offset_case_insensitive(
                                bytes,
                                3,
                                &[77, 101, 115, 115, 97, 103, 101, 45, 73, 68, 58],
                            ) || offset_case_insensitive(
                                bytes,
                                3,
                                &[77, 73, 77, 69, 45, 86, 101, 114, 115, 105, 111, 110, 58],
                            ) || offset_case_insensitive(
                                bytes,
                                3,
                                &[82, 101, 99, 101, 105, 118, 101, 100, 58],
                            ) || offset_case_insensitive(
                                bytes,
                                3,
                                &[
                                    82, 101, 108, 97, 121, 45, 86, 101, 114, 115, 105, 111, 110, 58,
                                ],
                            ) || offset_case_insensitive(
                                bytes,
                                3,
                                &[82, 101, 116, 117, 114, 110, 45, 80, 97, 116, 104, 58],
                            ) || offset(bytes, 3, &[83, 101, 110, 116, 58])
                                || offset(bytes, 3, &[83, 116, 97, 116, 117, 115, 58])
                                || offset(bytes, 3, &[83, 117, 98, 106, 101, 99, 116, 58])
                                || offset(bytes, 3, &[84, 111, 58])
                                || offset(
                                    bytes,
                                    3,
                                    &[85, 115, 101, 114, 45, 65, 103, 101, 110, 116, 58],
                                )
                                || offset(
                                    bytes,
                                    3,
                                    &[88, 45, 77, 97, 105, 108, 101, 114, 58],
                                )
                                || offset_case_insensitive(
                                    bytes,
                                    3,
                                    &[
                                        88, 45, 79, 114, 105, 103, 105, 110, 97, 116, 105, 110,
                                        103, 45, 73, 80, 58,
                                    ],
                                )))))
                    || (false
                        && (offset_range_case_insensitive(
                            bytes,
                            0,
                            1024,
                            &[10, 67, 111, 110, 116, 101, 110, 116, 45, 73, 68, 58],
                        ) || offset_range_case_insensitive(
                            bytes,
                            0,
                            1024,
                            &[
                                10, 67, 111, 110, 116, 101, 110, 116, 45, 76, 111, 99, 97, 116,
                                105, 111, 110, 58,
                            ],
                        ) || offset_range_case_insensitive(
                            bytes,
                            0,
                            1024,
                            &[
                                10, 67, 111, 110, 116, 101, 110, 116, 45, 84, 114, 97, 110, 115,
                                102, 101, 114, 45, 69, 110, 99, 111, 100, 105, 110, 103, 58,
                            ],
                        ) || offset_range_case_insensitive(
                            bytes,
                            0,
                            1024,
                            &[
                                10, 67, 111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58,
                            ],
                        ) || offset_range_case_insensitive(
                            bytes,
                            0,
                            1024,
                            &[10, 68, 97, 116, 101, 58],
                        ) || offset_range(
                            bytes,
                            0,
                            1024,
                            &[
                                10, 68, 101, 108, 105, 118, 101, 114, 101, 100, 45, 84, 111, 58,
                            ],
                        ) || offset_range_case_insensitive(
                            bytes,
                            0,
                            1024,
                            &[10, 70, 114, 111, 109, 58],
                        ) || offset_range_case_insensitive(
                            bytes,
                            0,
                            1024,
                            &[10, 77, 73, 77, 69, 45, 86, 101, 114, 115, 105, 111, 110, 58],
                        ) || offset_range_case_insensitive(
                            bytes,
                            0,
                            1024,
                            &[10, 82, 101, 99, 101, 105, 118, 101, 100, 58],
                        ) || offset_range_case_insensitive(
                            bytes,
                            0,
                            1024,
                            &[
                                10, 82, 101, 108, 97, 121, 45, 86, 101, 114, 115, 105, 111, 110, 58,
                            ],
                        ) || offset_range_case_insensitive(
                            bytes,
                            0,
                            1024,
                            &[10, 82, 101, 116, 117, 114, 110, 45, 80, 97, 116, 104, 58],
                        ) || offset_range(bytes, 0, 1024, &[10, 83, 101, 110, 116, 58])
                            || offset_range(
                                bytes,
                                0,
                                1024,
                                &[10, 83, 116, 97, 116, 117, 115, 58],
                            )
                            || offset_range(
                                bytes,
                                0,
                                1024,
                                &[10, 83, 117, 98, 106, 101, 99, 116, 58],
                            )
                            || offset_range(bytes, 0, 1024, &[10, 84, 111, 58])
                            || offset_range(
                                bytes,
                                0,
                                1024,
                                &[10, 85, 115, 101, 114, 45, 65, 103, 101, 110, 116, 58],
                            )
                            || offset_range(
                                bytes,
                                0,
                                1024,
                                &[10, 88, 45, 77, 97, 105, 108, 101, 114, 58],
                            )
                            || offset_range_case_insensitive(
                                bytes,
                                0,
                                1024,
                                &[
                                    10, 88, 45, 79, 114, 105, 103, 105, 110, 97, 116, 105, 110,
                                    103, 45, 73, 80, 58,
                                ],
                            )
                            || offset_range(bytes, 0, 1024, &[10, 68, 75, 73, 77, 45])
                            || offset_range(bytes, 0, 1024, &[10, 65, 82, 67, 45])))))
            || offset_range_case_insensitive(
                bytes,
                0,
                1000,
                &[10, 77, 101, 115, 115, 97, 103, 101, 45, 73, 68, 58],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_related_multipart]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_vnd_dwf_model;
impl MimeTypeChecker for T_vnd_dwf_model {
    fn get_mime(&self) -> &'static str {
        "model/vnd.dwf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dwf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[40, 68, 87, 70, 32, 86])
            && offset(bytes, 8, &[46])
            && offset(bytes, 11, &[41]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_vnd_dwf_version_6_model]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_msdownload_application;
impl MimeTypeChecker for T_x_msdownload_application {
    fn get_mime(&self) -> &'static str {
        "application/x-msdownload"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dll", "*.com"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[77, 90])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_x_dosexec_application,
            &T_x_msdownload_format_pe_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_rar_compressed_application;
impl MimeTypeChecker for T_x_rar_compressed_application {
    fn get_mime(&self) -> &'static str {
        "application/x-rar-compressed"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rar"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[82, 97, 114, 33]) || offset(bytes, 0, &[82, 97, 114, 33, 26]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_x_rar_compressed_version_4_application,
            &T_x_rar_compressed_version_5_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_ogg_application;
impl MimeTypeChecker for T_ogg_application {
    fn get_mime(&self) -> &'static str {
        "application/ogg"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ogx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[79, 103, 103, 83])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_kate_application, &T_ogg_audio, &T_ogg_video]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_berkeley_db_format_btree_application;
impl MimeTypeChecker for T_x_berkeley_db_format_btree_application {
    fn get_mime(&self) -> &'static str {
        "application/x-berkeley-db;format=btree"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[98, 49, 5, 0])
            || offset(bytes, 0, &[0, 5, 49, 98])
            || offset(bytes, 0, &[98, 49, 5, 0])
            || offset(bytes, 12, &[98, 49, 5, 0])
            || offset(bytes, 12, &[0, 5, 49, 98])
            || offset(bytes, 12, &[98, 49, 5, 0]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_x_berkeley_db_format_btree_version_2_application,
            &T_x_berkeley_db_format_btree_version_3_application,
            &T_x_berkeley_db_format_btree_version_4_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_sh_application;
impl MimeTypeChecker for T_x_sh_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sh"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sh", "*.bash"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[35, 33, 47])
            || offset(bytes, 0, &[35, 33, 32, 47])
            || offset(bytes, 0, &[35, 33, 9, 47])
            || offset(bytes, 0, &[101, 118, 97, 108, 32, 34, 101, 120, 101, 99]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_javascript_text, &T_x_lua_text, &T_x_tcl_text]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_vnd_wordperfect_application;
impl MimeTypeChecker for T_vnd_wordperfect_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wordperfect"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[
            "*.wpd", "*.wp", "*.wp5", "*.wp6", "*.w60", "*.wp61", "*.wpt",
        ]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                97, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 47, 118, 110, 100, 46, 119,
                111, 114, 100, 112, 101, 114, 102, 101, 99, 116, 59,
            ],
        ) || offset(bytes, 0, &[255, 87, 80, 67]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_vnd_wordperfect_version_4_2_application,
            &T_vnd_wordperfect_version_5_0_application,
            &T_vnd_wordperfect_version_5_1_application,
            &T_vnd_wordperfect_version_6_x_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_berkeley_db_format_hash_application;
impl MimeTypeChecker for T_x_berkeley_db_format_hash_application {
    fn get_mime(&self) -> &'static str {
        "application/x-berkeley-db;format=hash"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[97, 21, 6, 0])
            || offset(bytes, 0, &[0, 6, 21, 97])
            || offset(bytes, 0, &[97, 21, 6, 0])
            || offset(bytes, 12, &[97, 21, 6, 0])
            || offset(bytes, 12, &[0, 6, 21, 97])
            || offset(bytes, 12, &[97, 21, 6, 0]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_x_berkeley_db_format_hash_version_2_application,
            &T_x_berkeley_db_format_hash_version_3_application,
            &T_x_berkeley_db_format_hash_version_4_application,
            &T_x_berkeley_db_format_hash_version_5_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_elf_application;
impl MimeTypeChecker for T_x_elf_application {
    fn get_mime(&self) -> &'static str {
        "application/x-elf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[127, 69, 76, 70])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_x_object_application,
            &T_x_executable_application,
            &T_x_sharedlib_application,
            &T_x_coredump_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_jp2_container_image;
impl MimeTypeChecker for T_x_jp2_container_image {
    fn get_mime(&self) -> &'static str {
        "image/x-jp2-container"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[0, 0, 0, 12, 106, 80, 32, 32, 13, 10, 135, 10])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_jp2_image, &T_jpm_image, &T_jpx_image, &T_mj2_video]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_stata_dta_application;
impl MimeTypeChecker for T_x_stata_dta_application {
    fn get_mime(&self) -> &'static str {
        "application/x-stata-dta"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dta"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml_local(bytes, "stata_dta")
            || offset(
                bytes,
                0,
                &[
                    60, 115, 116, 97, 116, 97, 95, 100, 116, 97, 62, 60, 104, 101, 97, 100, 101,
                    114, 62, 60, 114, 101, 108, 101, 97, 115, 101, 62,
                ],
            )
            || offset(bytes, 0, &[60, 115, 116, 97, 116, 97, 95, 100, 116, 97, 62]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_x_stata_dta_version_14_application,
            &T_x_stata_dta_version_13_application,
            &T_x_stata_dta_version_12_application,
            &T_x_stata_dta_version_10_application,
            &T_x_stata_dta_version_8_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_quicktime_video;
impl MimeTypeChecker for T_quicktime_video {
    fn get_mime(&self) -> &'static str {
        "video/quicktime"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.qt", "*.mov", "*.mqv"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 4, &[109, 111, 111, 118, 0])
            || offset(bytes, 4, &[109, 100, 97, 116, 0])
            || offset(bytes, 4, &[102, 114, 101, 101, 0])
            || offset(bytes, 4, &[115, 107, 105, 112, 0])
            || offset(bytes, 4, &[112, 110, 111, 116, 0])
            || offset(bytes, 4, &[102, 116, 121, 112])
            || offset(bytes, 0, &[0, 0, 0, 8, 119, 105, 100, 101])
            || offset(bytes, 4, &[102, 116, 121, 112, 109, 113, 116, 32]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_mp4_audio,
            &T_heif_image,
            &T_heif_sequence_image,
            &T_x_canon_cr3_image,
            &T_iso_segment_video,
            &T_mp4_video,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_ogg_video;
impl MimeTypeChecker for T_ogg_video {
    fn get_mime(&self) -> &'static str {
        "video/ogg"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ogv"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[79, 103, 103, 83, 0])
            && (offset(bytes, 28, &[102, 105, 115, 104, 101, 97, 100])
                || offset(bytes, 28, &[116, 104, 101, 111, 114, 97])
                || offset(bytes, 28, &[1, 118, 105, 100, 101, 111])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_daala_video,
            &T_theora_video,
            &T_x_dirac_video,
            &T_x_ogm_video,
            &T_x_ogguvs_video,
            &T_x_oggyuv_video,
            &T_x_oggrgb_video,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_sqlite3_application;
impl MimeTypeChecker for T_x_sqlite3_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sqlite3"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sqlite"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                83, 81, 76, 105, 116, 101, 32, 102, 111, 114, 109, 97, 116, 32, 51, 0,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_x_geopackage_application,
            &T_x_geopackage__version_1_1Or1_0_application,
            &T_x_fossil_checkout_application,
            &T_x_fossil_global_conf_application,
            &T_x_fossil_repository_application,
            &T_x_bentley_besqlite_application,
            &T_x_bentley_localization_application,
            &T_x_monotone_source_repo_application,
            &T_x_esri_spatially_enabled_db_application,
            &T_x_mbtiles_application,
            &T_x_texnicard_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_tika_ooxml_application;
impl MimeTypeChecker for T_x_tika_ooxml_application {
    fn get_mime(&self) -> &'static str {
        "application/x-tika-ooxml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75, 3, 4])
            && (offset_range(
                bytes,
                30,
                65536,
                &[
                    91, 67, 111, 110, 116, 101, 110, 116, 95, 84, 121, 112, 101, 115, 93, 46, 120,
                    109, 108,
                ],
            ) || offset(
                bytes,
                30,
                &[95, 114, 101, 108, 115, 47, 46, 114, 101, 108, 115],
            )))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_vnd_ms_excel_addin_macroenabled_12_application,
            &T_vnd_ms_excel_sheet_macroenabled_12_application,
            &T_vnd_ms_excel_sheet_binary_macroenabled_12_application,
            &T_vnd_ms_powerpoint_addin_macroenabled_12_application,
            &T_vnd_ms_powerpoint_presentation_macroenabled_12_application,
            &T_vnd_ms_powerpoint_slide_macroenabled_12_application,
            &T_vnd_ms_powerpoint_slideshow_macroenabled_12_application,
            &T_vnd_ms_powerpoint_template_macroenabled_12_application,
            &T_vnd_ms_word_document_macroenabled_12_application,
            &T_vnd_ms_word_template_macroenabled_12_application,
            &T_vnd_ms_xpsdocument_application,
            &T_vnd_openxmlformats_officedocument_presentationml_presentation_application,
            &T_vnd_openxmlformats_officedocument_presentationml_slide_application,
            &T_vnd_openxmlformats_officedocument_presentationml_template_application,
            &T_vnd_openxmlformats_officedocument_presentationml_slideshow_application,
            &T_vnd_openxmlformats_officedocument_spreadsheetml_sheet_application,
            &T_vnd_openxmlformats_officedocument_spreadsheetml_template_application,
            &T_vnd_ms_excel_template_macroenabled_12_application,
            &T_vnd_openxmlformats_officedocument_wordprocessingml_document_application,
            &T_vnd_openxmlformats_officedocument_wordprocessingml_template_application,
            &T_x_tika_visio_ooxml_application,
            &T_vnd_dwfx_xps_model,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_zip_application;
impl MimeTypeChecker for T_zip_application {
    fn get_mime(&self) -> &'static str {
        "application/zip"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.zip", "*.zipx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75, 3, 4])
            || offset(bytes, 0, &[80, 75, 5, 6])
            || offset(bytes, 0, &[80, 75, 7, 8]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_bizagi_modeler_application,
            &T_epub_zip_application,
            &T_java_archive_application,
            &T_vnd_apple_unknown_13_application,
            &T_vnd_apple_iwork_application,
            &T_x_vnd_datapackage_zip_application,
            &T_vnd_etsi_asic_e_zip_application,
            &T_vnd_etsi_asic_s_zip_application,
            &T_vnd_google_earth_kmz_application,
            &T_vnd_mindjet_mindmanager_application,
            &T_vnd_oasis_opendocument_chart_application,
            &T_vnd_oasis_opendocument_chart_template_application,
            &T_vnd_oasis_opendocument_base_application,
            &T_vnd_oasis_opendocument_formula_application,
            &T_vnd_oasis_opendocument_formula_template_application,
            &T_vnd_oasis_opendocument_graphics_application,
            &T_vnd_oasis_opendocument_image_application,
            &T_vnd_oasis_opendocument_presentation_application,
            &T_vnd_oasis_opendocument_spreadsheet_application,
            &T_vnd_oasis_opendocument_text_application,
            &T_vnd_openofficeorg_extension_application,
            &T_vnd_openofficeorg_autotext_application,
            &T_vnd_sun_xml_calc_application,
            &T_vnd_sun_xml_draw_application,
            &T_vnd_sun_xml_impress_application,
            &T_vnd_adobe_indesign_idml_package_application,
            &T_hwp_zip_application,
            &T_x_itunes_ipa_application,
            &T_x_tika_ooxml_application,
            &T_x_xmind_application,
            &T_x_xliff_zip_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_xml_application;
impl MimeTypeChecker for T_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xml", "*.xsl", "*.xsd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[60, 63, 120, 109, 108])
            || offset(bytes, 0, &[60, 63, 88, 77, 76])
            || offset(bytes, 0, &[239, 187, 191, 60, 63, 120, 109, 108])
            || offset(bytes, 0, &[13, 10, 60, 63, 120, 109, 108])
            || offset(bytes, 0, &[255, 254, 60, 0, 63, 0, 120, 0, 109, 0, 108, 0])
            || offset(bytes, 0, &[254, 255, 0, 60, 0, 63, 0, 120, 0, 109, 0, 108])
            || (offset_range_case_insensitive(bytes, 0, 256, &[60, 63, 120, 109, 108])
                && (offset_range_case_insensitive(bytes, 0, 256, &[120, 109, 108, 110, 115, 61])
                    || offset_range_case_insensitive(
                        bytes,
                        0,
                        256,
                        &[120, 109, 108, 110, 115, 58],
                    )))
            || offset(bytes, 0, &[60, 33, 45, 45]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_iso19139_xml_text,
            &T_atom_xml_application,
            &T_dash_xml_application,
            &T_dita_xml_application,
            &T_vnd_ms_spreadsheetml_application,
            &T_vnd_ms_wordml_application,
            &T_vnd_ms_word2006ml_application,
            &T_rdf_xml_application,
            &T_rss_xml_application,
            &T_smil_xml_application,
            &T_vnd_adobe_xdp_xml_application,
            &T_vnd_adobe_xfdf_application,
            &T_vnd_google_earth_kml_xml_application,
            &T_vnd_iptc_g2_newsmessage_xml_application,
            &T_vnd_ms_package_3dmanufacturing_3dmodel_xml_application,
            &T_vnd_oasis_opendocument_tika_flat_document_application,
            &T_x_tmx_application,
            &T_ttml_xml_application,
            &T_x_amf_application,
            &T_x_adobe_indesign_interchange_application,
            &T_x_plist_application,
            &T_x_internet_archive_application,
            &T_svg_xml_image,
            &T_svg_xml_image,
            &T_vnd_adobe_premiere_image,
            &T_dif_xml_application,
            &T_onix_message_xml_application,
            &T_onix_message_short_xml_application,
            &T_x_ms_asx_application,
            &T_x_fictionbook_xml_application,
            &T_x_xliff_xml_application,
            &T_owl_xml_application,
            &T_vnd_collada_xml_model,
            &T_gml_xml_application,
            &T_gpx_xml_application,
            &T_vnd_garmin_tcx_xml_application,
            &T_x3d_xml_model,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_html_text;
impl MimeTypeChecker for T_html_text {
    fn get_mime(&self) -> &'static str {
        "text/html"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.html", "*.htm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> =
            Lazy::new(|| Regex::new("(?i)<(html|head|body|title|div)[ >]").unwrap());
        static REGEX_PATTERN_1: Lazy<Regex> = Lazy::new(|| Regex::new("(?i)<h[123][ >]").unwrap());

        (rootxml_local(bytes, "html")
            || rootxml_local(bytes, "HTML")
            || rootxml_local(bytes, "link")
            || rootxml_local(bytes, "LINK")
            || rootxml_local(bytes, "body")
            || rootxml_local(bytes, "BODY")
            || rootxml_local(bytes, "p")
            || rootxml_local(bytes, "P")
            || rootxml_local(bytes, "script")
            || rootxml_local(bytes, "SCRIPT")
            || rootxml_local(bytes, "frameset")
            || rootxml_local(bytes, "FRAMESET")
            || rootxml_local(bytes, "iframe")
            || rootxml_local(bytes, "IFRAME")
            || regex(bytes, 0, &REGEX_PATTERN_0)
            || regex(bytes, 0, &REGEX_PATTERN_1)
            || offset_range(
                bytes,
                0,
                64,
                &[60, 33, 68, 79, 67, 84, 89, 80, 69, 32, 72, 84, 77, 76],
            )
            || offset_range(
                bytes,
                0,
                64,
                &[60, 33, 68, 79, 67, 84, 89, 80, 69, 32, 104, 116, 109, 108],
            )
            || offset_range(
                bytes,
                0,
                64,
                &[60, 33, 100, 111, 99, 116, 121, 112, 101, 32, 72, 84, 77, 76],
            )
            || offset_range(
                bytes,
                0,
                64,
                &[
                    60, 33, 100, 111, 99, 116, 121, 112, 101, 32, 104, 116, 109, 108,
                ],
            )
            || offset_range(bytes, 0, 64, &[60, 72, 69, 65, 68])
            || offset_range(bytes, 0, 64, &[60, 104, 101, 97, 100])
            || offset_range(bytes, 0, 64, &[60, 84, 73, 84, 76, 69])
            || offset_range(bytes, 0, 64, &[60, 116, 105, 116, 108, 101])
            || offset_range(bytes, 0, 64, &[60, 72, 84, 77, 76])
            || offset_range(bytes, 0, 128, &[60, 104, 116, 109, 108])
            || offset_range(bytes, 128, 8192, &[60, 104, 116, 109, 108]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_zlib_application;
impl MimeTypeChecker for T_zlib_application {
    fn get_mime(&self) -> &'static str {
        "application/zlib"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[120, 1])
            || offset(bytes, 0, &[120, 94])
            || offset(bytes, 0, &[120, 156])
            || offset(bytes, 0, &[120, 218]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_gzip_application;
impl MimeTypeChecker for T_gzip_application {
    fn get_mime(&self) -> &'static str {
        "application/gzip"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gz", "*.tgz", "*-gz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[31, 139]) || offset(bytes, 0, &[31, 139]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_x_vnd_datapackage_gz_application,
            &T_x_ms_wmz_application,
            &T_x_emf_compressed_image,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_dbf_application;
impl MimeTypeChecker for T_x_dbf_application {
    fn get_mime(&self) -> &'static str {
        "application/x-dbf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dbf", "*.dbase", "*.dbase3"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_bzip2_application;
impl MimeTypeChecker for T_x_bzip2_application {
    fn get_mime(&self) -> &'static str {
        "application/x-bzip2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.bz2", "*.tbz2", "*.boz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> = Lazy::new(|| Regex::new("BZh[1-9]").unwrap());

        regex(bytes, 0, &REGEX_PATTERN_0)
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_font_otf_application;
impl MimeTypeChecker for T_x_font_otf_application {
    fn get_mime(&self) -> &'static str {
        "application/x-font-otf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.otf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[79, 84, 84, 79, 0])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_font_ttf_application;
impl MimeTypeChecker for T_x_font_ttf_application {
    fn get_mime(&self) -> &'static str {
        "application/x-font-ttf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ttf", "*.ttc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[0, 1, 0, 0])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_font_adobe_metric_application;
impl MimeTypeChecker for T_x_font_adobe_metric_application {
    fn get_mime(&self) -> &'static str {
        "application/x-font-adobe-metric"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.afm", "*.acfm", "*.amfm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                83, 116, 97, 114, 116, 70, 111, 110, 116, 77, 101, 116, 114, 105, 99, 115,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_font_printer_metric_application;
impl MimeTypeChecker for T_x_font_printer_metric_application {
    fn get_mime(&self) -> &'static str {
        "application/x-font-printer-metric"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pfm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_mask(
            bytes,
            0,
            &[0, 1, 255, 255, 0, 0, 67, 111, 112, 121, 114],
            &[255, 255, 0, 0, 255, 255, 255, 255, 255, 255, 255],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mysql_table_definition_application;
impl MimeTypeChecker for T_x_mysql_table_definition_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mysql-table-definition"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[254, 1, 7])
            || offset(bytes, 0, &[254, 1, 8])
            || offset(bytes, 0, &[254, 1, 9])
            || offset(bytes, 0, &[254, 1, 10])
            || offset(bytes, 0, &[254, 1, 11])
            || offset(bytes, 0, &[254, 1, 12]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mysql_misam_index_application;
impl MimeTypeChecker for T_x_mysql_misam_index_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mysql-misam-index"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[254, 254, 3]) || offset(bytes, 0, &[254, 254, 5]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mysql_misam_compressed_index_application;
impl MimeTypeChecker for T_x_mysql_misam_compressed_index_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mysql-misam-compressed-index"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.MYI"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[254, 254, 6]) || offset(bytes, 0, &[254, 254, 7]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sas_data_v6_application;
impl MimeTypeChecker for T_x_sas_data_v6_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sas-data-v6"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sd2"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[83, 65, 83, 32, 32, 32, 32, 32, 54, 46])
            || offset(bytes, 0, &[83, 65, 83, 32, 32, 32, 32, 32, 55, 46])
            || offset(bytes, 0, &[83, 65, 83, 32, 32, 32, 32, 32, 56, 46, 48])
            || offset(bytes, 0, &[83, 65, 83, 32, 32, 32, 32, 32, 57, 46, 48]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sas_data_application;
impl MimeTypeChecker for T_x_sas_data_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sas-data"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sd7", "*.sas7bdat"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 84, &[83, 65, 83, 32, 70, 73, 76, 69])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sas_xport_application;
impl MimeTypeChecker for T_x_sas_xport_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sas-xport"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xpt", "*.xport"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                72, 69, 65, 68, 69, 82, 32, 82, 69, 67, 79, 82, 68, 42, 42, 42, 42, 42, 42, 42, 76,
                73, 66, 82, 65, 82, 89, 32, 72, 69, 65, 68, 69, 82, 32, 82, 69, 67, 79, 82, 68, 33,
                33, 33, 33, 33, 33, 33,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_x509_key_format_der_application;
impl MimeTypeChecker for T_x_x509_key_format_der_application {
    fn get_mime(&self) -> &'static str {
        "application/x-x509-key;format=der"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset_mask(bytes, 0, &[48, 128, 2, 1, 0], &[255, 255, 255, 255, 252])
            || offset_mask(
                bytes,
                0,
                &[48, 129, 255, 2, 1, 0],
                &[255, 255, 0, 255, 255, 252],
            )
            || offset_mask(
                bytes,
                0,
                &[48, 130, 255, 255, 2, 1, 0],
                &[255, 255, 0, 0, 255, 255, 252],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_xhtml_xml_application;
impl MimeTypeChecker for T_xhtml_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/xhtml+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xhtml", "*.xhtml2", "*.xht"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml(bytes, "html", "http://www.w3.org/1999/xhtml")
            || offset_range(
                bytes,
                0,
                8192,
                &[60, 104, 116, 109, 108, 32, 120, 109, 108, 110, 115, 61],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_aac_audio;
impl MimeTypeChecker for T_x_aac_audio {
    fn get_mime(&self) -> &'static str {
        "audio/x-aac"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.aac"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> = Lazy::new(|| {
            Regex::new("\\xFF(\\xF0|\\xF1|\\xF8|\\xF9)(\\x40|\\x41|\\x44|\\x45|\\x48|\\x49|\\x4C|\\x4D|\\x50|\\x51|\\x54|\\x55|\\x58|\\x59|\\x5C|\\x5D|\\x60|\\x61|\\x64|\\x65|\\x68|\\x69|\\x6C|\\x6D|\\x70|\\x71|\\x80|\\x81|\\x84|\\x85|\\x88|\\x89|\\x8C|\\x8D|\\x90|\\x91|\\x94|\\x95|\\x98|\\x99|\\x9C|\\x9D|\\xA0|\\xA1|\\xA4|\\xA5|\\xA8|\\xA9|\\xAC|\\xAD|\\xB0|\\xB1)(\\x00|\\x01|\\x20|\\x40|\\x41|\\x60|\\x80|\\x81|\\x60|\\xA0|\\xC0|\\xC1|\\xE0)").unwrap()
        });

        (offset(bytes, 0, &[255, 249])
            || offset(bytes, 0, &[255, 241])
            || regex(bytes, 0, &REGEX_PATTERN_0)
            || (offset(bytes, 0, &[73, 68, 51]) && regex_range(bytes, 256, 2048, &REGEX_PATTERN_0)))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_zbrush_pcx_image;
impl MimeTypeChecker for T_vnd_zbrush_pcx_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.zbrush.pcx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pcx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[10])
            && (offset(bytes, 1, &[0])
                || offset(bytes, 1, &[2])
                || offset(bytes, 1, &[3])
                || offset(bytes, 1, &[4])
                || offset(bytes, 1, &[5])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vtt_text;
impl MimeTypeChecker for T_vtt_text {
    fn get_mime(&self) -> &'static str {
        "text/vtt"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vtt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[87, 69, 66, 86, 84, 84, 13])
            || offset(bytes, 0, &[87, 69, 66, 86, 84, 84, 10])
            || (offset(bytes, 0, &[254, 255])
                && (offset(bytes, 2, &[87, 69, 66, 86, 84, 84, 13])
                    || offset(bytes, 2, &[87, 69, 66, 86, 84, 84, 10])))
            || (offset(bytes, 0, &[254, 255])
                && (offset(bytes, 2, &[87, 69, 66, 86, 84, 84, 13])
                    || offset(bytes, 2, &[87, 69, 66, 86, 84, 84, 10])))
            || (offset(bytes, 0, &[239, 187, 191])
                && (offset(bytes, 3, &[87, 69, 66, 86, 84, 84, 13])
                    || offset(bytes, 3, &[87, 69, 66, 86, 84, 84, 10])))
            || offset(bytes, 0, &[87, 69, 66, 86, 84, 84, 32, 70, 73, 76, 69, 13])
            || offset(bytes, 0, &[87, 69, 66, 86, 84, 84, 32, 70, 73, 76, 69, 10])
            || (offset(bytes, 0, &[87, 69, 66, 86, 84, 84, 32])
                && offset_range(bytes, 10, 50, &[10, 10]))
            || (offset(bytes, 0, &[87, 69, 66, 86, 84, 84, 32])
                && offset_range(bytes, 10, 50, &[13, 13]))
            || (offset(bytes, 0, &[87, 69, 66, 86, 84, 84, 32])
                && offset_range(bytes, 10, 50, &[13, 10, 13, 10])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_bzip_application;
impl MimeTypeChecker for T_x_bzip_application {
    fn get_mime(&self) -> &'static str {
        "application/x-bzip"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.bz", "*.tbz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[66, 90, 48])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_x_bzip2_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_tar_application;
impl MimeTypeChecker for T_x_tar_application {
    fn get_mime(&self) -> &'static str {
        "application/x-tar"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.tar"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 257, &[117, 115, 116, 97, 114, 0])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_x_gtar_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_amr_audio;
impl MimeTypeChecker for T_amr_audio {
    fn get_mime(&self) -> &'static str {
        "audio/amr"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.amr"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[35, 33, 65, 77, 82, 10]) || offset(bytes, 0, &[35, 33, 65, 77, 82]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_amr_wb_audio, &T_amr_wb__audio]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_matroska_application;
impl MimeTypeChecker for T_x_matroska_application {
    fn get_mime(&self) -> &'static str {
        "application/x-matroska"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[26, 69, 223, 163])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_x_matroska_video,
            &T_x_matroska_audio,
            &T_webm_video,
            &T_webm_audio,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_tika_msoffice_application;
impl MimeTypeChecker for T_x_tika_msoffice_application {
    fn get_mime(&self) -> &'static str {
        "application/x-tika-msoffice"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_range(bytes, 0, 8, &[208, 207, 17, 224, 161, 177, 26, 225])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_msword_application,
            &T_sldworks_application,
            &T_vnd_ms_excel_application,
            &T_vnd_ms_outlook_application,
            &T_vnd_ms_powerpoint_application,
            &T_vnd_ms_project_application,
            &T_vnd_ms_works_application,
            &T_vnd_visio_application,
            &T_x_corelpresentations_application,
            &T_x_esri_layer_application,
            &T_x_hwp_v5_application,
            &T_x_ms_installer_application,
            &T_x_mspublisher_application,
            &T_x_quattro_pro_application,
            &T_x_tika_msoffice_embedded_application,
            &T_x_tika_ooxml_protected_application,
            &T_x_tika_staroffice_application,
            &T_vnd_dgn_version_8_image,
            &T_x_ole_storage_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_inf_application;
impl MimeTypeChecker for T_inf_application {
    fn get_mime(&self) -> &'static str {
        "application/inf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[91, 118, 101, 114, 115, 105, 111, 110, 93])
            || offset(bytes, 0, &[91, 115, 116, 114, 105, 110, 103, 115, 93]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_chdr_text;
impl MimeTypeChecker for T_x_chdr_text {
    fn get_mime(&self) -> &'static str {
        "text/x-chdr"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.h"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[35, 105, 102, 110, 100, 101, 102, 32])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_gimp_pat_image;
impl MimeTypeChecker for T_x_gimp_pat_image {
    fn get_mime(&self) -> &'static str {
        "image/x-gimp-pat"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pat"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 20, &[71, 80, 65, 84])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_gimp_gbr_image;
impl MimeTypeChecker for T_x_gimp_gbr_image {
    fn get_mime(&self) -> &'static str {
        "image/x-gimp-gbr"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gbr"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 20, &[71, 73, 77, 80])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_c_text;
impl MimeTypeChecker for T_x_c_text {
    fn get_mime(&self) -> &'static str {
        "text/x-c"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.c"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[35, 105, 110, 99, 108, 117, 100, 101, 32])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_x_xbitmap_image]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_jp2_codestream_image;
impl MimeTypeChecker for T_x_jp2_codestream_image {
    fn get_mime(&self) -> &'static str {
        "image/x-jp2-codestream"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.j2c"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[255, 79, 255, 81])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_msa_disk_image_application;
impl MimeTypeChecker for T_vnd_msa_disk_image_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.msa-disk-image"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.msa"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[14, 15])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_basic_audio;
impl MimeTypeChecker for T_basic_audio {
    fn get_mime(&self) -> &'static str {
        "audio/basic"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.au", "*.snd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        ((offset(bytes, 0, &[46, 115, 110, 100])
            && (offset(bytes, 12, &[0, 0, 0, 1])
                || offset(bytes, 12, &[0, 0, 0, 2])
                || offset(bytes, 12, &[0, 0, 0, 3])
                || offset(bytes, 12, &[0, 0, 0, 4])
                || offset(bytes, 12, &[0, 0, 0, 5])
                || offset(bytes, 12, &[0, 0, 0, 6])
                || offset(bytes, 12, &[0, 0, 0, 7])))
            || offset(bytes, 0, &[46, 115, 110, 100, 0, 0, 0]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_midi_audio;
impl MimeTypeChecker for T_midi_audio {
    fn get_mime(&self) -> &'static str {
        "audio/midi"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mid", "*.midi", "*.kar", "*.rmi"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[77, 84, 104, 100])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_adpcm_audio;
impl MimeTypeChecker for T_x_adpcm_audio {
    fn get_mime(&self) -> &'static str {
        "audio/x-adpcm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[46, 115, 110, 100]) && offset(bytes, 12, &[0, 0, 0, 23]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_aiff_audio;
impl MimeTypeChecker for T_x_aiff_audio {
    fn get_mime(&self) -> &'static str {
        "audio/x-aiff"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.aif", "*.aiff", "*.aifc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset_mask(
            bytes,
            0,
            &[70, 79, 82, 77, 46, 46, 46, 46, 65, 73, 70, 70],
            &[255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255],
        ) || offset_mask(
            bytes,
            0,
            &[70, 79, 82, 77, 46, 46, 46, 46, 65, 73, 70, 67],
            &[255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255],
        ) || offset_mask(
            bytes,
            0,
            &[70, 79, 82, 77, 46, 46, 46, 46, 56, 83, 86, 88],
            &[255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255],
        ) || offset(bytes, 0, &[70, 79, 82, 77, 0]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_dec_basic_audio;
impl MimeTypeChecker for T_x_dec_basic_audio {
    fn get_mime(&self) -> &'static str {
        "audio/x-dec-basic"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[0, 100, 115, 46])
            && (offset(bytes, 12, &[0, 0, 0, 1])
                || offset(bytes, 12, &[0, 0, 0, 2])
                || offset(bytes, 12, &[0, 0, 0, 3])
                || offset(bytes, 12, &[0, 0, 0, 4])
                || offset(bytes, 12, &[0, 0, 0, 5])
                || offset(bytes, 12, &[0, 0, 0, 6])
                || offset(bytes, 12, &[0, 0, 0, 7])))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_dec_adpcm_audio;
impl MimeTypeChecker for T_x_dec_adpcm_audio {
    fn get_mime(&self) -> &'static str {
        "audio/x-dec-adpcm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[0, 100, 115, 46]) && offset(bytes, 12, &[0, 0, 0, 23]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wave_audio;
impl MimeTypeChecker for T_vnd_wave_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.wave"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wav"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset_mask(
            bytes,
            0,
            &[82, 73, 70, 70, 46, 46, 46, 46, 87, 65, 86, 69],
            &[255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_makefile_text;
impl MimeTypeChecker for T_x_makefile_text {
    fn get_mime(&self) -> &'static str {
        "text/x-makefile"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["Makefile", "GNUMakefile"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(
            bytes,
            0,
            &[
                35, 32, 77, 97, 107, 101, 102, 105, 108, 101, 46, 105, 110, 32, 103, 101, 110, 101,
                114, 97, 116, 101, 100, 32, 98, 121,
            ],
        ) || offset(bytes, 0, &[35, 33, 109, 97, 107, 101])
            || offset(
                bytes,
                0,
                &[
                    35, 33, 47, 117, 115, 114, 47, 98, 105, 110, 47, 109, 97, 107, 101,
                ],
            )
            || offset(
                bytes,
                0,
                &[
                    35, 33, 47, 117, 115, 114, 47, 108, 111, 99, 97, 108, 47, 98, 105, 110, 47,
                    109, 97, 107, 101,
                ],
            )
            || offset(
                bytes,
                0,
                &[
                    35, 33, 47, 117, 115, 114, 47, 98, 105, 110, 47, 101, 110, 118, 32, 109, 97,
                    107, 101,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mpeg_audio;
impl MimeTypeChecker for T_mpeg_audio {
    fn get_mime(&self) -> &'static str {
        "audio/mpeg"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mpga", "*.mp2", "*.mp2a", "*.mp3", "*.m2a", "*.m3a"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> = Lazy::new(|| {
            Regex::new("(?:\\x0D\\x0A|\\x00{1,1024})(?:\\xff[\\xe3\\xf2\\xf3\\xf4\\xf5\\xf6\\xf7\\xf8\\xf9\\xfa\\xfb\\xfc\\xfd\\xfe\\xff]|ID3)").unwrap()
        });

        (offset(bytes, 0, &[255, 242])
            || offset(bytes, 0, &[255, 243])
            || offset(bytes, 0, &[255, 244])
            || offset(bytes, 0, &[255, 245])
            || offset(bytes, 0, &[255, 246])
            || offset(bytes, 0, &[255, 247])
            || offset(bytes, 0, &[255, 250])
            || offset(bytes, 0, &[255, 251])
            || offset(bytes, 0, &[255, 252])
            || offset(bytes, 0, &[255, 253])
            || offset(bytes, 0, &[255, 227])
            || offset(bytes, 0, &[255, 255])
            || offset(bytes, 0, &[73, 68, 51])
            || regex(bytes, 0, &REGEX_PATTERN_0))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_x_aac_audio]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_plain_text;
impl MimeTypeChecker for T_plain_text {
    fn get_mime(&self) -> &'static str {
        "text/plain"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[
            "*.txt",
            "*.text",
            "*.def",
            "*.list",
            "*.in",
            "INSTALL",
            "KEYS",
            "LICENSE",
            "NOTICE",
            "README",
            "abs-linkmap",
            "abs-menulinks",
            "*.aart",
            "*.ac",
            "*.am",
            "*.apt",
            "*.bsh",
            "*.classpath",
            "*.cnd",
            "*.cwiki",
            "*.data",
            "*.dcl",
            "*.dsp",
            "*.dsw",
            "*.egrm",
            "*.ent",
            "*.ft",
            "*.fn",
            "*.fv",
            "*.grm",
            "*.g",
            ".htaccess",
            "*.handlers",
            "*.htc",
            "*.ihtml",
            "*.jmx",
            "*.junit",
            "*.jx",
            "*.manifest",
            "*.m4",
            "*.mf",
            "*.MF",
            "*.meta",
            "*.mdo",
            "*.n3",
            "*.pen",
            "*.pod",
            "*.pom",
            "*.project",
            "*.rng",
            "*.rnx",
            "*.roles",
            "*.schemas",
            "*.tld",
            "*.types",
            "*.vm",
            "*.vsl",
            "*.wsdd",
            "*.xargs",
            "*.xcat",
            "*.xegrm",
            "*.xgrm",
            "*.xlex",
            "*.xlog",
            "*.xmap",
            "*.xroles",
            "*.xsamples",
            "*.xsp",
            "*.xtest",
            "*.xweb",
            "*.xwelcome",
        ]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        static REGEX_PATTERN_0: Lazy<Regex> = Lazy::new(|| Regex::new("^[ -~]{6}[ -~]+").unwrap());

        (offset(
            bytes,
            0,
            &[84, 104, 105, 115, 32, 105, 115, 32, 84, 101, 88, 44],
        ) || offset(
            bytes,
            0,
            &[
                84, 104, 105, 115, 32, 105, 115, 32, 77, 69, 84, 65, 70, 79, 78, 84, 44,
            ],
        ) || offset(bytes, 0, &[47, 42])
            || offset(bytes, 0, &[47, 47])
            || offset(bytes, 0, &[59, 59])
            || offset(bytes, 0, &[254, 255])
            || offset(bytes, 0, &[255, 254])
            || offset(bytes, 0, &[239, 187, 191])
            || regex(bytes, 0, &REGEX_PATTERN_0))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_x_bat_application,
            &T_inf_application,
            &T_javascript_text,
            &T_vnd_java_hprof_text_application,
            &T_mathematica_application,
            &T_relax_ng_compact_syntax_application,
            &T_rtf_application,
            &T_x_project_application,
            &T_x_robots_text,
            &T_x_subrip_application,
            &T_x_bibtex_text_file_application,
            &T_x_openscad_application,
            &T_xquery_application,
            &T_x_sas_application,
            &T_x_sh_application,
            &T_x_sfdu_application,
            &T_x_tex_application,
            &T_xml_application,
            &T_xml_dtd_application,
            &T_x_actionscript_text,
            &T_x_ada_text,
            &T_x_applescript_text,
            &T_asp_text,
            &T_aspdotnet_text,
            &T_x_aspectj_text,
            &T_x_assembly_text,
            &T_calendar_text,
            &T_x_config_text,
            &T_css_text,
            &T_csv_text,
            &T_x_makefile_text,
            &T_vnd_graphviz_text,
            &T_vtt_text,
            &T_x_awk_text,
            &T_x_basic_text,
            &T_x_c__hdr_text,
            &T_x_c__src_text,
            &T_x_cgi_text,
            &T_x_chdr_text,
            &T_x_clojure_text,
            &T_x_coffeescript_text,
            &T_x_c_text,
            &T_x_csharp_text,
            &T_x_cobol_text,
            &T_x_coldfusion_text,
            &T_x_common_lisp_text,
            &T_x_diff_text,
            &T_x_eiffel_text,
            &T_x_emacs_lisp_text,
            &T_x_erlang_text,
            &T_x_expect_text,
            &T_x_forth_text,
            &T_x_fortran_text,
            &T_x_go_text,
            &T_x_groovy_text,
            &T_x_haskell_text,
            &T_x_idl_text,
            &T_x_ini_text,
            &T_x_java_source_text,
            &T_x_java_properties_text,
            &T_x_jsp_text,
            &T_x_less_text,
            &T_x_lex_text,
            &T_x_log_text,
            &T_x_ml_text,
            &T_x_matlab_text,
            &T_x_modula_text,
            &T_x_objcsrc_text,
            &T_x_ocaml_text,
            &T_x_pascal_text,
            &T_x_perl_text,
            &T_x_php_text,
            &T_x_prolog_text,
            &T_x_python_text,
            &T_x_rst_text,
            &T_x_rexx_text,
            &T_x_ruby_text,
            &T_x_scala_text,
            &T_x_scheme_text,
            &T_x_sed_text,
            &T_x_sql_text,
            &T_x_setext_text,
            &T_x_stsrc_text,
            &T_x_vcalendar_text,
            &T_x_vcard_text,
            &T_x_verilog_text,
            &T_x_vhdl_text,
            &T_x_web_markdown_text,
            &T_x_yacc_text,
            &T_x_yaml_text,
            &T_x_asciidoc_text,
            &T_x_d_text,
            &T_x_haml_text,
            &T_x_haxe_text,
            &T_x_rsrc_text,
            &T_x_scss_text,
            &T_x_sass_text,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_activemessage_application;
impl MimeTypeChecker for T_activemessage_application {
    fn get_mime(&self) -> &'static str {
        "application/activemessage"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_andrew_inset_application;
impl MimeTypeChecker for T_andrew_inset_application {
    fn get_mime(&self) -> &'static str {
        "application/andrew-inset"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ez"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_applixware_application;
impl MimeTypeChecker for T_applixware_application {
    fn get_mime(&self) -> &'static str {
        "application/applixware"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.aw"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_iso19139_xml_text;
impl MimeTypeChecker for T_iso19139_xml_text {
    fn get_mime(&self) -> &'static str {
        "text/iso19139+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.iso19139"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml_local(bytes, "MD_metadata")
            || rootxml(bytes, "MD_metadata", "http://www.isotc211.org/2005/gmd"))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_atom_xml_application;
impl MimeTypeChecker for T_atom_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/atom+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.atom"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml(bytes, "feed", "http://purl.org/atom/ns#")
            || rootxml(bytes, "feed", "http://www.w3.org/2005/Atom"))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_atomcat_xml_application;
impl MimeTypeChecker for T_atomcat_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/atomcat+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.atomcat"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_atomicmail_application;
impl MimeTypeChecker for T_atomicmail_application {
    fn get_mime(&self) -> &'static str {
        "application/atomicmail"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_atomsvc_xml_application;
impl MimeTypeChecker for T_atomsvc_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/atomsvc+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.atomsvc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_auth_policy_xml_application;
impl MimeTypeChecker for T_auth_policy_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/auth-policy+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_batch_smtp_application;
impl MimeTypeChecker for T_batch_smtp_application {
    fn get_mime(&self) -> &'static str {
        "application/batch-smtp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_beep_xml_application;
impl MimeTypeChecker for T_beep_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/beep+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_bizagi_modeler_application;
impl MimeTypeChecker for T_bizagi_modeler_application {
    fn get_mime(&self) -> &'static str {
        "application/bizagi-modeler"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.bpm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_cals_1840_application;
impl MimeTypeChecker for T_cals_1840_application {
    fn get_mime(&self) -> &'static str {
        "application/cals-1840"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_ccxml_xml_application;
impl MimeTypeChecker for T_ccxml_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/ccxml+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ccxml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_cea_2018_xml_application;
impl MimeTypeChecker for T_cea_2018_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/cea-2018+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_cellml_xml_application;
impl MimeTypeChecker for T_cellml_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/cellml+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_cnrp_xml_application;
impl MimeTypeChecker for T_cnrp_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/cnrp+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_commonground_application;
impl MimeTypeChecker for T_commonground_application {
    fn get_mime(&self) -> &'static str {
        "application/commonground"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_conference_info_xml_application;
impl MimeTypeChecker for T_conference_info_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/conference-info+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_cpl_xml_application;
impl MimeTypeChecker for T_cpl_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/cpl+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_csta_xml_application;
impl MimeTypeChecker for T_csta_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/csta+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_cstadata_xml_application;
impl MimeTypeChecker for T_cstadata_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/cstadata+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_cu_seeme_application;
impl MimeTypeChecker for T_cu_seeme_application {
    fn get_mime(&self) -> &'static str {
        "application/cu-seeme"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cu"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_cybercash_application;
impl MimeTypeChecker for T_cybercash_application {
    fn get_mime(&self) -> &'static str {
        "application/cybercash"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dash_xml_application;
impl MimeTypeChecker for T_dash_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/dash+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mpd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(bytes, 0, &[60, 77, 80, 68])
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_davmount_xml_application;
impl MimeTypeChecker for T_davmount_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/davmount+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.davmount"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dca_rft_application;
impl MimeTypeChecker for T_dca_rft_application {
    fn get_mime(&self) -> &'static str {
        "application/dca-rft"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dec_dx_application;
impl MimeTypeChecker for T_dec_dx_application {
    fn get_mime(&self) -> &'static str {
        "application/dec-dx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dialog_info_xml_application;
impl MimeTypeChecker for T_dialog_info_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/dialog-info+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dita_xml_format_map_application;
impl MimeTypeChecker for T_dita_xml_format_map_application {
    fn get_mime(&self) -> &'static str {
        "application/dita+xml;format=map"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ditamap"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml_local(bytes, "map")
            || rootxml(bytes, "map", "http://docs.oasis-open.org/namespace"))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dita_xml_format_task_application;
impl MimeTypeChecker for T_dita_xml_format_task_application {
    fn get_mime(&self) -> &'static str {
        "application/dita+xml;format=task"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml_local(bytes, "task")
            || rootxml(bytes, "task", "http://docs.oasis-open.org/namespace"))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dita_xml_format_concept_application;
impl MimeTypeChecker for T_dita_xml_format_concept_application {
    fn get_mime(&self) -> &'static str {
        "application/dita+xml;format=concept"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml_local(bytes, "concept")
            || rootxml(bytes, "concept", "http://docs.oasis-open.org/namespace"))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dita_xml_format_val_application;
impl MimeTypeChecker for T_dita_xml_format_val_application {
    fn get_mime(&self) -> &'static str {
        "application/dita+xml;format=val"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ditaval"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml_local(bytes, "val")
            || rootxml(bytes, "val", "http://docs.oasis-open.org/namespace"))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dns_application;
impl MimeTypeChecker for T_dns_application {
    fn get_mime(&self) -> &'static str {
        "application/dns"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dvcs_application;
impl MimeTypeChecker for T_dvcs_application {
    fn get_mime(&self) -> &'static str {
        "application/dvcs"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_ecmascript_application;
impl MimeTypeChecker for T_ecmascript_application {
    fn get_mime(&self) -> &'static str {
        "application/ecmascript"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ecma"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_edi_consent_application;
impl MimeTypeChecker for T_edi_consent_application {
    fn get_mime(&self) -> &'static str {
        "application/edi-consent"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_edi_x12_application;
impl MimeTypeChecker for T_edi_x12_application {
    fn get_mime(&self) -> &'static str {
        "application/edi-x12"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_edifact_application;
impl MimeTypeChecker for T_edifact_application {
    fn get_mime(&self) -> &'static str {
        "application/edifact"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_emma_xml_application;
impl MimeTypeChecker for T_emma_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/emma+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.emma"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_envi_hdr_application;
impl MimeTypeChecker for T_envi_hdr_application {
    fn get_mime(&self) -> &'static str {
        "application/envi.hdr"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_epp_xml_application;
impl MimeTypeChecker for T_epp_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/epp+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_eshop_application;
impl MimeTypeChecker for T_eshop_application {
    fn get_mime(&self) -> &'static str {
        "application/eshop"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_example_application;
impl MimeTypeChecker for T_example_application {
    fn get_mime(&self) -> &'static str {
        "application/example"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_fastinfoset_application;
impl MimeTypeChecker for T_fastinfoset_application {
    fn get_mime(&self) -> &'static str {
        "application/fastinfoset"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_fastsoap_application;
impl MimeTypeChecker for T_fastsoap_application {
    fn get_mime(&self) -> &'static str {
        "application/fastsoap"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_font_tdpfr_application;
impl MimeTypeChecker for T_font_tdpfr_application {
    fn get_mime(&self) -> &'static str {
        "application/font-tdpfr"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pfr"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_h224_application;
impl MimeTypeChecker for T_h224_application {
    fn get_mime(&self) -> &'static str {
        "application/h224"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_http_application;
impl MimeTypeChecker for T_http_application {
    fn get_mime(&self) -> &'static str {
        "application/http"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_hyperstudio_application;
impl MimeTypeChecker for T_hyperstudio_application {
    fn get_mime(&self) -> &'static str {
        "application/hyperstudio"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.stk"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_ibe_key_request_xml_application;
impl MimeTypeChecker for T_ibe_key_request_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/ibe-key-request+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_ibe_pkg_reply_xml_application;
impl MimeTypeChecker for T_ibe_pkg_reply_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/ibe-pkg-reply+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_ibe_pp_data_application;
impl MimeTypeChecker for T_ibe_pp_data_application {
    fn get_mime(&self) -> &'static str {
        "application/ibe-pp-data"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_iges_application;
impl MimeTypeChecker for T_iges_application {
    fn get_mime(&self) -> &'static str {
        "application/iges"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_illustrator_application;
impl MimeTypeChecker for T_illustrator_application {
    fn get_mime(&self) -> &'static str {
        "application/illustrator"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ai"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_im_iscomposing_xml_application;
impl MimeTypeChecker for T_im_iscomposing_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/im-iscomposing+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_index_application;
impl MimeTypeChecker for T_index_application {
    fn get_mime(&self) -> &'static str {
        "application/index"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_index_cmd_application;
impl MimeTypeChecker for T_index_cmd_application {
    fn get_mime(&self) -> &'static str {
        "application/index.cmd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_index_obj_application;
impl MimeTypeChecker for T_index_obj_application {
    fn get_mime(&self) -> &'static str {
        "application/index.obj"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_index_response_application;
impl MimeTypeChecker for T_index_response_application {
    fn get_mime(&self) -> &'static str {
        "application/index.response"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_index_vnd_application;
impl MimeTypeChecker for T_index_vnd_application {
    fn get_mime(&self) -> &'static str {
        "application/index.vnd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_iotp_application;
impl MimeTypeChecker for T_iotp_application {
    fn get_mime(&self) -> &'static str {
        "application/iotp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_ipp_application;
impl MimeTypeChecker for T_ipp_application {
    fn get_mime(&self) -> &'static str {
        "application/ipp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_isup_application;
impl MimeTypeChecker for T_isup_application {
    fn get_mime(&self) -> &'static str {
        "application/isup"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_android_package_archive_application;
impl MimeTypeChecker for T_vnd_android_package_archive_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.android.package-archive"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.apk"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_tika_java_enterprise_archive_application;
impl MimeTypeChecker for T_x_tika_java_enterprise_archive_application {
    fn get_mime(&self) -> &'static str {
        "application/x-tika-java-enterprise-archive"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ear"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_tika_java_web_archive_application;
impl MimeTypeChecker for T_x_tika_java_web_archive_application {
    fn get_mime(&self) -> &'static str {
        "application/x-tika-java-web-archive"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.war"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_tika_unix_dump_application;
impl MimeTypeChecker for T_x_tika_unix_dump_application {
    fn get_mime(&self) -> &'static str {
        "application/x-tika-unix-dump"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_java_serialized_object_application;
impl MimeTypeChecker for T_java_serialized_object_application {
    fn get_mime(&self) -> &'static str {
        "application/java-serialized-object"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ser"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_manifest_json_application;
impl MimeTypeChecker for T_manifest_json_application {
    fn get_mime(&self) -> &'static str {
        "application/manifest+json"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.webmanifest"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_java_jnilib_application;
impl MimeTypeChecker for T_x_java_jnilib_application {
    fn get_mime(&self) -> &'static str {
        "application/x-java-jnilib"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jnilib"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_kpml_request_xml_application;
impl MimeTypeChecker for T_kpml_request_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/kpml-request+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_kpml_response_xml_application;
impl MimeTypeChecker for T_kpml_response_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/kpml-response+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_lost_xml_application;
impl MimeTypeChecker for T_lost_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/lost+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.lostxml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mac_compactpro_application;
impl MimeTypeChecker for T_mac_compactpro_application {
    fn get_mime(&self) -> &'static str {
        "application/mac-compactpro"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cpt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_macwriteii_application;
impl MimeTypeChecker for T_macwriteii_application {
    fn get_mime(&self) -> &'static str {
        "application/macwriteii"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mathml_xml_application;
impl MimeTypeChecker for T_mathml_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/mathml+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mathml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mbms_associated_procedure_description_xml_application;
impl MimeTypeChecker for T_mbms_associated_procedure_description_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/mbms-associated-procedure-description+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mbms_deregister_xml_application;
impl MimeTypeChecker for T_mbms_deregister_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/mbms-deregister+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mbms_envelope_xml_application;
impl MimeTypeChecker for T_mbms_envelope_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/mbms-envelope+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mbms_msk_xml_application;
impl MimeTypeChecker for T_mbms_msk_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/mbms-msk+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mbms_msk_response_xml_application;
impl MimeTypeChecker for T_mbms_msk_response_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/mbms-msk-response+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mbms_protection_description_xml_application;
impl MimeTypeChecker for T_mbms_protection_description_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/mbms-protection-description+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mbms_reception_report_xml_application;
impl MimeTypeChecker for T_mbms_reception_report_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/mbms-reception-report+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mbms_register_xml_application;
impl MimeTypeChecker for T_mbms_register_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/mbms-register+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mbms_register_response_xml_application;
impl MimeTypeChecker for T_mbms_register_response_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/mbms-register-response+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mbms_user_service_description_xml_application;
impl MimeTypeChecker for T_mbms_user_service_description_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/mbms-user-service-description+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_media_control_xml_application;
impl MimeTypeChecker for T_media_control_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/media_control+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mediaservercontrol_xml_application;
impl MimeTypeChecker for T_mediaservercontrol_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/mediaservercontrol+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mscml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mikey_application;
impl MimeTypeChecker for T_mikey_application {
    fn get_mime(&self) -> &'static str {
        "application/mikey"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_moss_keys_application;
impl MimeTypeChecker for T_moss_keys_application {
    fn get_mime(&self) -> &'static str {
        "application/moss-keys"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_moss_signature_application;
impl MimeTypeChecker for T_moss_signature_application {
    fn get_mime(&self) -> &'static str {
        "application/moss-signature"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mosskey_data_application;
impl MimeTypeChecker for T_mosskey_data_application {
    fn get_mime(&self) -> &'static str {
        "application/mosskey-data"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mosskey_request_application;
impl MimeTypeChecker for T_mosskey_request_application {
    fn get_mime(&self) -> &'static str {
        "application/mosskey-request"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mp4_application;
impl MimeTypeChecker for T_mp4_application {
    fn get_mime(&self) -> &'static str {
        "application/mp4"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mp4s"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mpeg4_generic_application;
impl MimeTypeChecker for T_mpeg4_generic_application {
    fn get_mime(&self) -> &'static str {
        "application/mpeg4-generic"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mpeg4_iod_application;
impl MimeTypeChecker for T_mpeg4_iod_application {
    fn get_mime(&self) -> &'static str {
        "application/mpeg4-iod"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mpeg4_iod_xmt_application;
impl MimeTypeChecker for T_mpeg4_iod_xmt_application {
    fn get_mime(&self) -> &'static str {
        "application/mpeg4-iod-xmt"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mxf_application;
impl MimeTypeChecker for T_mxf_application {
    fn get_mime(&self) -> &'static str {
        "application/mxf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mxf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_nasdata_application;
impl MimeTypeChecker for T_nasdata_application {
    fn get_mime(&self) -> &'static str {
        "application/nasdata"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_news_checkgroups_application;
impl MimeTypeChecker for T_news_checkgroups_application {
    fn get_mime(&self) -> &'static str {
        "application/news-checkgroups"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_news_groupinfo_application;
impl MimeTypeChecker for T_news_groupinfo_application {
    fn get_mime(&self) -> &'static str {
        "application/news-groupinfo"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_news_transmission_application;
impl MimeTypeChecker for T_news_transmission_application {
    fn get_mime(&self) -> &'static str {
        "application/news-transmission"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_nss_application;
impl MimeTypeChecker for T_nss_application {
    fn get_mime(&self) -> &'static str {
        "application/nss"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_ocsp_request_application;
impl MimeTypeChecker for T_ocsp_request_application {
    fn get_mime(&self) -> &'static str {
        "application/ocsp-request"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_ocsp_response_application;
impl MimeTypeChecker for T_ocsp_response_application {
    fn get_mime(&self) -> &'static str {
        "application/ocsp-response"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_oda_application;
impl MimeTypeChecker for T_oda_application {
    fn get_mime(&self) -> &'static str {
        "application/oda"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.oda"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_oebps_package_xml_application;
impl MimeTypeChecker for T_oebps_package_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/oebps-package+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.opf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_kate_application;
impl MimeTypeChecker for T_kate_application {
    fn get_mime(&self) -> &'static str {
        "application/kate"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_onenote__format_package_application;
impl MimeTypeChecker for T_onenote__format_package_application {
    fn get_mime(&self) -> &'static str {
        "application/onenote; format=package"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.onepkg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_parityfec_application;
impl MimeTypeChecker for T_parityfec_application {
    fn get_mime(&self) -> &'static str {
        "application/parityfec"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_patch_ops_error_xml_application;
impl MimeTypeChecker for T_patch_ops_error_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/patch-ops-error+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xer"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pgp_encrypted_application;
impl MimeTypeChecker for T_pgp_encrypted_application {
    fn get_mime(&self) -> &'static str {
        "application/pgp-encrypted"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pgp", "*.gpg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[133]) && offset(bytes, 3, &[3]))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pgp_keys_application;
impl MimeTypeChecker for T_pgp_keys_application {
    fn get_mime(&self) -> &'static str {
        "application/pgp-keys"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pgp_signature_application;
impl MimeTypeChecker for T_pgp_signature_application {
    fn get_mime(&self) -> &'static str {
        "application/pgp-signature"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.asc", "*.sig"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pics_rules_application;
impl MimeTypeChecker for T_pics_rules_application {
    fn get_mime(&self) -> &'static str {
        "application/pics-rules"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.prf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pidf_xml_application;
impl MimeTypeChecker for T_pidf_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/pidf+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pidf_diff_xml_application;
impl MimeTypeChecker for T_pidf_diff_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/pidf-diff+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pkcs10_application;
impl MimeTypeChecker for T_pkcs10_application {
    fn get_mime(&self) -> &'static str {
        "application/pkcs10"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.p10"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pkcs7_mime_application;
impl MimeTypeChecker for T_pkcs7_mime_application {
    fn get_mime(&self) -> &'static str {
        "application/pkcs7-mime"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.p7m", "*.p7c"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pkix_cert_application;
impl MimeTypeChecker for T_pkix_cert_application {
    fn get_mime(&self) -> &'static str {
        "application/pkix-cert"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cer"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pkix_crl_application;
impl MimeTypeChecker for T_pkix_crl_application {
    fn get_mime(&self) -> &'static str {
        "application/pkix-crl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.crl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pkix_pkipath_application;
impl MimeTypeChecker for T_pkix_pkipath_application {
    fn get_mime(&self) -> &'static str {
        "application/pkix-pkipath"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pkipath"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pkixcmp_application;
impl MimeTypeChecker for T_pkixcmp_application {
    fn get_mime(&self) -> &'static str {
        "application/pkixcmp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pki"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pls_xml_application;
impl MimeTypeChecker for T_pls_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/pls+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pls"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_poc_settings_xml_application;
impl MimeTypeChecker for T_poc_settings_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/poc-settings+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_prs_alvestrand_titrax_sheet_application;
impl MimeTypeChecker for T_prs_alvestrand_titrax_sheet_application {
    fn get_mime(&self) -> &'static str {
        "application/prs.alvestrand.titrax-sheet"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_prs_cww_application;
impl MimeTypeChecker for T_prs_cww_application {
    fn get_mime(&self) -> &'static str {
        "application/prs.cww"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cww"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_prs_nprend_application;
impl MimeTypeChecker for T_prs_nprend_application {
    fn get_mime(&self) -> &'static str {
        "application/prs.nprend"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_prs_plucker_application;
impl MimeTypeChecker for T_prs_plucker_application {
    fn get_mime(&self) -> &'static str {
        "application/prs.plucker"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_qsig_application;
impl MimeTypeChecker for T_qsig_application {
    fn get_mime(&self) -> &'static str {
        "application/qsig"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_spreadsheetml_application;
impl MimeTypeChecker for T_vnd_ms_spreadsheetml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-spreadsheetml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml(
            bytes,
            "Workbook",
            "urn:schemas-microsoft-com:office:spreadsheet",
        ) || rootxml_local(bytes, "Workbook"))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_wordml_application;
impl MimeTypeChecker for T_vnd_ms_wordml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-wordml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml(
            bytes,
            "wordDocument",
            "http://schemas.microsoft.com/office/word/2003/wordml",
        ) || rootxml_local(bytes, "wordDocument"))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_word2006ml_application;
impl MimeTypeChecker for T_vnd_ms_word2006ml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-word2006ml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml(
            bytes,
            "package",
            "http://schemas.microsoft.com/office/2006/xmlPackage",
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_rdf_xml_application;
impl MimeTypeChecker for T_rdf_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/rdf+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rdf", "*.owl", "^rdf$", "^owl$", "*.xmp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml_local(bytes, "RDF")
            || rootxml(bytes, "RDF", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_reginfo_xml_application;
impl MimeTypeChecker for T_reginfo_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/reginfo+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rif"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_relax_ng_compact_syntax_application;
impl MimeTypeChecker for T_relax_ng_compact_syntax_application {
    fn get_mime(&self) -> &'static str {
        "application/relax-ng-compact-syntax"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rnc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_remote_printing_application;
impl MimeTypeChecker for T_remote_printing_application {
    fn get_mime(&self) -> &'static str {
        "application/remote-printing"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_resource_lists_xml_application;
impl MimeTypeChecker for T_resource_lists_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/resource-lists+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_resource_lists_diff_xml_application;
impl MimeTypeChecker for T_resource_lists_diff_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/resource-lists-diff+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rld"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_riscos_application;
impl MimeTypeChecker for T_riscos_application {
    fn get_mime(&self) -> &'static str {
        "application/riscos"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_rlmi_xml_application;
impl MimeTypeChecker for T_rlmi_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/rlmi+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_rls_services_xml_application;
impl MimeTypeChecker for T_rls_services_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/rls-services+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rs"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_rsd_xml_application;
impl MimeTypeChecker for T_rsd_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/rsd+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rsd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_rss_xml_application;
impl MimeTypeChecker for T_rss_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/rss+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rss"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml(bytes, "rss", "http://purl.org/rss/1.0/") || rootxml_local(bytes, "rss"))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_rtx_application;
impl MimeTypeChecker for T_rtx_application {
    fn get_mime(&self) -> &'static str {
        "application/rtx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_samlassertion_xml_application;
impl MimeTypeChecker for T_samlassertion_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/samlassertion+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_samlmetadata_xml_application;
impl MimeTypeChecker for T_samlmetadata_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/samlmetadata+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_sbml_xml_application;
impl MimeTypeChecker for T_sbml_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/sbml+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sbml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_scvp_cv_request_application;
impl MimeTypeChecker for T_scvp_cv_request_application {
    fn get_mime(&self) -> &'static str {
        "application/scvp-cv-request"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.scq"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_scvp_cv_response_application;
impl MimeTypeChecker for T_scvp_cv_response_application {
    fn get_mime(&self) -> &'static str {
        "application/scvp-cv-response"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.scs"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_scvp_vp_request_application;
impl MimeTypeChecker for T_scvp_vp_request_application {
    fn get_mime(&self) -> &'static str {
        "application/scvp-vp-request"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.spq"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_scvp_vp_response_application;
impl MimeTypeChecker for T_scvp_vp_response_application {
    fn get_mime(&self) -> &'static str {
        "application/scvp-vp-response"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.spp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_sdp_application;
impl MimeTypeChecker for T_sdp_application {
    fn get_mime(&self) -> &'static str {
        "application/sdp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sdp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_set_payment_application;
impl MimeTypeChecker for T_set_payment_application {
    fn get_mime(&self) -> &'static str {
        "application/set-payment"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_set_payment_initiation_application;
impl MimeTypeChecker for T_set_payment_initiation_application {
    fn get_mime(&self) -> &'static str {
        "application/set-payment-initiation"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.setpay"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_set_registration_application;
impl MimeTypeChecker for T_set_registration_application {
    fn get_mime(&self) -> &'static str {
        "application/set-registration"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_set_registration_initiation_application;
impl MimeTypeChecker for T_set_registration_initiation_application {
    fn get_mime(&self) -> &'static str {
        "application/set-registration-initiation"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.setreg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_sgml_application;
impl MimeTypeChecker for T_sgml_application {
    fn get_mime(&self) -> &'static str {
        "application/sgml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_sgml_open_catalog_application;
impl MimeTypeChecker for T_sgml_open_catalog_application {
    fn get_mime(&self) -> &'static str {
        "application/sgml-open-catalog"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_shf_xml_application;
impl MimeTypeChecker for T_shf_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/shf+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.shf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_sieve_application;
impl MimeTypeChecker for T_sieve_application {
    fn get_mime(&self) -> &'static str {
        "application/sieve"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_simple_filter_xml_application;
impl MimeTypeChecker for T_simple_filter_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/simple-filter+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_simple_message_summary_application;
impl MimeTypeChecker for T_simple_message_summary_application {
    fn get_mime(&self) -> &'static str {
        "application/simple-message-summary"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_simplesymbolcontainer_application;
impl MimeTypeChecker for T_simplesymbolcontainer_application {
    fn get_mime(&self) -> &'static str {
        "application/simplesymbolcontainer"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_slate_application;
impl MimeTypeChecker for T_slate_application {
    fn get_mime(&self) -> &'static str {
        "application/slate"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_smil_xml_application;
impl MimeTypeChecker for T_smil_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/smil+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.smi", "*.smil", "*.sml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml_local(bytes, "smil")
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_soap_fastinfoset_application;
impl MimeTypeChecker for T_soap_fastinfoset_application {
    fn get_mime(&self) -> &'static str {
        "application/soap+fastinfoset"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_soap_xml_application;
impl MimeTypeChecker for T_soap_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/soap+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_sldworks_application;
impl MimeTypeChecker for T_sldworks_application {
    fn get_mime(&self) -> &'static str {
        "application/sldworks"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sldprt", "*.sldasm", "*.slddrw"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_sparql_query_application;
impl MimeTypeChecker for T_sparql_query_application {
    fn get_mime(&self) -> &'static str {
        "application/sparql-query"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rq"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_sparql_results_xml_application;
impl MimeTypeChecker for T_sparql_results_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/sparql-results+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.srx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_spirits_event_xml_application;
impl MimeTypeChecker for T_spirits_event_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/spirits-event+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_srgs_application;
impl MimeTypeChecker for T_srgs_application {
    fn get_mime(&self) -> &'static str {
        "application/srgs"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gram"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_srgs_xml_application;
impl MimeTypeChecker for T_srgs_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/srgs+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.grxml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_ssml_xml_application;
impl MimeTypeChecker for T_ssml_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/ssml+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ssml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_timestamp_query_application;
impl MimeTypeChecker for T_timestamp_query_application {
    fn get_mime(&self) -> &'static str {
        "application/timestamp-query"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_timestamp_reply_application;
impl MimeTypeChecker for T_timestamp_reply_application {
    fn get_mime(&self) -> &'static str {
        "application/timestamp-reply"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_tve_trigger_application;
impl MimeTypeChecker for T_tve_trigger_application {
    fn get_mime(&self) -> &'static str {
        "application/tve-trigger"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_ulpfec_application;
impl MimeTypeChecker for T_ulpfec_application {
    fn get_mime(&self) -> &'static str {
        "application/ulpfec"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vemmi_application;
impl MimeTypeChecker for T_vemmi_application {
    fn get_mime(&self) -> &'static str {
        "application/vemmi"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vividence_scriptfile_application;
impl MimeTypeChecker for T_vividence_scriptfile_application {
    fn get_mime(&self) -> &'static str {
        "application/vividence.scriptfile"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_3gpp_bsf_xml_application;
impl MimeTypeChecker for T_vnd_3gpp_bsf_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.3gpp.bsf+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_3gpp_pic_bw_large_application;
impl MimeTypeChecker for T_vnd_3gpp_pic_bw_large_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.3gpp.pic-bw-large"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.plb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_3gpp_pic_bw_small_application;
impl MimeTypeChecker for T_vnd_3gpp_pic_bw_small_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.3gpp.pic-bw-small"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.psb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_3gpp_pic_bw_var_application;
impl MimeTypeChecker for T_vnd_3gpp_pic_bw_var_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.3gpp.pic-bw-var"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pvb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_3gpp_sms_application;
impl MimeTypeChecker for T_vnd_3gpp_sms_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.3gpp.sms"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_3gpp2_bcmcsinfo_xml_application;
impl MimeTypeChecker for T_vnd_3gpp2_bcmcsinfo_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.3gpp2.bcmcsinfo+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_3gpp2_sms_application;
impl MimeTypeChecker for T_vnd_3gpp2_sms_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.3gpp2.sms"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_3gpp2_tcap_application;
impl MimeTypeChecker for T_vnd_3gpp2_tcap_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.3gpp2.tcap"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.tcap"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_3m_post_it_notes_application;
impl MimeTypeChecker for T_vnd_3m_post_it_notes_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.3m.post-it-notes"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pwn"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_accpac_simply_aso_application;
impl MimeTypeChecker for T_vnd_accpac_simply_aso_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.accpac.simply.aso"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.aso"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_accpac_simply_imp_application;
impl MimeTypeChecker for T_vnd_accpac_simply_imp_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.accpac.simply.imp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.imp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_acucobol_application;
impl MimeTypeChecker for T_vnd_acucobol_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.acucobol"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.acu"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_acucorp_application;
impl MimeTypeChecker for T_vnd_acucorp_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.acucorp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.atc", "*.acutc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_adobe_air_application_installer_package_zip_application;
impl MimeTypeChecker for T_vnd_adobe_air_application_installer_package_zip_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.adobe.air-application-installer-package+zip"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.air"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_adobe_aftereffects_project_application;
impl MimeTypeChecker for T_vnd_adobe_aftereffects_project_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.adobe.aftereffects.project"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.aep"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_adobe_aftereffects_template_application;
impl MimeTypeChecker for T_vnd_adobe_aftereffects_template_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.adobe.aftereffects.template"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.aet"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_adobe_xdp_xml_application;
impl MimeTypeChecker for T_vnd_adobe_xdp_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.adobe.xdp+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xdp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml(bytes, "xdp", "http://ns.adobe.com/xdp/")
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_adobe_xfdf_application;
impl MimeTypeChecker for T_vnd_adobe_xfdf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.adobe.xfdf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xfdf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml(bytes, "xfdf", "http://ns.adobe.com/xfdf/")
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_aether_imp_application;
impl MimeTypeChecker for T_vnd_aether_imp_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.aether.imp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_airzip_filesecure_azf_application;
impl MimeTypeChecker for T_vnd_airzip_filesecure_azf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.airzip.filesecure.azf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.azf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_airzip_filesecure_azs_application;
impl MimeTypeChecker for T_vnd_airzip_filesecure_azs_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.airzip.filesecure.azs"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.azs"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_amazon_ebook_application;
impl MimeTypeChecker for T_vnd_amazon_ebook_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.amazon.ebook"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.azw"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_americandynamics_acc_application;
impl MimeTypeChecker for T_vnd_americandynamics_acc_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.americandynamics.acc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.acc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_amiga_ami_application;
impl MimeTypeChecker for T_vnd_amiga_ami_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.amiga.ami"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ami"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_anser_web_certificate_issue_initiation_application;
impl MimeTypeChecker for T_vnd_anser_web_certificate_issue_initiation_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.anser-web-certificate-issue-initiation"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cii"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_anser_web_funds_transfer_initiation_application;
impl MimeTypeChecker for T_vnd_anser_web_funds_transfer_initiation_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.anser-web-funds-transfer-initiation"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fti"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_antix_game_component_application;
impl MimeTypeChecker for T_vnd_antix_game_component_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.antix.game-component"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.atx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_apple_installer_xml_application;
impl MimeTypeChecker for T_vnd_apple_installer_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.apple.installer+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mpkg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_apple_unknown_13_application;
impl MimeTypeChecker for T_vnd_apple_unknown_13_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.apple.unknown.13"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_apple_keynote_application;
impl MimeTypeChecker for T_vnd_apple_keynote_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.apple.keynote"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.key"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml(
            bytes,
            "presentation",
            "http://developer.apple.com/namespaces/keynote2",
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_apple_pages_application;
impl MimeTypeChecker for T_vnd_apple_pages_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.apple.pages"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pages"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml(
            bytes,
            "document",
            "http://developer.apple.com/namespaces/sl",
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_apple_numbers_application;
impl MimeTypeChecker for T_vnd_apple_numbers_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.apple.numbers"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.numbers"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml(
            bytes,
            "document",
            "http://developer.apple.com/namespaces/ls",
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_tika_iworks_protected_application;
impl MimeTypeChecker for T_x_tika_iworks_protected_application {
    fn get_mime(&self) -> &'static str {
        "application/x-tika-iworks-protected"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_arastra_swi_application;
impl MimeTypeChecker for T_vnd_arastra_swi_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.arastra.swi"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.swi"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_audiograph_application;
impl MimeTypeChecker for T_vnd_audiograph_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.audiograph"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_autopackage_application;
impl MimeTypeChecker for T_vnd_autopackage_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.autopackage"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_avistar_xml_application;
impl MimeTypeChecker for T_vnd_avistar_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.avistar+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_blueice_multipass_application;
impl MimeTypeChecker for T_vnd_blueice_multipass_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.blueice.multipass"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mpm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_bluetooth_ep_oob_application;
impl MimeTypeChecker for T_vnd_bluetooth_ep_oob_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.bluetooth.ep.oob"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_bmi_application;
impl MimeTypeChecker for T_vnd_bmi_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.bmi"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.bmi"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_businessobjects_application;
impl MimeTypeChecker for T_vnd_businessobjects_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.businessobjects"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rep"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_cab_jscript_application;
impl MimeTypeChecker for T_vnd_cab_jscript_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.cab-jscript"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_canon_cpdl_application;
impl MimeTypeChecker for T_vnd_canon_cpdl_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.canon-cpdl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_canon_lips_application;
impl MimeTypeChecker for T_vnd_canon_lips_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.canon-lips"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_cendio_thinlinc_clientconf_application;
impl MimeTypeChecker for T_vnd_cendio_thinlinc_clientconf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.cendio.thinlinc.clientconf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_chemdraw_xml_application;
impl MimeTypeChecker for T_vnd_chemdraw_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.chemdraw+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cdxml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_chipnuts_karaoke_mmd_application;
impl MimeTypeChecker for T_vnd_chipnuts_karaoke_mmd_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.chipnuts.karaoke-mmd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mmd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_cinderella_application;
impl MimeTypeChecker for T_vnd_cinderella_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.cinderella"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cdy"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_cirpack_isdn_ext_application;
impl MimeTypeChecker for T_vnd_cirpack_isdn_ext_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.cirpack.isdn-ext"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_claymore_application;
impl MimeTypeChecker for T_vnd_claymore_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.claymore"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cla"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_clonk_c4group_application;
impl MimeTypeChecker for T_vnd_clonk_c4group_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.clonk.c4group"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.c4g", "*.c4d", "*.c4f", "*.c4p", "*.c4u"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_commerce_battelle_application;
impl MimeTypeChecker for T_vnd_commerce_battelle_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.commerce-battelle"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_commonspace_application;
impl MimeTypeChecker for T_vnd_commonspace_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.commonspace"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.csp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_contact_cmsg_application;
impl MimeTypeChecker for T_vnd_contact_cmsg_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.contact.cmsg"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cdbcmsg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_cosmocaller_application;
impl MimeTypeChecker for T_vnd_cosmocaller_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.cosmocaller"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cmc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_crick_clicker_application;
impl MimeTypeChecker for T_vnd_crick_clicker_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.crick.clicker"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.clkx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_crick_clicker_keyboard_application;
impl MimeTypeChecker for T_vnd_crick_clicker_keyboard_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.crick.clicker.keyboard"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.clkk"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_crick_clicker_palette_application;
impl MimeTypeChecker for T_vnd_crick_clicker_palette_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.crick.clicker.palette"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.clkp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_crick_clicker_template_application;
impl MimeTypeChecker for T_vnd_crick_clicker_template_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.crick.clicker.template"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.clkt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_crick_clicker_wordbank_application;
impl MimeTypeChecker for T_vnd_crick_clicker_wordbank_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.crick.clicker.wordbank"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.clkw"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_criticaltools_wbs_xml_application;
impl MimeTypeChecker for T_vnd_criticaltools_wbs_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.criticaltools.wbs+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wbs"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ctc_posml_application;
impl MimeTypeChecker for T_vnd_ctc_posml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ctc-posml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ctct_ws_xml_application;
impl MimeTypeChecker for T_vnd_ctct_ws_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ctct.ws+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_cups_pdf_application;
impl MimeTypeChecker for T_vnd_cups_pdf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.cups-pdf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_cups_postscript_application;
impl MimeTypeChecker for T_vnd_cups_postscript_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.cups-postscript"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_cups_ppd_application;
impl MimeTypeChecker for T_vnd_cups_ppd_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.cups-ppd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ppd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_cups_raster_application;
impl MimeTypeChecker for T_vnd_cups_raster_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.cups-raster"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_cups_raw_application;
impl MimeTypeChecker for T_vnd_cups_raw_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.cups-raw"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_curl_car_application;
impl MimeTypeChecker for T_vnd_curl_car_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.curl.car"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.car"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_curl_pcurl_application;
impl MimeTypeChecker for T_vnd_curl_pcurl_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.curl.pcurl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pcurl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_cybank_application;
impl MimeTypeChecker for T_vnd_cybank_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.cybank"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_wacz_application;
impl MimeTypeChecker for T_x_wacz_application {
    fn get_mime(&self) -> &'static str {
        "application/x-wacz"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_vnd_datapackage_json_application;
impl MimeTypeChecker for T_x_vnd_datapackage_json_application {
    fn get_mime(&self) -> &'static str {
        "application/x-vnd.datapackage+json"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_vnd_datapackage_gz_application;
impl MimeTypeChecker for T_x_vnd_datapackage_gz_application {
    fn get_mime(&self) -> &'static str {
        "application/x-vnd.datapackage+gz"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_data_vision_rdz_application;
impl MimeTypeChecker for T_vnd_data_vision_rdz_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.data-vision.rdz"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rdz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_denovo_fcselayout_link_application;
impl MimeTypeChecker for T_vnd_denovo_fcselayout_link_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.denovo.fcselayout-link"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fe_launch"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dir_bi_plate_dl_nosuffix_application;
impl MimeTypeChecker for T_vnd_dir_bi_plate_dl_nosuffix_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dir-bi.plate-dl-nosuffix"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dna_application;
impl MimeTypeChecker for T_vnd_dna_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dna"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dna"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dolby_mlp_application;
impl MimeTypeChecker for T_vnd_dolby_mlp_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dolby.mlp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mlp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dolby_mobile_1_application;
impl MimeTypeChecker for T_vnd_dolby_mobile_1_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dolby.mobile.1"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dolby_mobile_2_application;
impl MimeTypeChecker for T_vnd_dolby_mobile_2_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dolby.mobile.2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dpgraph_application;
impl MimeTypeChecker for T_vnd_dpgraph_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dpgraph"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dpg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dreamfactory_application;
impl MimeTypeChecker for T_vnd_dreamfactory_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dreamfactory"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dfac"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dvb_esgcontainer_application;
impl MimeTypeChecker for T_vnd_dvb_esgcontainer_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dvb.esgcontainer"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dvb_ipdcdftnotifaccess_application;
impl MimeTypeChecker for T_vnd_dvb_ipdcdftnotifaccess_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dvb.ipdcdftnotifaccess"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dvb_ipdcesgaccess_application;
impl MimeTypeChecker for T_vnd_dvb_ipdcesgaccess_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dvb.ipdcesgaccess"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dvb_ipdcroaming_application;
impl MimeTypeChecker for T_vnd_dvb_ipdcroaming_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dvb.ipdcroaming"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dvb_iptv_alfec_base_application;
impl MimeTypeChecker for T_vnd_dvb_iptv_alfec_base_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dvb.iptv.alfec-base"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dvb_iptv_alfec_enhancement_application;
impl MimeTypeChecker for T_vnd_dvb_iptv_alfec_enhancement_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dvb.iptv.alfec-enhancement"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dvb_notif_aggregate_root_xml_application;
impl MimeTypeChecker for T_vnd_dvb_notif_aggregate_root_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dvb.notif-aggregate-root+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dvb_notif_container_xml_application;
impl MimeTypeChecker for T_vnd_dvb_notif_container_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dvb.notif-container+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dvb_notif_generic_xml_application;
impl MimeTypeChecker for T_vnd_dvb_notif_generic_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dvb.notif-generic+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dvb_notif_ia_msglist_xml_application;
impl MimeTypeChecker for T_vnd_dvb_notif_ia_msglist_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dvb.notif-ia-msglist+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dvb_notif_ia_registration_request_xml_application;
impl MimeTypeChecker for T_vnd_dvb_notif_ia_registration_request_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dvb.notif-ia-registration-request+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dvb_notif_ia_registration_response_xml_application;
impl MimeTypeChecker for T_vnd_dvb_notif_ia_registration_response_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dvb.notif-ia-registration-response+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dvb_notif_init_xml_application;
impl MimeTypeChecker for T_vnd_dvb_notif_init_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dvb.notif-init+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dxr_application;
impl MimeTypeChecker for T_vnd_dxr_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dxr"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dynageo_application;
impl MimeTypeChecker for T_vnd_dynageo_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.dynageo"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.geo"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ecdis_update_application;
impl MimeTypeChecker for T_vnd_ecdis_update_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ecdis-update"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ecowin_chart_application;
impl MimeTypeChecker for T_vnd_ecowin_chart_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ecowin.chart"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mag"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ecowin_filerequest_application;
impl MimeTypeChecker for T_vnd_ecowin_filerequest_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ecowin.filerequest"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ecowin_fileupdate_application;
impl MimeTypeChecker for T_vnd_ecowin_fileupdate_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ecowin.fileupdate"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ecowin_series_application;
impl MimeTypeChecker for T_vnd_ecowin_series_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ecowin.series"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ecowin_seriesrequest_application;
impl MimeTypeChecker for T_vnd_ecowin_seriesrequest_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ecowin.seriesrequest"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ecowin_seriesupdate_application;
impl MimeTypeChecker for T_vnd_ecowin_seriesupdate_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ecowin.seriesupdate"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_emclient_accessrequest_xml_application;
impl MimeTypeChecker for T_vnd_emclient_accessrequest_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.emclient.accessrequest+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_enliven_application;
impl MimeTypeChecker for T_vnd_enliven_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.enliven"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.nml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_epson_esf_application;
impl MimeTypeChecker for T_vnd_epson_esf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.epson.esf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.esf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_epson_msf_application;
impl MimeTypeChecker for T_vnd_epson_msf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.epson.msf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.msf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_epson_quickanime_application;
impl MimeTypeChecker for T_vnd_epson_quickanime_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.epson.quickanime"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.qam"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_epson_salt_application;
impl MimeTypeChecker for T_vnd_epson_salt_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.epson.salt"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.slt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_epson_ssf_application;
impl MimeTypeChecker for T_vnd_epson_ssf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.epson.ssf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ssf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ericsson_quickcall_application;
impl MimeTypeChecker for T_vnd_ericsson_quickcall_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ericsson.quickcall"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_eszigno3_xml_application;
impl MimeTypeChecker for T_vnd_eszigno3_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.eszigno3+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.es3", "*.et3"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_etsi_aoc_xml_application;
impl MimeTypeChecker for T_vnd_etsi_aoc_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.etsi.aoc+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_etsi_cug_xml_application;
impl MimeTypeChecker for T_vnd_etsi_cug_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.etsi.cug+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_etsi_iptvcommand_xml_application;
impl MimeTypeChecker for T_vnd_etsi_iptvcommand_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.etsi.iptvcommand+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_etsi_iptvdiscovery_xml_application;
impl MimeTypeChecker for T_vnd_etsi_iptvdiscovery_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.etsi.iptvdiscovery+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_etsi_iptvprofile_xml_application;
impl MimeTypeChecker for T_vnd_etsi_iptvprofile_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.etsi.iptvprofile+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_etsi_iptvsad_bc_xml_application;
impl MimeTypeChecker for T_vnd_etsi_iptvsad_bc_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.etsi.iptvsad-bc+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_etsi_iptvsad_cod_xml_application;
impl MimeTypeChecker for T_vnd_etsi_iptvsad_cod_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.etsi.iptvsad-cod+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_etsi_iptvsad_npvr_xml_application;
impl MimeTypeChecker for T_vnd_etsi_iptvsad_npvr_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.etsi.iptvsad-npvr+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_etsi_iptvueprofile_xml_application;
impl MimeTypeChecker for T_vnd_etsi_iptvueprofile_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.etsi.iptvueprofile+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_etsi_mcid_xml_application;
impl MimeTypeChecker for T_vnd_etsi_mcid_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.etsi.mcid+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_etsi_sci_xml_application;
impl MimeTypeChecker for T_vnd_etsi_sci_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.etsi.sci+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_etsi_simservs_xml_application;
impl MimeTypeChecker for T_vnd_etsi_simservs_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.etsi.simservs+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_eudora_data_application;
impl MimeTypeChecker for T_vnd_eudora_data_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.eudora.data"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ezpix_album_application;
impl MimeTypeChecker for T_vnd_ezpix_album_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ezpix-album"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ez2"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ezpix_package_application;
impl MimeTypeChecker for T_vnd_ezpix_package_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ezpix-package"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ez3"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_f_secure_mobile_application;
impl MimeTypeChecker for T_vnd_f_secure_mobile_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.f-secure.mobile"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fdsn_mseed_application;
impl MimeTypeChecker for T_vnd_fdsn_mseed_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.fdsn.mseed"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mseed"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fdsn_seed_application;
impl MimeTypeChecker for T_vnd_fdsn_seed_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.fdsn.seed"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.seed", "*.dataless"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ffsns_application;
impl MimeTypeChecker for T_vnd_ffsns_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ffsns"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fints_application;
impl MimeTypeChecker for T_vnd_fints_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.fints"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_flographit_application;
impl MimeTypeChecker for T_vnd_flographit_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.flographit"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gph"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fluxtime_clip_application;
impl MimeTypeChecker for T_vnd_fluxtime_clip_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.fluxtime.clip"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ftc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_font_fontforge_sfd_application;
impl MimeTypeChecker for T_vnd_font_fontforge_sfd_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.font-fontforge-sfd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_framemaker_application;
impl MimeTypeChecker for T_vnd_framemaker_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.framemaker"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fm", "*.frame", "*.maker", "*.book"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_frogans_fnc_application;
impl MimeTypeChecker for T_vnd_frogans_fnc_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.frogans.fnc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fnc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_frogans_ltf_application;
impl MimeTypeChecker for T_vnd_frogans_ltf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.frogans.ltf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ltf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fsc_weblaunch_application;
impl MimeTypeChecker for T_vnd_fsc_weblaunch_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.fsc.weblaunch"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fsc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fujitsu_oasys_application;
impl MimeTypeChecker for T_vnd_fujitsu_oasys_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.fujitsu.oasys"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.oas"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fujitsu_oasys2_application;
impl MimeTypeChecker for T_vnd_fujitsu_oasys2_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.fujitsu.oasys2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.oa2"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fujitsu_oasys3_application;
impl MimeTypeChecker for T_vnd_fujitsu_oasys3_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.fujitsu.oasys3"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.oa3"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fujitsu_oasysgp_application;
impl MimeTypeChecker for T_vnd_fujitsu_oasysgp_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.fujitsu.oasysgp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fg5"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fujitsu_oasysprs_application;
impl MimeTypeChecker for T_vnd_fujitsu_oasysprs_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.fujitsu.oasysprs"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.bh2"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fujixerox_art_ex_application;
impl MimeTypeChecker for T_vnd_fujixerox_art_ex_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.fujixerox.art-ex"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fujixerox_art4_application;
impl MimeTypeChecker for T_vnd_fujixerox_art4_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.fujixerox.art4"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fujixerox_hbpl_application;
impl MimeTypeChecker for T_vnd_fujixerox_hbpl_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.fujixerox.hbpl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fujixerox_ddd_application;
impl MimeTypeChecker for T_vnd_fujixerox_ddd_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.fujixerox.ddd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ddd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fujixerox_docuworks_application;
impl MimeTypeChecker for T_vnd_fujixerox_docuworks_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.fujixerox.docuworks"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xdw"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fujixerox_docuworks_binder_application;
impl MimeTypeChecker for T_vnd_fujixerox_docuworks_binder_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.fujixerox.docuworks.binder"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xbd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fut_misnet_application;
impl MimeTypeChecker for T_vnd_fut_misnet_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.fut-misnet"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fuzzysheet_application;
impl MimeTypeChecker for T_vnd_fuzzysheet_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.fuzzysheet"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fzs"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_genomatix_tuxedo_application;
impl MimeTypeChecker for T_vnd_genomatix_tuxedo_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.genomatix.tuxedo"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.txd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_geogebra_file_application;
impl MimeTypeChecker for T_vnd_geogebra_file_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.geogebra.file"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ggb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_geogebra_tool_application;
impl MimeTypeChecker for T_vnd_geogebra_tool_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.geogebra.tool"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ggt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_geometry_explorer_application;
impl MimeTypeChecker for T_vnd_geometry_explorer_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.geometry-explorer"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gex", "*.gre"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_gmx_application;
impl MimeTypeChecker for T_vnd_gmx_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.gmx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gmx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_google_earth_kml_xml_application;
impl MimeTypeChecker for T_vnd_google_earth_kml_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.google-earth.kml+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.kml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml_local(bytes, "kml")
            || rootxml(bytes, "kml", "http://www.opengis.net/kml/2.2")
            || rootxml(bytes, "kml", "http://earth.google.com/kml/2.0")
            || rootxml(bytes, "kml", "http://earth.google.com/kml/2.1")
            || rootxml(bytes, "kml", "http://earth.google.com/kml/2.2"))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_google_earth_kmz_application;
impl MimeTypeChecker for T_vnd_google_earth_kmz_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.google-earth.kmz"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.kmz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_grafeq_application;
impl MimeTypeChecker for T_vnd_grafeq_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.grafeq"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gqf", "*.gqs"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_gridmp_application;
impl MimeTypeChecker for T_vnd_gridmp_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.gridmp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_groove_account_application;
impl MimeTypeChecker for T_vnd_groove_account_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.groove-account"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gac"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_groove_help_application;
impl MimeTypeChecker for T_vnd_groove_help_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.groove-help"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ghf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_groove_identity_message_application;
impl MimeTypeChecker for T_vnd_groove_identity_message_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.groove-identity-message"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gim"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_groove_injector_application;
impl MimeTypeChecker for T_vnd_groove_injector_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.groove-injector"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.grv"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_groove_tool_message_application;
impl MimeTypeChecker for T_vnd_groove_tool_message_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.groove-tool-message"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gtm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_groove_tool_template_application;
impl MimeTypeChecker for T_vnd_groove_tool_template_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.groove-tool-template"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.tpl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_groove_vcard_application;
impl MimeTypeChecker for T_vnd_groove_vcard_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.groove-vcard"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vcg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_handheld_entertainment_xml_application;
impl MimeTypeChecker for T_vnd_handheld_entertainment_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.handheld-entertainment+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.zmm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_hbci_application;
impl MimeTypeChecker for T_vnd_hbci_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.hbci"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.hbci"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_hcl_bireports_application;
impl MimeTypeChecker for T_vnd_hcl_bireports_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.hcl-bireports"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_hhe_lesson_player_application;
impl MimeTypeChecker for T_vnd_hhe_lesson_player_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.hhe.lesson-player"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.les"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_hp_hpgl_application;
impl MimeTypeChecker for T_vnd_hp_hpgl_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.hp-hpgl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.hpgl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_hp_hpid_application;
impl MimeTypeChecker for T_vnd_hp_hpid_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.hp-hpid"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.hpid"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_hp_hps_application;
impl MimeTypeChecker for T_vnd_hp_hps_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.hp-hps"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.hps"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_hp_jlyt_application;
impl MimeTypeChecker for T_vnd_hp_jlyt_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.hp-jlyt"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jlt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_hp_pcl_application;
impl MimeTypeChecker for T_vnd_hp_pcl_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.hp-pcl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pcl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_hp_pclxl_application;
impl MimeTypeChecker for T_vnd_hp_pclxl_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.hp-pclxl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pclxl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_httphone_application;
impl MimeTypeChecker for T_vnd_httphone_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.httphone"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_hydrostatix_sof_data_application;
impl MimeTypeChecker for T_vnd_hydrostatix_sof_data_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.hydrostatix.sof-data"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sfd-hdstx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_hzn_3d_crossword_application;
impl MimeTypeChecker for T_vnd_hzn_3d_crossword_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.hzn-3d-crossword"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.x3d"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ibm_afplinedata_application;
impl MimeTypeChecker for T_vnd_ibm_afplinedata_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ibm.afplinedata"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ibm_electronic_media_application;
impl MimeTypeChecker for T_vnd_ibm_electronic_media_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ibm.electronic-media"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ibm_minipay_application;
impl MimeTypeChecker for T_vnd_ibm_minipay_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ibm.minipay"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mpy"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ibm_modcap_application;
impl MimeTypeChecker for T_vnd_ibm_modcap_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ibm.modcap"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.afp", "*.listafp", "*.list3820"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ibm_rights_management_application;
impl MimeTypeChecker for T_vnd_ibm_rights_management_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ibm.rights-management"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.irm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ibm_secure_container_application;
impl MimeTypeChecker for T_vnd_ibm_secure_container_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ibm.secure-container"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_igloader_application;
impl MimeTypeChecker for T_vnd_igloader_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.igloader"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.igl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_immervision_ivp_application;
impl MimeTypeChecker for T_vnd_immervision_ivp_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.immervision-ivp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ivp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_immervision_ivu_application;
impl MimeTypeChecker for T_vnd_immervision_ivu_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.immervision-ivu"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ivu"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_informedcontrol_rms_xml_application;
impl MimeTypeChecker for T_vnd_informedcontrol_rms_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.informedcontrol.rms+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_informix_visionary_application;
impl MimeTypeChecker for T_vnd_informix_visionary_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.informix-visionary"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_intercon_formnet_application;
impl MimeTypeChecker for T_vnd_intercon_formnet_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.intercon.formnet"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xpw", "*.xpx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_intertrust_digibox_application;
impl MimeTypeChecker for T_vnd_intertrust_digibox_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.intertrust.digibox"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_intertrust_nncp_application;
impl MimeTypeChecker for T_vnd_intertrust_nncp_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.intertrust.nncp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_intu_qbo_application;
impl MimeTypeChecker for T_vnd_intu_qbo_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.intu.qbo"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.qbo"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_intu_qfx_application;
impl MimeTypeChecker for T_vnd_intu_qfx_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.intu.qfx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.qfx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_iptc_g2_catalogitem_xml_application;
impl MimeTypeChecker for T_vnd_iptc_g2_catalogitem_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.iptc.g2.catalogitem+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_iptc_g2_conceptitem_xml_application;
impl MimeTypeChecker for T_vnd_iptc_g2_conceptitem_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.iptc.g2.conceptitem+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_iptc_g2_knowledgeitem_xml_application;
impl MimeTypeChecker for T_vnd_iptc_g2_knowledgeitem_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.iptc.g2.knowledgeitem+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_iptc_g2_newsitem_xml_application;
impl MimeTypeChecker for T_vnd_iptc_g2_newsitem_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.iptc.g2.newsitem+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_iptc_g2_newsmessage_xml_application;
impl MimeTypeChecker for T_vnd_iptc_g2_newsmessage_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.iptc.g2.newsmessage+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.nar"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml_local(bytes, "newsMessage")
            || rootxml(bytes, "newsMessage", "http://iptc.org/std/nar/2006-10-01/"))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_iptc_g2_packageitem_xml_application;
impl MimeTypeChecker for T_vnd_iptc_g2_packageitem_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.iptc.g2.packageitem+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_iptc_g2_planningitem_xml_application;
impl MimeTypeChecker for T_vnd_iptc_g2_planningitem_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.iptc.g2.planningitem+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ipunplugged_rcprofile_application;
impl MimeTypeChecker for T_vnd_ipunplugged_rcprofile_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ipunplugged.rcprofile"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rcprofile"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_irepository_package_xml_application;
impl MimeTypeChecker for T_vnd_irepository_package_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.irepository.package+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.irp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_is_xpr_application;
impl MimeTypeChecker for T_vnd_is_xpr_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.is-xpr"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xpr"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_jam_application;
impl MimeTypeChecker for T_vnd_jam_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.jam"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jam"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_japannet_directory_service_application;
impl MimeTypeChecker for T_vnd_japannet_directory_service_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.japannet-directory-service"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_japannet_jpnstore_wakeup_application;
impl MimeTypeChecker for T_vnd_japannet_jpnstore_wakeup_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.japannet-jpnstore-wakeup"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_japannet_payment_wakeup_application;
impl MimeTypeChecker for T_vnd_japannet_payment_wakeup_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.japannet-payment-wakeup"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_japannet_registration_application;
impl MimeTypeChecker for T_vnd_japannet_registration_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.japannet-registration"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_japannet_registration_wakeup_application;
impl MimeTypeChecker for T_vnd_japannet_registration_wakeup_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.japannet-registration-wakeup"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_japannet_setstore_wakeup_application;
impl MimeTypeChecker for T_vnd_japannet_setstore_wakeup_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.japannet-setstore-wakeup"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_japannet_verification_application;
impl MimeTypeChecker for T_vnd_japannet_verification_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.japannet-verification"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_japannet_verification_wakeup_application;
impl MimeTypeChecker for T_vnd_japannet_verification_wakeup_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.japannet-verification-wakeup"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_jcp_javame_midlet_rms_application;
impl MimeTypeChecker for T_vnd_jcp_javame_midlet_rms_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.jcp.javame.midlet-rms"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rms"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_jisp_application;
impl MimeTypeChecker for T_vnd_jisp_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.jisp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jisp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_joost_joda_archive_application;
impl MimeTypeChecker for T_vnd_joost_joda_archive_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.joost.joda-archive"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.joda"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_kahootz_application;
impl MimeTypeChecker for T_vnd_kahootz_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.kahootz"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ktz", "*.ktr"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_kde_karbon_application;
impl MimeTypeChecker for T_vnd_kde_karbon_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.kde.karbon"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.karbon"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_kde_kchart_application;
impl MimeTypeChecker for T_vnd_kde_kchart_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.kde.kchart"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.chrt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_kde_kformula_application;
impl MimeTypeChecker for T_vnd_kde_kformula_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.kde.kformula"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.kfo"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_kde_kivio_application;
impl MimeTypeChecker for T_vnd_kde_kivio_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.kde.kivio"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.flw"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_kde_kontour_application;
impl MimeTypeChecker for T_vnd_kde_kontour_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.kde.kontour"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.kon"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_kde_kpresenter_application;
impl MimeTypeChecker for T_vnd_kde_kpresenter_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.kde.kpresenter"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.kpr", "*.kpt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_kde_kspread_application;
impl MimeTypeChecker for T_vnd_kde_kspread_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.kde.kspread"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ksp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_kde_kword_application;
impl MimeTypeChecker for T_vnd_kde_kword_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.kde.kword"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.kwd", "*.kwt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_kenameaapp_application;
impl MimeTypeChecker for T_vnd_kenameaapp_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.kenameaapp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.htke"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_kidspiration_application;
impl MimeTypeChecker for T_vnd_kidspiration_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.kidspiration"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.kia"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_kinar_application;
impl MimeTypeChecker for T_vnd_kinar_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.kinar"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.kne", "*.knp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_koan_application;
impl MimeTypeChecker for T_vnd_koan_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.koan"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.skp", "*.skd", "*.skt", "*.skm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_kodak_descriptor_application;
impl MimeTypeChecker for T_vnd_kodak_descriptor_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.kodak-descriptor"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sse"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_liberty_request_xml_application;
impl MimeTypeChecker for T_vnd_liberty_request_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.liberty-request+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_llamagraphics_life_balance_desktop_application;
impl MimeTypeChecker for T_vnd_llamagraphics_life_balance_desktop_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.llamagraphics.life-balance.desktop"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.lbd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_llamagraphics_life_balance_exchange_xml_application;
impl MimeTypeChecker for T_vnd_llamagraphics_life_balance_exchange_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.llamagraphics.life-balance.exchange+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.lbe"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_lotus_approach_application;
impl MimeTypeChecker for T_vnd_lotus_approach_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.lotus-approach"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.apr"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_lotus_freelance_application;
impl MimeTypeChecker for T_vnd_lotus_freelance_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.lotus-freelance"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pre"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_lotus_notes_application;
impl MimeTypeChecker for T_vnd_lotus_notes_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.lotus-notes"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.nsf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_lotus_organizer_application;
impl MimeTypeChecker for T_vnd_lotus_organizer_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.lotus-organizer"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.org"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_lotus_screencam_application;
impl MimeTypeChecker for T_vnd_lotus_screencam_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.lotus-screencam"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_macports_portpkg_application;
impl MimeTypeChecker for T_vnd_macports_portpkg_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.macports.portpkg"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.portpkg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_marlin_drm_actiontoken_xml_application;
impl MimeTypeChecker for T_vnd_marlin_drm_actiontoken_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.marlin.drm.actiontoken+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_marlin_drm_conftoken_xml_application;
impl MimeTypeChecker for T_vnd_marlin_drm_conftoken_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.marlin.drm.conftoken+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_marlin_drm_license_xml_application;
impl MimeTypeChecker for T_vnd_marlin_drm_license_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.marlin.drm.license+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_marlin_drm_mdcf_application;
impl MimeTypeChecker for T_vnd_marlin_drm_mdcf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.marlin.drm.mdcf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mcd_application;
impl MimeTypeChecker for T_vnd_mcd_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.mcd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mcd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_medcalcdata_application;
impl MimeTypeChecker for T_vnd_medcalcdata_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.medcalcdata"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mc1"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mediastation_cdkey_application;
impl MimeTypeChecker for T_vnd_mediastation_cdkey_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.mediastation.cdkey"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cdkey"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_meridian_slingshot_application;
impl MimeTypeChecker for T_vnd_meridian_slingshot_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.meridian-slingshot"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mfer_application;
impl MimeTypeChecker for T_vnd_mfer_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.mfer"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mwf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mfmp_application;
impl MimeTypeChecker for T_vnd_mfmp_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.mfmp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mfm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_micrografx_flo_application;
impl MimeTypeChecker for T_vnd_micrografx_flo_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.micrografx.flo"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.flo"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_micrografx_igx_application;
impl MimeTypeChecker for T_vnd_micrografx_igx_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.micrografx.igx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.igx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mindjet_mindmanager_application;
impl MimeTypeChecker for T_vnd_mindjet_mindmanager_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.mindjet.mindmanager"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mmp", "*.mmap", "*.mmpt", "*.mmat", "*.mmmp", "*.mmas"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_minisoft_hp3000_save_application;
impl MimeTypeChecker for T_vnd_minisoft_hp3000_save_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.minisoft-hp3000-save"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mitsubishi_misty_guard_trustweb_application;
impl MimeTypeChecker for T_vnd_mitsubishi_misty_guard_trustweb_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.mitsubishi.misty-guard.trustweb"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mobius_daf_application;
impl MimeTypeChecker for T_vnd_mobius_daf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.mobius.daf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.daf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mobius_dis_application;
impl MimeTypeChecker for T_vnd_mobius_dis_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.mobius.dis"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dis"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mobius_mbk_application;
impl MimeTypeChecker for T_vnd_mobius_mbk_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.mobius.mbk"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mbk"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mobius_mqy_application;
impl MimeTypeChecker for T_vnd_mobius_mqy_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.mobius.mqy"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mqy"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mobius_msl_application;
impl MimeTypeChecker for T_vnd_mobius_msl_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.mobius.msl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.msl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mobius_plc_application;
impl MimeTypeChecker for T_vnd_mobius_plc_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.mobius.plc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.plc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mobius_txf_application;
impl MimeTypeChecker for T_vnd_mobius_txf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.mobius.txf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.txf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mophun_application_application;
impl MimeTypeChecker for T_vnd_mophun_application_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.mophun.application"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mpn"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mophun_certificate_application;
impl MimeTypeChecker for T_vnd_mophun_certificate_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.mophun.certificate"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mpc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_motorola_flexsuite_application;
impl MimeTypeChecker for T_vnd_motorola_flexsuite_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.motorola.flexsuite"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_motorola_flexsuite_adsi_application;
impl MimeTypeChecker for T_vnd_motorola_flexsuite_adsi_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.motorola.flexsuite.adsi"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_motorola_flexsuite_fis_application;
impl MimeTypeChecker for T_vnd_motorola_flexsuite_fis_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.motorola.flexsuite.fis"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_motorola_flexsuite_gotap_application;
impl MimeTypeChecker for T_vnd_motorola_flexsuite_gotap_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.motorola.flexsuite.gotap"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_motorola_flexsuite_kmr_application;
impl MimeTypeChecker for T_vnd_motorola_flexsuite_kmr_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.motorola.flexsuite.kmr"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_motorola_flexsuite_ttc_application;
impl MimeTypeChecker for T_vnd_motorola_flexsuite_ttc_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.motorola.flexsuite.ttc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_motorola_flexsuite_wem_application;
impl MimeTypeChecker for T_vnd_motorola_flexsuite_wem_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.motorola.flexsuite.wem"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_motorola_iprm_application;
impl MimeTypeChecker for T_vnd_motorola_iprm_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.motorola.iprm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mozilla_xul_xml_application;
impl MimeTypeChecker for T_vnd_mozilla_xul_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.mozilla.xul+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xul"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_artgalry_application;
impl MimeTypeChecker for T_vnd_ms_artgalry_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-artgalry"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cil"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_asf_application;
impl MimeTypeChecker for T_vnd_ms_asf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-asf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_excel_addin_macroenabled_12_application;
impl MimeTypeChecker for T_vnd_ms_excel_addin_macroenabled_12_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-excel.addin.macroenabled.12"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xlam"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_excel_sheet_macroenabled_12_application;
impl MimeTypeChecker for T_vnd_ms_excel_sheet_macroenabled_12_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-excel.sheet.macroenabled.12"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xlsm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_excel_sheet_binary_macroenabled_12_application;
impl MimeTypeChecker for T_vnd_ms_excel_sheet_binary_macroenabled_12_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-excel.sheet.binary.macroenabled.12"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xlsb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_ims_application;
impl MimeTypeChecker for T_vnd_ms_ims_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-ims"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ims"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_lrm_application;
impl MimeTypeChecker for T_vnd_ms_lrm_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-lrm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.lrm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_outlook_application;
impl MimeTypeChecker for T_vnd_ms_outlook_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-outlook"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.msg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_package_3dmanufacturing_3dmodel_xml_application;
impl MimeTypeChecker for T_vnd_ms_package_3dmanufacturing_3dmodel_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-package.3dmanufacturing-3dmodel+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.3mf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml(
            bytes,
            "model",
            "http://schemas.microsoft.com/3dmanufacturing/core/2015/02",
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_pki_seccat_application;
impl MimeTypeChecker for T_vnd_ms_pki_seccat_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-pki.seccat"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cat"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_pki_stl_application;
impl MimeTypeChecker for T_vnd_ms_pki_stl_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-pki.stl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_playready_initiator_xml_application;
impl MimeTypeChecker for T_vnd_ms_playready_initiator_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-playready.initiator+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_powerpoint_addin_macroenabled_12_application;
impl MimeTypeChecker for T_vnd_ms_powerpoint_addin_macroenabled_12_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-powerpoint.addin.macroenabled.12"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ppam"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_powerpoint_presentation_macroenabled_12_application;
impl MimeTypeChecker for T_vnd_ms_powerpoint_presentation_macroenabled_12_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-powerpoint.presentation.macroenabled.12"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pptm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_powerpoint_slide_macroenabled_12_application;
impl MimeTypeChecker for T_vnd_ms_powerpoint_slide_macroenabled_12_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-powerpoint.slide.macroenabled.12"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sldm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_powerpoint_slideshow_macroenabled_12_application;
impl MimeTypeChecker for T_vnd_ms_powerpoint_slideshow_macroenabled_12_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-powerpoint.slideshow.macroenabled.12"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ppsm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_powerpoint_template_macroenabled_12_application;
impl MimeTypeChecker for T_vnd_ms_powerpoint_template_macroenabled_12_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-powerpoint.template.macroenabled.12"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.potm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_project_application;
impl MimeTypeChecker for T_vnd_ms_project_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-project"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mpp", "*.mpt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_wmdrm_lic_chlg_req_application;
impl MimeTypeChecker for T_vnd_ms_wmdrm_lic_chlg_req_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-wmdrm.lic-chlg-req"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_wmdrm_lic_resp_application;
impl MimeTypeChecker for T_vnd_ms_wmdrm_lic_resp_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-wmdrm.lic-resp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_wmdrm_meter_chlg_req_application;
impl MimeTypeChecker for T_vnd_ms_wmdrm_meter_chlg_req_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-wmdrm.meter-chlg-req"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_wmdrm_meter_resp_application;
impl MimeTypeChecker for T_vnd_ms_wmdrm_meter_resp_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-wmdrm.meter-resp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_word_document_macroenabled_12_application;
impl MimeTypeChecker for T_vnd_ms_word_document_macroenabled_12_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-word.document.macroenabled.12"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.docm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_word_template_macroenabled_12_application;
impl MimeTypeChecker for T_vnd_ms_word_template_macroenabled_12_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-word.template.macroenabled.12"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dotm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_wpl_application;
impl MimeTypeChecker for T_vnd_ms_wpl_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-wpl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wpl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_xpsdocument_application;
impl MimeTypeChecker for T_vnd_ms_xpsdocument_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-xpsdocument"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xps", "*.oxps"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mseq_application;
impl MimeTypeChecker for T_vnd_mseq_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.mseq"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mseq"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_msign_application;
impl MimeTypeChecker for T_vnd_msign_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.msign"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_multiad_creator_application;
impl MimeTypeChecker for T_vnd_multiad_creator_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.multiad.creator"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_multiad_creator_cif_application;
impl MimeTypeChecker for T_vnd_multiad_creator_cif_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.multiad.creator.cif"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_music_niff_application;
impl MimeTypeChecker for T_vnd_music_niff_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.music-niff"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_musician_application;
impl MimeTypeChecker for T_vnd_musician_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.musician"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mus"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_muvee_style_application;
impl MimeTypeChecker for T_vnd_muvee_style_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.muvee.style"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.msty"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ncd_control_application;
impl MimeTypeChecker for T_vnd_ncd_control_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ncd.control"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ncd_reference_application;
impl MimeTypeChecker for T_vnd_ncd_reference_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ncd.reference"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nervana_application;
impl MimeTypeChecker for T_vnd_nervana_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.nervana"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_netfpx_application;
impl MimeTypeChecker for T_vnd_netfpx_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.netfpx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_neurolanguage_nlu_application;
impl MimeTypeChecker for T_vnd_neurolanguage_nlu_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.neurolanguage.nlu"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.nlu"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_noblenet_directory_application;
impl MimeTypeChecker for T_vnd_noblenet_directory_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.noblenet-directory"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.nnd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_noblenet_sealer_application;
impl MimeTypeChecker for T_vnd_noblenet_sealer_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.noblenet-sealer"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.nns"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_noblenet_web_application;
impl MimeTypeChecker for T_vnd_noblenet_web_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.noblenet-web"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.nnw"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nokia_catalogs_application;
impl MimeTypeChecker for T_vnd_nokia_catalogs_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.nokia.catalogs"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nokia_conml_wbxml_application;
impl MimeTypeChecker for T_vnd_nokia_conml_wbxml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.nokia.conml+wbxml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nokia_conml_xml_application;
impl MimeTypeChecker for T_vnd_nokia_conml_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.nokia.conml+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nokia_isds_radio_presets_application;
impl MimeTypeChecker for T_vnd_nokia_isds_radio_presets_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.nokia.isds-radio-presets"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nokia_iptv_config_xml_application;
impl MimeTypeChecker for T_vnd_nokia_iptv_config_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.nokia.iptv.config+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nokia_landmark_wbxml_application;
impl MimeTypeChecker for T_vnd_nokia_landmark_wbxml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.nokia.landmark+wbxml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nokia_landmark_xml_application;
impl MimeTypeChecker for T_vnd_nokia_landmark_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.nokia.landmark+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nokia_landmarkcollection_xml_application;
impl MimeTypeChecker for T_vnd_nokia_landmarkcollection_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.nokia.landmarkcollection+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nokia_n_gage_ac_xml_application;
impl MimeTypeChecker for T_vnd_nokia_n_gage_ac_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.nokia.n-gage.ac+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nokia_n_gage_data_application;
impl MimeTypeChecker for T_vnd_nokia_n_gage_data_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.nokia.n-gage.data"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ngdat"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nokia_n_gage_symbian_install_application;
impl MimeTypeChecker for T_vnd_nokia_n_gage_symbian_install_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.nokia.n-gage.symbian.install"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.n-gage"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nokia_ncd_application;
impl MimeTypeChecker for T_vnd_nokia_ncd_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.nokia.ncd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nokia_pcd_wbxml_application;
impl MimeTypeChecker for T_vnd_nokia_pcd_wbxml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.nokia.pcd+wbxml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nokia_pcd_xml_application;
impl MimeTypeChecker for T_vnd_nokia_pcd_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.nokia.pcd+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nokia_radio_preset_application;
impl MimeTypeChecker for T_vnd_nokia_radio_preset_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.nokia.radio-preset"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rpst"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nokia_radio_presets_application;
impl MimeTypeChecker for T_vnd_nokia_radio_presets_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.nokia.radio-presets"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rpss"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_novadigm_edm_application;
impl MimeTypeChecker for T_vnd_novadigm_edm_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.novadigm.edm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.edm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_novadigm_edx_application;
impl MimeTypeChecker for T_vnd_novadigm_edx_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.novadigm.edx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.edx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_novadigm_ext_application;
impl MimeTypeChecker for T_vnd_novadigm_ext_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.novadigm.ext"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ext"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oasis_opendocument_chart_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_chart_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.chart"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.odc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 111, 97, 115, 105, 115, 46, 111, 112,
                    101, 110, 100, 111, 99, 117, 109, 101, 110, 116, 46, 99, 104, 97, 114, 116,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oasis_opendocument_formula_template_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_formula_template_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.formula-template"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.odft"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    97, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 47, 118, 110, 100, 46, 111,
                    97, 115, 105, 115, 46, 111, 112, 101, 110, 100, 111, 99, 117, 109, 101, 110,
                    116, 46, 102, 111, 114, 109, 117, 108, 97, 45, 116, 101, 109, 112, 108, 97,
                    116, 101,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oasis_opendocument_graphics_template_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_graphics_template_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.graphics-template"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.otg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 111, 97, 115, 105, 115, 46, 111, 112,
                    101, 110, 100, 111, 99, 117, 109, 101, 110, 116, 46, 103, 114, 97, 112, 104,
                    105, 99, 115, 45, 116, 101, 109, 112, 108, 97, 116, 101,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oasis_opendocument_image_template_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_image_template_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.image-template"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.oti"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 111, 97, 115, 105, 115, 46, 111, 112,
                    101, 110, 100, 111, 99, 117, 109, 101, 110, 116, 46, 105, 109, 97, 103, 101,
                    45, 116, 101, 109, 112, 108, 97, 116, 101,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oasis_opendocument_presentation_template_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_presentation_template_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.presentation-template"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.otp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 111, 97, 115, 105, 115, 46, 111, 112,
                    101, 110, 100, 111, 99, 117, 109, 101, 110, 116, 46, 112, 114, 101, 115, 101,
                    110, 116, 97, 116, 105, 111, 110, 45, 116, 101, 109, 112, 108, 97, 116, 101,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oasis_opendocument_spreadsheet_template_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_spreadsheet_template_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.spreadsheet-template"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ots"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 111, 97, 115, 105, 115, 46, 111, 112,
                    101, 110, 100, 111, 99, 117, 109, 101, 110, 116, 46, 115, 112, 114, 101, 97,
                    100, 115, 104, 101, 101, 116, 45, 116, 101, 109, 112, 108, 97, 116, 101,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oasis_opendocument_text_template_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_text_template_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.text-template"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ott"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 111, 97, 115, 105, 115, 46, 111, 112,
                    101, 110, 100, 111, 99, 117, 109, 101, 110, 116, 46, 116, 101, 120, 116, 45,
                    116, 101, 109, 112, 108, 97, 116, 101,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oasis_opendocument_text_web_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_text_web_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.text-web"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.oth"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 111, 97, 115, 105, 115, 46, 111, 112,
                    101, 110, 100, 111, 99, 117, 109, 101, 110, 116, 46, 116, 101, 120, 116, 45,
                    119, 101, 98,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_obn_application;
impl MimeTypeChecker for T_vnd_obn_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.obn"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_olpc_sugar_application;
impl MimeTypeChecker for T_vnd_olpc_sugar_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.olpc-sugar"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xo"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_scws_config_application;
impl MimeTypeChecker for T_vnd_oma_scws_config_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma-scws-config"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_scws_http_request_application;
impl MimeTypeChecker for T_vnd_oma_scws_http_request_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma-scws-http-request"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_scws_http_response_application;
impl MimeTypeChecker for T_vnd_oma_scws_http_response_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma-scws-http-response"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_bcast_associated_procedure_parameter_xml_application;
impl MimeTypeChecker for T_vnd_oma_bcast_associated_procedure_parameter_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.bcast.associated-procedure-parameter+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_bcast_drm_trigger_xml_application;
impl MimeTypeChecker for T_vnd_oma_bcast_drm_trigger_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.bcast.drm-trigger+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_bcast_imd_xml_application;
impl MimeTypeChecker for T_vnd_oma_bcast_imd_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.bcast.imd+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_bcast_ltkm_application;
impl MimeTypeChecker for T_vnd_oma_bcast_ltkm_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.bcast.ltkm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_bcast_notification_xml_application;
impl MimeTypeChecker for T_vnd_oma_bcast_notification_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.bcast.notification+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_bcast_provisioningtrigger_application;
impl MimeTypeChecker for T_vnd_oma_bcast_provisioningtrigger_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.bcast.provisioningtrigger"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_bcast_sgboot_application;
impl MimeTypeChecker for T_vnd_oma_bcast_sgboot_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.bcast.sgboot"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_bcast_sgdd_xml_application;
impl MimeTypeChecker for T_vnd_oma_bcast_sgdd_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.bcast.sgdd+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_bcast_sgdu_application;
impl MimeTypeChecker for T_vnd_oma_bcast_sgdu_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.bcast.sgdu"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_bcast_simple_symbol_container_application;
impl MimeTypeChecker for T_vnd_oma_bcast_simple_symbol_container_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.bcast.simple-symbol-container"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_bcast_smartcard_trigger_xml_application;
impl MimeTypeChecker for T_vnd_oma_bcast_smartcard_trigger_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.bcast.smartcard-trigger+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_bcast_sprov_xml_application;
impl MimeTypeChecker for T_vnd_oma_bcast_sprov_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.bcast.sprov+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_bcast_stkm_application;
impl MimeTypeChecker for T_vnd_oma_bcast_stkm_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.bcast.stkm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_dcd_application;
impl MimeTypeChecker for T_vnd_oma_dcd_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.dcd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_dcdc_application;
impl MimeTypeChecker for T_vnd_oma_dcdc_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.dcdc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_dd2_xml_application;
impl MimeTypeChecker for T_vnd_oma_dd2_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.dd2+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dd2"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_drm_risd_xml_application;
impl MimeTypeChecker for T_vnd_oma_drm_risd_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.drm.risd+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_group_usage_list_xml_application;
impl MimeTypeChecker for T_vnd_oma_group_usage_list_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.group-usage-list+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_poc_detailed_progress_report_xml_application;
impl MimeTypeChecker for T_vnd_oma_poc_detailed_progress_report_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.poc.detailed-progress-report+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_poc_final_report_xml_application;
impl MimeTypeChecker for T_vnd_oma_poc_final_report_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.poc.final-report+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_poc_groups_xml_application;
impl MimeTypeChecker for T_vnd_oma_poc_groups_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.poc.groups+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_poc_invocation_descriptor_xml_application;
impl MimeTypeChecker for T_vnd_oma_poc_invocation_descriptor_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.poc.invocation-descriptor+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_poc_optimized_progress_report_xml_application;
impl MimeTypeChecker for T_vnd_oma_poc_optimized_progress_report_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.poc.optimized-progress-report+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_oma_xcap_directory_xml_application;
impl MimeTypeChecker for T_vnd_oma_xcap_directory_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oma.xcap-directory+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_omads_email_xml_application;
impl MimeTypeChecker for T_vnd_omads_email_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.omads-email+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_omads_file_xml_application;
impl MimeTypeChecker for T_vnd_omads_file_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.omads-file+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_omads_folder_xml_application;
impl MimeTypeChecker for T_vnd_omads_folder_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.omads-folder+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_omaloc_supl_init_application;
impl MimeTypeChecker for T_vnd_omaloc_supl_init_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.omaloc-supl-init"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_openofficeorg_extension_application;
impl MimeTypeChecker for T_vnd_openofficeorg_extension_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.openofficeorg.extension"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.oxt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_openofficeorg_autotext_application;
impl MimeTypeChecker for T_vnd_openofficeorg_autotext_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.openofficeorg.autotext"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.bau"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_openxmlformats_officedocument_presentationml_slide_application;
impl MimeTypeChecker for T_vnd_openxmlformats_officedocument_presentationml_slide_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.openxmlformats-officedocument.presentationml.slide"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sldx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_openxmlformats_officedocument_presentationml_template_application;
impl MimeTypeChecker for T_vnd_openxmlformats_officedocument_presentationml_template_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.openxmlformats-officedocument.presentationml.template"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.potx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_openxmlformats_officedocument_presentationml_slideshow_application;
impl MimeTypeChecker for T_vnd_openxmlformats_officedocument_presentationml_slideshow_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.openxmlformats-officedocument.presentationml.slideshow"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ppsx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_openxmlformats_officedocument_spreadsheetml_template_application;
impl MimeTypeChecker for T_vnd_openxmlformats_officedocument_spreadsheetml_template_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.openxmlformats-officedocument.spreadsheetml.template"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xltx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_excel_template_macroenabled_12_application;
impl MimeTypeChecker for T_vnd_ms_excel_template_macroenabled_12_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-excel.template.macroenabled.12"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xltm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_openxmlformats_officedocument_wordprocessingml_template_application;
impl MimeTypeChecker for T_vnd_openxmlformats_officedocument_wordprocessingml_template_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.openxmlformats-officedocument.wordprocessingml.template"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dotx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_osa_netdeploy_application;
impl MimeTypeChecker for T_vnd_osa_netdeploy_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.osa.netdeploy"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_osgi_bundle_application;
impl MimeTypeChecker for T_vnd_osgi_bundle_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.osgi.bundle"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_osgi_dp_application;
impl MimeTypeChecker for T_vnd_osgi_dp_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.osgi.dp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_otps_ct_kip_xml_application;
impl MimeTypeChecker for T_vnd_otps_ct_kip_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.otps.ct-kip+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_palm_application;
impl MimeTypeChecker for T_vnd_palm_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.palm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pqa", "*.oprc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_paos_xml_application;
impl MimeTypeChecker for T_vnd_paos_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.paos.xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_pg_format_application;
impl MimeTypeChecker for T_vnd_pg_format_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.pg.format"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.str"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_pg_osasli_application;
impl MimeTypeChecker for T_vnd_pg_osasli_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.pg.osasli"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ei6"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_piaccess_application_licence_application;
impl MimeTypeChecker for T_vnd_piaccess_application_licence_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.piaccess.application-licence"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_picsel_application;
impl MimeTypeChecker for T_vnd_picsel_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.picsel"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.efif"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_poc_group_advertisement_xml_application;
impl MimeTypeChecker for T_vnd_poc_group_advertisement_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.poc.group-advertisement+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_pocketlearn_application;
impl MimeTypeChecker for T_vnd_pocketlearn_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.pocketlearn"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.plf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_powerbuilder6_application;
impl MimeTypeChecker for T_vnd_powerbuilder6_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.powerbuilder6"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pbd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_powerbuilder6_s_application;
impl MimeTypeChecker for T_vnd_powerbuilder6_s_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.powerbuilder6-s"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_powerbuilder7_application;
impl MimeTypeChecker for T_vnd_powerbuilder7_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.powerbuilder7"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_powerbuilder7_s_application;
impl MimeTypeChecker for T_vnd_powerbuilder7_s_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.powerbuilder7-s"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_powerbuilder75_application;
impl MimeTypeChecker for T_vnd_powerbuilder75_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.powerbuilder75"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_powerbuilder75_s_application;
impl MimeTypeChecker for T_vnd_powerbuilder75_s_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.powerbuilder75-s"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_preminet_application;
impl MimeTypeChecker for T_vnd_preminet_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.preminet"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_previewsystems_box_application;
impl MimeTypeChecker for T_vnd_previewsystems_box_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.previewsystems.box"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.box"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_proteus_magazine_application;
impl MimeTypeChecker for T_vnd_proteus_magazine_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.proteus.magazine"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mgz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_publishare_delta_tree_application;
impl MimeTypeChecker for T_vnd_publishare_delta_tree_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.publishare-delta-tree"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.qps"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_pvi_ptid1_application;
impl MimeTypeChecker for T_vnd_pvi_ptid1_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.pvi.ptid1"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ptid"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_pwg_multiplexed_application;
impl MimeTypeChecker for T_vnd_pwg_multiplexed_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.pwg-multiplexed"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_pwg_xhtml_print_xml_application;
impl MimeTypeChecker for T_vnd_pwg_xhtml_print_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.pwg-xhtml-print+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_qualcomm_brew_app_res_application;
impl MimeTypeChecker for T_vnd_qualcomm_brew_app_res_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.qualcomm.brew-app-res"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_quark_quarkxpress_application;
impl MimeTypeChecker for T_vnd_quark_quarkxpress_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.quark.quarkxpress"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.qxd", "*.qxt", "*.qwd", "*.qwt", "*.qxl", "*.qxb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_rapid_application;
impl MimeTypeChecker for T_vnd_rapid_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.rapid"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_recordare_musicxml_application;
impl MimeTypeChecker for T_vnd_recordare_musicxml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.recordare.musicxml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mxl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_recordare_musicxml_xml_application;
impl MimeTypeChecker for T_vnd_recordare_musicxml_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.recordare.musicxml+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.musicxml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_renlearn_rlprint_application;
impl MimeTypeChecker for T_vnd_renlearn_rlprint_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.renlearn.rlprint"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_rim_cod_application;
impl MimeTypeChecker for T_vnd_rim_cod_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.rim.cod"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cod"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_route66_link66_xml_application;
impl MimeTypeChecker for T_vnd_route66_link66_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.route66.link66+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.link66"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ruckus_download_application;
impl MimeTypeChecker for T_vnd_ruckus_download_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ruckus.download"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_s3sms_application;
impl MimeTypeChecker for T_vnd_s3sms_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.s3sms"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sbm_cid_application;
impl MimeTypeChecker for T_vnd_sbm_cid_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sbm.cid"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sbm_mid2_application;
impl MimeTypeChecker for T_vnd_sbm_mid2_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sbm.mid2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_scribus_application;
impl MimeTypeChecker for T_vnd_scribus_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.scribus"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sealed_3df_application;
impl MimeTypeChecker for T_vnd_sealed_3df_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sealed.3df"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sealed_csf_application;
impl MimeTypeChecker for T_vnd_sealed_csf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sealed.csf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sealed_doc_application;
impl MimeTypeChecker for T_vnd_sealed_doc_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sealed.doc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sealed_eml_application;
impl MimeTypeChecker for T_vnd_sealed_eml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sealed.eml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sealed_mht_application;
impl MimeTypeChecker for T_vnd_sealed_mht_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sealed.mht"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sealed_net_application;
impl MimeTypeChecker for T_vnd_sealed_net_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sealed.net"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sealed_ppt_application;
impl MimeTypeChecker for T_vnd_sealed_ppt_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sealed.ppt"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sealed_tiff_application;
impl MimeTypeChecker for T_vnd_sealed_tiff_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sealed.tiff"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sealed_xls_application;
impl MimeTypeChecker for T_vnd_sealed_xls_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sealed.xls"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sealedmedia_softseal_html_application;
impl MimeTypeChecker for T_vnd_sealedmedia_softseal_html_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sealedmedia.softseal.html"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sealedmedia_softseal_pdf_application;
impl MimeTypeChecker for T_vnd_sealedmedia_softseal_pdf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sealedmedia.softseal.pdf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_seemail_application;
impl MimeTypeChecker for T_vnd_seemail_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.seemail"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.see"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sema_application;
impl MimeTypeChecker for T_vnd_sema_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sema"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sema"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_semd_application;
impl MimeTypeChecker for T_vnd_semd_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.semd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.semd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_semf_application;
impl MimeTypeChecker for T_vnd_semf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.semf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.semf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_shana_informed_formdata_application;
impl MimeTypeChecker for T_vnd_shana_informed_formdata_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.shana.informed.formdata"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ifm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_shana_informed_formtemplate_application;
impl MimeTypeChecker for T_vnd_shana_informed_formtemplate_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.shana.informed.formtemplate"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.itp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_shana_informed_interchange_application;
impl MimeTypeChecker for T_vnd_shana_informed_interchange_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.shana.informed.interchange"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.iif"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_shana_informed_package_application;
impl MimeTypeChecker for T_vnd_shana_informed_package_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.shana.informed.package"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ipk"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_simtech_mindmapper_application;
impl MimeTypeChecker for T_vnd_simtech_mindmapper_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.simtech-mindmapper"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.twd", "*.twds"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_smaf_application;
impl MimeTypeChecker for T_vnd_smaf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.smaf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mmf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_smart_teacher_application;
impl MimeTypeChecker for T_vnd_smart_teacher_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.smart.teacher"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.teacher"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_software602_filler_form_xml_application;
impl MimeTypeChecker for T_vnd_software602_filler_form_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.software602.filler.form+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_software602_filler_form_xml_zip_application;
impl MimeTypeChecker for T_vnd_software602_filler_form_xml_zip_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.software602.filler.form-xml-zip"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_solent_sdkm_xml_application;
impl MimeTypeChecker for T_vnd_solent_sdkm_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.solent.sdkm+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sdkm", "*.sdkd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_spotfire_dxp_application;
impl MimeTypeChecker for T_vnd_spotfire_dxp_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.spotfire.dxp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dxp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_spotfire_sfs_application;
impl MimeTypeChecker for T_vnd_spotfire_sfs_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.spotfire.sfs"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sfs"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sss_cod_application;
impl MimeTypeChecker for T_vnd_sss_cod_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sss-cod"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sss_dtf_application;
impl MimeTypeChecker for T_vnd_sss_dtf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sss-dtf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sss_ntf_application;
impl MimeTypeChecker for T_vnd_sss_ntf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sss-ntf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_stardivision_math_application;
impl MimeTypeChecker for T_vnd_stardivision_math_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.stardivision.math"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.smf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_staroffice_template_application;
impl MimeTypeChecker for T_x_staroffice_template_application {
    fn get_mime(&self) -> &'static str {
        "application/x-staroffice-template"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vor"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sun_xml_writer_template_application;
impl MimeTypeChecker for T_vnd_sun_xml_writer_template_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sun.xml.writer.template"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.stw"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_stardivision_writer_global_application;
impl MimeTypeChecker for T_vnd_stardivision_writer_global_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.stardivision.writer-global"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sgl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_street_stream_application;
impl MimeTypeChecker for T_vnd_street_stream_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.street-stream"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sun_xml_calc_template_application;
impl MimeTypeChecker for T_vnd_sun_xml_calc_template_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sun.xml.calc.template"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.stc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 115, 117, 110, 46, 120, 109, 108, 46, 99,
                    97, 108, 99, 46, 116, 101, 109, 112, 108, 97, 116, 101,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sun_xml_draw_template_application;
impl MimeTypeChecker for T_vnd_sun_xml_draw_template_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sun.xml.draw.template"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.std"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 115, 117, 110, 46, 120, 109, 108, 46,
                    100, 114, 97, 119, 46, 116, 101, 109, 112, 108, 97, 116, 101,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sun_xml_impress_template_application;
impl MimeTypeChecker for T_vnd_sun_xml_impress_template_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sun.xml.impress.template"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sti"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 115, 117, 110, 46, 120, 109, 108, 46,
                    105, 109, 112, 114, 101, 115, 115, 46, 116, 101, 109, 112, 108, 97, 116, 101,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sun_xml_math_application;
impl MimeTypeChecker for T_vnd_sun_xml_math_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sun.xml.math"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sxm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sun_xml_writer_global_application;
impl MimeTypeChecker for T_vnd_sun_xml_writer_global_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sun.xml.writer.global"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sxg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sun_wadl_xml_application;
impl MimeTypeChecker for T_vnd_sun_wadl_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sun.wadl+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sus_calendar_application;
impl MimeTypeChecker for T_vnd_sus_calendar_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sus-calendar"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sus", "*.susp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_svd_application;
impl MimeTypeChecker for T_vnd_svd_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.svd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.svd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_swiftview_ics_application;
impl MimeTypeChecker for T_vnd_swiftview_ics_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.swiftview-ics"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_syncml_xml_application;
impl MimeTypeChecker for T_vnd_syncml_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.syncml+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xsm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_syncml_dm_wbxml_application;
impl MimeTypeChecker for T_vnd_syncml_dm_wbxml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.syncml.dm+wbxml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.bdm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_syncml_dm_xml_application;
impl MimeTypeChecker for T_vnd_syncml_dm_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.syncml.dm+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xdm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_syncml_dm_notification_application;
impl MimeTypeChecker for T_vnd_syncml_dm_notification_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.syncml.dm.notification"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_syncml_ds_notification_application;
impl MimeTypeChecker for T_vnd_syncml_ds_notification_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.syncml.ds.notification"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_tao_intent_module_archive_application;
impl MimeTypeChecker for T_vnd_tao_intent_module_archive_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.tao.intent-module-archive"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.tao"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_tmobile_livetv_application;
impl MimeTypeChecker for T_vnd_tmobile_livetv_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.tmobile-livetv"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.tmo"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_trid_tpt_application;
impl MimeTypeChecker for T_vnd_trid_tpt_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.trid.tpt"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.tpt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_triscape_mxs_application;
impl MimeTypeChecker for T_vnd_triscape_mxs_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.triscape.mxs"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mxs"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_trueapp_application;
impl MimeTypeChecker for T_vnd_trueapp_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.trueapp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.tra"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_truedoc_application;
impl MimeTypeChecker for T_vnd_truedoc_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.truedoc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ufdl_application;
impl MimeTypeChecker for T_vnd_ufdl_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ufdl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ufd", "*.ufdl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_ttml_xml_application;
impl MimeTypeChecker for T_ttml_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/ttml+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ttml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml(bytes, "tt", "http://www.w3.org/ns/ttml")
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_uiq_theme_application;
impl MimeTypeChecker for T_vnd_uiq_theme_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.uiq.theme"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.utz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_umajin_application;
impl MimeTypeChecker for T_vnd_umajin_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.umajin"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.umj"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_unity_application;
impl MimeTypeChecker for T_vnd_unity_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.unity"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.unityweb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_uoml_xml_application;
impl MimeTypeChecker for T_vnd_uoml_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.uoml+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.uoml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_uplanet_alert_application;
impl MimeTypeChecker for T_vnd_uplanet_alert_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.uplanet.alert"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_uplanet_alert_wbxml_application;
impl MimeTypeChecker for T_vnd_uplanet_alert_wbxml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.uplanet.alert-wbxml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_uplanet_bearer_choice_application;
impl MimeTypeChecker for T_vnd_uplanet_bearer_choice_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.uplanet.bearer-choice"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_uplanet_bearer_choice_wbxml_application;
impl MimeTypeChecker for T_vnd_uplanet_bearer_choice_wbxml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.uplanet.bearer-choice-wbxml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_uplanet_cacheop_application;
impl MimeTypeChecker for T_vnd_uplanet_cacheop_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.uplanet.cacheop"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_uplanet_cacheop_wbxml_application;
impl MimeTypeChecker for T_vnd_uplanet_cacheop_wbxml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.uplanet.cacheop-wbxml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_uplanet_channel_application;
impl MimeTypeChecker for T_vnd_uplanet_channel_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.uplanet.channel"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_uplanet_channel_wbxml_application;
impl MimeTypeChecker for T_vnd_uplanet_channel_wbxml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.uplanet.channel-wbxml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_uplanet_list_application;
impl MimeTypeChecker for T_vnd_uplanet_list_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.uplanet.list"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_uplanet_list_wbxml_application;
impl MimeTypeChecker for T_vnd_uplanet_list_wbxml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.uplanet.list-wbxml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_uplanet_listcmd_application;
impl MimeTypeChecker for T_vnd_uplanet_listcmd_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.uplanet.listcmd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_uplanet_listcmd_wbxml_application;
impl MimeTypeChecker for T_vnd_uplanet_listcmd_wbxml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.uplanet.listcmd-wbxml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_uplanet_signal_application;
impl MimeTypeChecker for T_vnd_uplanet_signal_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.uplanet.signal"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_vcx_application;
impl MimeTypeChecker for T_vnd_vcx_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.vcx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vcx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_vd_study_application;
impl MimeTypeChecker for T_vnd_vd_study_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.vd-study"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_vectorworks_application;
impl MimeTypeChecker for T_vnd_vectorworks_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.vectorworks"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_vidsoft_vidconference_application;
impl MimeTypeChecker for T_vnd_vidsoft_vidconference_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.vidsoft.vidconference"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_visio_application;
impl MimeTypeChecker for T_vnd_visio_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.visio"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vsd", "*.vst", "*.vss", "*.vsw"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_visio_drawing_application;
impl MimeTypeChecker for T_vnd_ms_visio_drawing_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-visio.drawing"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vsdx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_visio_template_application;
impl MimeTypeChecker for T_vnd_ms_visio_template_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-visio.template"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vstx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_visio_stencil_application;
impl MimeTypeChecker for T_vnd_ms_visio_stencil_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-visio.stencil"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vssx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_visio_drawing_macroEnabled_12_application;
impl MimeTypeChecker for T_vnd_ms_visio_drawing_macroEnabled_12_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-visio.drawing.macroEnabled.12"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vsdm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_visio_template_macroEnabled_12_application;
impl MimeTypeChecker for T_vnd_ms_visio_template_macroEnabled_12_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-visio.template.macroEnabled.12"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vstm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_visio_stencil_macroEnabled_12_application;
impl MimeTypeChecker for T_vnd_ms_visio_stencil_macroEnabled_12_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.ms-visio.stencil.macroEnabled.12"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vssm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_visionary_application;
impl MimeTypeChecker for T_vnd_visionary_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.visionary"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vis"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_vividence_scriptfile_application;
impl MimeTypeChecker for T_vnd_vividence_scriptfile_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.vividence.scriptfile"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_vsf_application;
impl MimeTypeChecker for T_vnd_vsf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.vsf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vsf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wap_sic_application;
impl MimeTypeChecker for T_vnd_wap_sic_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wap.sic"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wap_slc_application;
impl MimeTypeChecker for T_vnd_wap_slc_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wap.slc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wap_wbxml_application;
impl MimeTypeChecker for T_vnd_wap_wbxml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wap.wbxml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wbxml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wap_wmlc_application;
impl MimeTypeChecker for T_vnd_wap_wmlc_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wap.wmlc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wmlc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wap_wmlscriptc_application;
impl MimeTypeChecker for T_vnd_wap_wmlscriptc_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wap.wmlscriptc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wmlsc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_webturbo_application;
impl MimeTypeChecker for T_vnd_webturbo_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.webturbo"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wtb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wfa_wsc_application;
impl MimeTypeChecker for T_vnd_wfa_wsc_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wfa.wsc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wmc_application;
impl MimeTypeChecker for T_vnd_wmc_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wmc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wmf_bootstrap_application;
impl MimeTypeChecker for T_vnd_wmf_bootstrap_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wmf.bootstrap"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wqd_application;
impl MimeTypeChecker for T_vnd_wqd_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wqd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wqd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wrq_hp3000_labelled_application;
impl MimeTypeChecker for T_vnd_wrq_hp3000_labelled_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wrq-hp3000-labelled"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wt_stf_application;
impl MimeTypeChecker for T_vnd_wt_stf_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wt.stf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.stf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wv_csp_wbxml_application;
impl MimeTypeChecker for T_vnd_wv_csp_wbxml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wv.csp+wbxml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wv_csp_xml_application;
impl MimeTypeChecker for T_vnd_wv_csp_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wv.csp+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wv_ssp_xml_application;
impl MimeTypeChecker for T_vnd_wv_ssp_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.wv.ssp+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_xfdl_application;
impl MimeTypeChecker for T_vnd_xfdl_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.xfdl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xfdl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_xfdl_webform_application;
impl MimeTypeChecker for T_vnd_xfdl_webform_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.xfdl.webform"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_xmi_xml_application;
impl MimeTypeChecker for T_vnd_xmi_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.xmi+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_xmpie_cpkg_application;
impl MimeTypeChecker for T_vnd_xmpie_cpkg_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.xmpie.cpkg"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_xmpie_dpkg_application;
impl MimeTypeChecker for T_vnd_xmpie_dpkg_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.xmpie.dpkg"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_xmpie_plan_application;
impl MimeTypeChecker for T_vnd_xmpie_plan_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.xmpie.plan"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_xmpie_ppkg_application;
impl MimeTypeChecker for T_vnd_xmpie_ppkg_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.xmpie.ppkg"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_xmpie_xlim_application;
impl MimeTypeChecker for T_vnd_xmpie_xlim_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.xmpie.xlim"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_yamaha_hv_dic_application;
impl MimeTypeChecker for T_vnd_yamaha_hv_dic_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.yamaha.hv-dic"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.hvd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_yamaha_hv_script_application;
impl MimeTypeChecker for T_vnd_yamaha_hv_script_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.yamaha.hv-script"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.hvs"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_yamaha_hv_voice_application;
impl MimeTypeChecker for T_vnd_yamaha_hv_voice_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.yamaha.hv-voice"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.hvp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_yamaha_openscoreformat_application;
impl MimeTypeChecker for T_vnd_yamaha_openscoreformat_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.yamaha.openscoreformat"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.osf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_yamaha_openscoreformat_osfpvg_xml_application;
impl MimeTypeChecker for T_vnd_yamaha_openscoreformat_osfpvg_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.yamaha.openscoreformat.osfpvg+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.osfpvg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_yamaha_smaf_audio_application;
impl MimeTypeChecker for T_vnd_yamaha_smaf_audio_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.yamaha.smaf-audio"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.saf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_yamaha_smaf_phrase_application;
impl MimeTypeChecker for T_vnd_yamaha_smaf_phrase_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.yamaha.smaf-phrase"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.spf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_yellowriver_custom_menu_application;
impl MimeTypeChecker for T_vnd_yellowriver_custom_menu_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.yellowriver-custom-menu"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cmp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_zul_application;
impl MimeTypeChecker for T_vnd_zul_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.zul"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.zir", "*.zirz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_zzazz_deck_xml_application;
impl MimeTypeChecker for T_vnd_zzazz_deck_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.zzazz.deck+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.zaz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_voicexml_xml_application;
impl MimeTypeChecker for T_voicexml_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/voicexml+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vxml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_warc_gz_application;
impl MimeTypeChecker for T_warc_gz_application {
    fn get_mime(&self) -> &'static str {
        "application/warc+gz"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.warc.gz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_watcherinfo_xml_application;
impl MimeTypeChecker for T_watcherinfo_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/watcherinfo+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_whoispp_query_application;
impl MimeTypeChecker for T_whoispp_query_application {
    fn get_mime(&self) -> &'static str {
        "application/whoispp-query"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_whoispp_response_application;
impl MimeTypeChecker for T_whoispp_response_application {
    fn get_mime(&self) -> &'static str {
        "application/whoispp-response"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_winhlp_application;
impl MimeTypeChecker for T_winhlp_application {
    fn get_mime(&self) -> &'static str {
        "application/winhlp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.hlp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_wita_application;
impl MimeTypeChecker for T_wita_application {
    fn get_mime(&self) -> &'static str {
        "application/wita"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_wordperfect5_1_application;
impl MimeTypeChecker for T_wordperfect5_1_application {
    fn get_mime(&self) -> &'static str {
        "application/wordperfect5.1"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_wsdl_xml_application;
impl MimeTypeChecker for T_wsdl_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/wsdl+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wsdl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_wspolicy_xml_application;
impl MimeTypeChecker for T_wspolicy_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/wspolicy+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wspolicy"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_abiword_application;
impl MimeTypeChecker for T_x_abiword_application {
    fn get_mime(&self) -> &'static str {
        "application/x-abiword"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.abw"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ace_compressed_application;
impl MimeTypeChecker for T_x_ace_compressed_application {
    fn get_mime(&self) -> &'static str {
        "application/x-ace-compressed"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ace"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_amf_application;
impl MimeTypeChecker for T_x_amf_application {
    fn get_mime(&self) -> &'static str {
        "application/x-amf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.amf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml_local(bytes, "amf")
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_apple_diskimage_application;
impl MimeTypeChecker for T_x_apple_diskimage_application {
    fn get_mime(&self) -> &'static str {
        "application/x-apple-diskimage"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dmg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_appleworks_application;
impl MimeTypeChecker for T_x_appleworks_application {
    fn get_mime(&self) -> &'static str {
        "application/x-appleworks"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cwk"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_authorware_bin_application;
impl MimeTypeChecker for T_x_authorware_bin_application {
    fn get_mime(&self) -> &'static str {
        "application/x-authorware-bin"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.aab", "*.x32", "*.u32", "*.vox"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_authorware_map_application;
impl MimeTypeChecker for T_x_authorware_map_application {
    fn get_mime(&self) -> &'static str {
        "application/x-authorware-map"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.aam"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_authorware_seg_application;
impl MimeTypeChecker for T_x_authorware_seg_application {
    fn get_mime(&self) -> &'static str {
        "application/x-authorware-seg"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.aas"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_bcpio_application;
impl MimeTypeChecker for T_x_bcpio_application {
    fn get_mime(&self) -> &'static str {
        "application/x-bcpio"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.bcpio"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_plist_application;
impl MimeTypeChecker for T_x_plist_application {
    fn get_mime(&self) -> &'static str {
        "application/x-plist"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml_local(bytes, "plist")
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_brotli_application;
impl MimeTypeChecker for T_x_brotli_application {
    fn get_mime(&self) -> &'static str {
        "application/x-brotli"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.br", "*.brotli"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_cdlink_application;
impl MimeTypeChecker for T_x_cdlink_application {
    fn get_mime(&self) -> &'static str {
        "application/x-cdlink"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vcd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_chat_application;
impl MimeTypeChecker for T_x_chat_application {
    fn get_mime(&self) -> &'static str {
        "application/x-chat"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.chat"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_chess_pgn_application;
impl MimeTypeChecker for T_x_chess_pgn_application {
    fn get_mime(&self) -> &'static str {
        "application/x-chess-pgn"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pgn"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_corelpresentations_application;
impl MimeTypeChecker for T_x_corelpresentations_application {
    fn get_mime(&self) -> &'static str {
        "application/x-corelpresentations"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.shw"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_csh_application;
impl MimeTypeChecker for T_x_csh_application {
    fn get_mime(&self) -> &'static str {
        "application/x-csh"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.csh", "*.tcsh"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_director_application;
impl MimeTypeChecker for T_x_director_application {
    fn get_mime(&self) -> &'static str {
        "application/x-director"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[
            "*.dir", "*.dcr", "*.dxr", "*.cst", "*.cct", "*.cxt", "*.w3d", "*.fgd", "*.swa",
        ]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_doom_application;
impl MimeTypeChecker for T_x_doom_application {
    fn get_mime(&self) -> &'static str {
        "application/x-doom"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wad"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_dtbncx_xml_application;
impl MimeTypeChecker for T_x_dtbncx_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/x-dtbncx+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ncx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_dtbook_xml_application;
impl MimeTypeChecker for T_x_dtbook_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/x-dtbook+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dtb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_dtbresource_xml_application;
impl MimeTypeChecker for T_x_dtbresource_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/x-dtbresource+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.res"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_killustrator_application;
impl MimeTypeChecker for T_x_killustrator_application {
    fn get_mime(&self) -> &'static str {
        "application/x-killustrator"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.kil"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_openscad_application;
impl MimeTypeChecker for T_x_openscad_application {
    fn get_mime(&self) -> &'static str {
        "application/x-openscad"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.scad"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_dosexec_application;
impl MimeTypeChecker for T_x_dosexec_application {
    fn get_mime(&self) -> &'static str {
        "application/x-dosexec"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.exe"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_font_bdf_application;
impl MimeTypeChecker for T_x_font_bdf_application {
    fn get_mime(&self) -> &'static str {
        "application/x-font-bdf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.bdf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_font_dos_application;
impl MimeTypeChecker for T_x_font_dos_application {
    fn get_mime(&self) -> &'static str {
        "application/x-font-dos"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_font_framemaker_application;
impl MimeTypeChecker for T_x_font_framemaker_application {
    fn get_mime(&self) -> &'static str {
        "application/x-font-framemaker"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_font_ghostscript_application;
impl MimeTypeChecker for T_x_font_ghostscript_application {
    fn get_mime(&self) -> &'static str {
        "application/x-font-ghostscript"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gsf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_font_libgrx_application;
impl MimeTypeChecker for T_x_font_libgrx_application {
    fn get_mime(&self) -> &'static str {
        "application/x-font-libgrx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_font_linux_psf_application;
impl MimeTypeChecker for T_x_font_linux_psf_application {
    fn get_mime(&self) -> &'static str {
        "application/x-font-linux-psf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.psf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_font_pcf_application;
impl MimeTypeChecker for T_x_font_pcf_application {
    fn get_mime(&self) -> &'static str {
        "application/x-font-pcf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pcf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_font_snf_application;
impl MimeTypeChecker for T_x_font_snf_application {
    fn get_mime(&self) -> &'static str {
        "application/x-font-snf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.snf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_font_speedo_application;
impl MimeTypeChecker for T_x_font_speedo_application {
    fn get_mime(&self) -> &'static str {
        "application/x-font-speedo"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_font_sunos_news_application;
impl MimeTypeChecker for T_x_font_sunos_news_application {
    fn get_mime(&self) -> &'static str {
        "application/x-font-sunos-news"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_font_vfont_application;
impl MimeTypeChecker for T_x_font_vfont_application {
    fn get_mime(&self) -> &'static str {
        "application/x-font-vfont"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_futuresplash_application;
impl MimeTypeChecker for T_x_futuresplash_application {
    fn get_mime(&self) -> &'static str {
        "application/x-futuresplash"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.spl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_gnucash_application;
impl MimeTypeChecker for T_x_gnucash_application {
    fn get_mime(&self) -> &'static str {
        "application/x-gnucash"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gnucash"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_esri_layer_application;
impl MimeTypeChecker for T_x_esri_layer_application {
    fn get_mime(&self) -> &'static str {
        "application/x-esri-layer"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.lyr"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_hwp_v5_application;
impl MimeTypeChecker for T_x_hwp_v5_application {
    fn get_mime(&self) -> &'static str {
        "application/x-hwp-v5"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_hwp_zip_application;
impl MimeTypeChecker for T_hwp_zip_application {
    fn get_mime(&self) -> &'static str {
        "application/hwp+zip"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.hwpx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_itunes_bplist_application;
impl MimeTypeChecker for T_x_itunes_bplist_application {
    fn get_mime(&self) -> &'static str {
        "application/x-itunes-bplist"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_itunes_ipa_application;
impl MimeTypeChecker for T_x_itunes_ipa_application {
    fn get_mime(&self) -> &'static str {
        "application/x-itunes-ipa"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ipa"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_java_jnlp_file_application;
impl MimeTypeChecker for T_x_java_jnlp_file_application {
    fn get_mime(&self) -> &'static str {
        "application/x-java-jnlp-file"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jnlp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_java_pack200_application;
impl MimeTypeChecker for T_x_java_pack200_application {
    fn get_mime(&self) -> &'static str {
        "application/x-java-pack200"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pack"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_lzma_application;
impl MimeTypeChecker for T_x_lzma_application {
    fn get_mime(&self) -> &'static str {
        "application/x-lzma"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.lzma"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_memgraph_application;
impl MimeTypeChecker for T_x_memgraph_application {
    fn get_mime(&self) -> &'static str {
        "application/x-memgraph"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.memgraph"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ms_application_application;
impl MimeTypeChecker for T_x_ms_application_application {
    fn get_mime(&self) -> &'static str {
        "application/x-ms-application"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.application"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ms_wmd_application;
impl MimeTypeChecker for T_x_ms_wmd_application {
    fn get_mime(&self) -> &'static str {
        "application/x-ms-wmd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wmd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ms_wmz_application;
impl MimeTypeChecker for T_x_ms_wmz_application {
    fn get_mime(&self) -> &'static str {
        "application/x-ms-wmz"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wmz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ms_xbap_application;
impl MimeTypeChecker for T_x_ms_xbap_application {
    fn get_mime(&self) -> &'static str {
        "application/x-ms-xbap"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xbap"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_msbinder_application;
impl MimeTypeChecker for T_x_msbinder_application {
    fn get_mime(&self) -> &'static str {
        "application/x-msbinder"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.obd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mscardfile_application;
impl MimeTypeChecker for T_x_mscardfile_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mscardfile"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.crd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_msclip_application;
impl MimeTypeChecker for T_x_msclip_application {
    fn get_mime(&self) -> &'static str {
        "application/x-msclip"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.clp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ms_installer_application;
impl MimeTypeChecker for T_x_ms_installer_application {
    fn get_mime(&self) -> &'static str {
        "application/x-ms-installer"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.msi", "*.msp", "*.mst"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_msmediaview_application;
impl MimeTypeChecker for T_x_msmediaview_application {
    fn get_mime(&self) -> &'static str {
        "application/x-msmediaview"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mvb", "*.m13", "*.m14"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mspublisher_application;
impl MimeTypeChecker for T_x_mspublisher_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mspublisher"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pub"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_msschedule_application;
impl MimeTypeChecker for T_x_msschedule_application {
    fn get_mime(&self) -> &'static str {
        "application/x-msschedule"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.scd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_msterminal_application;
impl MimeTypeChecker for T_x_msterminal_application {
    fn get_mime(&self) -> &'static str {
        "application/x-msterminal"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.trm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_mysql_misam_data_application;
impl MimeTypeChecker for T_x_mysql_misam_data_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mysql-misam-data"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.MYD"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_pds_application;
impl MimeTypeChecker for T_x_pds_application {
    fn get_mime(&self) -> &'static str {
        "application/x-pds"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[80, 68, 83, 95, 86, 69, 82, 83, 73, 79, 78, 95, 73, 68],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_pkcs12_application;
impl MimeTypeChecker for T_x_pkcs12_application {
    fn get_mime(&self) -> &'static str {
        "application/x-pkcs12"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.p12", "*.pfx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_pkcs7_certificates_application;
impl MimeTypeChecker for T_x_pkcs7_certificates_application {
    fn get_mime(&self) -> &'static str {
        "application/x-pkcs7-certificates"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.p7b", "*.spc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_pkcs7_certreqresp_application;
impl MimeTypeChecker for T_x_pkcs7_certreqresp_application {
    fn get_mime(&self) -> &'static str {
        "application/x-pkcs7-certreqresp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.p7r"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_xquery_application;
impl MimeTypeChecker for T_xquery_application {
    fn get_mime(&self) -> &'static str {
        "application/xquery"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xq", "*.xquery"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_roxio_toast_application;
impl MimeTypeChecker for T_x_roxio_toast_application {
    fn get_mime(&self) -> &'static str {
        "application/x-roxio-toast"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.toast"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sas_application;
impl MimeTypeChecker for T_x_sas_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sas"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sas"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sas_program_data_application;
impl MimeTypeChecker for T_x_sas_program_data_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sas-program-data"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ss7", "*.sas7bpgm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sas_audit_application;
impl MimeTypeChecker for T_x_sas_audit_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sas-audit"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.st7", "*.sas7baud"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sas_view_application;
impl MimeTypeChecker for T_x_sas_view_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sas-view"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sv7", "*.sas7bvew"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sas_data_index_application;
impl MimeTypeChecker for T_x_sas_data_index_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sas-data-index"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.si7", "*.sas7bndx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sas_catalog_application;
impl MimeTypeChecker for T_x_sas_catalog_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sas-catalog"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sc7", "*.sas7bcat"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sas_access_application;
impl MimeTypeChecker for T_x_sas_access_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sas-access"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sa7", "*.sas7bacs"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sas_fdb_application;
impl MimeTypeChecker for T_x_sas_fdb_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sas-fdb"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sf7", "*.sas7bfdb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sas_mddb_application;
impl MimeTypeChecker for T_x_sas_mddb_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sas-mddb"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sm7", "*.sas7bmdb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sas_dmdb_application;
impl MimeTypeChecker for T_x_sas_dmdb_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sas-dmdb"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.s7m", "*.sas7bdmd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sas_itemstor_application;
impl MimeTypeChecker for T_x_sas_itemstor_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sas-itemstor"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sr7", "*.sas7bitm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sas_utility_application;
impl MimeTypeChecker for T_x_sas_utility_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sas-utility"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.su7", "*.sas7butl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sas_putility_application;
impl MimeTypeChecker for T_x_sas_putility_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sas-putility"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sp7", "*.sas7bput"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sas_transport_application;
impl MimeTypeChecker for T_x_sas_transport_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sas-transport"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.stx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sas_backup_application;
impl MimeTypeChecker for T_x_sas_backup_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sas-backup"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sas7bbak"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_shar_application;
impl MimeTypeChecker for T_x_shar_application {
    fn get_mime(&self) -> &'static str {
        "application/x-shar"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.shar"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_silverlight_app_application;
impl MimeTypeChecker for T_x_silverlight_app_application {
    fn get_mime(&self) -> &'static str {
        "application/x-silverlight-app"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xap"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sfdu_application;
impl MimeTypeChecker for T_x_sfdu_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sfdu"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sfdu"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_stata_do_application;
impl MimeTypeChecker for T_x_stata_do_application {
    fn get_mime(&self) -> &'static str {
        "application/x-stata-do"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.do"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_stuffitx_application;
impl MimeTypeChecker for T_x_stuffitx_application {
    fn get_mime(&self) -> &'static str {
        "application/x-stuffitx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sitx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sv4cpio_application;
impl MimeTypeChecker for T_x_sv4cpio_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sv4cpio"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sv4cpio"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sv4crc_application;
impl MimeTypeChecker for T_x_sv4crc_application {
    fn get_mime(&self) -> &'static str {
        "application/x-sv4crc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sv4crc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_tex_tfm_application;
impl MimeTypeChecker for T_x_tex_tfm_application {
    fn get_mime(&self) -> &'static str {
        "application/x-tex-tfm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.tfm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_tika_msoffice_embedded_format_ole10_native_application;
impl MimeTypeChecker for T_x_tika_msoffice_embedded_format_ole10_native_application {
    fn get_mime(&self) -> &'static str {
        "application/x-tika-msoffice-embedded;format=ole10_native"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_tika_msoffice_embedded_format_comp_obj_application;
impl MimeTypeChecker for T_x_tika_msoffice_embedded_format_comp_obj_application {
    fn get_mime(&self) -> &'static str {
        "application/x-tika-msoffice-embedded;format=comp_obj"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_tika_ooxml_protected_application;
impl MimeTypeChecker for T_x_tika_ooxml_protected_application {
    fn get_mime(&self) -> &'static str {
        "application/x-tika-ooxml-protected"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ustar_application;
impl MimeTypeChecker for T_x_ustar_application {
    fn get_mime(&self) -> &'static str {
        "application/x-ustar"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ustar"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_vmdk_application;
impl MimeTypeChecker for T_x_vmdk_application {
    fn get_mime(&self) -> &'static str {
        "application/x-vmdk"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vmdk"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_wais_source_application;
impl MimeTypeChecker for T_x_wais_source_application {
    fn get_mime(&self) -> &'static str {
        "application/x-wais-source"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.src"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_webarchive_application;
impl MimeTypeChecker for T_x_webarchive_application {
    fn get_mime(&self) -> &'static str {
        "application/x-webarchive"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.webarchive"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_xfig_application;
impl MimeTypeChecker for T_x_xfig_application {
    fn get_mime(&self) -> &'static str {
        "application/x-xfig"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fig"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_xpinstall_application;
impl MimeTypeChecker for T_x_xpinstall_application {
    fn get_mime(&self) -> &'static str {
        "application/x-xpinstall"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xpi"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_xmind_application;
impl MimeTypeChecker for T_x_xmind_application {
    fn get_mime(&self) -> &'static str {
        "application/x-xmind"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xmind"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x400_bp_application;
impl MimeTypeChecker for T_x400_bp_application {
    fn get_mime(&self) -> &'static str {
        "application/x400-bp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_xcap_att_xml_application;
impl MimeTypeChecker for T_xcap_att_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/xcap-att+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_xcap_caps_xml_application;
impl MimeTypeChecker for T_xcap_caps_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/xcap-caps+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_xcap_el_xml_application;
impl MimeTypeChecker for T_xcap_el_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/xcap-el+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_xcap_error_xml_application;
impl MimeTypeChecker for T_xcap_error_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/xcap-error+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_xcap_ns_xml_application;
impl MimeTypeChecker for T_xcap_ns_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/xcap-ns+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_xcon_conference_info_diff_xml_application;
impl MimeTypeChecker for T_xcon_conference_info_diff_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/xcon-conference-info-diff+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_xcon_conference_info_xml_application;
impl MimeTypeChecker for T_xcon_conference_info_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/xcon-conference-info+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_xenc_xml_application;
impl MimeTypeChecker for T_xenc_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/xenc+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xenc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_xhtml_voice_xml_application;
impl MimeTypeChecker for T_xhtml_voice_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/xhtml-voice+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_xml_dtd_application;
impl MimeTypeChecker for T_xml_dtd_application {
    fn get_mime(&self) -> &'static str {
        "application/xml-dtd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dtd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_xml_external_parsed_entity_application;
impl MimeTypeChecker for T_xml_external_parsed_entity_application {
    fn get_mime(&self) -> &'static str {
        "application/xml-external-parsed-entity"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_xmpp_xml_application;
impl MimeTypeChecker for T_xmpp_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/xmpp+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_xop_xml_application;
impl MimeTypeChecker for T_xop_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/xop+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xop"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_xslfo_xml_application;
impl MimeTypeChecker for T_xslfo_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/xslfo+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xslfo", "*.fo"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml(bytes, "root", "http://www.w3.org/1999/XSL/Format")
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_xslt_xml_application;
impl MimeTypeChecker for T_xslt_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/xslt+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xslt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml(bytes, "stylesheet", "http://www.w3.org/1999/XSL/Transform")
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_xspf_xml_application;
impl MimeTypeChecker for T_xspf_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/xspf+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xspf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml(bytes, "playlist", "http://xspf.org/ns/0/")
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_xv_xml_application;
impl MimeTypeChecker for T_xv_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/xv+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mxml", "*.xhvml", "*.xvml", "*.xvm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_32kadpcm_audio;
impl MimeTypeChecker for T_32kadpcm_audio {
    fn get_mime(&self) -> &'static str {
        "audio/32kadpcm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_adpcm_audio;
impl MimeTypeChecker for T_adpcm_audio {
    fn get_mime(&self) -> &'static str {
        "audio/adpcm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.adp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_amr_wb__audio;
impl MimeTypeChecker for T_amr_wb__audio {
    fn get_mime(&self) -> &'static str {
        "audio/amr-wb+"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_asc_audio;
impl MimeTypeChecker for T_asc_audio {
    fn get_mime(&self) -> &'static str {
        "audio/asc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_bv16_audio;
impl MimeTypeChecker for T_bv16_audio {
    fn get_mime(&self) -> &'static str {
        "audio/bv16"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_bv32_audio;
impl MimeTypeChecker for T_bv32_audio {
    fn get_mime(&self) -> &'static str {
        "audio/bv32"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_clearmode_audio;
impl MimeTypeChecker for T_clearmode_audio {
    fn get_mime(&self) -> &'static str {
        "audio/clearmode"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_cn_audio;
impl MimeTypeChecker for T_cn_audio {
    fn get_mime(&self) -> &'static str {
        "audio/cn"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dat12_audio;
impl MimeTypeChecker for T_dat12_audio {
    fn get_mime(&self) -> &'static str {
        "audio/dat12"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dls_audio;
impl MimeTypeChecker for T_dls_audio {
    fn get_mime(&self) -> &'static str {
        "audio/dls"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dsr_es201108_audio;
impl MimeTypeChecker for T_dsr_es201108_audio {
    fn get_mime(&self) -> &'static str {
        "audio/dsr-es201108"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dsr_es202050_audio;
impl MimeTypeChecker for T_dsr_es202050_audio {
    fn get_mime(&self) -> &'static str {
        "audio/dsr-es202050"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dsr_es202211_audio;
impl MimeTypeChecker for T_dsr_es202211_audio {
    fn get_mime(&self) -> &'static str {
        "audio/dsr-es202211"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dsr_es202212_audio;
impl MimeTypeChecker for T_dsr_es202212_audio {
    fn get_mime(&self) -> &'static str {
        "audio/dsr-es202212"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dvi4_audio;
impl MimeTypeChecker for T_dvi4_audio {
    fn get_mime(&self) -> &'static str {
        "audio/dvi4"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_evrc_audio;
impl MimeTypeChecker for T_evrc_audio {
    fn get_mime(&self) -> &'static str {
        "audio/evrc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_evrc_qcp_audio;
impl MimeTypeChecker for T_evrc_qcp_audio {
    fn get_mime(&self) -> &'static str {
        "audio/evrc-qcp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_evrc0_audio;
impl MimeTypeChecker for T_evrc0_audio {
    fn get_mime(&self) -> &'static str {
        "audio/evrc0"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_evrc1_audio;
impl MimeTypeChecker for T_evrc1_audio {
    fn get_mime(&self) -> &'static str {
        "audio/evrc1"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_evrcb_audio;
impl MimeTypeChecker for T_evrcb_audio {
    fn get_mime(&self) -> &'static str {
        "audio/evrcb"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_evrcb0_audio;
impl MimeTypeChecker for T_evrcb0_audio {
    fn get_mime(&self) -> &'static str {
        "audio/evrcb0"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_evrcb1_audio;
impl MimeTypeChecker for T_evrcb1_audio {
    fn get_mime(&self) -> &'static str {
        "audio/evrcb1"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_evrcwb_audio;
impl MimeTypeChecker for T_evrcwb_audio {
    fn get_mime(&self) -> &'static str {
        "audio/evrcwb"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_evrcwb0_audio;
impl MimeTypeChecker for T_evrcwb0_audio {
    fn get_mime(&self) -> &'static str {
        "audio/evrcwb0"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_evrcwb1_audio;
impl MimeTypeChecker for T_evrcwb1_audio {
    fn get_mime(&self) -> &'static str {
        "audio/evrcwb1"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_example_audio;
impl MimeTypeChecker for T_example_audio {
    fn get_mime(&self) -> &'static str {
        "audio/example"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_g719_audio;
impl MimeTypeChecker for T_g719_audio {
    fn get_mime(&self) -> &'static str {
        "audio/g719"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_g722_audio;
impl MimeTypeChecker for T_g722_audio {
    fn get_mime(&self) -> &'static str {
        "audio/g722"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_g7221_audio;
impl MimeTypeChecker for T_g7221_audio {
    fn get_mime(&self) -> &'static str {
        "audio/g7221"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_g723_audio;
impl MimeTypeChecker for T_g723_audio {
    fn get_mime(&self) -> &'static str {
        "audio/g723"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_g726_16_audio;
impl MimeTypeChecker for T_g726_16_audio {
    fn get_mime(&self) -> &'static str {
        "audio/g726-16"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_g726_24_audio;
impl MimeTypeChecker for T_g726_24_audio {
    fn get_mime(&self) -> &'static str {
        "audio/g726-24"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_g726_32_audio;
impl MimeTypeChecker for T_g726_32_audio {
    fn get_mime(&self) -> &'static str {
        "audio/g726-32"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_g726_40_audio;
impl MimeTypeChecker for T_g726_40_audio {
    fn get_mime(&self) -> &'static str {
        "audio/g726-40"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_g728_audio;
impl MimeTypeChecker for T_g728_audio {
    fn get_mime(&self) -> &'static str {
        "audio/g728"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_g729_audio;
impl MimeTypeChecker for T_g729_audio {
    fn get_mime(&self) -> &'static str {
        "audio/g729"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_g7291_audio;
impl MimeTypeChecker for T_g7291_audio {
    fn get_mime(&self) -> &'static str {
        "audio/g7291"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_g729d_audio;
impl MimeTypeChecker for T_g729d_audio {
    fn get_mime(&self) -> &'static str {
        "audio/g729d"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_g729e_audio;
impl MimeTypeChecker for T_g729e_audio {
    fn get_mime(&self) -> &'static str {
        "audio/g729e"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_gsm_audio;
impl MimeTypeChecker for T_gsm_audio {
    fn get_mime(&self) -> &'static str {
        "audio/gsm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_gsm_efr_audio;
impl MimeTypeChecker for T_gsm_efr_audio {
    fn get_mime(&self) -> &'static str {
        "audio/gsm-efr"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_ilbc_audio;
impl MimeTypeChecker for T_ilbc_audio {
    fn get_mime(&self) -> &'static str {
        "audio/ilbc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_l16_audio;
impl MimeTypeChecker for T_l16_audio {
    fn get_mime(&self) -> &'static str {
        "audio/l16"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_l20_audio;
impl MimeTypeChecker for T_l20_audio {
    fn get_mime(&self) -> &'static str {
        "audio/l20"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_l24_audio;
impl MimeTypeChecker for T_l24_audio {
    fn get_mime(&self) -> &'static str {
        "audio/l24"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_l8_audio;
impl MimeTypeChecker for T_l8_audio {
    fn get_mime(&self) -> &'static str {
        "audio/l8"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_lpc_audio;
impl MimeTypeChecker for T_lpc_audio {
    fn get_mime(&self) -> &'static str {
        "audio/lpc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mobile_xmf_audio;
impl MimeTypeChecker for T_mobile_xmf_audio {
    fn get_mime(&self) -> &'static str {
        "audio/mobile-xmf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mp4a_latm_audio;
impl MimeTypeChecker for T_mp4a_latm_audio {
    fn get_mime(&self) -> &'static str {
        "audio/mp4a-latm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mpa_audio;
impl MimeTypeChecker for T_mpa_audio {
    fn get_mime(&self) -> &'static str {
        "audio/mpa"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mpa_robust_audio;
impl MimeTypeChecker for T_mpa_robust_audio {
    fn get_mime(&self) -> &'static str {
        "audio/mpa-robust"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mpeg4_generic_audio;
impl MimeTypeChecker for T_mpeg4_generic_audio {
    fn get_mime(&self) -> &'static str {
        "audio/mpeg4-generic"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_parityfec_audio;
impl MimeTypeChecker for T_parityfec_audio {
    fn get_mime(&self) -> &'static str {
        "audio/parityfec"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pcma_audio;
impl MimeTypeChecker for T_pcma_audio {
    fn get_mime(&self) -> &'static str {
        "audio/pcma"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pcma_wb_audio;
impl MimeTypeChecker for T_pcma_wb_audio {
    fn get_mime(&self) -> &'static str {
        "audio/pcma-wb"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pcmu_wb_audio;
impl MimeTypeChecker for T_pcmu_wb_audio {
    fn get_mime(&self) -> &'static str {
        "audio/pcmu-wb"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pcmu_audio;
impl MimeTypeChecker for T_pcmu_audio {
    fn get_mime(&self) -> &'static str {
        "audio/pcmu"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_red_audio;
impl MimeTypeChecker for T_red_audio {
    fn get_mime(&self) -> &'static str {
        "audio/red"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_rtp_enc_aescm128_audio;
impl MimeTypeChecker for T_rtp_enc_aescm128_audio {
    fn get_mime(&self) -> &'static str {
        "audio/rtp-enc-aescm128"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_rtp_midi_audio;
impl MimeTypeChecker for T_rtp_midi_audio {
    fn get_mime(&self) -> &'static str {
        "audio/rtp-midi"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_rtx_audio;
impl MimeTypeChecker for T_rtx_audio {
    fn get_mime(&self) -> &'static str {
        "audio/rtx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_smv_audio;
impl MimeTypeChecker for T_smv_audio {
    fn get_mime(&self) -> &'static str {
        "audio/smv"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_smv0_audio;
impl MimeTypeChecker for T_smv0_audio {
    fn get_mime(&self) -> &'static str {
        "audio/smv0"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_smv_qcp_audio;
impl MimeTypeChecker for T_smv_qcp_audio {
    fn get_mime(&self) -> &'static str {
        "audio/smv-qcp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_sp_midi_audio;
impl MimeTypeChecker for T_sp_midi_audio {
    fn get_mime(&self) -> &'static str {
        "audio/sp-midi"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_t140c_audio;
impl MimeTypeChecker for T_t140c_audio {
    fn get_mime(&self) -> &'static str {
        "audio/t140c"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_t38_audio;
impl MimeTypeChecker for T_t38_audio {
    fn get_mime(&self) -> &'static str {
        "audio/t38"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_telephone_event_audio;
impl MimeTypeChecker for T_telephone_event_audio {
    fn get_mime(&self) -> &'static str {
        "audio/telephone-event"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_tone_audio;
impl MimeTypeChecker for T_tone_audio {
    fn get_mime(&self) -> &'static str {
        "audio/tone"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_ulpfec_audio;
impl MimeTypeChecker for T_ulpfec_audio {
    fn get_mime(&self) -> &'static str {
        "audio/ulpfec"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vdvi_audio;
impl MimeTypeChecker for T_vdvi_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vdvi"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vmr_wb_audio;
impl MimeTypeChecker for T_vmr_wb_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vmr-wb"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_3gpp_iufp_audio;
impl MimeTypeChecker for T_vnd_3gpp_iufp_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.3gpp.iufp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_4sb_audio;
impl MimeTypeChecker for T_vnd_4sb_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.4sb"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_audiokoz_audio;
impl MimeTypeChecker for T_vnd_audiokoz_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.audiokoz"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_adobe_soundbooth_audio;
impl MimeTypeChecker for T_vnd_adobe_soundbooth_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.adobe.soundbooth"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.asnd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_celp_audio;
impl MimeTypeChecker for T_vnd_celp_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.celp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_cisco_nse_audio;
impl MimeTypeChecker for T_vnd_cisco_nse_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.cisco.nse"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_cmles_radio_events_audio;
impl MimeTypeChecker for T_vnd_cmles_radio_events_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.cmles.radio-events"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_cns_anp1_audio;
impl MimeTypeChecker for T_vnd_cns_anp1_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.cns.anp1"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_cns_inf1_audio;
impl MimeTypeChecker for T_vnd_cns_inf1_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.cns.inf1"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_digital_winds_audio;
impl MimeTypeChecker for T_vnd_digital_winds_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.digital-winds"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.eol"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dlna_adts_audio;
impl MimeTypeChecker for T_vnd_dlna_adts_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.dlna.adts"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dolby_heaac_1_audio;
impl MimeTypeChecker for T_vnd_dolby_heaac_1_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.dolby.heaac.1"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dolby_heaac_2_audio;
impl MimeTypeChecker for T_vnd_dolby_heaac_2_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.dolby.heaac.2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dolby_mlp_audio;
impl MimeTypeChecker for T_vnd_dolby_mlp_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.dolby.mlp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dolby_mps_audio;
impl MimeTypeChecker for T_vnd_dolby_mps_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.dolby.mps"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dolby_pl2_audio;
impl MimeTypeChecker for T_vnd_dolby_pl2_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.dolby.pl2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dolby_pl2x_audio;
impl MimeTypeChecker for T_vnd_dolby_pl2x_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.dolby.pl2x"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dolby_pl2z_audio;
impl MimeTypeChecker for T_vnd_dolby_pl2z_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.dolby.pl2z"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dts_audio;
impl MimeTypeChecker for T_vnd_dts_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.dts"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dts"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dts_hd_audio;
impl MimeTypeChecker for T_vnd_dts_hd_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.dts.hd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dtshd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_everad_plj_audio;
impl MimeTypeChecker for T_vnd_everad_plj_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.everad.plj"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_hns_audio_audio;
impl MimeTypeChecker for T_vnd_hns_audio_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.hns.audio"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_lucent_voice_audio;
impl MimeTypeChecker for T_vnd_lucent_voice_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.lucent.voice"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.lvp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_playready_media_pya_audio;
impl MimeTypeChecker for T_vnd_ms_playready_media_pya_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.ms-playready.media.pya"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pya"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nokia_mobile_xmf_audio;
impl MimeTypeChecker for T_vnd_nokia_mobile_xmf_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.nokia.mobile-xmf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nortel_vbk_audio;
impl MimeTypeChecker for T_vnd_nortel_vbk_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.nortel.vbk"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nuera_ecelp4800_audio;
impl MimeTypeChecker for T_vnd_nuera_ecelp4800_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.nuera.ecelp4800"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ecelp4800"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nuera_ecelp7470_audio;
impl MimeTypeChecker for T_vnd_nuera_ecelp7470_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.nuera.ecelp7470"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ecelp7470"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nuera_ecelp9600_audio;
impl MimeTypeChecker for T_vnd_nuera_ecelp9600_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.nuera.ecelp9600"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ecelp9600"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_octel_sbc_audio;
impl MimeTypeChecker for T_vnd_octel_sbc_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.octel.sbc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_qcelp_audio;
impl MimeTypeChecker for T_vnd_qcelp_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.qcelp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_rhetorex_32kadpcm_audio;
impl MimeTypeChecker for T_vnd_rhetorex_32kadpcm_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.rhetorex.32kadpcm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sealedmedia_softseal_mpeg_audio;
impl MimeTypeChecker for T_vnd_sealedmedia_softseal_mpeg_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.sealedmedia.softseal.mpeg"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_vmx_cvsd_audio;
impl MimeTypeChecker for T_vnd_vmx_cvsd_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vnd.vmx.cvsd"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vorbis_config_audio;
impl MimeTypeChecker for T_vorbis_config_audio {
    fn get_mime(&self) -> &'static str {
        "audio/vorbis-config"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ms_wax_audio;
impl MimeTypeChecker for T_x_ms_wax_audio {
    fn get_mime(&self) -> &'static str {
        "audio/x-ms-wax"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wax"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_pn_realaudio_plugin_audio;
impl MimeTypeChecker for T_x_pn_realaudio_plugin_audio {
    fn get_mime(&self) -> &'static str {
        "audio/x-pn-realaudio-plugin"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rmp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_cif_chemical;
impl MimeTypeChecker for T_x_cif_chemical {
    fn get_mime(&self) -> &'static str {
        "chemical/x-cif"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cif"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_cmdf_chemical;
impl MimeTypeChecker for T_x_cmdf_chemical {
    fn get_mime(&self) -> &'static str {
        "chemical/x-cmdf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cmdf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_cml_chemical;
impl MimeTypeChecker for T_x_cml_chemical {
    fn get_mime(&self) -> &'static str {
        "chemical/x-cml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_csml_chemical;
impl MimeTypeChecker for T_x_csml_chemical {
    fn get_mime(&self) -> &'static str {
        "chemical/x-csml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.csml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_pdb_chemical;
impl MimeTypeChecker for T_x_pdb_chemical {
    fn get_mime(&self) -> &'static str {
        "chemical/x-pdb"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pdb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_xyz_chemical;
impl MimeTypeChecker for T_x_xyz_chemical {
    fn get_mime(&self) -> &'static str {
        "chemical/x-xyz"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xyz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_emf_compressed_image;
impl MimeTypeChecker for T_x_emf_compressed_image {
    fn get_mime(&self) -> &'static str {
        "image/x-emf-compressed"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.emz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_example_image;
impl MimeTypeChecker for T_example_image {
    fn get_mime(&self) -> &'static str {
        "image/example"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_g3fax_image;
impl MimeTypeChecker for T_g3fax_image {
    fn get_mime(&self) -> &'static str {
        "image/g3fax"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.g3"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_ief_image;
impl MimeTypeChecker for T_ief_image {
    fn get_mime(&self) -> &'static str {
        "image/ief"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ief"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_naplps_image;
impl MimeTypeChecker for T_naplps_image {
    fn get_mime(&self) -> &'static str {
        "image/naplps"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_prs_btif_image;
impl MimeTypeChecker for T_prs_btif_image {
    fn get_mime(&self) -> &'static str {
        "image/prs.btif"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.btif"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_prs_pti_image;
impl MimeTypeChecker for T_prs_pti_image {
    fn get_mime(&self) -> &'static str {
        "image/prs.pti"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_t38_image;
impl MimeTypeChecker for T_t38_image {
    fn get_mime(&self) -> &'static str {
        "image/t38"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_tiff_fx_image;
impl MimeTypeChecker for T_tiff_fx_image {
    fn get_mime(&self) -> &'static str {
        "image/tiff-fx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_adobe_premiere_image;
impl MimeTypeChecker for T_vnd_adobe_premiere_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.adobe.premiere"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ppj"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml_local(bytes, "PremiereData")
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_cns_inf2_image;
impl MimeTypeChecker for T_vnd_cns_inf2_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.cns.inf2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dgn_version_8_image;
impl MimeTypeChecker for T_vnd_dgn_version_8_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.dgn;version=8"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fastbidsheet_image;
impl MimeTypeChecker for T_vnd_fastbidsheet_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.fastbidsheet"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fbs"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fpx_image;
impl MimeTypeChecker for T_vnd_fpx_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.fpx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fpx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fst_image;
impl MimeTypeChecker for T_vnd_fst_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.fst"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fst"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fujixerox_edmics_mmr_image;
impl MimeTypeChecker for T_vnd_fujixerox_edmics_mmr_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.fujixerox.edmics-mmr"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mmr"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fujixerox_edmics_rlc_image;
impl MimeTypeChecker for T_vnd_fujixerox_edmics_rlc_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.fujixerox.edmics-rlc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rlc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_globalgraphics_pgb_image;
impl MimeTypeChecker for T_vnd_globalgraphics_pgb_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.globalgraphics.pgb"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mix_image;
impl MimeTypeChecker for T_vnd_mix_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.mix"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_net_fpx_image;
impl MimeTypeChecker for T_vnd_net_fpx_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.net-fpx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.npx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sealed_png_image;
impl MimeTypeChecker for T_vnd_sealed_png_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.sealed.png"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sealedmedia_softseal_gif_image;
impl MimeTypeChecker for T_vnd_sealedmedia_softseal_gif_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.sealedmedia.softseal.gif"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sealedmedia_softseal_jpg_image;
impl MimeTypeChecker for T_vnd_sealedmedia_softseal_jpg_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.sealedmedia.softseal.jpg"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_svf_image;
impl MimeTypeChecker for T_vnd_svf_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.svf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wap_wbmp_image;
impl MimeTypeChecker for T_vnd_wap_wbmp_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.wap.wbmp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wbmp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_xiff_image;
impl MimeTypeChecker for T_vnd_xiff_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.xiff"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xif"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_cmu_raster_image;
impl MimeTypeChecker for T_x_cmu_raster_image {
    fn get_mime(&self) -> &'static str {
        "image/x-cmu-raster"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ras"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_cmx_image;
impl MimeTypeChecker for T_x_cmx_image {
    fn get_mime(&self) -> &'static str {
        "image/x-cmx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cmx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_adobe_image;
impl MimeTypeChecker for T_x_raw_adobe_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-adobe"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dng"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_hasselblad_image;
impl MimeTypeChecker for T_x_raw_hasselblad_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-hasselblad"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.3fr"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_fuji_image;
impl MimeTypeChecker for T_x_raw_fuji_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-fuji"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.raf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_kodak_image;
impl MimeTypeChecker for T_x_raw_kodak_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-kodak"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.k25", "*.kdc", "*.dcs", "*.drf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_minolta_image;
impl MimeTypeChecker for T_x_raw_minolta_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-minolta"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mrw"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_nikon_image;
impl MimeTypeChecker for T_x_raw_nikon_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-nikon"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.nef", "*.nrw"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_pentax_image;
impl MimeTypeChecker for T_x_raw_pentax_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-pentax"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ptx", "*.pef"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_sony_image;
impl MimeTypeChecker for T_x_raw_sony_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-sony"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.arw", "*.srf", "*.sr2"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_sigma_image;
impl MimeTypeChecker for T_x_raw_sigma_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-sigma"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.x3f"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_epson_image;
impl MimeTypeChecker for T_x_raw_epson_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-epson"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.erf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_mamiya_image;
impl MimeTypeChecker for T_x_raw_mamiya_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-mamiya"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mef"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_leaf_image;
impl MimeTypeChecker for T_x_raw_leaf_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-leaf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mos"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_panasonic_image;
impl MimeTypeChecker for T_x_raw_panasonic_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-panasonic"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.raw", "*.rw2"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_phaseone_image;
impl MimeTypeChecker for T_x_raw_phaseone_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-phaseone"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.iiq"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_red_image;
impl MimeTypeChecker for T_x_raw_red_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-red"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.r3d"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_imacon_image;
impl MimeTypeChecker for T_x_raw_imacon_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-imacon"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fff"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_logitech_image;
impl MimeTypeChecker for T_x_raw_logitech_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-logitech"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pxn"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_casio_image;
impl MimeTypeChecker for T_x_raw_casio_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-casio"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.bay"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_raw_rawzor_image;
impl MimeTypeChecker for T_x_raw_rawzor_image {
    fn get_mime(&self) -> &'static str {
        "image/x-raw-rawzor"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rwz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_xwindowdump_image;
impl MimeTypeChecker for T_x_xwindowdump_image {
    fn get_mime(&self) -> &'static str {
        "image/x-xwindowdump"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xwd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_cpim_message;
impl MimeTypeChecker for T_cpim_message {
    fn get_mime(&self) -> &'static str {
        "message/cpim"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_delivery_status_message;
impl MimeTypeChecker for T_delivery_status_message {
    fn get_mime(&self) -> &'static str {
        "message/delivery-status"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_disposition_notification_message;
impl MimeTypeChecker for T_disposition_notification_message {
    fn get_mime(&self) -> &'static str {
        "message/disposition-notification"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_example_message;
impl MimeTypeChecker for T_example_message {
    fn get_mime(&self) -> &'static str {
        "message/example"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_external_body_message;
impl MimeTypeChecker for T_external_body_message {
    fn get_mime(&self) -> &'static str {
        "message/external-body"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_global_message;
impl MimeTypeChecker for T_global_message {
    fn get_mime(&self) -> &'static str {
        "message/global"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_global_delivery_status_message;
impl MimeTypeChecker for T_global_delivery_status_message {
    fn get_mime(&self) -> &'static str {
        "message/global-delivery-status"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_global_disposition_notification_message;
impl MimeTypeChecker for T_global_disposition_notification_message {
    fn get_mime(&self) -> &'static str {
        "message/global-disposition-notification"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_global_headers_message;
impl MimeTypeChecker for T_global_headers_message {
    fn get_mime(&self) -> &'static str {
        "message/global-headers"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_http_message;
impl MimeTypeChecker for T_http_message {
    fn get_mime(&self) -> &'static str {
        "message/http"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_imdn_xml_message;
impl MimeTypeChecker for T_imdn_xml_message {
    fn get_mime(&self) -> &'static str {
        "message/imdn+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_partial_message;
impl MimeTypeChecker for T_partial_message {
    fn get_mime(&self) -> &'static str {
        "message/partial"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_s_http_message;
impl MimeTypeChecker for T_s_http_message {
    fn get_mime(&self) -> &'static str {
        "message/s-http"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_sip_message;
impl MimeTypeChecker for T_sip_message {
    fn get_mime(&self) -> &'static str {
        "message/sip"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_sipfrag_message;
impl MimeTypeChecker for T_sipfrag_message {
    fn get_mime(&self) -> &'static str {
        "message/sipfrag"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_tracking_status_message;
impl MimeTypeChecker for T_tracking_status_message {
    fn get_mime(&self) -> &'static str {
        "message/tracking-status"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_si_simp_message;
impl MimeTypeChecker for T_vnd_si_simp_message {
    fn get_mime(&self) -> &'static str {
        "message/vnd.si.simp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_example_model;
impl MimeTypeChecker for T_example_model {
    fn get_mime(&self) -> &'static str {
        "model/example"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_iges_model;
impl MimeTypeChecker for T_iges_model {
    fn get_mime(&self) -> &'static str {
        "model/iges"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.igs", "*.iges"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mesh_model;
impl MimeTypeChecker for T_mesh_model {
    fn get_mime(&self) -> &'static str {
        "model/mesh"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.msh", "*.mesh", "*.silo"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_stl_binary_model;
impl MimeTypeChecker for T_x_stl_binary_model {
    fn get_mime(&self) -> &'static str {
        "model/x.stl-binary"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.stl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dwfx_xps_model;
impl MimeTypeChecker for T_vnd_dwfx_xps_model {
    fn get_mime(&self) -> &'static str {
        "model/vnd.dwfx+xps"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dwfx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_flatland_3dml_model;
impl MimeTypeChecker for T_vnd_flatland_3dml_model {
    fn get_mime(&self) -> &'static str {
        "model/vnd.flatland.3dml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_gdl_model;
impl MimeTypeChecker for T_vnd_gdl_model {
    fn get_mime(&self) -> &'static str {
        "model/vnd.gdl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gdl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_gs_gdl_model;
impl MimeTypeChecker for T_vnd_gs_gdl_model {
    fn get_mime(&self) -> &'static str {
        "model/vnd.gs-gdl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_gtw_model;
impl MimeTypeChecker for T_vnd_gtw_model {
    fn get_mime(&self) -> &'static str {
        "model/vnd.gtw"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gtw"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_moml_xml_model;
impl MimeTypeChecker for T_vnd_moml_xml_model {
    fn get_mime(&self) -> &'static str {
        "model/vnd.moml+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mts_model;
impl MimeTypeChecker for T_vnd_mts_model {
    fn get_mime(&self) -> &'static str {
        "model/vnd.mts"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mts"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_parasolid_transmit_binary_model;
impl MimeTypeChecker for T_vnd_parasolid_transmit_binary_model {
    fn get_mime(&self) -> &'static str {
        "model/vnd.parasolid.transmit.binary"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_parasolid_transmit_text_model;
impl MimeTypeChecker for T_vnd_parasolid_transmit_text_model {
    fn get_mime(&self) -> &'static str {
        "model/vnd.parasolid.transmit.text"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_vtu_model;
impl MimeTypeChecker for T_vnd_vtu_model {
    fn get_mime(&self) -> &'static str {
        "model/vnd.vtu"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vtu"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vrml_model;
impl MimeTypeChecker for T_vrml_model {
    fn get_mime(&self) -> &'static str {
        "model/vrml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wrl", "*.vrml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_alternative_multipart;
impl MimeTypeChecker for T_alternative_multipart {
    fn get_mime(&self) -> &'static str {
        "multipart/alternative"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_byteranges_multipart;
impl MimeTypeChecker for T_byteranges_multipart {
    fn get_mime(&self) -> &'static str {
        "multipart/byteranges"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_digest_multipart;
impl MimeTypeChecker for T_digest_multipart {
    fn get_mime(&self) -> &'static str {
        "multipart/digest"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_encrypted_multipart;
impl MimeTypeChecker for T_encrypted_multipart {
    fn get_mime(&self) -> &'static str {
        "multipart/encrypted"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_example_multipart;
impl MimeTypeChecker for T_example_multipart {
    fn get_mime(&self) -> &'static str {
        "multipart/example"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_form_data_multipart;
impl MimeTypeChecker for T_form_data_multipart {
    fn get_mime(&self) -> &'static str {
        "multipart/form-data"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_header_set_multipart;
impl MimeTypeChecker for T_header_set_multipart {
    fn get_mime(&self) -> &'static str {
        "multipart/header-set"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mixed_multipart;
impl MimeTypeChecker for T_mixed_multipart {
    fn get_mime(&self) -> &'static str {
        "multipart/mixed"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_parallel_multipart;
impl MimeTypeChecker for T_parallel_multipart {
    fn get_mime(&self) -> &'static str {
        "multipart/parallel"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_report_multipart;
impl MimeTypeChecker for T_report_multipart {
    fn get_mime(&self) -> &'static str {
        "multipart/report"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_signed_multipart;
impl MimeTypeChecker for T_signed_multipart {
    fn get_mime(&self) -> &'static str {
        "multipart/signed"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_voice_message_multipart;
impl MimeTypeChecker for T_voice_message_multipart {
    fn get_mime(&self) -> &'static str {
        "multipart/voice-message"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dif_xml_application;
impl MimeTypeChecker for T_dif_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/dif+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dif"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml_local(bytes, "DIF")
            || rootxml(bytes, "DIF", "http://gcmd.gsfc.nasa.gov/Aboutus/xml/dif/"))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_onix_message_xml_application;
impl MimeTypeChecker for T_onix_message_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/onix-message+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml(
            bytes,
            "ONIXMessage",
            "http://ns.editeur.org/onix/3.0/reference",
        ) || rootxml(bytes, "ONIXmessage", "http://ns.editeur.org/onix/3.0/short")
            || rootxml_local(bytes, "ONIXMessage"))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_onix_message_short_xml_application;
impl MimeTypeChecker for T_onix_message_short_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/onix-message-short+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml(
            bytes,
            "ONIXMessage",
            "http://ns.editeur.org/onix/3.0/reference",
        ) || rootxml_local(bytes, "ONIXMessage"))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_actionscript_text;
impl MimeTypeChecker for T_x_actionscript_text {
    fn get_mime(&self) -> &'static str {
        "text/x-actionscript"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.as"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ada_text;
impl MimeTypeChecker for T_x_ada_text {
    fn get_mime(&self) -> &'static str {
        "text/x-ada"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ada", "*.adb", "*.ads"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_applescript_text;
impl MimeTypeChecker for T_x_applescript_text {
    fn get_mime(&self) -> &'static str {
        "text/x-applescript"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.applescript"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_asp_text;
impl MimeTypeChecker for T_asp_text {
    fn get_mime(&self) -> &'static str {
        "text/asp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.asp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_aspdotnet_text;
impl MimeTypeChecker for T_aspdotnet_text {
    fn get_mime(&self) -> &'static str {
        "text/aspdotnet"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.aspx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_aspectj_text;
impl MimeTypeChecker for T_x_aspectj_text {
    fn get_mime(&self) -> &'static str {
        "text/x-aspectj"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.aj"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_assembly_text;
impl MimeTypeChecker for T_x_assembly_text {
    fn get_mime(&self) -> &'static str {
        "text/x-assembly"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.s", "*.S", "*.asm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_config_text;
impl MimeTypeChecker for T_x_config_text {
    fn get_mime(&self) -> &'static str {
        "text/x-config"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.config", "*.conf", "*.cfg", "*.xconf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_css_text;
impl MimeTypeChecker for T_css_text {
    fn get_mime(&self) -> &'static str {
        "text/css"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.css"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_csv_text;
impl MimeTypeChecker for T_csv_text {
    fn get_mime(&self) -> &'static str {
        "text/csv"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.csv"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_directory_text;
impl MimeTypeChecker for T_directory_text {
    fn get_mime(&self) -> &'static str {
        "text/directory"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dns_text;
impl MimeTypeChecker for T_dns_text {
    fn get_mime(&self) -> &'static str {
        "text/dns"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_ecmascript_text;
impl MimeTypeChecker for T_ecmascript_text {
    fn get_mime(&self) -> &'static str {
        "text/ecmascript"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_enriched_text;
impl MimeTypeChecker for T_enriched_text {
    fn get_mime(&self) -> &'static str {
        "text/enriched"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_example_text;
impl MimeTypeChecker for T_example_text {
    fn get_mime(&self) -> &'static str {
        "text/example"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_parityfec_text;
impl MimeTypeChecker for T_parityfec_text {
    fn get_mime(&self) -> &'static str {
        "text/parityfec"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_prs_fallenstein_rst_text;
impl MimeTypeChecker for T_prs_fallenstein_rst_text {
    fn get_mime(&self) -> &'static str {
        "text/prs.fallenstein.rst"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_prs_lines_tag_text;
impl MimeTypeChecker for T_prs_lines_tag_text {
    fn get_mime(&self) -> &'static str {
        "text/prs.lines.tag"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dsc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_red_text;
impl MimeTypeChecker for T_red_text {
    fn get_mime(&self) -> &'static str {
        "text/red"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_rfc822_headers_text;
impl MimeTypeChecker for T_rfc822_headers_text {
    fn get_mime(&self) -> &'static str {
        "text/rfc822-headers"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_richtext_text;
impl MimeTypeChecker for T_richtext_text {
    fn get_mime(&self) -> &'static str {
        "text/richtext"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rtx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_rtp_enc_aescm128_text;
impl MimeTypeChecker for T_rtp_enc_aescm128_text {
    fn get_mime(&self) -> &'static str {
        "text/rtp-enc-aescm128"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_rtx_text;
impl MimeTypeChecker for T_rtx_text {
    fn get_mime(&self) -> &'static str {
        "text/rtx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_sgml_text;
impl MimeTypeChecker for T_sgml_text {
    fn get_mime(&self) -> &'static str {
        "text/sgml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sgml", "*.sgm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_t140_text;
impl MimeTypeChecker for T_t140_text {
    fn get_mime(&self) -> &'static str {
        "text/t140"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_tab_separated_values_text;
impl MimeTypeChecker for T_tab_separated_values_text {
    fn get_mime(&self) -> &'static str {
        "text/tab-separated-values"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.tsv"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_ulpfec_text;
impl MimeTypeChecker for T_ulpfec_text {
    fn get_mime(&self) -> &'static str {
        "text/ulpfec"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_uri_list_text;
impl MimeTypeChecker for T_uri_list_text {
    fn get_mime(&self) -> &'static str {
        "text/uri-list"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.uri", "*.uris", "*.urls"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_abc_text;
impl MimeTypeChecker for T_vnd_abc_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.abc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_curl_text;
impl MimeTypeChecker for T_vnd_curl_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.curl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.curl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_curl_dcurl_text;
impl MimeTypeChecker for T_vnd_curl_dcurl_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.curl.dcurl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dcurl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_curl_scurl_text;
impl MimeTypeChecker for T_vnd_curl_scurl_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.curl.scurl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.scurl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_curl_mcurl_text;
impl MimeTypeChecker for T_vnd_curl_mcurl_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.curl.mcurl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mcurl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dmclientscript_text;
impl MimeTypeChecker for T_vnd_dmclientscript_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.dmclientscript"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_esmertec_theme_descriptor_text;
impl MimeTypeChecker for T_vnd_esmertec_theme_descriptor_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.esmertec.theme-descriptor"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fly_text;
impl MimeTypeChecker for T_vnd_fly_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.fly"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fly"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fmi_flexstor_text;
impl MimeTypeChecker for T_vnd_fmi_flexstor_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.fmi.flexstor"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.flx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_in3d_3dml_text;
impl MimeTypeChecker for T_vnd_in3d_3dml_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.in3d.3dml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.3dml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_in3d_spot_text;
impl MimeTypeChecker for T_vnd_in3d_spot_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.in3d.spot"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.spot"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_iptc_newsml_text;
impl MimeTypeChecker for T_vnd_iptc_newsml_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.iptc.newsml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_iptc_nitf_text;
impl MimeTypeChecker for T_vnd_iptc_nitf_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.iptc.nitf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_latex_z_text;
impl MimeTypeChecker for T_vnd_latex_z_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.latex-z"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_motorola_reflex_text;
impl MimeTypeChecker for T_vnd_motorola_reflex_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.motorola.reflex"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_mediapackage_text;
impl MimeTypeChecker for T_vnd_ms_mediapackage_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.ms-mediapackage"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_net2phone_commcenter_command_text;
impl MimeTypeChecker for T_vnd_net2phone_commcenter_command_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.net2phone.commcenter.command"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_si_uricatalogue_text;
impl MimeTypeChecker for T_vnd_si_uricatalogue_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.si.uricatalogue"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sun_j2me_app_descriptor_text;
impl MimeTypeChecker for T_vnd_sun_j2me_app_descriptor_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.sun.j2me.app-descriptor"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jad"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_trolltech_linguist_text;
impl MimeTypeChecker for T_vnd_trolltech_linguist_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.trolltech.linguist"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wap_si_text;
impl MimeTypeChecker for T_vnd_wap_si_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.wap.si"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wap_sl_text;
impl MimeTypeChecker for T_vnd_wap_sl_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.wap.sl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wap_wml_text;
impl MimeTypeChecker for T_vnd_wap_wml_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.wap.wml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_wap_wmlscript_text;
impl MimeTypeChecker for T_vnd_wap_wmlscript_text {
    fn get_mime(&self) -> &'static str {
        "text/vnd.wap.wmlscript"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wmls"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_c__hdr_text;
impl MimeTypeChecker for T_x_c__hdr_text {
    fn get_mime(&self) -> &'static str {
        "text/x-c++hdr"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.hpp", "*.hxx", "*.hh", "*.H", "*.h++", "*.hp", "*.HPP"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_c__src_text;
impl MimeTypeChecker for T_x_c__src_text {
    fn get_mime(&self) -> &'static str {
        "text/x-c++src"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cpp", "*.cxx", "*.cc", "*.C", "*.c++", "*.CPP"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_cgi_text;
impl MimeTypeChecker for T_x_cgi_text {
    fn get_mime(&self) -> &'static str {
        "text/x-cgi"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cgi"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_clojure_text;
impl MimeTypeChecker for T_x_clojure_text {
    fn get_mime(&self) -> &'static str {
        "text/x-clojure"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.clj"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_coffeescript_text;
impl MimeTypeChecker for T_x_coffeescript_text {
    fn get_mime(&self) -> &'static str {
        "text/x-coffeescript"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.coffee"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_csharp_text;
impl MimeTypeChecker for T_x_csharp_text {
    fn get_mime(&self) -> &'static str {
        "text/x-csharp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cs"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_cobol_text;
impl MimeTypeChecker for T_x_cobol_text {
    fn get_mime(&self) -> &'static str {
        "text/x-cobol"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cbl", "*.Cbl", "*.CBL", "*.cob", "*.Cob", "*.COB"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_coldfusion_text;
impl MimeTypeChecker for T_x_coldfusion_text {
    fn get_mime(&self) -> &'static str {
        "text/x-coldfusion"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cfm", "*.cfml", "*.cfc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_common_lisp_text;
impl MimeTypeChecker for T_x_common_lisp_text {
    fn get_mime(&self) -> &'static str {
        "text/x-common-lisp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cl", "*.jl", "*.lisp", "*.lsp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_eiffel_text;
impl MimeTypeChecker for T_x_eiffel_text {
    fn get_mime(&self) -> &'static str {
        "text/x-eiffel"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.e"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_emacs_lisp_text;
impl MimeTypeChecker for T_x_emacs_lisp_text {
    fn get_mime(&self) -> &'static str {
        "text/x-emacs-lisp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.el"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_erlang_text;
impl MimeTypeChecker for T_x_erlang_text {
    fn get_mime(&self) -> &'static str {
        "text/x-erlang"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.erl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_expect_text;
impl MimeTypeChecker for T_x_expect_text {
    fn get_mime(&self) -> &'static str {
        "text/x-expect"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.exp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_forth_text;
impl MimeTypeChecker for T_x_forth_text {
    fn get_mime(&self) -> &'static str {
        "text/x-forth"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.4th"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_fortran_text;
impl MimeTypeChecker for T_x_fortran_text {
    fn get_mime(&self) -> &'static str {
        "text/x-fortran"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.f", "*.F", "*.for", "*.f77", "*.f90"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_go_text;
impl MimeTypeChecker for T_x_go_text {
    fn get_mime(&self) -> &'static str {
        "text/x-go"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.go"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_groovy_text;
impl MimeTypeChecker for T_x_groovy_text {
    fn get_mime(&self) -> &'static str {
        "text/x-groovy"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.groovy"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_haskell_text;
impl MimeTypeChecker for T_x_haskell_text {
    fn get_mime(&self) -> &'static str {
        "text/x-haskell"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.hs", "*.lhs"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_idl_text;
impl MimeTypeChecker for T_x_idl_text {
    fn get_mime(&self) -> &'static str {
        "text/x-idl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.idl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ini_text;
impl MimeTypeChecker for T_x_ini_text {
    fn get_mime(&self) -> &'static str {
        "text/x-ini"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ini"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_java_source_text;
impl MimeTypeChecker for T_x_java_source_text {
    fn get_mime(&self) -> &'static str {
        "text/x-java-source"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.java"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_java_properties_text;
impl MimeTypeChecker for T_x_java_properties_text {
    fn get_mime(&self) -> &'static str {
        "text/x-java-properties"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.properties"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_less_text;
impl MimeTypeChecker for T_x_less_text {
    fn get_mime(&self) -> &'static str {
        "text/x-less"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.less"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_lex_text;
impl MimeTypeChecker for T_x_lex_text {
    fn get_mime(&self) -> &'static str {
        "text/x-lex"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.l"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_log_text;
impl MimeTypeChecker for T_x_log_text {
    fn get_mime(&self) -> &'static str {
        "text/x-log"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.log"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ml_text;
impl MimeTypeChecker for T_x_ml_text {
    fn get_mime(&self) -> &'static str {
        "text/x-ml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_modula_text;
impl MimeTypeChecker for T_x_modula_text {
    fn get_mime(&self) -> &'static str {
        "text/x-modula"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.m3", "*.i3", "*.mg", "*.ig"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_objcsrc_text;
impl MimeTypeChecker for T_x_objcsrc_text {
    fn get_mime(&self) -> &'static str {
        "text/x-objcsrc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.m"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ocaml_text;
impl MimeTypeChecker for T_x_ocaml_text {
    fn get_mime(&self) -> &'static str {
        "text/x-ocaml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ocaml", "*.mli"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_pascal_text;
impl MimeTypeChecker for T_x_pascal_text {
    fn get_mime(&self) -> &'static str {
        "text/x-pascal"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.p", "*.pp", "*.pas", "*.PAS", "*.dpr"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_prolog_text;
impl MimeTypeChecker for T_x_prolog_text {
    fn get_mime(&self) -> &'static str {
        "text/x-prolog"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pro"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_rst_text;
impl MimeTypeChecker for T_x_rst_text {
    fn get_mime(&self) -> &'static str {
        "text/x-rst"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rest", "*.rst", "*.restx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_rexx_text;
impl MimeTypeChecker for T_x_rexx_text {
    fn get_mime(&self) -> &'static str {
        "text/x-rexx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rexx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ruby_text;
impl MimeTypeChecker for T_x_ruby_text {
    fn get_mime(&self) -> &'static str {
        "text/x-ruby"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.rb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_scala_text;
impl MimeTypeChecker for T_x_scala_text {
    fn get_mime(&self) -> &'static str {
        "text/x-scala"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.scala"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_scheme_text;
impl MimeTypeChecker for T_x_scheme_text {
    fn get_mime(&self) -> &'static str {
        "text/x-scheme"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.scm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sed_text;
impl MimeTypeChecker for T_x_sed_text {
    fn get_mime(&self) -> &'static str {
        "text/x-sed"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sed"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sql_text;
impl MimeTypeChecker for T_x_sql_text {
    fn get_mime(&self) -> &'static str {
        "text/x-sql"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sql"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_setext_text;
impl MimeTypeChecker for T_x_setext_text {
    fn get_mime(&self) -> &'static str {
        "text/x-setext"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.etx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_stsrc_text;
impl MimeTypeChecker for T_x_stsrc_text {
    fn get_mime(&self) -> &'static str {
        "text/x-stsrc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.st"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_vbdotnet_text;
impl MimeTypeChecker for T_x_vbdotnet_text {
    fn get_mime(&self) -> &'static str {
        "text/x-vbdotnet"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vb"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_vbscript_text;
impl MimeTypeChecker for T_x_vbscript_text {
    fn get_mime(&self) -> &'static str {
        "text/x-vbscript"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vbs"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_verilog_text;
impl MimeTypeChecker for T_x_verilog_text {
    fn get_mime(&self) -> &'static str {
        "text/x-verilog"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.v"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_vhdl_text;
impl MimeTypeChecker for T_x_vhdl_text {
    fn get_mime(&self) -> &'static str {
        "text/x-vhdl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.vhd", "*.vhdl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_web_markdown_text;
impl MimeTypeChecker for T_x_web_markdown_text {
    fn get_mime(&self) -> &'static str {
        "text/x-web-markdown"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.md", "*.mdtext", "*.mkd", "*.markdown"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_yacc_text;
impl MimeTypeChecker for T_x_yacc_text {
    fn get_mime(&self) -> &'static str {
        "text/x-yacc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.y"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_yaml_text;
impl MimeTypeChecker for T_x_yaml_text {
    fn get_mime(&self) -> &'static str {
        "text/x-yaml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.yaml", "*.yml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_3gpp_tt_video;
impl MimeTypeChecker for T_3gpp_tt_video {
    fn get_mime(&self) -> &'static str {
        "video/3gpp-tt"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_bmpeg_video;
impl MimeTypeChecker for T_bmpeg_video {
    fn get_mime(&self) -> &'static str {
        "video/bmpeg"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_bt656_video;
impl MimeTypeChecker for T_bt656_video {
    fn get_mime(&self) -> &'static str {
        "video/bt656"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_celb_video;
impl MimeTypeChecker for T_celb_video {
    fn get_mime(&self) -> &'static str {
        "video/celb"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dv_video;
impl MimeTypeChecker for T_dv_video {
    fn get_mime(&self) -> &'static str {
        "video/dv"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_example_video;
impl MimeTypeChecker for T_example_video {
    fn get_mime(&self) -> &'static str {
        "video/example"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_h261_video;
impl MimeTypeChecker for T_h261_video {
    fn get_mime(&self) -> &'static str {
        "video/h261"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.h261"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_h263_video;
impl MimeTypeChecker for T_h263_video {
    fn get_mime(&self) -> &'static str {
        "video/h263"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.h263"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_h263_1998_video;
impl MimeTypeChecker for T_h263_1998_video {
    fn get_mime(&self) -> &'static str {
        "video/h263-1998"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_h263_2000_video;
impl MimeTypeChecker for T_h263_2000_video {
    fn get_mime(&self) -> &'static str {
        "video/h263-2000"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_h264_video;
impl MimeTypeChecker for T_h264_video {
    fn get_mime(&self) -> &'static str {
        "video/h264"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.h264"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_iso_segment_video;
impl MimeTypeChecker for T_iso_segment_video {
    fn get_mime(&self) -> &'static str {
        "video/iso.segment"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.m4s"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_jpeg_video;
impl MimeTypeChecker for T_jpeg_video {
    fn get_mime(&self) -> &'static str {
        "video/jpeg"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jpgv"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_jpeg2000_video;
impl MimeTypeChecker for T_jpeg2000_video {
    fn get_mime(&self) -> &'static str {
        "video/jpeg2000"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mp1s_video;
impl MimeTypeChecker for T_mp1s_video {
    fn get_mime(&self) -> &'static str {
        "video/mp1s"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mp2p_video;
impl MimeTypeChecker for T_mp2p_video {
    fn get_mime(&self) -> &'static str {
        "video/mp2p"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mp2t_video;
impl MimeTypeChecker for T_mp2t_video {
    fn get_mime(&self) -> &'static str {
        "video/mp2t"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mp4v_es_video;
impl MimeTypeChecker for T_mp4v_es_video {
    fn get_mime(&self) -> &'static str {
        "video/mp4v-es"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mpeg4_generic_video;
impl MimeTypeChecker for T_mpeg4_generic_video {
    fn get_mime(&self) -> &'static str {
        "video/mpeg4-generic"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_mpv_video;
impl MimeTypeChecker for T_mpv_video {
    fn get_mime(&self) -> &'static str {
        "video/mpv"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_nv_video;
impl MimeTypeChecker for T_nv_video {
    fn get_mime(&self) -> &'static str {
        "video/nv"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_parityfec_video;
impl MimeTypeChecker for T_parityfec_video {
    fn get_mime(&self) -> &'static str {
        "video/parityfec"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_pointer_video;
impl MimeTypeChecker for T_pointer_video {
    fn get_mime(&self) -> &'static str {
        "video/pointer"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_raw_video;
impl MimeTypeChecker for T_raw_video {
    fn get_mime(&self) -> &'static str {
        "video/raw"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_rtp_enc_aescm128_video;
impl MimeTypeChecker for T_rtp_enc_aescm128_video {
    fn get_mime(&self) -> &'static str {
        "video/rtp-enc-aescm128"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_rtx_video;
impl MimeTypeChecker for T_rtx_video {
    fn get_mime(&self) -> &'static str {
        "video/rtx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_smpte292m_video;
impl MimeTypeChecker for T_smpte292m_video {
    fn get_mime(&self) -> &'static str {
        "video/smpte292m"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_ulpfec_video;
impl MimeTypeChecker for T_ulpfec_video {
    fn get_mime(&self) -> &'static str {
        "video/ulpfec"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vc1_video;
impl MimeTypeChecker for T_vc1_video {
    fn get_mime(&self) -> &'static str {
        "video/vc1"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_cctv_video;
impl MimeTypeChecker for T_vnd_cctv_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.cctv"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_dlna_mpeg_tts_video;
impl MimeTypeChecker for T_vnd_dlna_mpeg_tts_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.dlna.mpeg-tts"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_fvt_video;
impl MimeTypeChecker for T_vnd_fvt_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.fvt"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fvt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_hns_video_video;
impl MimeTypeChecker for T_vnd_hns_video_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.hns.video"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_iptvforum_1dparityfec_1010_video;
impl MimeTypeChecker for T_vnd_iptvforum_1dparityfec_1010_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.iptvforum.1dparityfec-1010"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_iptvforum_1dparityfec_2005_video;
impl MimeTypeChecker for T_vnd_iptvforum_1dparityfec_2005_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.iptvforum.1dparityfec-2005"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_iptvforum_2dparityfec_1010_video;
impl MimeTypeChecker for T_vnd_iptvforum_2dparityfec_1010_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.iptvforum.2dparityfec-1010"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_iptvforum_2dparityfec_2005_video;
impl MimeTypeChecker for T_vnd_iptvforum_2dparityfec_2005_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.iptvforum.2dparityfec-2005"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_iptvforum_ttsavc_video;
impl MimeTypeChecker for T_vnd_iptvforum_ttsavc_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.iptvforum.ttsavc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_iptvforum_ttsmpeg2_video;
impl MimeTypeChecker for T_vnd_iptvforum_ttsmpeg2_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.iptvforum.ttsmpeg2"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_motorola_video_video;
impl MimeTypeChecker for T_vnd_motorola_video_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.motorola.video"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_motorola_videop_video;
impl MimeTypeChecker for T_vnd_motorola_videop_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.motorola.videop"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_mpegurl_video;
impl MimeTypeChecker for T_vnd_mpegurl_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.mpegurl"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mxu", "*.m4u"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_ms_playready_media_pyv_video;
impl MimeTypeChecker for T_vnd_ms_playready_media_pyv_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.ms-playready.media.pyv"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pyv"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nokia_interleaved_multimedia_video;
impl MimeTypeChecker for T_vnd_nokia_interleaved_multimedia_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.nokia.interleaved-multimedia"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_nokia_videovoip_video;
impl MimeTypeChecker for T_vnd_nokia_videovoip_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.nokia.videovoip"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_objectvideo_video;
impl MimeTypeChecker for T_vnd_objectvideo_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.objectvideo"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sealed_mpeg1_video;
impl MimeTypeChecker for T_vnd_sealed_mpeg1_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.sealed.mpeg1"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sealed_mpeg4_video;
impl MimeTypeChecker for T_vnd_sealed_mpeg4_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.sealed.mpeg4"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sealed_swf_video;
impl MimeTypeChecker for T_vnd_sealed_swf_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.sealed.swf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_sealedmedia_softseal_mov_video;
impl MimeTypeChecker for T_vnd_sealedmedia_softseal_mov_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.sealedmedia.softseal.mov"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_vivo_video;
impl MimeTypeChecker for T_vnd_vivo_video {
    fn get_mime(&self) -> &'static str {
        "video/vnd.vivo"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.viv"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_f4v_video;
impl MimeTypeChecker for T_x_f4v_video {
    fn get_mime(&self) -> &'static str {
        "video/x-f4v"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.f4v"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_flc_video;
impl MimeTypeChecker for T_x_flc_video {
    fn get_mime(&self) -> &'static str {
        "video/x-flc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.flc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_fli_video;
impl MimeTypeChecker for T_x_fli_video {
    fn get_mime(&self) -> &'static str {
        "video/x-fli"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fli"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ms_asx_application;
impl MimeTypeChecker for T_x_ms_asx_application {
    fn get_mime(&self) -> &'static str {
        "application/x-ms-asx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.asx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml_local(bytes, "asx") || rootxml_local(bytes, "ASX"))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ms_wm_video;
impl MimeTypeChecker for T_x_ms_wm_video {
    fn get_mime(&self) -> &'static str {
        "video/x-ms-wm"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ms_wmx_video;
impl MimeTypeChecker for T_x_ms_wmx_video {
    fn get_mime(&self) -> &'static str {
        "video/x-ms-wmx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wmx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_ms_wvx_video;
impl MimeTypeChecker for T_x_ms_wvx_video {
    fn get_mime(&self) -> &'static str {
        "video/x-ms-wvx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wvx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_matroska_audio;
impl MimeTypeChecker for T_x_matroska_audio {
    fn get_mime(&self) -> &'static str {
        "audio/x-matroska"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.mka"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_cooltalk_x_conference;
impl MimeTypeChecker for T_x_cooltalk_x_conference {
    fn get_mime(&self) -> &'static str {
        "x-conference/x-cooltalk"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ice"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_fictionbook_xml_application;
impl MimeTypeChecker for T_x_fictionbook_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/x-fictionbook+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.fb2"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml(
            bytes,
            "FictionBook",
            "http://www.gribuser.ru/xml/fictionbook/2.0",
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_asciidoc_text;
impl MimeTypeChecker for T_x_asciidoc_text {
    fn get_mime(&self) -> &'static str {
        "text/x-asciidoc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.asciidoc", "*.adoc", "*.ad", "*.ad.txt", "*.adoc.txt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_d_text;
impl MimeTypeChecker for T_x_d_text {
    fn get_mime(&self) -> &'static str {
        "text/x-d"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.d"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_haml_text;
impl MimeTypeChecker for T_x_haml_text {
    fn get_mime(&self) -> &'static str {
        "text/x-haml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.haml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_haxe_text;
impl MimeTypeChecker for T_x_haxe_text {
    fn get_mime(&self) -> &'static str {
        "text/x-haxe"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.hx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_xliff_xml_application;
impl MimeTypeChecker for T_x_xliff_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/x-xliff+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xlf", "*.xliff"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml(bytes, "xliff", "urn:oasis:names:tc:xliff:document:1.2")
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_xliff_zip_application;
impl MimeTypeChecker for T_x_xliff_zip_application {
    fn get_mime(&self) -> &'static str {
        "application/x-xliff+zip"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.xlz"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_rsrc_text;
impl MimeTypeChecker for T_x_rsrc_text {
    fn get_mime(&self) -> &'static str {
        "text/x-rsrc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.r"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_scss_text;
impl MimeTypeChecker for T_x_scss_text {
    fn get_mime(&self) -> &'static str {
        "text/x-scss"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.scss"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x_sass_text;
impl MimeTypeChecker for T_x_sass_text {
    fn get_mime(&self) -> &'static str {
        "text/x-sass"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sass"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_shp_application;
impl MimeTypeChecker for T_vnd_shp_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.shp"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.shp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_shx_application;
impl MimeTypeChecker for T_vnd_shx_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.shx"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.shx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_owl_xml_application;
impl MimeTypeChecker for T_owl_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/owl+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.owl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml(bytes, "Ontology", "http://www.w3.org/2002/07/owl")
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_collada_xml_model;
impl MimeTypeChecker for T_vnd_collada_xml_model {
    fn get_mime(&self) -> &'static str {
        "model/vnd.collada+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dae"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml(
            bytes,
            "COLLADA",
            "http://www.collada.org/2005/11/COLLADASchema",
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_gml_xml_application;
impl MimeTypeChecker for T_gml_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/gml+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gml"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml_namespace(bytes, "http://www.opengis.net/gml")
            || rootxml_namespace(bytes, "http://www.opengis.net/gml/3.2")
            || rootxml_namespace(bytes, "http://www.opengis.net/gml/3.2/exr"))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_gpx_xml_application;
impl MimeTypeChecker for T_gpx_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/gpx+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.gpx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml(bytes, "gpx", "http://www.topografix.com/GPX/1/1")
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_vnd_garmin_tcx_xml_application;
impl MimeTypeChecker for T_vnd_garmin_tcx_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.garmin.tcx+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.tcx"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml(
            bytes,
            "TrainingCenterDatabase",
            "http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2",
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_x3d_xml_model;
impl MimeTypeChecker for T_x3d_xml_model {
    fn get_mime(&self) -> &'static str {
        "model/x3d+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.3xd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        rootxml(bytes, "X3D", "http://www.w3.org/2001/XMLSchema-instance")
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[]
    }
    fn is_virtual(&self) -> bool {
        false
    }
}

pub(super) struct T_dita_xml_format_topic_application;
impl MimeTypeChecker for T_dita_xml_format_topic_application {
    fn get_mime(&self) -> &'static str {
        "application/dita+xml;format=topic"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dita"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml_local(bytes, "topic")
            || rootxml(bytes, "topic", "http://docs.oasis-open.org/namespace"))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_dita_xml_format_concept_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_vnd_datapackage_zip_application;
impl MimeTypeChecker for T_x_vnd_datapackage_zip_application {
    fn get_mime(&self) -> &'static str {
        "application/x-vnd.datapackage+zip"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_x_wacz_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_vnd_oasis_opendocument_graphics_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_graphics_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.graphics"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.odg"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 111, 97, 115, 105, 115, 46, 111, 112,
                    101, 110, 100, 111, 99, 117, 109, 101, 110, 116, 46, 103, 114, 97, 112, 104,
                    105, 99, 115,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_vnd_oasis_opendocument_graphics_template_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_vnd_oasis_opendocument_image_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_image_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.image"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.odi"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 111, 97, 115, 105, 115, 46, 111, 112,
                    101, 110, 100, 111, 99, 117, 109, 101, 110, 116, 46, 105, 109, 97, 103, 101,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_vnd_oasis_opendocument_image_template_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_vnd_oasis_opendocument_presentation_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_presentation_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.presentation"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.odp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 111, 97, 115, 105, 115, 46, 111, 112,
                    101, 110, 100, 111, 99, 117, 109, 101, 110, 116, 46, 112, 114, 101, 115, 101,
                    110, 116, 97, 116, 105, 111, 110,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_vnd_oasis_opendocument_presentation_template_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_vnd_oasis_opendocument_spreadsheet_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_spreadsheet_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.spreadsheet"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.ods"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 111, 97, 115, 105, 115, 46, 111, 112,
                    101, 110, 100, 111, 99, 117, 109, 101, 110, 116, 46, 115, 112, 114, 101, 97,
                    100, 115, 104, 101, 101, 116,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_vnd_oasis_opendocument_spreadsheet_template_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_vnd_sun_xml_calc_application;
impl MimeTypeChecker for T_vnd_sun_xml_calc_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sun.xml.calc"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sxc"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 115, 117, 110, 46, 120, 109, 108, 46, 99,
                    97, 108, 99,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_vnd_sun_xml_calc_template_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_vnd_sun_xml_draw_application;
impl MimeTypeChecker for T_vnd_sun_xml_draw_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sun.xml.draw"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sxd"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 115, 117, 110, 46, 120, 109, 108, 46,
                    100, 114, 97, 119,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_vnd_sun_xml_draw_template_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_vnd_sun_xml_impress_application;
impl MimeTypeChecker for T_vnd_sun_xml_impress_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sun.xml.impress"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sxi"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 115, 117, 110, 46, 120, 109, 108, 46,
                    105, 109, 112, 114, 101, 115, 115,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_vnd_sun_xml_impress_template_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_vnd_sun_xml_writer_application;
impl MimeTypeChecker for T_vnd_sun_xml_writer_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.sun.xml.writer"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.sxw"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 115, 117, 110, 46, 120, 109, 108, 46,
                    119, 114, 105, 116, 101, 114,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_vnd_sun_xml_writer_template_application]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_vnd_dgn_image;
impl MimeTypeChecker for T_vnd_dgn_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.dgn"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dgn", "*.dgnlib", "*.cel"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_vnd_dgn_version_7_image]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_basic_text;
impl MimeTypeChecker for T_x_basic_text {
    fn get_mime(&self) -> &'static str {
        "text/x-basic"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.bas", "*.Bas", "*.BAS"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_x_vbasic_text]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_json_application;
impl MimeTypeChecker for T_json_application {
    fn get_mime(&self) -> &'static str {
        "application/json"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.json"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_manifest_json_application,
            &T_x_vnd_datapackage_json_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_quicktime_application;
impl MimeTypeChecker for T_quicktime_application {
    fn get_mime(&self) -> &'static str {
        "application/quicktime"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_mp4_application, &T_quicktime_video]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_onenote_application;
impl MimeTypeChecker for T_onenote_application {
    fn get_mime(&self) -> &'static str {
        "application/onenote"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.onetmp"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_onenote_format_one_application,
            &T_onenote_format_onetoc2_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_tika_msoffice_embedded_application;
impl MimeTypeChecker for T_x_tika_msoffice_embedded_application {
    fn get_mime(&self) -> &'static str {
        "application/x-tika-msoffice-embedded"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_x_tika_msoffice_embedded_format_ole10_native_application,
            &T_x_tika_msoffice_embedded_format_comp_obj_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_x509_cert_application;
impl MimeTypeChecker for T_x_x509_cert_application {
    fn get_mime(&self) -> &'static str {
        "application/x-x509-cert"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.crt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_x_x509_cert_format_pem_application,
            &T_x_x509_cert_format_der_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_x509_key_application;
impl MimeTypeChecker for T_x_x509_key_application {
    fn get_mime(&self) -> &'static str {
        "application/x-x509-key"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_x_x509_key_format_pem_application,
            &T_x_x509_key_format_der_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_vnd_dxf_image;
impl MimeTypeChecker for T_vnd_dxf_image {
    fn get_mime(&self) -> &'static str {
        "image/vnd.dxf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.dxf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_vnd_dxf_format_binary_image,
            &T_vnd_dxf_format_ascii_image,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_vbasic_text;
impl MimeTypeChecker for T_x_vbasic_text {
    fn get_mime(&self) -> &'static str {
        "text/x-vbasic"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.cls", "*.Cls", "*.CLS", "*.frm", "*.Frm", "*.FRM"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_x_vbdotnet_text, &T_x_vbscript_text]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_ms_asf_video;
impl MimeTypeChecker for T_x_ms_asf_video {
    fn get_mime(&self) -> &'static str {
        "video/x-ms-asf"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.asf"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        offset(
            bytes,
            0,
            &[
                48, 38, 178, 117, 142, 102, 207, 17, 166, 217, 0, 170, 0, 98, 206, 108,
            ],
        )
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[&T_x_ms_wma_audio, &T_x_ms_wmv_video]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_java_archive_application;
impl MimeTypeChecker for T_java_archive_application {
    fn get_mime(&self) -> &'static str {
        "application/java-archive"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.jar"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_vnd_android_package_archive_application,
            &T_x_tika_java_enterprise_archive_application,
            &T_x_tika_java_web_archive_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_sereal_application;
impl MimeTypeChecker for T_sereal_application {
    fn get_mime(&self) -> &'static str {
        "application/sereal"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.srl"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_sereal_version_1_application,
            &T_sereal_version_2_application,
            &T_sereal_version_3_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_vnd_oasis_opendocument_text_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_text_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.text"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.odt"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (offset(bytes, 0, &[80, 75])
            && offset(
                bytes,
                30,
                &[
                    109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116,
                    105, 111, 110, 47, 118, 110, 100, 46, 111, 97, 115, 105, 115, 46, 111, 112,
                    101, 110, 100, 111, 99, 117, 109, 101, 110, 116, 46, 116, 101, 120, 116,
                ],
            ))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_vnd_oasis_opendocument_text_master_application,
            &T_vnd_oasis_opendocument_text_template_application,
            &T_vnd_oasis_opendocument_text_web_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_vnd_oasis_opendocument_tika_flat_document_application;
impl MimeTypeChecker for T_vnd_oasis_opendocument_tika_flat_document_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.oasis.opendocument.tika.flat.document"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        (rootxml(
            bytes,
            "document",
            "urn:oasis:names:tc:opendocument:xmlns:office:1.0",
        ) || rootxml(bytes, "office", "http://openoffice.org/2009/office")
            || rootxml(bytes, "document", "http://openoffice.org/2009/office"))
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_vnd_oasis_opendocument_flat_text_application,
            &T_vnd_oasis_opendocument_flat_presentation_application,
            &T_vnd_oasis_opendocument_flat_spreadsheet_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_dita_xml_application;
impl MimeTypeChecker for T_dita_xml_application {
    fn get_mime(&self) -> &'static str {
        "application/dita+xml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_dita_xml_format_map_application,
            &T_dita_xml_format_topic_application,
            &T_dita_xml_format_task_application,
            &T_dita_xml_format_val_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_vnd_apple_iwork_application;
impl MimeTypeChecker for T_vnd_apple_iwork_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.apple.iwork"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_vnd_apple_keynote_application,
            &T_vnd_apple_pages_application,
            &T_vnd_apple_numbers_application,
            &T_x_tika_iworks_protected_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_berkeley_db_application;
impl MimeTypeChecker for T_x_berkeley_db_application {
    fn get_mime(&self) -> &'static str {
        "application/x-berkeley-db"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_x_berkeley_db_format_hash_application,
            &T_x_berkeley_db_format_btree_application,
            &T_x_berkeley_db_format_queue_application,
            &T_x_berkeley_db_format_log_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_mysql_db_application;
impl MimeTypeChecker for T_x_mysql_db_application {
    fn get_mime(&self) -> &'static str {
        "application/x-mysql-db"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_x_mysql_table_definition_application,
            &T_x_mysql_misam_index_application,
            &T_x_mysql_misam_compressed_index_application,
            &T_x_mysql_misam_data_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_quattro_pro_application;
impl MimeTypeChecker for T_x_quattro_pro_application {
    fn get_mime(&self) -> &'static str {
        "application/x-quattro-pro"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[
            "*.wq1", "*.wq2", "*.wkq", "*.qpw", "*.wb1", "*.wb2", "*.wb3",
        ]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_x_quattro_pro_version_1_4_application,
            &T_x_quattro_pro_version_5_application,
            &T_x_quattro_pro_version_1_5_application,
            &T_x_quattro_pro_version_6_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_portable_anymap_image;
impl MimeTypeChecker for T_x_portable_anymap_image {
    fn get_mime(&self) -> &'static str {
        "image/x-portable-anymap"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.pnm"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_x_portable_bitmap_image,
            &T_x_portable_graymap_image,
            &T_x_portable_pixmap_image,
            &T_x_portable_arbitrarymap_image,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_tika_text_based_message_text;
impl MimeTypeChecker for T_x_tika_text_based_message_text {
    fn get_mime(&self) -> &'static str {
        "text/x-tika-text-based-message"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_mbox_application,
            &T_x_emlx_message,
            &T_news_message,
            &T_rfc822_message,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_vnd_lotus_1_2_3_application;
impl MimeTypeChecker for T_vnd_lotus_1_2_3_application {
    fn get_mime(&self) -> &'static str {
        "application/vnd.lotus-1-2-3"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.wk1", "*.wk2", "*.wk3", "*.wk4", "*.123"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_vnd_lotus_1_2_3_version_1_application,
            &T_vnd_lotus_1_2_3_version_2_application,
            &T_vnd_lotus_1_2_3_version_3_application,
            &T_vnd_lotus_1_2_3_version_4_application,
            &T_vnd_lotus_1_2_3_version_97_9_x_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_tika_old_excel_application;
impl MimeTypeChecker for T_x_tika_old_excel_application {
    fn get_mime(&self) -> &'static str {
        "application/x-tika-old-excel"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_vnd_ms_excel_sheet_4_application,
            &T_vnd_ms_excel_workspace_4_application,
            &T_vnd_ms_excel_sheet_3_application,
            &T_vnd_ms_excel_workspace_3_application,
            &T_vnd_ms_excel_sheet_2_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_tika_staroffice_application;
impl MimeTypeChecker for T_x_tika_staroffice_application {
    fn get_mime(&self) -> &'static str {
        "application/x-tika-staroffice"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_vnd_stardivision_calc_application,
            &T_vnd_stardivision_draw_application,
            &T_vnd_stardivision_impress_application,
            &T_vnd_stardivision_writer_application,
            &T_x_staroffice_template_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_ogg_audio;
impl MimeTypeChecker for T_ogg_audio {
    fn get_mime(&self) -> &'static str {
        "audio/ogg"
    }
    fn get_ext(&self) -> &[&'static str] {
        &["*.oga"]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_vorbis_audio,
            &T_x_oggflac_audio,
            &T_x_oggpcm_audio,
            &T_opus_audio,
            &T_speex_audio,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub(super) struct T_x_tika_visio_ooxml_application;
impl MimeTypeChecker for T_x_tika_visio_ooxml_application {
    fn get_mime(&self) -> &'static str {
        "application/x-tika-visio-ooxml"
    }
    fn get_ext(&self) -> &[&'static str] {
        &[]
    }
    fn check(&self, bytes: &[u8]) -> bool {
        false
    }
    fn get_children(&self) -> &[&'static dyn MimeTypeChecker] {
        &[
            &T_vnd_ms_visio_drawing_application,
            &T_vnd_ms_visio_template_application,
            &T_vnd_ms_visio_stencil_application,
            &T_vnd_ms_visio_drawing_macroEnabled_12_application,
            &T_vnd_ms_visio_template_macroEnabled_12_application,
            &T_vnd_ms_visio_stencil_macroEnabled_12_application,
        ]
    }
    fn is_virtual(&self) -> bool {
        true
    }
}

pub static MIME_TYPES: &[&'static dyn MimeTypeChecker] = &[
    &T_x_tga_image,
    &T_x_tmx_application,
    &T_x_endnote_refer_application,
    &T_x_dvd_ifo_application,
    &T_x_ebu_stl_application,
    &T_mbox_application,
    &T_x_emlx_message,
    &T_x_ms_nls_application,
    &T_x_mswrite_application,
    &T_pdf_application,
    &T_x_bplist_application,
    &T_cbor_application,
    &T_coreldraw_application,
    &T_illustrator_ps_application,
    &T_vnd_apple_mpegurl_application,
    &T_vnd_etsi_asic_e_zip_application,
    &T_vnd_etsi_asic_s_zip_application,
    &T_vnd_ms_excel_sheet_4_application,
    &T_vnd_ms_excel_workspace_4_application,
    &T_vnd_ms_excel_sheet_3_application,
    &T_vnd_ms_excel_workspace_3_application,
    &T_vnd_ms_excel_sheet_2_application,
    &T_vnd_tcpdump_pcap_application,
    &T_vnd_tcpdump_pcapng_application,
    &T_warc_application,
    &T_x_activemime_application,
    &T_x_axcrypt_application,
    &T_x_berkeley_db_format_hash_version_2_application,
    &T_x_berkeley_db_format_hash_version_3_application,
    &T_x_berkeley_db_format_hash_version_4_application,
    &T_x_berkeley_db_format_hash_version_5_application,
    &T_x_berkeley_db_format_btree_version_2_application,
    &T_x_berkeley_db_format_btree_version_3_application,
    &T_x_berkeley_db_format_btree_version_4_application,
    &T_x_debian_package_application,
    &T_x_font_type1_application,
    &T_x_foxmail_application,
    &T_x_internet_archive_application,
    &T_x_lz4_application,
    &T_x_mobipocket_ebook_application,
    &T_x_msaccess_application,
    &T_x_msdownload_format_pe32_application,
    &T_x_msdownload_format_pe64_application,
    &T_x_msdownload_format_pe_itanium_application,
    &T_x_msdownload_format_pe_armLE_application,
    &T_x_msdownload_format_pe_arm7_application,
    &T_x_msmoney_application,
    &T_x_rar_compressed_version_4_application,
    &T_x_rar_compressed_version_5_application,
    &T_x_shapefile_application,
    &T_x_geopackage_application,
    &T_x_geopackage__version_1_1Or1_0_application,
    &T_x_fossil_checkout_application,
    &T_x_fossil_global_conf_application,
    &T_x_fossil_repository_application,
    &T_x_bentley_besqlite_application,
    &T_x_bentley_localization_application,
    &T_x_monotone_source_repo_application,
    &T_x_esri_spatially_enabled_db_application,
    &T_x_mbtiles_application,
    &T_x_texnicard_application,
    &T_x_stata_dta_version_14_application,
    &T_x_stata_dta_version_13_application,
    &T_x_stata_dta_version_12_application,
    &T_x_stata_dta_version_10_application,
    &T_x_stata_dta_version_8_application,
    &T_mp4_audio,
    &T_vorbis_audio,
    &T_x_oggflac_audio,
    &T_x_oggpcm_audio,
    &T_opus_audio,
    &T_speex_audio,
    &T_x_caf_audio,
    &T_avif_image,
    &T_heic_image,
    &T_heic_sequence_image,
    &T_x_canon_cr2_image,
    &T_x_canon_cr3_image,
    &T_news_message,
    &T_x_httpresponse_application,
    &T_related_multipart,
    &T_e57_model,
    &T_x_stl_ascii_model,
    &T_vnd_dwf_version_6_model,
    &T_vnd_dwf_version_5_model,
    &T_vnd_dwf_version_2_model,
    &T_x_php_text,
    &T_3gpp_video,
    &T_3gpp2_video,
    &T_daala_video,
    &T_theora_video,
    &T_x_dirac_video,
    &T_x_ogm_video,
    &T_x_ogguvs_video,
    &T_x_oggyuv_video,
    &T_x_oggrgb_video,
    &T_x_m4v_video,
    &T_x_ms_wmv_video,
    &T_x_mach_o_universal_application,
    &T_heif_image,
    &T_heif_sequence_image,
    &T_mp4_video,
    &T_x_robots_text,
    &T_x_mach_o_object_application,
    &T_x_mach_o_executable_application,
    &T_x_mach_o_fvmlib_application,
    &T_x_mach_o_core_application,
    &T_x_mach_o_preload_application,
    &T_x_mach_o_dylib_application,
    &T_x_mach_o_dylinker_application,
    &T_x_mach_o_bundle_application,
    &T_x_mach_o_dylib_stub_application,
    &T_x_mach_o_dsym_application,
    &T_x_mach_o_kext_bundle_application,
    &T_x_msdownload_format_pe_application,
    &T_applefile_application,
    &T_x_bat_application,
    &T_dicom_application,
    &T_java_vm_application,
    &T_vnd_java_hprof__application,
    &T_vnd_java_hprof_text_application,
    &T_mac_binhex40_application,
    &T_marc_application,
    &T_vnd_wolfram_wl_application,
    &T_msword_application,
    &T_msword2_application,
    &T_msword5_application,
    &T_octet_stream_application,
    &T_onenote_format_one_application,
    &T_onenote_format_onetoc2_application,
    &T_pkcs7_signature_application,
    &T_timestamped_data_application,
    &T_rtf_application,
    &T_sereal_version_1_application,
    &T_sereal_version_2_application,
    &T_sereal_version_3_application,
    &T_vnd_digilite_prolights_application,
    &T_vnd_fdf_application,
    &T_vnd_iccprofile_application,
    &T_vnd_lotus_1_2_3_version_1_application,
    &T_vnd_lotus_1_2_3_version_2_application,
    &T_vnd_lotus_1_2_3_version_3_application,
    &T_vnd_lotus_1_2_3_version_4_application,
    &T_vnd_lotus_1_2_3_version_97_9_x_application,
    &T_vnd_lotus_wordpro_application,
    &T_vnd_mif_application,
    &T_vnd_ms_excel_application,
    &T_vnd_ms_fontobject_application,
    &T_vnd_ms_htmlhelp_application,
    &T_vnd_ms_outlook_pst_application,
    &T_vnd_ms_powerpoint_application,
    &T_x_project_application,
    &T_vnd_ms_tnef_application,
    &T_vnd_ms_works_application,
    &T_vnd_oasis_opendocument_chart_template_application,
    &T_vnd_oasis_opendocument_base_application,
    &T_vnd_oasis_opendocument_formula_application,
    &T_vnd_oasis_opendocument_flat_text_application,
    &T_vnd_oasis_opendocument_flat_presentation_application,
    &T_vnd_oasis_opendocument_flat_spreadsheet_application,
    &T_vnd_oasis_opendocument_text_master_application,
    &T_vnd_openxmlformats_officedocument_presentationml_presentation_application,
    &T_vnd_openxmlformats_officedocument_spreadsheetml_sheet_application,
    &T_vnd_openxmlformats_officedocument_wordprocessingml_document_application,
    &T_vnd_rn_realmedia_application,
    &T_vnd_stardivision_calc_application,
    &T_vnd_stardivision_draw_application,
    &T_vnd_stardivision_impress_application,
    &T_vnd_stardivision_writer_application,
    &T_x_subrip_application,
    &T_vnd_symbian_install_application,
    &T_vnd_wordperfect_version_4_2_application,
    &T_vnd_wordperfect_version_5_0_application,
    &T_vnd_wordperfect_version_5_1_application,
    &T_vnd_wordperfect_version_6_x_application,
    &T_vnd_xara_application,
    &T_wasm_application,
    &T_x_atari_floppy_disk_image_application,
    &T_x_adobe_indesign_application,
    &T_vnd_isac_fcs_application,
    &T_vnd_adobe_indesign_idml_package_application,
    &T_x_adobe_indesign_interchange_application,
    &T_x_arj_application,
    &T_x_asprs_application,
    &T_x_berkeley_db_format_queue_application,
    &T_x_berkeley_db_format_log_application,
    &T_x_bibtex_text_file_application,
    &T_x_bittorrent_application,
    &T_x_cdf_application,
    &T_x_gtar_application,
    &T_x_guitar_pro_application,
    &T_x_amiga_disk_format_application,
    &T_x_chrome_package_application,
    &T_x_compress_application,
    &T_x_cpio_application,
    &T_x_dex_application,
    &T_x_dvi_application,
    &T_x_elc_application,
    &T_x_endnote_style_application,
    &T_x_fat_diskimage_application,
    &T_x_object_application,
    &T_x_executable_application,
    &T_x_sharedlib_application,
    &T_x_coredump_application,
    &T_x_mmm_digisonde_application,
    &T_x_erdas_hfa_application,
    &T_x_filemaker_application,
    &T_x_gnumeric_application,
    &T_x_grib_application,
    &T_zstd_application,
    &T_x_hdf_application,
    &T_x_hwp_application,
    &T_x_ibooks_zip_application,
    &T_x_idl_save_file_application,
    &T_x_isatab_investigation_application,
    &T_x_isatab_application,
    &T_x_isatab_assay_application,
    &T_x_jeol_jdf_application,
    &T_x_jigdo_application,
    &T_x_kdelnk_application,
    &T_x_latex_application,
    &T_x_lha_application,
    &T_x_lharc_application,
    &T_x_lzip_application,
    &T_x_mach_o_application,
    &T_x_ms_compress_szdd_application,
    &T_x_nesrom_application,
    &T_x_netcdf_application,
    &T_x_parquet_application,
    &T_x_prt_application,
    &T_x_quattro_pro_version_1_4_application,
    &T_x_quattro_pro_version_5_application,
    &T_x_quattro_pro_version_1_5_application,
    &T_x_quattro_pro_version_6_application,
    &T_x_rpm_application,
    &T_x_spss_sav_application,
    &T_x_sc_application,
    &T_x_shockwave_flash_application,
    &T_x_sibelius_application,
    &T_x_snappy_framed_application,
    &T_x_spectrum_tzx_application,
    &T_x_stuffit_application,
    &T_x_texinfo_application,
    &T_x_tex_virtual_font_application,
    &T_x_touhou_application,
    &T_x_uc2_compressed_application,
    &T_x_vhd_application,
    &T_x_x509_cert_format_pem_application,
    &T_x_x509_cert_format_der_application,
    &T_x_x509_key_format_pem_application,
    &T_x_x509_dsa_parameters_application,
    &T_x_x509_ec_parameters_application,
    &T_x_java_keystore_application,
    &T_x_xz_application,
    &T_x_zim_application,
    &T_x_zoo_application,
    &T_x_7z_compressed_application,
    &T_eac3_audio,
    &T_amr_wb_audio,
    &T_x_psf_audio,
    &T_x_sap_audio,
    &T_prs_sid_audio,
    &T_qcelp_audio,
    &T_x_flac_audio,
    &T_x_mod_audio,
    &T_x_mpegurl_audio,
    &T_x_ms_wma_audio,
    &T_x_pn_realaudio_audio,
    &T_x_cdx_chemical,
    &T_x_3ds_image,
    &T_aces_image,
    &T_x_os2_graphics__charset_binary_image,
    &T_bmp_image,
    &T_x_bpg_image,
    &T_cgm_image,
    &T_x_dpx_image,
    &T_emf_image,
    &T_fits_image,
    &T_gif_image,
    &T_icns_image,
    &T_jp2_image,
    &T_jpeg_image,
    &T_jpm_image,
    &T_jpx_image,
    &T_nitf_image,
    &T_svg_xml_image,
    &T_vnd_adobe_photoshop_image,
    &T_vnd_dgn_version_7_image,
    &T_vnd_djvu_image,
    &T_vnd_dwg_image,
    &T_vnd_dxb_image,
    &T_vnd_dxf_format_binary_image,
    &T_vnd_dxf_format_ascii_image,
    &T_vnd_microsoft_icon_image,
    &T_vnd_ms_modi_image,
    &T_vnd_radiance_image,
    &T_vnd_zbrush_dcx_image,
    &T_webp_image,
    &T_wmf_image,
    &T_x_freehand_image,
    &T_x_jbig2_image,
    &T_jxl_image,
    &T_x_niff_image,
    &T_x_pict_image,
    &T_x_portable_bitmap_image,
    &T_x_portable_graymap_image,
    &T_x_portable_pixmap_image,
    &T_x_portable_arbitrarymap_image,
    &T_x_raw_canon_image,
    &T_x_raw_olympus_image,
    &T_x_rgb_image,
    &T_x_xcf_image,
    &T_x_xpixmap_image,
    &T_appledouble_multipart,
    &T_calendar_text,
    &T_troff_text,
    &T_vnd_graphviz_text,
    &T_vnd_iptc_anpa_text,
    &T_x_awk_text,
    &T_x_diff_text,
    &T_x_jsp_text,
    &T_x_lua_text,
    &T_x_matlab_text,
    &T_x_matlab_data_application,
    &T_x_perl_text,
    &T_x_python_text,
    &T_x_tcl_text,
    &T_x_uuencode_text,
    &T_x_vcalendar_text,
    &T_x_vcard_text,
    &T_mj2_video,
    &T_mpeg_video,
    &T_x_flv_video,
    &T_x_jng_video,
    &T_x_mng_video,
    &T_x_msvideo_video,
    &T_x_sgi_movie_video,
    &T_x_matroska_video,
    &T_webm_video,
    &T_x_ole_storage_application,
    &T_webm_audio,
    &T_woff_font,
    &T_woff2_font,
    &T_x_xar_application,
    &T_lzip_application,
    &T_x_installshield_application,
    &T_x_chrome_extension_application,
    &T_ape_audio,
    &T_musepack_audio,
    &T_x_unknown_audio,
    &T_x_ms_shortcut_application,
    &T_gltf_binary_model,
    &T_tzif_application,
    &T_collection_font,
    &T_vnd_dvb_file_video,
    &T_vnd_mozilla_apng_image,
    &T_bpg_image,
    &T_jxs_image,
    &T_jxr_image,
    &T_x_ms_reader_application,
    &T_epub_zip_application,
    &T_fits_application,
    &T_javascript_text,
    &T_mathematica_application,
    &T_postscript_application,
    &T_vnd_ms_cab_compressed_application,
    &T_x_archive_application,
    &T_x_iso9660_image_application,
    &T_x_tex_application,
    &T_ac3_audio,
    &T_png_image,
    &T_tiff_image,
    &T_x_xbitmap_image,
    &T_rfc822_message,
    &T_vnd_dwf_model,
    &T_x_msdownload_application,
    &T_x_rar_compressed_application,
    &T_ogg_application,
    &T_x_berkeley_db_format_btree_application,
    &T_x_sh_application,
    &T_vnd_wordperfect_application,
    &T_x_berkeley_db_format_hash_application,
    &T_x_elf_application,
    &T_x_jp2_container_image,
    &T_x_stata_dta_application,
    &T_quicktime_video,
    &T_ogg_video,
    &T_x_sqlite3_application,
    &T_x_tika_ooxml_application,
    &T_zip_application,
    &T_xml_application,
    &T_html_text,
    &T_zlib_application,
    &T_gzip_application,
    &T_x_dbf_application,
    &T_x_bzip2_application,
    &T_x_font_otf_application,
    &T_x_font_ttf_application,
    &T_x_font_adobe_metric_application,
    &T_x_font_printer_metric_application,
    &T_x_mysql_table_definition_application,
    &T_x_mysql_misam_index_application,
    &T_x_mysql_misam_compressed_index_application,
    &T_x_sas_data_v6_application,
    &T_x_sas_data_application,
    &T_x_sas_xport_application,
    &T_x_x509_key_format_der_application,
    &T_xhtml_xml_application,
    &T_x_aac_audio,
    &T_vnd_zbrush_pcx_image,
    &T_vtt_text,
    &T_x_bzip_application,
    &T_x_tar_application,
    &T_amr_audio,
    &T_x_matroska_application,
    &T_x_tika_msoffice_application,
    &T_inf_application,
    &T_x_chdr_text,
    &T_x_gimp_pat_image,
    &T_x_gimp_gbr_image,
    &T_x_c_text,
    &T_x_jp2_codestream_image,
    &T_vnd_msa_disk_image_application,
    &T_basic_audio,
    &T_midi_audio,
    &T_x_adpcm_audio,
    &T_x_aiff_audio,
    &T_x_dec_basic_audio,
    &T_x_dec_adpcm_audio,
    &T_vnd_wave_audio,
    &T_x_makefile_text,
    &T_mpeg_audio,
    &T_plain_text,
    &T_activemessage_application,
    &T_andrew_inset_application,
    &T_applixware_application,
    &T_iso19139_xml_text,
    &T_atom_xml_application,
    &T_atomcat_xml_application,
    &T_atomicmail_application,
    &T_atomsvc_xml_application,
    &T_auth_policy_xml_application,
    &T_batch_smtp_application,
    &T_beep_xml_application,
    &T_bizagi_modeler_application,
    &T_cals_1840_application,
    &T_ccxml_xml_application,
    &T_cea_2018_xml_application,
    &T_cellml_xml_application,
    &T_cnrp_xml_application,
    &T_commonground_application,
    &T_conference_info_xml_application,
    &T_cpl_xml_application,
    &T_csta_xml_application,
    &T_cstadata_xml_application,
    &T_cu_seeme_application,
    &T_cybercash_application,
    &T_dash_xml_application,
    &T_davmount_xml_application,
    &T_dca_rft_application,
    &T_dec_dx_application,
    &T_dialog_info_xml_application,
    &T_dita_xml_format_map_application,
    &T_dita_xml_format_task_application,
    &T_dita_xml_format_concept_application,
    &T_dita_xml_format_val_application,
    &T_dns_application,
    &T_dvcs_application,
    &T_ecmascript_application,
    &T_edi_consent_application,
    &T_edi_x12_application,
    &T_edifact_application,
    &T_emma_xml_application,
    &T_envi_hdr_application,
    &T_epp_xml_application,
    &T_eshop_application,
    &T_example_application,
    &T_fastinfoset_application,
    &T_fastsoap_application,
    &T_font_tdpfr_application,
    &T_h224_application,
    &T_http_application,
    &T_hyperstudio_application,
    &T_ibe_key_request_xml_application,
    &T_ibe_pkg_reply_xml_application,
    &T_ibe_pp_data_application,
    &T_iges_application,
    &T_illustrator_application,
    &T_im_iscomposing_xml_application,
    &T_index_application,
    &T_index_cmd_application,
    &T_index_obj_application,
    &T_index_response_application,
    &T_index_vnd_application,
    &T_iotp_application,
    &T_ipp_application,
    &T_isup_application,
    &T_vnd_android_package_archive_application,
    &T_x_tika_java_enterprise_archive_application,
    &T_x_tika_java_web_archive_application,
    &T_x_tika_unix_dump_application,
    &T_java_serialized_object_application,
    &T_manifest_json_application,
    &T_x_java_jnilib_application,
    &T_kpml_request_xml_application,
    &T_kpml_response_xml_application,
    &T_lost_xml_application,
    &T_mac_compactpro_application,
    &T_macwriteii_application,
    &T_mathml_xml_application,
    &T_mbms_associated_procedure_description_xml_application,
    &T_mbms_deregister_xml_application,
    &T_mbms_envelope_xml_application,
    &T_mbms_msk_xml_application,
    &T_mbms_msk_response_xml_application,
    &T_mbms_protection_description_xml_application,
    &T_mbms_reception_report_xml_application,
    &T_mbms_register_xml_application,
    &T_mbms_register_response_xml_application,
    &T_mbms_user_service_description_xml_application,
    &T_media_control_xml_application,
    &T_mediaservercontrol_xml_application,
    &T_mikey_application,
    &T_moss_keys_application,
    &T_moss_signature_application,
    &T_mosskey_data_application,
    &T_mosskey_request_application,
    &T_mp4_application,
    &T_mpeg4_generic_application,
    &T_mpeg4_iod_application,
    &T_mpeg4_iod_xmt_application,
    &T_mxf_application,
    &T_nasdata_application,
    &T_news_checkgroups_application,
    &T_news_groupinfo_application,
    &T_news_transmission_application,
    &T_nss_application,
    &T_ocsp_request_application,
    &T_ocsp_response_application,
    &T_oda_application,
    &T_oebps_package_xml_application,
    &T_kate_application,
    &T_onenote__format_package_application,
    &T_parityfec_application,
    &T_patch_ops_error_xml_application,
    &T_pgp_encrypted_application,
    &T_pgp_keys_application,
    &T_pgp_signature_application,
    &T_pics_rules_application,
    &T_pidf_xml_application,
    &T_pidf_diff_xml_application,
    &T_pkcs10_application,
    &T_pkcs7_mime_application,
    &T_pkix_cert_application,
    &T_pkix_crl_application,
    &T_pkix_pkipath_application,
    &T_pkixcmp_application,
    &T_pls_xml_application,
    &T_poc_settings_xml_application,
    &T_prs_alvestrand_titrax_sheet_application,
    &T_prs_cww_application,
    &T_prs_nprend_application,
    &T_prs_plucker_application,
    &T_qsig_application,
    &T_vnd_ms_spreadsheetml_application,
    &T_vnd_ms_wordml_application,
    &T_vnd_ms_word2006ml_application,
    &T_rdf_xml_application,
    &T_reginfo_xml_application,
    &T_relax_ng_compact_syntax_application,
    &T_remote_printing_application,
    &T_resource_lists_xml_application,
    &T_resource_lists_diff_xml_application,
    &T_riscos_application,
    &T_rlmi_xml_application,
    &T_rls_services_xml_application,
    &T_rsd_xml_application,
    &T_rss_xml_application,
    &T_rtx_application,
    &T_samlassertion_xml_application,
    &T_samlmetadata_xml_application,
    &T_sbml_xml_application,
    &T_scvp_cv_request_application,
    &T_scvp_cv_response_application,
    &T_scvp_vp_request_application,
    &T_scvp_vp_response_application,
    &T_sdp_application,
    &T_set_payment_application,
    &T_set_payment_initiation_application,
    &T_set_registration_application,
    &T_set_registration_initiation_application,
    &T_sgml_application,
    &T_sgml_open_catalog_application,
    &T_shf_xml_application,
    &T_sieve_application,
    &T_simple_filter_xml_application,
    &T_simple_message_summary_application,
    &T_simplesymbolcontainer_application,
    &T_slate_application,
    &T_smil_xml_application,
    &T_soap_fastinfoset_application,
    &T_soap_xml_application,
    &T_sldworks_application,
    &T_sparql_query_application,
    &T_sparql_results_xml_application,
    &T_spirits_event_xml_application,
    &T_srgs_application,
    &T_srgs_xml_application,
    &T_ssml_xml_application,
    &T_timestamp_query_application,
    &T_timestamp_reply_application,
    &T_tve_trigger_application,
    &T_ulpfec_application,
    &T_vemmi_application,
    &T_vividence_scriptfile_application,
    &T_vnd_3gpp_bsf_xml_application,
    &T_vnd_3gpp_pic_bw_large_application,
    &T_vnd_3gpp_pic_bw_small_application,
    &T_vnd_3gpp_pic_bw_var_application,
    &T_vnd_3gpp_sms_application,
    &T_vnd_3gpp2_bcmcsinfo_xml_application,
    &T_vnd_3gpp2_sms_application,
    &T_vnd_3gpp2_tcap_application,
    &T_vnd_3m_post_it_notes_application,
    &T_vnd_accpac_simply_aso_application,
    &T_vnd_accpac_simply_imp_application,
    &T_vnd_acucobol_application,
    &T_vnd_acucorp_application,
    &T_vnd_adobe_air_application_installer_package_zip_application,
    &T_vnd_adobe_aftereffects_project_application,
    &T_vnd_adobe_aftereffects_template_application,
    &T_vnd_adobe_xdp_xml_application,
    &T_vnd_adobe_xfdf_application,
    &T_vnd_aether_imp_application,
    &T_vnd_airzip_filesecure_azf_application,
    &T_vnd_airzip_filesecure_azs_application,
    &T_vnd_amazon_ebook_application,
    &T_vnd_americandynamics_acc_application,
    &T_vnd_amiga_ami_application,
    &T_vnd_anser_web_certificate_issue_initiation_application,
    &T_vnd_anser_web_funds_transfer_initiation_application,
    &T_vnd_antix_game_component_application,
    &T_vnd_apple_installer_xml_application,
    &T_vnd_apple_unknown_13_application,
    &T_vnd_apple_keynote_application,
    &T_vnd_apple_pages_application,
    &T_vnd_apple_numbers_application,
    &T_x_tika_iworks_protected_application,
    &T_vnd_arastra_swi_application,
    &T_vnd_audiograph_application,
    &T_vnd_autopackage_application,
    &T_vnd_avistar_xml_application,
    &T_vnd_blueice_multipass_application,
    &T_vnd_bluetooth_ep_oob_application,
    &T_vnd_bmi_application,
    &T_vnd_businessobjects_application,
    &T_vnd_cab_jscript_application,
    &T_vnd_canon_cpdl_application,
    &T_vnd_canon_lips_application,
    &T_vnd_cendio_thinlinc_clientconf_application,
    &T_vnd_chemdraw_xml_application,
    &T_vnd_chipnuts_karaoke_mmd_application,
    &T_vnd_cinderella_application,
    &T_vnd_cirpack_isdn_ext_application,
    &T_vnd_claymore_application,
    &T_vnd_clonk_c4group_application,
    &T_vnd_commerce_battelle_application,
    &T_vnd_commonspace_application,
    &T_vnd_contact_cmsg_application,
    &T_vnd_cosmocaller_application,
    &T_vnd_crick_clicker_application,
    &T_vnd_crick_clicker_keyboard_application,
    &T_vnd_crick_clicker_palette_application,
    &T_vnd_crick_clicker_template_application,
    &T_vnd_crick_clicker_wordbank_application,
    &T_vnd_criticaltools_wbs_xml_application,
    &T_vnd_ctc_posml_application,
    &T_vnd_ctct_ws_xml_application,
    &T_vnd_cups_pdf_application,
    &T_vnd_cups_postscript_application,
    &T_vnd_cups_ppd_application,
    &T_vnd_cups_raster_application,
    &T_vnd_cups_raw_application,
    &T_vnd_curl_car_application,
    &T_vnd_curl_pcurl_application,
    &T_vnd_cybank_application,
    &T_x_wacz_application,
    &T_x_vnd_datapackage_json_application,
    &T_x_vnd_datapackage_gz_application,
    &T_vnd_data_vision_rdz_application,
    &T_vnd_denovo_fcselayout_link_application,
    &T_vnd_dir_bi_plate_dl_nosuffix_application,
    &T_vnd_dna_application,
    &T_vnd_dolby_mlp_application,
    &T_vnd_dolby_mobile_1_application,
    &T_vnd_dolby_mobile_2_application,
    &T_vnd_dpgraph_application,
    &T_vnd_dreamfactory_application,
    &T_vnd_dvb_esgcontainer_application,
    &T_vnd_dvb_ipdcdftnotifaccess_application,
    &T_vnd_dvb_ipdcesgaccess_application,
    &T_vnd_dvb_ipdcroaming_application,
    &T_vnd_dvb_iptv_alfec_base_application,
    &T_vnd_dvb_iptv_alfec_enhancement_application,
    &T_vnd_dvb_notif_aggregate_root_xml_application,
    &T_vnd_dvb_notif_container_xml_application,
    &T_vnd_dvb_notif_generic_xml_application,
    &T_vnd_dvb_notif_ia_msglist_xml_application,
    &T_vnd_dvb_notif_ia_registration_request_xml_application,
    &T_vnd_dvb_notif_ia_registration_response_xml_application,
    &T_vnd_dvb_notif_init_xml_application,
    &T_vnd_dxr_application,
    &T_vnd_dynageo_application,
    &T_vnd_ecdis_update_application,
    &T_vnd_ecowin_chart_application,
    &T_vnd_ecowin_filerequest_application,
    &T_vnd_ecowin_fileupdate_application,
    &T_vnd_ecowin_series_application,
    &T_vnd_ecowin_seriesrequest_application,
    &T_vnd_ecowin_seriesupdate_application,
    &T_vnd_emclient_accessrequest_xml_application,
    &T_vnd_enliven_application,
    &T_vnd_epson_esf_application,
    &T_vnd_epson_msf_application,
    &T_vnd_epson_quickanime_application,
    &T_vnd_epson_salt_application,
    &T_vnd_epson_ssf_application,
    &T_vnd_ericsson_quickcall_application,
    &T_vnd_eszigno3_xml_application,
    &T_vnd_etsi_aoc_xml_application,
    &T_vnd_etsi_cug_xml_application,
    &T_vnd_etsi_iptvcommand_xml_application,
    &T_vnd_etsi_iptvdiscovery_xml_application,
    &T_vnd_etsi_iptvprofile_xml_application,
    &T_vnd_etsi_iptvsad_bc_xml_application,
    &T_vnd_etsi_iptvsad_cod_xml_application,
    &T_vnd_etsi_iptvsad_npvr_xml_application,
    &T_vnd_etsi_iptvueprofile_xml_application,
    &T_vnd_etsi_mcid_xml_application,
    &T_vnd_etsi_sci_xml_application,
    &T_vnd_etsi_simservs_xml_application,
    &T_vnd_eudora_data_application,
    &T_vnd_ezpix_album_application,
    &T_vnd_ezpix_package_application,
    &T_vnd_f_secure_mobile_application,
    &T_vnd_fdsn_mseed_application,
    &T_vnd_fdsn_seed_application,
    &T_vnd_ffsns_application,
    &T_vnd_fints_application,
    &T_vnd_flographit_application,
    &T_vnd_fluxtime_clip_application,
    &T_vnd_font_fontforge_sfd_application,
    &T_vnd_framemaker_application,
    &T_vnd_frogans_fnc_application,
    &T_vnd_frogans_ltf_application,
    &T_vnd_fsc_weblaunch_application,
    &T_vnd_fujitsu_oasys_application,
    &T_vnd_fujitsu_oasys2_application,
    &T_vnd_fujitsu_oasys3_application,
    &T_vnd_fujitsu_oasysgp_application,
    &T_vnd_fujitsu_oasysprs_application,
    &T_vnd_fujixerox_art_ex_application,
    &T_vnd_fujixerox_art4_application,
    &T_vnd_fujixerox_hbpl_application,
    &T_vnd_fujixerox_ddd_application,
    &T_vnd_fujixerox_docuworks_application,
    &T_vnd_fujixerox_docuworks_binder_application,
    &T_vnd_fut_misnet_application,
    &T_vnd_fuzzysheet_application,
    &T_vnd_genomatix_tuxedo_application,
    &T_vnd_geogebra_file_application,
    &T_vnd_geogebra_tool_application,
    &T_vnd_geometry_explorer_application,
    &T_vnd_gmx_application,
    &T_vnd_google_earth_kml_xml_application,
    &T_vnd_google_earth_kmz_application,
    &T_vnd_grafeq_application,
    &T_vnd_gridmp_application,
    &T_vnd_groove_account_application,
    &T_vnd_groove_help_application,
    &T_vnd_groove_identity_message_application,
    &T_vnd_groove_injector_application,
    &T_vnd_groove_tool_message_application,
    &T_vnd_groove_tool_template_application,
    &T_vnd_groove_vcard_application,
    &T_vnd_handheld_entertainment_xml_application,
    &T_vnd_hbci_application,
    &T_vnd_hcl_bireports_application,
    &T_vnd_hhe_lesson_player_application,
    &T_vnd_hp_hpgl_application,
    &T_vnd_hp_hpid_application,
    &T_vnd_hp_hps_application,
    &T_vnd_hp_jlyt_application,
    &T_vnd_hp_pcl_application,
    &T_vnd_hp_pclxl_application,
    &T_vnd_httphone_application,
    &T_vnd_hydrostatix_sof_data_application,
    &T_vnd_hzn_3d_crossword_application,
    &T_vnd_ibm_afplinedata_application,
    &T_vnd_ibm_electronic_media_application,
    &T_vnd_ibm_minipay_application,
    &T_vnd_ibm_modcap_application,
    &T_vnd_ibm_rights_management_application,
    &T_vnd_ibm_secure_container_application,
    &T_vnd_igloader_application,
    &T_vnd_immervision_ivp_application,
    &T_vnd_immervision_ivu_application,
    &T_vnd_informedcontrol_rms_xml_application,
    &T_vnd_informix_visionary_application,
    &T_vnd_intercon_formnet_application,
    &T_vnd_intertrust_digibox_application,
    &T_vnd_intertrust_nncp_application,
    &T_vnd_intu_qbo_application,
    &T_vnd_intu_qfx_application,
    &T_vnd_iptc_g2_catalogitem_xml_application,
    &T_vnd_iptc_g2_conceptitem_xml_application,
    &T_vnd_iptc_g2_knowledgeitem_xml_application,
    &T_vnd_iptc_g2_newsitem_xml_application,
    &T_vnd_iptc_g2_newsmessage_xml_application,
    &T_vnd_iptc_g2_packageitem_xml_application,
    &T_vnd_iptc_g2_planningitem_xml_application,
    &T_vnd_ipunplugged_rcprofile_application,
    &T_vnd_irepository_package_xml_application,
    &T_vnd_is_xpr_application,
    &T_vnd_jam_application,
    &T_vnd_japannet_directory_service_application,
    &T_vnd_japannet_jpnstore_wakeup_application,
    &T_vnd_japannet_payment_wakeup_application,
    &T_vnd_japannet_registration_application,
    &T_vnd_japannet_registration_wakeup_application,
    &T_vnd_japannet_setstore_wakeup_application,
    &T_vnd_japannet_verification_application,
    &T_vnd_japannet_verification_wakeup_application,
    &T_vnd_jcp_javame_midlet_rms_application,
    &T_vnd_jisp_application,
    &T_vnd_joost_joda_archive_application,
    &T_vnd_kahootz_application,
    &T_vnd_kde_karbon_application,
    &T_vnd_kde_kchart_application,
    &T_vnd_kde_kformula_application,
    &T_vnd_kde_kivio_application,
    &T_vnd_kde_kontour_application,
    &T_vnd_kde_kpresenter_application,
    &T_vnd_kde_kspread_application,
    &T_vnd_kde_kword_application,
    &T_vnd_kenameaapp_application,
    &T_vnd_kidspiration_application,
    &T_vnd_kinar_application,
    &T_vnd_koan_application,
    &T_vnd_kodak_descriptor_application,
    &T_vnd_liberty_request_xml_application,
    &T_vnd_llamagraphics_life_balance_desktop_application,
    &T_vnd_llamagraphics_life_balance_exchange_xml_application,
    &T_vnd_lotus_approach_application,
    &T_vnd_lotus_freelance_application,
    &T_vnd_lotus_notes_application,
    &T_vnd_lotus_organizer_application,
    &T_vnd_lotus_screencam_application,
    &T_vnd_macports_portpkg_application,
    &T_vnd_marlin_drm_actiontoken_xml_application,
    &T_vnd_marlin_drm_conftoken_xml_application,
    &T_vnd_marlin_drm_license_xml_application,
    &T_vnd_marlin_drm_mdcf_application,
    &T_vnd_mcd_application,
    &T_vnd_medcalcdata_application,
    &T_vnd_mediastation_cdkey_application,
    &T_vnd_meridian_slingshot_application,
    &T_vnd_mfer_application,
    &T_vnd_mfmp_application,
    &T_vnd_micrografx_flo_application,
    &T_vnd_micrografx_igx_application,
    &T_vnd_mindjet_mindmanager_application,
    &T_vnd_minisoft_hp3000_save_application,
    &T_vnd_mitsubishi_misty_guard_trustweb_application,
    &T_vnd_mobius_daf_application,
    &T_vnd_mobius_dis_application,
    &T_vnd_mobius_mbk_application,
    &T_vnd_mobius_mqy_application,
    &T_vnd_mobius_msl_application,
    &T_vnd_mobius_plc_application,
    &T_vnd_mobius_txf_application,
    &T_vnd_mophun_application_application,
    &T_vnd_mophun_certificate_application,
    &T_vnd_motorola_flexsuite_application,
    &T_vnd_motorola_flexsuite_adsi_application,
    &T_vnd_motorola_flexsuite_fis_application,
    &T_vnd_motorola_flexsuite_gotap_application,
    &T_vnd_motorola_flexsuite_kmr_application,
    &T_vnd_motorola_flexsuite_ttc_application,
    &T_vnd_motorola_flexsuite_wem_application,
    &T_vnd_motorola_iprm_application,
    &T_vnd_mozilla_xul_xml_application,
    &T_vnd_ms_artgalry_application,
    &T_vnd_ms_asf_application,
    &T_vnd_ms_excel_addin_macroenabled_12_application,
    &T_vnd_ms_excel_sheet_macroenabled_12_application,
    &T_vnd_ms_excel_sheet_binary_macroenabled_12_application,
    &T_vnd_ms_ims_application,
    &T_vnd_ms_lrm_application,
    &T_vnd_ms_outlook_application,
    &T_vnd_ms_package_3dmanufacturing_3dmodel_xml_application,
    &T_vnd_ms_pki_seccat_application,
    &T_vnd_ms_pki_stl_application,
    &T_vnd_ms_playready_initiator_xml_application,
    &T_vnd_ms_powerpoint_addin_macroenabled_12_application,
    &T_vnd_ms_powerpoint_presentation_macroenabled_12_application,
    &T_vnd_ms_powerpoint_slide_macroenabled_12_application,
    &T_vnd_ms_powerpoint_slideshow_macroenabled_12_application,
    &T_vnd_ms_powerpoint_template_macroenabled_12_application,
    &T_vnd_ms_project_application,
    &T_vnd_ms_wmdrm_lic_chlg_req_application,
    &T_vnd_ms_wmdrm_lic_resp_application,
    &T_vnd_ms_wmdrm_meter_chlg_req_application,
    &T_vnd_ms_wmdrm_meter_resp_application,
    &T_vnd_ms_word_document_macroenabled_12_application,
    &T_vnd_ms_word_template_macroenabled_12_application,
    &T_vnd_ms_wpl_application,
    &T_vnd_ms_xpsdocument_application,
    &T_vnd_mseq_application,
    &T_vnd_msign_application,
    &T_vnd_multiad_creator_application,
    &T_vnd_multiad_creator_cif_application,
    &T_vnd_music_niff_application,
    &T_vnd_musician_application,
    &T_vnd_muvee_style_application,
    &T_vnd_ncd_control_application,
    &T_vnd_ncd_reference_application,
    &T_vnd_nervana_application,
    &T_vnd_netfpx_application,
    &T_vnd_neurolanguage_nlu_application,
    &T_vnd_noblenet_directory_application,
    &T_vnd_noblenet_sealer_application,
    &T_vnd_noblenet_web_application,
    &T_vnd_nokia_catalogs_application,
    &T_vnd_nokia_conml_wbxml_application,
    &T_vnd_nokia_conml_xml_application,
    &T_vnd_nokia_isds_radio_presets_application,
    &T_vnd_nokia_iptv_config_xml_application,
    &T_vnd_nokia_landmark_wbxml_application,
    &T_vnd_nokia_landmark_xml_application,
    &T_vnd_nokia_landmarkcollection_xml_application,
    &T_vnd_nokia_n_gage_ac_xml_application,
    &T_vnd_nokia_n_gage_data_application,
    &T_vnd_nokia_n_gage_symbian_install_application,
    &T_vnd_nokia_ncd_application,
    &T_vnd_nokia_pcd_wbxml_application,
    &T_vnd_nokia_pcd_xml_application,
    &T_vnd_nokia_radio_preset_application,
    &T_vnd_nokia_radio_presets_application,
    &T_vnd_novadigm_edm_application,
    &T_vnd_novadigm_edx_application,
    &T_vnd_novadigm_ext_application,
    &T_vnd_oasis_opendocument_chart_application,
    &T_vnd_oasis_opendocument_formula_template_application,
    &T_vnd_oasis_opendocument_graphics_template_application,
    &T_vnd_oasis_opendocument_image_template_application,
    &T_vnd_oasis_opendocument_presentation_template_application,
    &T_vnd_oasis_opendocument_spreadsheet_template_application,
    &T_vnd_oasis_opendocument_text_template_application,
    &T_vnd_oasis_opendocument_text_web_application,
    &T_vnd_obn_application,
    &T_vnd_olpc_sugar_application,
    &T_vnd_oma_scws_config_application,
    &T_vnd_oma_scws_http_request_application,
    &T_vnd_oma_scws_http_response_application,
    &T_vnd_oma_bcast_associated_procedure_parameter_xml_application,
    &T_vnd_oma_bcast_drm_trigger_xml_application,
    &T_vnd_oma_bcast_imd_xml_application,
    &T_vnd_oma_bcast_ltkm_application,
    &T_vnd_oma_bcast_notification_xml_application,
    &T_vnd_oma_bcast_provisioningtrigger_application,
    &T_vnd_oma_bcast_sgboot_application,
    &T_vnd_oma_bcast_sgdd_xml_application,
    &T_vnd_oma_bcast_sgdu_application,
    &T_vnd_oma_bcast_simple_symbol_container_application,
    &T_vnd_oma_bcast_smartcard_trigger_xml_application,
    &T_vnd_oma_bcast_sprov_xml_application,
    &T_vnd_oma_bcast_stkm_application,
    &T_vnd_oma_dcd_application,
    &T_vnd_oma_dcdc_application,
    &T_vnd_oma_dd2_xml_application,
    &T_vnd_oma_drm_risd_xml_application,
    &T_vnd_oma_group_usage_list_xml_application,
    &T_vnd_oma_poc_detailed_progress_report_xml_application,
    &T_vnd_oma_poc_final_report_xml_application,
    &T_vnd_oma_poc_groups_xml_application,
    &T_vnd_oma_poc_invocation_descriptor_xml_application,
    &T_vnd_oma_poc_optimized_progress_report_xml_application,
    &T_vnd_oma_xcap_directory_xml_application,
    &T_vnd_omads_email_xml_application,
    &T_vnd_omads_file_xml_application,
    &T_vnd_omads_folder_xml_application,
    &T_vnd_omaloc_supl_init_application,
    &T_vnd_openofficeorg_extension_application,
    &T_vnd_openofficeorg_autotext_application,
    &T_vnd_openxmlformats_officedocument_presentationml_slide_application,
    &T_vnd_openxmlformats_officedocument_presentationml_template_application,
    &T_vnd_openxmlformats_officedocument_presentationml_slideshow_application,
    &T_vnd_openxmlformats_officedocument_spreadsheetml_template_application,
    &T_vnd_ms_excel_template_macroenabled_12_application,
    &T_vnd_openxmlformats_officedocument_wordprocessingml_template_application,
    &T_vnd_osa_netdeploy_application,
    &T_vnd_osgi_bundle_application,
    &T_vnd_osgi_dp_application,
    &T_vnd_otps_ct_kip_xml_application,
    &T_vnd_palm_application,
    &T_vnd_paos_xml_application,
    &T_vnd_pg_format_application,
    &T_vnd_pg_osasli_application,
    &T_vnd_piaccess_application_licence_application,
    &T_vnd_picsel_application,
    &T_vnd_poc_group_advertisement_xml_application,
    &T_vnd_pocketlearn_application,
    &T_vnd_powerbuilder6_application,
    &T_vnd_powerbuilder6_s_application,
    &T_vnd_powerbuilder7_application,
    &T_vnd_powerbuilder7_s_application,
    &T_vnd_powerbuilder75_application,
    &T_vnd_powerbuilder75_s_application,
    &T_vnd_preminet_application,
    &T_vnd_previewsystems_box_application,
    &T_vnd_proteus_magazine_application,
    &T_vnd_publishare_delta_tree_application,
    &T_vnd_pvi_ptid1_application,
    &T_vnd_pwg_multiplexed_application,
    &T_vnd_pwg_xhtml_print_xml_application,
    &T_vnd_qualcomm_brew_app_res_application,
    &T_vnd_quark_quarkxpress_application,
    &T_vnd_rapid_application,
    &T_vnd_recordare_musicxml_application,
    &T_vnd_recordare_musicxml_xml_application,
    &T_vnd_renlearn_rlprint_application,
    &T_vnd_rim_cod_application,
    &T_vnd_route66_link66_xml_application,
    &T_vnd_ruckus_download_application,
    &T_vnd_s3sms_application,
    &T_vnd_sbm_cid_application,
    &T_vnd_sbm_mid2_application,
    &T_vnd_scribus_application,
    &T_vnd_sealed_3df_application,
    &T_vnd_sealed_csf_application,
    &T_vnd_sealed_doc_application,
    &T_vnd_sealed_eml_application,
    &T_vnd_sealed_mht_application,
    &T_vnd_sealed_net_application,
    &T_vnd_sealed_ppt_application,
    &T_vnd_sealed_tiff_application,
    &T_vnd_sealed_xls_application,
    &T_vnd_sealedmedia_softseal_html_application,
    &T_vnd_sealedmedia_softseal_pdf_application,
    &T_vnd_seemail_application,
    &T_vnd_sema_application,
    &T_vnd_semd_application,
    &T_vnd_semf_application,
    &T_vnd_shana_informed_formdata_application,
    &T_vnd_shana_informed_formtemplate_application,
    &T_vnd_shana_informed_interchange_application,
    &T_vnd_shana_informed_package_application,
    &T_vnd_simtech_mindmapper_application,
    &T_vnd_smaf_application,
    &T_vnd_smart_teacher_application,
    &T_vnd_software602_filler_form_xml_application,
    &T_vnd_software602_filler_form_xml_zip_application,
    &T_vnd_solent_sdkm_xml_application,
    &T_vnd_spotfire_dxp_application,
    &T_vnd_spotfire_sfs_application,
    &T_vnd_sss_cod_application,
    &T_vnd_sss_dtf_application,
    &T_vnd_sss_ntf_application,
    &T_vnd_stardivision_math_application,
    &T_x_staroffice_template_application,
    &T_vnd_sun_xml_writer_template_application,
    &T_vnd_stardivision_writer_global_application,
    &T_vnd_street_stream_application,
    &T_vnd_sun_xml_calc_template_application,
    &T_vnd_sun_xml_draw_template_application,
    &T_vnd_sun_xml_impress_template_application,
    &T_vnd_sun_xml_math_application,
    &T_vnd_sun_xml_writer_global_application,
    &T_vnd_sun_wadl_xml_application,
    &T_vnd_sus_calendar_application,
    &T_vnd_svd_application,
    &T_vnd_swiftview_ics_application,
    &T_vnd_syncml_xml_application,
    &T_vnd_syncml_dm_wbxml_application,
    &T_vnd_syncml_dm_xml_application,
    &T_vnd_syncml_dm_notification_application,
    &T_vnd_syncml_ds_notification_application,
    &T_vnd_tao_intent_module_archive_application,
    &T_vnd_tmobile_livetv_application,
    &T_vnd_trid_tpt_application,
    &T_vnd_triscape_mxs_application,
    &T_vnd_trueapp_application,
    &T_vnd_truedoc_application,
    &T_vnd_ufdl_application,
    &T_ttml_xml_application,
    &T_vnd_uiq_theme_application,
    &T_vnd_umajin_application,
    &T_vnd_unity_application,
    &T_vnd_uoml_xml_application,
    &T_vnd_uplanet_alert_application,
    &T_vnd_uplanet_alert_wbxml_application,
    &T_vnd_uplanet_bearer_choice_application,
    &T_vnd_uplanet_bearer_choice_wbxml_application,
    &T_vnd_uplanet_cacheop_application,
    &T_vnd_uplanet_cacheop_wbxml_application,
    &T_vnd_uplanet_channel_application,
    &T_vnd_uplanet_channel_wbxml_application,
    &T_vnd_uplanet_list_application,
    &T_vnd_uplanet_list_wbxml_application,
    &T_vnd_uplanet_listcmd_application,
    &T_vnd_uplanet_listcmd_wbxml_application,
    &T_vnd_uplanet_signal_application,
    &T_vnd_vcx_application,
    &T_vnd_vd_study_application,
    &T_vnd_vectorworks_application,
    &T_vnd_vidsoft_vidconference_application,
    &T_vnd_visio_application,
    &T_vnd_ms_visio_drawing_application,
    &T_vnd_ms_visio_template_application,
    &T_vnd_ms_visio_stencil_application,
    &T_vnd_ms_visio_drawing_macroEnabled_12_application,
    &T_vnd_ms_visio_template_macroEnabled_12_application,
    &T_vnd_ms_visio_stencil_macroEnabled_12_application,
    &T_vnd_visionary_application,
    &T_vnd_vividence_scriptfile_application,
    &T_vnd_vsf_application,
    &T_vnd_wap_sic_application,
    &T_vnd_wap_slc_application,
    &T_vnd_wap_wbxml_application,
    &T_vnd_wap_wmlc_application,
    &T_vnd_wap_wmlscriptc_application,
    &T_vnd_webturbo_application,
    &T_vnd_wfa_wsc_application,
    &T_vnd_wmc_application,
    &T_vnd_wmf_bootstrap_application,
    &T_vnd_wqd_application,
    &T_vnd_wrq_hp3000_labelled_application,
    &T_vnd_wt_stf_application,
    &T_vnd_wv_csp_wbxml_application,
    &T_vnd_wv_csp_xml_application,
    &T_vnd_wv_ssp_xml_application,
    &T_vnd_xfdl_application,
    &T_vnd_xfdl_webform_application,
    &T_vnd_xmi_xml_application,
    &T_vnd_xmpie_cpkg_application,
    &T_vnd_xmpie_dpkg_application,
    &T_vnd_xmpie_plan_application,
    &T_vnd_xmpie_ppkg_application,
    &T_vnd_xmpie_xlim_application,
    &T_vnd_yamaha_hv_dic_application,
    &T_vnd_yamaha_hv_script_application,
    &T_vnd_yamaha_hv_voice_application,
    &T_vnd_yamaha_openscoreformat_application,
    &T_vnd_yamaha_openscoreformat_osfpvg_xml_application,
    &T_vnd_yamaha_smaf_audio_application,
    &T_vnd_yamaha_smaf_phrase_application,
    &T_vnd_yellowriver_custom_menu_application,
    &T_vnd_zul_application,
    &T_vnd_zzazz_deck_xml_application,
    &T_voicexml_xml_application,
    &T_warc_gz_application,
    &T_watcherinfo_xml_application,
    &T_whoispp_query_application,
    &T_whoispp_response_application,
    &T_winhlp_application,
    &T_wita_application,
    &T_wordperfect5_1_application,
    &T_wsdl_xml_application,
    &T_wspolicy_xml_application,
    &T_x_abiword_application,
    &T_x_ace_compressed_application,
    &T_x_amf_application,
    &T_x_apple_diskimage_application,
    &T_x_appleworks_application,
    &T_x_authorware_bin_application,
    &T_x_authorware_map_application,
    &T_x_authorware_seg_application,
    &T_x_bcpio_application,
    &T_x_plist_application,
    &T_x_brotli_application,
    &T_x_cdlink_application,
    &T_x_chat_application,
    &T_x_chess_pgn_application,
    &T_x_corelpresentations_application,
    &T_x_csh_application,
    &T_x_director_application,
    &T_x_doom_application,
    &T_x_dtbncx_xml_application,
    &T_x_dtbook_xml_application,
    &T_x_dtbresource_xml_application,
    &T_x_killustrator_application,
    &T_x_openscad_application,
    &T_x_dosexec_application,
    &T_x_font_bdf_application,
    &T_x_font_dos_application,
    &T_x_font_framemaker_application,
    &T_x_font_ghostscript_application,
    &T_x_font_libgrx_application,
    &T_x_font_linux_psf_application,
    &T_x_font_pcf_application,
    &T_x_font_snf_application,
    &T_x_font_speedo_application,
    &T_x_font_sunos_news_application,
    &T_x_font_vfont_application,
    &T_x_futuresplash_application,
    &T_x_gnucash_application,
    &T_x_esri_layer_application,
    &T_x_hwp_v5_application,
    &T_hwp_zip_application,
    &T_x_itunes_bplist_application,
    &T_x_itunes_ipa_application,
    &T_x_java_jnlp_file_application,
    &T_x_java_pack200_application,
    &T_x_lzma_application,
    &T_x_memgraph_application,
    &T_x_ms_application_application,
    &T_x_ms_wmd_application,
    &T_x_ms_wmz_application,
    &T_x_ms_xbap_application,
    &T_x_msbinder_application,
    &T_x_mscardfile_application,
    &T_x_msclip_application,
    &T_x_ms_installer_application,
    &T_x_msmediaview_application,
    &T_x_mspublisher_application,
    &T_x_msschedule_application,
    &T_x_msterminal_application,
    &T_x_mysql_misam_data_application,
    &T_x_pds_application,
    &T_x_pkcs12_application,
    &T_x_pkcs7_certificates_application,
    &T_x_pkcs7_certreqresp_application,
    &T_xquery_application,
    &T_x_roxio_toast_application,
    &T_x_sas_application,
    &T_x_sas_program_data_application,
    &T_x_sas_audit_application,
    &T_x_sas_view_application,
    &T_x_sas_data_index_application,
    &T_x_sas_catalog_application,
    &T_x_sas_access_application,
    &T_x_sas_fdb_application,
    &T_x_sas_mddb_application,
    &T_x_sas_dmdb_application,
    &T_x_sas_itemstor_application,
    &T_x_sas_utility_application,
    &T_x_sas_putility_application,
    &T_x_sas_transport_application,
    &T_x_sas_backup_application,
    &T_x_shar_application,
    &T_x_silverlight_app_application,
    &T_x_sfdu_application,
    &T_x_stata_do_application,
    &T_x_stuffitx_application,
    &T_x_sv4cpio_application,
    &T_x_sv4crc_application,
    &T_x_tex_tfm_application,
    &T_x_tika_msoffice_embedded_format_ole10_native_application,
    &T_x_tika_msoffice_embedded_format_comp_obj_application,
    &T_x_tika_ooxml_protected_application,
    &T_x_ustar_application,
    &T_x_vmdk_application,
    &T_x_wais_source_application,
    &T_x_webarchive_application,
    &T_x_xfig_application,
    &T_x_xpinstall_application,
    &T_x_xmind_application,
    &T_x400_bp_application,
    &T_xcap_att_xml_application,
    &T_xcap_caps_xml_application,
    &T_xcap_el_xml_application,
    &T_xcap_error_xml_application,
    &T_xcap_ns_xml_application,
    &T_xcon_conference_info_diff_xml_application,
    &T_xcon_conference_info_xml_application,
    &T_xenc_xml_application,
    &T_xhtml_voice_xml_application,
    &T_xml_dtd_application,
    &T_xml_external_parsed_entity_application,
    &T_xmpp_xml_application,
    &T_xop_xml_application,
    &T_xslfo_xml_application,
    &T_xslt_xml_application,
    &T_xspf_xml_application,
    &T_xv_xml_application,
    &T_32kadpcm_audio,
    &T_adpcm_audio,
    &T_amr_wb__audio,
    &T_asc_audio,
    &T_bv16_audio,
    &T_bv32_audio,
    &T_clearmode_audio,
    &T_cn_audio,
    &T_dat12_audio,
    &T_dls_audio,
    &T_dsr_es201108_audio,
    &T_dsr_es202050_audio,
    &T_dsr_es202211_audio,
    &T_dsr_es202212_audio,
    &T_dvi4_audio,
    &T_evrc_audio,
    &T_evrc_qcp_audio,
    &T_evrc0_audio,
    &T_evrc1_audio,
    &T_evrcb_audio,
    &T_evrcb0_audio,
    &T_evrcb1_audio,
    &T_evrcwb_audio,
    &T_evrcwb0_audio,
    &T_evrcwb1_audio,
    &T_example_audio,
    &T_g719_audio,
    &T_g722_audio,
    &T_g7221_audio,
    &T_g723_audio,
    &T_g726_16_audio,
    &T_g726_24_audio,
    &T_g726_32_audio,
    &T_g726_40_audio,
    &T_g728_audio,
    &T_g729_audio,
    &T_g7291_audio,
    &T_g729d_audio,
    &T_g729e_audio,
    &T_gsm_audio,
    &T_gsm_efr_audio,
    &T_ilbc_audio,
    &T_l16_audio,
    &T_l20_audio,
    &T_l24_audio,
    &T_l8_audio,
    &T_lpc_audio,
    &T_mobile_xmf_audio,
    &T_mp4a_latm_audio,
    &T_mpa_audio,
    &T_mpa_robust_audio,
    &T_mpeg4_generic_audio,
    &T_parityfec_audio,
    &T_pcma_audio,
    &T_pcma_wb_audio,
    &T_pcmu_wb_audio,
    &T_pcmu_audio,
    &T_red_audio,
    &T_rtp_enc_aescm128_audio,
    &T_rtp_midi_audio,
    &T_rtx_audio,
    &T_smv_audio,
    &T_smv0_audio,
    &T_smv_qcp_audio,
    &T_sp_midi_audio,
    &T_t140c_audio,
    &T_t38_audio,
    &T_telephone_event_audio,
    &T_tone_audio,
    &T_ulpfec_audio,
    &T_vdvi_audio,
    &T_vmr_wb_audio,
    &T_vnd_3gpp_iufp_audio,
    &T_vnd_4sb_audio,
    &T_vnd_audiokoz_audio,
    &T_vnd_adobe_soundbooth_audio,
    &T_vnd_celp_audio,
    &T_vnd_cisco_nse_audio,
    &T_vnd_cmles_radio_events_audio,
    &T_vnd_cns_anp1_audio,
    &T_vnd_cns_inf1_audio,
    &T_vnd_digital_winds_audio,
    &T_vnd_dlna_adts_audio,
    &T_vnd_dolby_heaac_1_audio,
    &T_vnd_dolby_heaac_2_audio,
    &T_vnd_dolby_mlp_audio,
    &T_vnd_dolby_mps_audio,
    &T_vnd_dolby_pl2_audio,
    &T_vnd_dolby_pl2x_audio,
    &T_vnd_dolby_pl2z_audio,
    &T_vnd_dts_audio,
    &T_vnd_dts_hd_audio,
    &T_vnd_everad_plj_audio,
    &T_vnd_hns_audio_audio,
    &T_vnd_lucent_voice_audio,
    &T_vnd_ms_playready_media_pya_audio,
    &T_vnd_nokia_mobile_xmf_audio,
    &T_vnd_nortel_vbk_audio,
    &T_vnd_nuera_ecelp4800_audio,
    &T_vnd_nuera_ecelp7470_audio,
    &T_vnd_nuera_ecelp9600_audio,
    &T_vnd_octel_sbc_audio,
    &T_vnd_qcelp_audio,
    &T_vnd_rhetorex_32kadpcm_audio,
    &T_vnd_sealedmedia_softseal_mpeg_audio,
    &T_vnd_vmx_cvsd_audio,
    &T_vorbis_config_audio,
    &T_x_ms_wax_audio,
    &T_x_pn_realaudio_plugin_audio,
    &T_x_cif_chemical,
    &T_x_cmdf_chemical,
    &T_x_cml_chemical,
    &T_x_csml_chemical,
    &T_x_pdb_chemical,
    &T_x_xyz_chemical,
    &T_x_emf_compressed_image,
    &T_example_image,
    &T_g3fax_image,
    &T_ief_image,
    &T_naplps_image,
    &T_prs_btif_image,
    &T_prs_pti_image,
    &T_t38_image,
    &T_tiff_fx_image,
    &T_vnd_adobe_premiere_image,
    &T_vnd_cns_inf2_image,
    &T_vnd_dgn_version_8_image,
    &T_vnd_fastbidsheet_image,
    &T_vnd_fpx_image,
    &T_vnd_fst_image,
    &T_vnd_fujixerox_edmics_mmr_image,
    &T_vnd_fujixerox_edmics_rlc_image,
    &T_vnd_globalgraphics_pgb_image,
    &T_vnd_mix_image,
    &T_vnd_net_fpx_image,
    &T_vnd_sealed_png_image,
    &T_vnd_sealedmedia_softseal_gif_image,
    &T_vnd_sealedmedia_softseal_jpg_image,
    &T_vnd_svf_image,
    &T_vnd_wap_wbmp_image,
    &T_vnd_xiff_image,
    &T_x_cmu_raster_image,
    &T_x_cmx_image,
    &T_x_raw_adobe_image,
    &T_x_raw_hasselblad_image,
    &T_x_raw_fuji_image,
    &T_x_raw_kodak_image,
    &T_x_raw_minolta_image,
    &T_x_raw_nikon_image,
    &T_x_raw_pentax_image,
    &T_x_raw_sony_image,
    &T_x_raw_sigma_image,
    &T_x_raw_epson_image,
    &T_x_raw_mamiya_image,
    &T_x_raw_leaf_image,
    &T_x_raw_panasonic_image,
    &T_x_raw_phaseone_image,
    &T_x_raw_red_image,
    &T_x_raw_imacon_image,
    &T_x_raw_logitech_image,
    &T_x_raw_casio_image,
    &T_x_raw_rawzor_image,
    &T_x_xwindowdump_image,
    &T_cpim_message,
    &T_delivery_status_message,
    &T_disposition_notification_message,
    &T_example_message,
    &T_external_body_message,
    &T_global_message,
    &T_global_delivery_status_message,
    &T_global_disposition_notification_message,
    &T_global_headers_message,
    &T_http_message,
    &T_imdn_xml_message,
    &T_partial_message,
    &T_s_http_message,
    &T_sip_message,
    &T_sipfrag_message,
    &T_tracking_status_message,
    &T_vnd_si_simp_message,
    &T_example_model,
    &T_iges_model,
    &T_mesh_model,
    &T_x_stl_binary_model,
    &T_vnd_dwfx_xps_model,
    &T_vnd_flatland_3dml_model,
    &T_vnd_gdl_model,
    &T_vnd_gs_gdl_model,
    &T_vnd_gtw_model,
    &T_vnd_moml_xml_model,
    &T_vnd_mts_model,
    &T_vnd_parasolid_transmit_binary_model,
    &T_vnd_parasolid_transmit_text_model,
    &T_vnd_vtu_model,
    &T_vrml_model,
    &T_alternative_multipart,
    &T_byteranges_multipart,
    &T_digest_multipart,
    &T_encrypted_multipart,
    &T_example_multipart,
    &T_form_data_multipart,
    &T_header_set_multipart,
    &T_mixed_multipart,
    &T_parallel_multipart,
    &T_report_multipart,
    &T_signed_multipart,
    &T_voice_message_multipart,
    &T_dif_xml_application,
    &T_onix_message_xml_application,
    &T_onix_message_short_xml_application,
    &T_x_actionscript_text,
    &T_x_ada_text,
    &T_x_applescript_text,
    &T_asp_text,
    &T_aspdotnet_text,
    &T_x_aspectj_text,
    &T_x_assembly_text,
    &T_x_config_text,
    &T_css_text,
    &T_csv_text,
    &T_directory_text,
    &T_dns_text,
    &T_ecmascript_text,
    &T_enriched_text,
    &T_example_text,
    &T_parityfec_text,
    &T_prs_fallenstein_rst_text,
    &T_prs_lines_tag_text,
    &T_red_text,
    &T_rfc822_headers_text,
    &T_richtext_text,
    &T_rtp_enc_aescm128_text,
    &T_rtx_text,
    &T_sgml_text,
    &T_t140_text,
    &T_tab_separated_values_text,
    &T_ulpfec_text,
    &T_uri_list_text,
    &T_vnd_abc_text,
    &T_vnd_curl_text,
    &T_vnd_curl_dcurl_text,
    &T_vnd_curl_scurl_text,
    &T_vnd_curl_mcurl_text,
    &T_vnd_dmclientscript_text,
    &T_vnd_esmertec_theme_descriptor_text,
    &T_vnd_fly_text,
    &T_vnd_fmi_flexstor_text,
    &T_vnd_in3d_3dml_text,
    &T_vnd_in3d_spot_text,
    &T_vnd_iptc_newsml_text,
    &T_vnd_iptc_nitf_text,
    &T_vnd_latex_z_text,
    &T_vnd_motorola_reflex_text,
    &T_vnd_ms_mediapackage_text,
    &T_vnd_net2phone_commcenter_command_text,
    &T_vnd_si_uricatalogue_text,
    &T_vnd_sun_j2me_app_descriptor_text,
    &T_vnd_trolltech_linguist_text,
    &T_vnd_wap_si_text,
    &T_vnd_wap_sl_text,
    &T_vnd_wap_wml_text,
    &T_vnd_wap_wmlscript_text,
    &T_x_c__hdr_text,
    &T_x_c__src_text,
    &T_x_cgi_text,
    &T_x_clojure_text,
    &T_x_coffeescript_text,
    &T_x_csharp_text,
    &T_x_cobol_text,
    &T_x_coldfusion_text,
    &T_x_common_lisp_text,
    &T_x_eiffel_text,
    &T_x_emacs_lisp_text,
    &T_x_erlang_text,
    &T_x_expect_text,
    &T_x_forth_text,
    &T_x_fortran_text,
    &T_x_go_text,
    &T_x_groovy_text,
    &T_x_haskell_text,
    &T_x_idl_text,
    &T_x_ini_text,
    &T_x_java_source_text,
    &T_x_java_properties_text,
    &T_x_less_text,
    &T_x_lex_text,
    &T_x_log_text,
    &T_x_ml_text,
    &T_x_modula_text,
    &T_x_objcsrc_text,
    &T_x_ocaml_text,
    &T_x_pascal_text,
    &T_x_prolog_text,
    &T_x_rst_text,
    &T_x_rexx_text,
    &T_x_ruby_text,
    &T_x_scala_text,
    &T_x_scheme_text,
    &T_x_sed_text,
    &T_x_sql_text,
    &T_x_setext_text,
    &T_x_stsrc_text,
    &T_x_vbdotnet_text,
    &T_x_vbscript_text,
    &T_x_verilog_text,
    &T_x_vhdl_text,
    &T_x_web_markdown_text,
    &T_x_yacc_text,
    &T_x_yaml_text,
    &T_3gpp_tt_video,
    &T_bmpeg_video,
    &T_bt656_video,
    &T_celb_video,
    &T_dv_video,
    &T_example_video,
    &T_h261_video,
    &T_h263_video,
    &T_h263_1998_video,
    &T_h263_2000_video,
    &T_h264_video,
    &T_iso_segment_video,
    &T_jpeg_video,
    &T_jpeg2000_video,
    &T_mp1s_video,
    &T_mp2p_video,
    &T_mp2t_video,
    &T_mp4v_es_video,
    &T_mpeg4_generic_video,
    &T_mpv_video,
    &T_nv_video,
    &T_parityfec_video,
    &T_pointer_video,
    &T_raw_video,
    &T_rtp_enc_aescm128_video,
    &T_rtx_video,
    &T_smpte292m_video,
    &T_ulpfec_video,
    &T_vc1_video,
    &T_vnd_cctv_video,
    &T_vnd_dlna_mpeg_tts_video,
    &T_vnd_fvt_video,
    &T_vnd_hns_video_video,
    &T_vnd_iptvforum_1dparityfec_1010_video,
    &T_vnd_iptvforum_1dparityfec_2005_video,
    &T_vnd_iptvforum_2dparityfec_1010_video,
    &T_vnd_iptvforum_2dparityfec_2005_video,
    &T_vnd_iptvforum_ttsavc_video,
    &T_vnd_iptvforum_ttsmpeg2_video,
    &T_vnd_motorola_video_video,
    &T_vnd_motorola_videop_video,
    &T_vnd_mpegurl_video,
    &T_vnd_ms_playready_media_pyv_video,
    &T_vnd_nokia_interleaved_multimedia_video,
    &T_vnd_nokia_videovoip_video,
    &T_vnd_objectvideo_video,
    &T_vnd_sealed_mpeg1_video,
    &T_vnd_sealed_mpeg4_video,
    &T_vnd_sealed_swf_video,
    &T_vnd_sealedmedia_softseal_mov_video,
    &T_vnd_vivo_video,
    &T_x_f4v_video,
    &T_x_flc_video,
    &T_x_fli_video,
    &T_x_ms_asx_application,
    &T_x_ms_wm_video,
    &T_x_ms_wmx_video,
    &T_x_ms_wvx_video,
    &T_x_matroska_audio,
    &T_x_cooltalk_x_conference,
    &T_x_fictionbook_xml_application,
    &T_x_asciidoc_text,
    &T_x_d_text,
    &T_x_haml_text,
    &T_x_haxe_text,
    &T_x_xliff_xml_application,
    &T_x_xliff_zip_application,
    &T_x_rsrc_text,
    &T_x_scss_text,
    &T_x_sass_text,
    &T_vnd_shp_application,
    &T_vnd_shx_application,
    &T_owl_xml_application,
    &T_vnd_collada_xml_model,
    &T_gml_xml_application,
    &T_gpx_xml_application,
    &T_vnd_garmin_tcx_xml_application,
    &T_x3d_xml_model,
    &T_dita_xml_format_topic_application,
    &T_x_vnd_datapackage_zip_application,
    &T_vnd_oasis_opendocument_graphics_application,
    &T_vnd_oasis_opendocument_image_application,
    &T_vnd_oasis_opendocument_presentation_application,
    &T_vnd_oasis_opendocument_spreadsheet_application,
    &T_vnd_sun_xml_calc_application,
    &T_vnd_sun_xml_draw_application,
    &T_vnd_sun_xml_impress_application,
    &T_vnd_sun_xml_writer_application,
    &T_vnd_dgn_image,
    &T_x_basic_text,
    &T_json_application,
    &T_quicktime_application,
    &T_onenote_application,
    &T_x_tika_msoffice_embedded_application,
    &T_x_x509_cert_application,
    &T_x_x509_key_application,
    &T_vnd_dxf_image,
    &T_x_vbasic_text,
    &T_x_ms_asf_video,
    &T_java_archive_application,
    &T_sereal_application,
    &T_vnd_oasis_opendocument_text_application,
    &T_vnd_oasis_opendocument_tika_flat_document_application,
    &T_dita_xml_application,
    &T_vnd_apple_iwork_application,
    &T_x_berkeley_db_application,
    &T_x_mysql_db_application,
    &T_x_quattro_pro_application,
    &T_x_portable_anymap_image,
    &T_x_tika_text_based_message_text,
    &T_vnd_lotus_1_2_3_application,
    &T_x_tika_old_excel_application,
    &T_x_tika_staroffice_application,
    &T_ogg_audio,
    &T_x_tika_visio_ooxml_application,
];

pub static MIME_MAP: phf::Map<&'static str, &[&'static dyn MimeTypeChecker]> = phf_map! {
"application/vnd.airzip.filesecure.azs" => &[&T_vnd_airzip_filesecure_azs_application],
"audio/cn" => &[&T_cn_audio],
"application/vnd.intercon.formnet" => &[&T_vnd_intercon_formnet_application],
"application/vnd.ms-wmdrm.meter-resp" => &[&T_vnd_ms_wmdrm_meter_resp_application],
"application/xenc+xml" => &[&T_xenc_xml_application],
"application/vnd.oasis.opendocument.text-master" => &[&T_vnd_oasis_opendocument_text_master_application],
"application/x-stata-dta;version=13" => &[&T_x_stata_dta_version_13_application],
"application/vnd.ms-word2006ml" => &[&T_vnd_ms_word2006ml_application],
"application/x-snappy-framed" => &[&T_x_snappy_framed_application],
"application/mac-binhex" => &[&T_mac_binhex40_application],
"audio/x-caf" => &[&T_x_caf_audio],
"application/vnd.cups-postscript" => &[&T_vnd_cups_postscript_application],
"application/x-openscad" => &[&T_x_openscad_application],
"application/photoshop" => &[&T_vnd_adobe_photoshop_image],
"text/rtx" => &[&T_rtx_text],
"application/vnd.crick.clicker.template" => &[&T_vnd_crick_clicker_template_application],
"application/vnd.oasis.opendocument.presentation-template" => &[&T_vnd_oasis_opendocument_presentation_template_application],
"application/vnd.dvb.notif-init+xml" => &[&T_vnd_dvb_notif_init_xml_application],
"application/dita+xml;format=concept" => &[&T_dita_xml_format_concept_application],
"application/x-dex" => &[&T_x_dex_application],
"application/vnd.olpc-sugar" => &[&T_vnd_olpc_sugar_application],
"video/vnd.ms-playready.media.pyv" => &[&T_vnd_ms_playready_media_pyv_video],
"application/x-wacz" => &[&T_x_wacz_application],
"application/vnd.sun.wadl+xml" => &[&T_vnd_sun_wadl_xml_application],
"image/vnd.zbrush.dcx" => &[&T_vnd_zbrush_dcx_image],
"application/vnd.apple.installer+xml" => &[&T_vnd_apple_installer_xml_application],
"application/x-authorware-bin" => &[&T_x_authorware_bin_application],
"application/x-mach-o-bundle" => &[&T_x_mach_o_bundle_application],
"application/x-vhd" => &[&T_x_vhd_application],
"image/vnd.svf" => &[&T_vnd_svf_image],
"video/h261" => &[&T_h261_video],
"application/vnd.fujitsu.oasys3" => &[&T_vnd_fujitsu_oasys3_application],
"application/simple-filter+xml" => &[&T_simple_filter_xml_application],
"application/vnd.etsi.iptvdiscovery+xml" => &[&T_vnd_etsi_iptvdiscovery_xml_application],
"image/prs.pti" => &[&T_prs_pti_image],
"application/vnd.xmi+xml" => &[&T_vnd_xmi_xml_application],
"image/vnd.globalgraphics.pgb" => &[&T_vnd_globalgraphics_pgb_image],
"text/directory" => &[&T_directory_text],
"video/mp4" => &[&T_mp4_video],
"application/x-yaml" => &[&T_x_yaml_text],
"application/vnd.route66.link66+xml" => &[&T_vnd_route66_link66_xml_application],
"application/vnd.shana.informed.interchange" => &[&T_vnd_shana_informed_interchange_application],
"text/x-verilog" => &[&T_x_verilog_text],
"application/x-tika-ooxml-protected" => &[&T_x_tika_ooxml_protected_application],
"audio/parityfec" => &[&T_parityfec_audio],
"application/vnd.pwg-xhtml-print+xml" => &[&T_vnd_pwg_xhtml_print_xml_application],
"application/mbms-msk+xml" => &[&T_mbms_msk_xml_application],
"application/vnd.noblenet-sealer" => &[&T_vnd_noblenet_sealer_application],
"application/vnd.marlin.drm.license+xml" => &[&T_vnd_marlin_drm_license_xml_application],
"audio/dsr-es202050" => &[&T_dsr_es202050_audio],
"application/cellml+xml" => &[&T_cellml_xml_application],
"audio/vnd.dolby.pl2" => &[&T_vnd_dolby_pl2_audio],
"application/x-autocad" => &[&T_vnd_dwg_image],
"application/rtx" => &[&T_rtx_application],
"audio/x-ogg-flac" => &[&T_x_oggflac_audio],
"application/vnd.oma.xcap-directory+xml" => &[&T_vnd_oma_xcap_directory_xml_application],
"application/vnd.audiograph" => &[&T_vnd_audiograph_application],
"image/x-icns" => &[&T_icns_image],
"application/x-tcl" => &[&T_x_tcl_text],
"application/x-vnd.oasis.opendocument.graphics" => &[&T_vnd_oasis_opendocument_graphics_application],
"audio/x-oggflac" => &[&T_x_oggflac_audio],
"application/x-font-sunos-news" => &[&T_x_font_sunos_news_application],
"application/x-berkeley-db;format=hash;version=5" => &[&T_x_berkeley_db_format_hash_version_5_application],
"application/x-isatab-assay" => &[&T_x_isatab_assay_application],
"text/ulpfec" => &[&T_ulpfec_text],
"application/octet-stream" => &[&T_octet_stream_application],
"application/sereal;version=1" => &[&T_sereal_version_1_application],
"application/vnd.oma.bcast.sprov+xml" => &[&T_vnd_oma_bcast_sprov_xml_application],
"application/x-ibooks+zip" => &[&T_x_ibooks_zip_application],
"application/vnd.jcp.javame.midlet-rms" => &[&T_vnd_jcp_javame_midlet_rms_application],
"application/vnd.mcd" => &[&T_vnd_mcd_application],
"image/x-xpixmap" => &[&T_x_xpixmap_image],
"application/x-frame" => &[&T_vnd_mif_application],
"text/xsl" => &[&T_xslfo_xml_application,&T_xslt_xml_application],
"application/vnd.crick.clicker" => &[&T_vnd_crick_clicker_application],
"application/xcap-error+xml" => &[&T_xcap_error_xml_application],
"application/vnd.eudora.data" => &[&T_vnd_eudora_data_application],
"application/x-ms-installer" => &[&T_x_ms_installer_application],
"application/x-sqlite3" => &[&T_x_sqlite3_application],
"audio/x-adpcm" => &[&T_x_adpcm_audio],
"image/x-wmf" => &[&T_wmf_image],
"text/x-coffeescript" => &[&T_x_coffeescript_text],
"application/x-msdownload;format=pe-itanium" => &[&T_x_msdownload_format_pe_itanium_application],
"application/shf+xml" => &[&T_shf_xml_application],
"image/x-freehand" => &[&T_x_freehand_image],
"image/x-jb2" => &[&T_x_jbig2_image],
"application/simplesymbolcontainer" => &[&T_simplesymbolcontainer_application],
"audio/vnd.4sb" => &[&T_vnd_4sb_audio],
"image/x-icon" => &[&T_vnd_microsoft_icon_image],
"application/vnd.hp-hpgl" => &[&T_vnd_hp_hpgl_application],
"application/onix-message-short+xml" => &[&T_onix_message_short_xml_application],
"application/vnd.nokia.n-gage.symbian.install" => &[&T_vnd_nokia_n_gage_symbian_install_application],
"application/vnd.sealed.3df" => &[&T_vnd_sealed_3df_application],
"chemical/x-cmdf" => &[&T_x_cmdf_chemical],
"application/auth-policy+xml" => &[&T_auth_policy_xml_application],
"application/vnd.uplanet.listcmd" => &[&T_vnd_uplanet_listcmd_application],
"application/x-stata-dta;version=14" => &[&T_x_stata_dta_version_14_application],
"application/x-sc" => &[&T_x_sc_application],
"audio/rtp-midi" => &[&T_rtp_midi_audio],
"application/vnd.mitsubishi.misty-guard.trustweb" => &[&T_vnd_mitsubishi_misty_guard_trustweb_application],
"application/x-stuffitx" => &[&T_x_stuffitx_application],
"image/vnd.dgn;version=8" => &[&T_vnd_dgn_version_8_image],
"application/x-esri-layer" => &[&T_x_esri_layer_application],
"application/x-idl-save-file" => &[&T_x_idl_save_file_application],
"application/x-berkeley-db" => &[&T_x_berkeley_db_application],
"audio/prs.sid" => &[&T_prs_sid_audio],
"image/bmp" => &[&T_bmp_image],
"application/x-dvi" => &[&T_x_dvi_application],
"image/x-raw-sony" => &[&T_x_raw_sony_image],
"text/x-uuencode" => &[&T_x_uuencode_text],
"drawing/x-dwf" => &[&T_vnd_dwf_model],
"application/vnd.epson.salt" => &[&T_vnd_epson_salt_application],
"text/x-actionscript" => &[&T_x_actionscript_text],
"application/vnd.japannet-payment-wakeup" => &[&T_vnd_japannet_payment_wakeup_application],
"application/envi.hdr" => &[&T_envi_hdr_application],
"application/index.response" => &[&T_index_response_application],
"application/winhlp" => &[&T_winhlp_application],
"application/vnd.oma.bcast.stkm" => &[&T_vnd_oma_bcast_stkm_application],
"application/wspolicy+xml" => &[&T_wspolicy_xml_application],
"application/vnd.lotus-wordpro" => &[&T_vnd_lotus_wordpro_application],
"application/xmpp+xml" => &[&T_xmpp_xml_application],
"application/tzif" => &[&T_tzif_application],
"application/x-vnd.oasis.opendocument.presentation-template" => &[&T_vnd_oasis_opendocument_presentation_template_application],
"image/x-raw-hasselblad" => &[&T_x_raw_hasselblad_image],
"application/x-x509-cert;format=pem" => &[&T_x_x509_cert_format_pem_application],
"image/vnd.fpx" => &[&T_vnd_fpx_image],
"application/vnd.ericsson.quickcall" => &[&T_vnd_ericsson_quickcall_application],
"application/vnd.shana.informed.package" => &[&T_vnd_shana_informed_package_application],
"video/vnd.fvt" => &[&T_vnd_fvt_video],
"application/mac-compactpro" => &[&T_mac_compactpro_application],
"application/resource-lists+xml" => &[&T_resource_lists_xml_application],
"video/vnd.nokia.interleaved-multimedia" => &[&T_vnd_nokia_interleaved_multimedia_video],
"application/vnd.cybank" => &[&T_vnd_cybank_application],
"audio/t140c" => &[&T_t140c_audio],
"application/x-internet-archive" => &[&T_x_internet_archive_application],
"application/x-filemaker" => &[&T_x_filemaker_application],
"video/vnd.objectvideo" => &[&T_vnd_objectvideo_video],
"application/vnd.motorola.flexsuite.gotap" => &[&T_vnd_motorola_flexsuite_gotap_application],
"application/epub+zip" => &[&T_epub_zip_application],
"application/x-elf" => &[&T_x_elf_application],
"application/vnd.oma.bcast.ltkm" => &[&T_vnd_oma_bcast_ltkm_application],
"application/vnd.iccprofile" => &[&T_vnd_iccprofile_application],
"audio/vnd.wave" => &[&T_vnd_wave_audio],
"audio/lpc" => &[&T_lpc_audio],
"multipart/encrypted" => &[&T_encrypted_multipart],
"text/x-python" => &[&T_x_python_text],
"application/x-erdas-hfa" => &[&T_x_erdas_hfa_application],
"application/yaml" => &[&T_x_yaml_text],
"audio/mpa" => &[&T_mpa_audio],
"application/vnd.avistar+xml" => &[&T_vnd_avistar_xml_application],
"video/mpeg" => &[&T_mpeg_video],
"application/x-tika-unix-dump" => &[&T_x_tika_unix_dump_application],
"application/x-project" => &[&T_x_project_application],
"application/x-vnd.datapackage+zip" => &[&T_x_vnd_datapackage_zip_application],
"application/vnd.groove-help" => &[&T_vnd_groove_help_application],
"application/x-sv4crc" => &[&T_x_sv4crc_application],
"application/vnd.oasis.opendocument.flat.spreadsheet" => &[&T_vnd_oasis_opendocument_flat_spreadsheet_application],
"application/vnd.wqd" => &[&T_vnd_wqd_application],
"application/vnd.iptc.g2.conceptitem+xml" => &[&T_vnd_iptc_g2_conceptitem_xml_application],
"application/vnd.ms-asf" => &[&T_vnd_ms_asf_application],
"application/marc" => &[&T_marc_application],
"application/x-quattro-pro;version=1-4" => &[&T_x_quattro_pro_version_1_4_application],
"text/vnd.latex-z" => &[&T_vnd_latex_z_text],
"audio/evrc1" => &[&T_evrc1_audio],
"application/vnd.piaccess.application-licence" => &[&T_vnd_piaccess_application_licence_application],
"application/vnd.xmpie.ppkg" => &[&T_vnd_xmpie_ppkg_application],
"text/x-setext" => &[&T_x_setext_text],
"audio/rtp-enc-aescm128" => &[&T_rtp_enc_aescm128_audio],
"application/vnd.oma.bcast.drm-trigger+xml" => &[&T_vnd_oma_bcast_drm_trigger_xml_application],
"application/vnd.rim.cod" => &[&T_vnd_rim_cod_application],
"image/vnd.dwg" => &[&T_vnd_dwg_image],
"image/x-xbitmap" => &[&T_x_xbitmap_image],
"image/heic" => &[&T_heic_image],
"application/x-bittorrent" => &[&T_x_bittorrent_application],
"application/vnd.xmpie.xlim" => &[&T_vnd_xmpie_xlim_application],
"application/vnd.uplanet.cacheop" => &[&T_vnd_uplanet_cacheop_application],
"application/vnd.musician" => &[&T_vnd_musician_application],
"audio/x-aiff" => &[&T_x_aiff_audio],
"image/vnd.cns.inf2" => &[&T_vnd_cns_inf2_image],
"application/xcap-ns+xml" => &[&T_xcap_ns_xml_application],
"application/vnd.oma.dd2+xml" => &[&T_vnd_oma_dd2_xml_application],
"application/oda" => &[&T_oda_application],
"application/postscript" => &[&T_postscript_application],
"application/x-unix-archive" => &[&T_x_archive_application],
"multipart/mixed" => &[&T_mixed_multipart],
"application/vnd.ms-visio.template" => &[&T_vnd_ms_visio_template_application],
"text/vnd.wap.sl" => &[&T_vnd_wap_sl_text],
"model/vnd.flatland.3dml" => &[&T_vnd_flatland_3dml_model],
"application/vnd.cendio.thinlinc.clientconf" => &[&T_vnd_cendio_thinlinc_clientconf_application],
"application/vnd.kde.kword" => &[&T_vnd_kde_kword_application],
"model/vnd.mts" => &[&T_vnd_mts_model],
"image/x-jp2-container" => &[&T_x_jp2_container_image],
"application/vnd.sealed.eml" => &[&T_vnd_sealed_eml_application],
"application/vnd.uplanet.listcmd-wbxml" => &[&T_vnd_uplanet_listcmd_wbxml_application],
"application/vnd.anser-web-funds-transfer-initiation" => &[&T_vnd_anser_web_funds_transfer_initiation_application],
"application/vnd.japannet-registration" => &[&T_vnd_japannet_registration_application],
"application/vnd.ms-powerpoint" => &[&T_vnd_ms_powerpoint_application],
"text/x-rsrc" => &[&T_x_rsrc_text],
"application/font-woff" => &[&T_woff_font],
"video/3g2" => &[&T_3gpp2_video],
"application/vnd.nokia.conml+xml" => &[&T_vnd_nokia_conml_xml_application],
"application/vnd.stardivision.calc" => &[&T_vnd_stardivision_calc_application],
"application/x-coredump" => &[&T_x_coredump_application],
"application/example" => &[&T_example_application],
"text/x-sed" => &[&T_x_sed_text],
"application/x-dbm" => &[&T_x_berkeley_db_application],
"application/x-roxio-toast" => &[&T_x_roxio_toast_application],
"application/vnd.xfdl" => &[&T_vnd_xfdl_application],
"text/t140" => &[&T_t140_text],
"application/vnd.mobius.msl" => &[&T_vnd_mobius_msl_application],
"application/ocsp-request" => &[&T_ocsp_request_application],
"application/x-lha" => &[&T_x_lha_application],
"application/cea-2018+xml" => &[&T_cea_2018_xml_application],
"application/vnd.sun.xml.math" => &[&T_vnd_sun_xml_math_application],
"application/x-vmdk" => &[&T_x_vmdk_application],
"image/nitf" => &[&T_nitf_image],
"text/x-perl" => &[&T_x_perl_text],
"audio/g722" => &[&T_g722_audio],
"audio/evrcwb0" => &[&T_evrcwb0_audio],
"application/java-serialized-object" => &[&T_java_serialized_object_application],
"application/x-fictionbook+xml" => &[&T_x_fictionbook_xml_application],
"text/x-chdr" => &[&T_x_chdr_text],
"video/pointer" => &[&T_pointer_video],
"application/x-x509-ca-cert" => &[&T_x_x509_cert_application],
"application/x-mysql-misam-compressed-index" => &[&T_x_mysql_misam_compressed_index_application],
"image/x-jbig2" => &[&T_x_jbig2_image],
"application/edi-x12" => &[&T_edi_x12_application],
"application/x-fossil-repository" => &[&T_x_fossil_repository_application],
"application/vnd.msa-disk-image" => &[&T_vnd_msa_disk_image_application],
"application/vnd.xmpie.plan" => &[&T_vnd_xmpie_plan_application],
"multipart/parallel" => &[&T_parallel_multipart],
"application/vnd.yamaha.smaf-audio" => &[&T_vnd_yamaha_smaf_audio_application],
"text/rtp-enc-aescm128" => &[&T_rtp_enc_aescm128_text],
"application/bizagi-modeler" => &[&T_bizagi_modeler_application],
"video/vnd.iptvforum.2dparityfec-1010" => &[&T_vnd_iptvforum_2dparityfec_1010_video],
"application/vnd.businessobjects" => &[&T_vnd_businessobjects_application],
"application/vnd.geogebra.file" => &[&T_vnd_geogebra_file_application],
"application/x-abiword" => &[&T_x_abiword_application],
"application/vnd.nervana" => &[&T_vnd_nervana_application],
"application/vnd.dpgraph" => &[&T_vnd_dpgraph_application],
"audio/vnd.dolby.pl2x" => &[&T_vnd_dolby_pl2x_audio],
"application/vnd.epson.msf" => &[&T_vnd_epson_msf_application],
"application/x-hwp" => &[&T_x_hwp_application],
"message/partial" => &[&T_partial_message],
"application/json" => &[&T_json_application],
"application/vnd.hbci" => &[&T_vnd_hbci_application],
"application/inf" => &[&T_inf_application],
"application/x-ms-nls" => &[&T_x_ms_nls_application],
"application/vnd.ms-wmdrm.meter-chlg-req" => &[&T_vnd_ms_wmdrm_meter_chlg_req_application],
"audio/l8" => &[&T_l8_audio],
"audio/x-wav" => &[&T_vnd_wave_audio],
"application/vnd.netfpx" => &[&T_vnd_netfpx_application],
"text/vnd.sun.j2me.app-descriptor" => &[&T_vnd_sun_j2me_app_descriptor_text],
"application/vnd.muvee.style" => &[&T_vnd_muvee_style_application],
"application/vnd.ms-visio.drawing.macroEnabled.12" => &[&T_vnd_ms_visio_drawing_macroEnabled_12_application],
"video/ulpfec" => &[&T_ulpfec_video],
"audio/vnd.dolby.heaac.1" => &[&T_vnd_dolby_heaac_1_audio],
"text/x-log" => &[&T_x_log_text],
"chemical/x-pdb" => &[&T_x_pdb_chemical],
"audio/vnd.digital-winds" => &[&T_vnd_digital_winds_audio],
"application/remote-printing" => &[&T_remote_printing_application],
"text/ecmascript" => &[&T_ecmascript_text],
"audio/g728" => &[&T_g728_audio],
"application/x-director" => &[&T_x_director_application],
"application/x-mach-o-dsym" => &[&T_x_mach_o_dsym_application],
"audio/vnd.cisco.nse" => &[&T_vnd_cisco_nse_audio],
"video/vnd.cctv" => &[&T_vnd_cctv_video],
"application/vnd.lotus-approach" => &[&T_vnd_lotus_approach_application],
"model/vnd.vtu" => &[&T_vnd_vtu_model],
"application/vnd.mozilla.xul+xml" => &[&T_vnd_mozilla_xul_xml_application],
"video/theora" => &[&T_theora_video],
"application/conference-info+xml" => &[&T_conference_info_xml_application],
"application/vnd.ibm.minipay" => &[&T_vnd_ibm_minipay_application],
"application/vnd.oasis.opendocument.spreadsheet" => &[&T_vnd_oasis_opendocument_spreadsheet_application],
"application/smil+xml" => &[&T_smil_xml_application],
"text/x-java-properties" => &[&T_x_java_properties_text],
"application/vnd.cups-raster" => &[&T_vnd_cups_raster_application],
"application/vnd.uplanet.bearer-choice" => &[&T_vnd_uplanet_bearer_choice_application],
"application/vnd.hzn-3d-crossword" => &[&T_vnd_hzn_3d_crossword_application],
"application/x-monotone-source-repo" => &[&T_x_monotone_source_repo_application],
"application/x-tika-msoffice-embedded" => &[&T_x_tika_msoffice_embedded_application],
"audio/x-oggpcm" => &[&T_x_oggpcm_audio],
"audio/vdvi" => &[&T_vdvi_audio],
"application/x-sv4cpio" => &[&T_x_sv4cpio_application],
"application/vnd.iptc.g2.catalogitem+xml" => &[&T_vnd_iptc_g2_catalogitem_xml_application],
"text/red" => &[&T_red_text],
"application/mediaservercontrol+xml" => &[&T_mediaservercontrol_xml_application],
"application/pkix-pkipath" => &[&T_pkix_pkipath_application],
"application/srgs" => &[&T_srgs_application],
"video/x-ogg-uvs" => &[&T_x_ogguvs_video],
"application/sereal;version=3" => &[&T_sereal_version_3_application],
"application/x-jigdo" => &[&T_x_jigdo_application],
"application/owl+xml" => &[&T_owl_xml_application],
"application/lost+xml" => &[&T_lost_xml_application],
"application/matlab-mat" => &[&T_x_matlab_data_application],
"application/x-sas-view" => &[&T_x_sas_view_application],
"text/x-haxe" => &[&T_x_haxe_text],
"application/vnd.nokia.ncd" => &[&T_vnd_nokia_ncd_application],
"application/dca-rft" => &[&T_dca_rft_application],
"text/x-basic" => &[&T_x_basic_text],
"video/3gpp2" => &[&T_3gpp2_video],
"video/vnd.sealed.mpeg1" => &[&T_vnd_sealed_mpeg1_video],
"image/hevc" => &[&T_heic_image],
"application/vnd.etsi.mcid+xml" => &[&T_vnd_etsi_mcid_xml_application],
"application/vnd.syncml.ds.notification" => &[&T_vnd_syncml_ds_notification_application],
"text/x-sass" => &[&T_x_sass_text],
"application/vnd.openxmlformats-officedocument.wordprocessingml.template" => &[&T_vnd_openxmlformats_officedocument_wordprocessingml_template_application],
"image/vnd.fst" => &[&T_vnd_fst_image],
"application/vnd.adobe.indesign-idml-package" => &[&T_vnd_adobe_indesign_idml_package_application],
"image/x-portable-graymap" => &[&T_x_portable_graymap_image],
"application/x-x509-user-cert" => &[&T_x_x509_cert_application],
"application/x-ole-storage" => &[&T_x_ole_storage_application],
"application/vnd.ms-spreadsheetml" => &[&T_vnd_ms_spreadsheetml_application],
"image/x-dcx" => &[&T_vnd_zbrush_dcx_image],
"image/x-raw-panasonic" => &[&T_x_raw_panasonic_image],
"application/x-java-vm" => &[&T_java_vm_application],
"text/x-web-markdown" => &[&T_x_web_markdown_text],
"image/x-pcx" => &[&T_vnd_zbrush_pcx_image],
"application/vnd.lotus-1-2-3;version=1" => &[&T_vnd_lotus_1_2_3_version_1_application],
"application/x-chess-pgn" => &[&T_x_chess_pgn_application],
"application/vnd.oma.bcast.sgdu" => &[&T_vnd_oma_bcast_sgdu_application],
"model/e57" => &[&T_e57_model],
"text/rfc822-headers" => &[&T_rfc822_headers_text],
"video/x-dirac" => &[&T_x_dirac_video],
"application/x-msclip" => &[&T_x_msclip_application],
"text/vnd.iptc.anpa" => &[&T_vnd_iptc_anpa_text],
"application/vnd.hp-jlyt" => &[&T_vnd_hp_jlyt_application],
"application/vnd.kinar" => &[&T_vnd_kinar_application],
"application/vnd.picsel" => &[&T_vnd_picsel_application],
"application/x-ms-application" => &[&T_x_ms_application_application],
"application/x-mach-o-kext-bundle" => &[&T_x_mach_o_kext_bundle_application],
"application/x-msmoney" => &[&T_x_msmoney_application],
"audio/vnd.ms-playready.media.pya" => &[&T_vnd_ms_playready_media_pya_audio],
"application/commonground" => &[&T_commonground_application],
"application/vnd.ibm.electronic-media" => &[&T_vnd_ibm_electronic_media_application],
"application/vnd.ms-wmdrm.lic-resp" => &[&T_vnd_ms_wmdrm_lic_resp_application],
"chemical/x-cml" => &[&T_x_cml_chemical],
"video/vnd.iptvforum.1dparityfec-1010" => &[&T_vnd_iptvforum_1dparityfec_1010_video],
"application/vnd.koan" => &[&T_vnd_koan_application],
"application/vnd.sun.xml.writer.global" => &[&T_vnd_sun_xml_writer_global_application],
"application/coreldraw" => &[&T_coreldraw_application],
"audio/wav" => &[&T_vnd_wave_audio],
"application/vnd.uplanet.cacheop-wbxml" => &[&T_vnd_uplanet_cacheop_wbxml_application],
"audio/eac3" => &[&T_eac3_audio],
"application/vnd.sun.xml.impress" => &[&T_vnd_sun_xml_impress_application],
"application/vnd.nokia.iptv.config+xml" => &[&T_vnd_nokia_iptv_config_xml_application],
"application/scvp-cv-response" => &[&T_scvp_cv_response_application],
"application/x-esri-spatially-enabled-db" => &[&T_x_esri_spatially_enabled_db_application],
"image/g3fax" => &[&T_g3fax_image],
"video/webm" => &[&T_webm_video],
"application/x-Gnumeric-spreadsheet" => &[&T_x_gnumeric_application],
"application/x-gnucash" => &[&T_x_gnucash_application],
"video/mp1s" => &[&T_mp1s_video],
"application/vnd.epson.esf" => &[&T_vnd_epson_esf_application],
"image/vnd.dxb" => &[&T_vnd_dxb_image],
"application/x-x509-key" => &[&T_x_x509_key_application],
"application/vnd.epson.quickanime" => &[&T_vnd_epson_quickanime_application],
"application/vnd.powerbuilder75-s" => &[&T_vnd_powerbuilder75_s_application],
"application/vnd.wap.wmlc" => &[&T_vnd_wap_wmlc_application],
"application/vnd.apple.keynote" => &[&T_vnd_apple_keynote_application],
"video/dv" => &[&T_dv_video],
"application/x-vnd.oasis.opendocument.image-template" => &[&T_vnd_oasis_opendocument_image_template_application],
"text/x-csharp" => &[&T_x_csharp_text],
"image/x-raw-imacon" => &[&T_x_raw_imacon_image],
"application/vnd.sun.xml.calc.template" => &[&T_vnd_sun_xml_calc_template_application],
"application/x-xliff+zip" => &[&T_x_xliff_zip_application],
"video/vnd.dvb.file" => &[&T_vnd_dvb_file_video],
"video/smpte292m" => &[&T_smpte292m_video],
"application/simple-message-summary" => &[&T_simple_message_summary_application],
"application/x-appleworks" => &[&T_x_appleworks_application],
"text/x-d" => &[&T_x_d_text],
"application/vnd.crick.clicker.wordbank" => &[&T_vnd_crick_clicker_wordbank_application],
"application/x-gnumeric" => &[&T_x_gnumeric_application],
"image/x-portable-bitmap" => &[&T_x_portable_bitmap_image],
"application/x-vnd.oasis.opendocument.formula" => &[&T_vnd_oasis_opendocument_formula_application],
"application/vnd.syncml.dm+wbxml" => &[&T_vnd_syncml_dm_wbxml_application],
"text/x-lua" => &[&T_x_lua_text],
"text/vnd.curl.dcurl" => &[&T_vnd_curl_dcurl_text],
"application/x-font-printer-metric" => &[&T_x_font_printer_metric_application],
"application/x-rar-compressed;version=4" => &[&T_x_rar_compressed_version_4_application],
"application/scvp-cv-request" => &[&T_scvp_cv_request_application],
"application/vnd.curl.pcurl" => &[&T_vnd_curl_pcurl_application],
"application/vnd.msign" => &[&T_vnd_msign_application],
"application/lzip" => &[&T_lzip_application],
"application/sparql-results+xml" => &[&T_sparql_results_xml_application],
"application/x-xmind" => &[&T_x_xmind_application],
"application/x-ms-shortcut" => &[&T_x_ms_shortcut_application],
"application/nasdata" => &[&T_nasdata_application],
"application/x-mbtiles" => &[&T_x_mbtiles_application],
"application/set-registration-initiation" => &[&T_set_registration_initiation_application],
"application/mxf" => &[&T_mxf_application],
"application/x-setupscript" => &[&T_inf_application],
"application/vnd.vectorworks" => &[&T_vnd_vectorworks_application],
"audio/asc" => &[&T_asc_audio],
"message/global-headers" => &[&T_global_headers_message],
"application/vnd.sema" => &[&T_vnd_sema_application],
"audio/dsr-es202212" => &[&T_dsr_es202212_audio],
"image/tiff" => &[&T_tiff_image],
"image/x-portable-arbitrarymap" => &[&T_x_portable_arbitrarymap_image],
"video/vnd.iptvforum.1dparityfec-2005" => &[&T_vnd_iptvforum_1dparityfec_2005_video],
"application/x-isatab" => &[&T_x_isatab_application],
"application/illustrator" => &[&T_illustrator_application],
"audio/dat12" => &[&T_dat12_audio],
"application/vnd.kahootz" => &[&T_vnd_kahootz_application],
"application/x-berkeley-db;format=queue" => &[&T_x_berkeley_db_format_queue_application],
"application/x-mach-o-executable" => &[&T_x_mach_o_executable_application],
"application/vnd.nokia.landmarkcollection+xml" => &[&T_vnd_nokia_landmarkcollection_xml_application],
"application/x-sas-program-data" => &[&T_x_sas_program_data_application],
"application/kpml-request+xml" => &[&T_kpml_request_xml_application],
"application/ssml+xml" => &[&T_ssml_xml_application],
"application/x-mscardfile" => &[&T_x_mscardfile_application],
"application/x-coreldraw" => &[&T_coreldraw_application],
"application/x-tika-java-enterprise-archive" => &[&T_x_tika_java_enterprise_archive_application],
"audio/pcma-wb" => &[&T_pcma_wb_audio],
"chemical/x-cif" => &[&T_x_cif_chemical],
"application/vnd.motorola.iprm" => &[&T_vnd_motorola_iprm_application],
"text/vnd.ms-mediapackage" => &[&T_vnd_ms_mediapackage_text],
"application/onenote" => &[&T_onenote_application],
"audio/vnd.cmles.radio-events" => &[&T_vnd_cmles_radio_events_audio],
"image/heif" => &[&T_heif_image],
"video/x-ogm" => &[&T_x_ogm_video],
"text/x-yml" => &[&T_x_yaml_text],
"application/vnd.publishare-delta-tree" => &[&T_vnd_publishare_delta_tree_application],
"application/vnd.syncml+xml" => &[&T_vnd_syncml_xml_application],
"application/x-tex-virtual-font" => &[&T_x_tex_virtual_font_application],
"image/vnd.fastbidsheet" => &[&T_vnd_fastbidsheet_image],
"image/wmf" => &[&T_wmf_image],
"multipart/example" => &[&T_example_multipart],
"application/x-ms-emz" => &[&T_x_emf_compressed_image],
"video/h264" => &[&T_h264_video],
"font/collection" => &[&T_collection_font],
"application/x-koan" => &[&T_vnd_koan_application],
"application/vnd.iptc.g2.packageitem+xml" => &[&T_vnd_iptc_g2_packageitem_xml_application],
"image/x-raw-pentax" => &[&T_x_raw_pentax_image],
"application/vnd.yamaha.smaf-phrase" => &[&T_vnd_yamaha_smaf_phrase_application],
"application/vnd.uplanet.signal" => &[&T_vnd_uplanet_signal_application],
"message/external-body" => &[&T_external_body_message],
"video/x-ms-wmx" => &[&T_x_ms_wmx_video],
"font/woff2" => &[&T_woff2_font],
"application/vnd.uoml+xml" => &[&T_vnd_uoml_xml_application],
"application/vnd.3gpp2.tcap" => &[&T_vnd_3gpp2_tcap_application],
"application/xslt+xml" => &[&T_xslt_xml_application],
"message/example" => &[&T_example_message],
"application/set-payment" => &[&T_set_payment_application],
"audio/vnd.dolby.pl2z" => &[&T_vnd_dolby_pl2z_audio],
"application/x-subrip" => &[&T_x_subrip_application],
"message/global" => &[&T_global_message],
"text/x-vhdl" => &[&T_x_vhdl_text],
"image/x-portable-pixmap" => &[&T_x_portable_pixmap_image],
"message/disposition-notification" => &[&T_disposition_notification_message],
"application/vnd.dvb.notif-ia-msglist+xml" => &[&T_vnd_dvb_notif_ia_msglist_xml_application],
"text/x-ada" => &[&T_x_ada_text],
"application/sparql-query" => &[&T_sparql_query_application],
"application/vnd.bluetooth.ep.oob" => &[&T_vnd_bluetooth_ep_oob_application],
"application/hwp+zip" => &[&T_hwp_zip_application],
"application/vnd.vcx" => &[&T_vnd_vcx_application],
"application/x-msbinder" => &[&T_x_msbinder_application],
"text/vnd.in3d.3dml" => &[&T_vnd_in3d_3dml_text],
"audio/g729" => &[&T_g729_audio],
"application/vnd.ms-publisher" => &[&T_x_mspublisher_application],
"audio/vorbis-config" => &[&T_vorbis_config_audio],
"application/riscos" => &[&T_riscos_application],
"image/x-raw-nikon" => &[&T_x_raw_nikon_image],
"application/x-sfdu" => &[&T_x_sfdu_application],
"application/vnd.google-earth.kmz" => &[&T_vnd_google_earth_kmz_application],
"application/x-texnicard" => &[&T_x_texnicard_application],
"application/x-emf" => &[&T_emf_image],
"video/celb" => &[&T_celb_video],
"application/vnd.japannet-verification" => &[&T_vnd_japannet_verification_application],
"image/x-3ds" => &[&T_x_3ds_image],
"application/x-berkeley-db;format=btree;version=3" => &[&T_x_berkeley_db_format_btree_version_3_application],
"video/msvideo" => &[&T_x_msvideo_video],
"application/vnd.wap.wbxml" => &[&T_vnd_wap_wbxml_application],
"audio/vnd.octel.sbc" => &[&T_vnd_octel_sbc_audio],
"model/vnd.parasolid.transmit.text" => &[&T_vnd_parasolid_transmit_text_model],
"application/x-font-speedo" => &[&T_x_font_speedo_application],
"image/x-cmu-raster" => &[&T_x_cmu_raster_image],
"text/parityfec" => &[&T_parityfec_text],
"image/x-raw-minolta" => &[&T_x_raw_minolta_image],
"video/ogg" => &[&T_ogg_video],
"application/x-quattro-pro" => &[&T_x_quattro_pro_application],
"application/vnd.oma.dcd" => &[&T_vnd_oma_dcd_application],
"application/x-berkeley-db;format=hash;version=3" => &[&T_x_berkeley_db_format_hash_version_3_application],
"application/x-font-pcf" => &[&T_x_font_pcf_application],
"application/nss" => &[&T_nss_application],
"application/vnd.ms-visio.stencil" => &[&T_vnd_ms_visio_stencil_application],
"application/vnd.informedcontrol.rms+xml" => &[&T_vnd_informedcontrol_rms_xml_application],
"application/vnd.symbian.install" => &[&T_vnd_symbian_install_application],
"video/x-daala" => &[&T_daala_video],
"audio/mp4" => &[&T_mp4_audio],
"application/x-javascript" => &[&T_javascript_text],
"application/vnd.sealedmedia.softseal.pdf" => &[&T_vnd_sealedmedia_softseal_pdf_application],
"application/whoispp-response" => &[&T_whoispp_response_application],
"text/x-rst" => &[&T_x_rst_text],
"application/sgml-open-catalog" => &[&T_sgml_open_catalog_application],
"text/x-vcalendar" => &[&T_x_vcalendar_text],
"application/vnd.garmin.tcx+xml" => &[&T_vnd_garmin_tcx_xml_application],
"application/vnd.ezpix-album" => &[&T_vnd_ezpix_album_application],
"application/x-acad" => &[&T_vnd_dwg_image],
"application/ms-tnef" => &[&T_vnd_ms_tnef_application],
"application/x-mysql-misam-index" => &[&T_x_mysql_misam_index_application],
"application/vnd.etsi.asic-s+zip" => &[&T_vnd_etsi_asic_s_zip_application],
"application/vnd.oasis.opendocument.base" => &[&T_vnd_oasis_opendocument_base_application],
"audio/mp4a-latm" => &[&T_mp4a_latm_audio],
"application/pkix-cert" => &[&T_pkix_cert_application],
"application/vnd.semf" => &[&T_vnd_semf_application],
"application/gzip" => &[&T_gzip_application],
"model/iges" => &[&T_iges_model],
"text/enriched" => &[&T_enriched_text],
"text/sgml" => &[&T_sgml_text],
"application/x-kchart" => &[&T_vnd_kde_kchart_application],
"application/x-rar-compressed" => &[&T_x_rar_compressed_application],
"application/vnd.oma.drm.risd+xml" => &[&T_vnd_oma_drm_risd_xml_application],
"audio/vnd.dlna.adts" => &[&T_vnd_dlna_adts_audio],
"image/vnd.fujixerox.edmics-mmr" => &[&T_vnd_fujixerox_edmics_mmr_image],
"application/vnd.dolby.mlp" => &[&T_vnd_dolby_mlp_application],
"application/vnd.cups-raw" => &[&T_vnd_cups_raw_application],
"application/h224" => &[&T_h224_application],
"application/vnd.dvb.notif-ia-registration-request+xml" => &[&T_vnd_dvb_notif_ia_registration_request_xml_application],
"application/vnd.ms-excel.template.macroenabled.12" => &[&T_vnd_ms_excel_template_macroenabled_12_application],
"application/vnd.frogans.ltf" => &[&T_vnd_frogans_ltf_application],
"image/webp" => &[&T_webp_image],
"application/x-cdf" => &[&T_x_cdf_application],
"application/xml-dtd" => &[&T_xml_dtd_application],
"video/mpv" => &[&T_mpv_video],
"application/dita+xml;format=map" => &[&T_dita_xml_format_map_application],
"application/x-killustrator" => &[&T_x_killustrator_application],
"application/vnd.fdsn.seed" => &[&T_vnd_fdsn_seed_application],
"application/vnd.fujixerox.art-ex" => &[&T_vnd_fujixerox_art_ex_application],
"application/x-bentley-besqlite" => &[&T_x_bentley_besqlite_application],
"audio/g723" => &[&T_g723_audio],
"audio/vnd.celp" => &[&T_vnd_celp_audio],
"text/aspdotnet" => &[&T_aspdotnet_text],
"application/x-httpresponse" => &[&T_x_httpresponse_application],
"image/vnd.adobe.photoshop" => &[&T_vnd_adobe_photoshop_image],
"application/x-amiga-disk-format" => &[&T_x_amiga_disk_format_application],
"application/vnd.unity" => &[&T_vnd_unity_application],
"application/x-prt" => &[&T_x_prt_application],
"application/vnd.nokia.conml+wbxml" => &[&T_vnd_nokia_conml_wbxml_application],
"application/davmount+xml" => &[&T_davmount_xml_application],
"audio/adpcm" => &[&T_adpcm_audio],
"application/x-msaccess" => &[&T_x_msaccess_application],
"application/vnd.oasis.opendocument.graphics" => &[&T_vnd_oasis_opendocument_graphics_application],
"application/vnd.omads-email+xml" => &[&T_vnd_omads_email_xml_application],
"application/vnd.oasis.opendocument.spreadsheet-template" => &[&T_vnd_oasis_opendocument_spreadsheet_template_application],
"application/cstadata+xml" => &[&T_cstadata_xml_application],
"application/vnd.crick.clicker.keyboard" => &[&T_vnd_crick_clicker_keyboard_application],
"application/vnd.fujitsu.oasysgp" => &[&T_vnd_fujitsu_oasysgp_application],
"application/x-mysql-table-definition" => &[&T_x_mysql_table_definition_application],
"application/vnd.ecowin.series" => &[&T_vnd_ecowin_series_application],
"application/zip" => &[&T_zip_application],
"text/vnd.curl" => &[&T_vnd_curl_text],
"text/x-scheme" => &[&T_x_scheme_text],
"application/x-msi" => &[&T_x_ms_installer_application],
"video/x-ms-wm" => &[&T_x_ms_wm_video],
"message/news" => &[&T_news_message],
"application/soap+xml" => &[&T_soap_xml_application],
"application/vnd.digilite.prolights" => &[&T_vnd_digilite_prolights_application],
"application/vnd.noblenet-directory" => &[&T_vnd_noblenet_directory_application],
"application/vnd.ruckus.download" => &[&T_vnd_ruckus_download_application],
"text/x-texinfo" => &[&T_x_texinfo_application],
"multipart/appledouble" => &[&T_appledouble_multipart],
"application/x-dvd-ifo" => &[&T_x_dvd_ifo_application],
"application/x-sas-transport" => &[&T_x_sas_transport_application],
"application/parityfec" => &[&T_parityfec_application],
"application/kate" => &[&T_kate_application],
"video/jpeg2000" => &[&T_jpeg2000_video],
"text/properties" => &[&T_x_java_properties_text],
"text/vnd.iptc.newsml" => &[&T_vnd_iptc_newsml_text],
"audio/x-flac" => &[&T_x_flac_audio],
"application/reginfo+xml" => &[&T_reginfo_xml_application],
"application/illustrator+ps" => &[&T_illustrator_ps_application],
"application/vnd.oasis.opendocument.flat.text" => &[&T_vnd_oasis_opendocument_flat_text_application],
"application/vnd.intertrust.nncp" => &[&T_vnd_intertrust_nncp_application],
"application/vnd.visionary" => &[&T_vnd_visionary_application],
"application/x-sas-putility" => &[&T_x_sas_putility_application],
"application/x-cdr" => &[&T_coreldraw_application],
"application/x-isatab-investigation" => &[&T_x_isatab_investigation_application],
"model/gltf-binary" => &[&T_gltf_binary_model],
"video/x-flc" => &[&T_x_flc_video],
"application/vnd.jam" => &[&T_vnd_jam_application],
"application/vnd.arastra.swi" => &[&T_vnd_arastra_swi_application],
"text/tab-separated-values" => &[&T_tab_separated_values_text],
"audio/vnd.dts.hd" => &[&T_vnd_dts_hd_audio],
"audio/x-matroska" => &[&T_x_matroska_audio],
"application/vnd.ctct.ws+xml" => &[&T_vnd_ctct_ws_xml_application],
"application/x-gunzip" => &[&T_gzip_application],
"application/vnd.lotus-freelance" => &[&T_vnd_lotus_freelance_application],
"application/vnd.nokia.n-gage.ac+xml" => &[&T_vnd_nokia_n_gage_ac_xml_application],
"text/vnd.fmi.flexstor" => &[&T_vnd_fmi_flexstor_text],
"application/voicexml+xml" => &[&T_voicexml_xml_application],
"image/vnd.radiance" => &[&T_vnd_radiance_image],
"application/binhex" => &[&T_mac_binhex40_application],
"text/x-aspectj" => &[&T_x_aspectj_text],
"application/vnd.oma.bcast.provisioningtrigger" => &[&T_vnd_oma_bcast_provisioningtrigger_application],
"audio/vnd.nuera.ecelp4800" => &[&T_vnd_nuera_ecelp4800_audio],
"application/beep+xml" => &[&T_beep_xml_application],
"image/x-jp2-codestream" => &[&T_x_jp2_codestream_image],
"application/vnd.sbm.cid" => &[&T_vnd_sbm_cid_application],
"application/vnd.software602.filler.form+xml" => &[&T_vnd_software602_filler_form_xml_application],
"application/x-chrome-package" => &[&T_x_chrome_package_application],
"audio/clearmode" => &[&T_clearmode_audio],
"application/vnd.novadigm.edx" => &[&T_vnd_novadigm_edx_application],
"video/h263-1998" => &[&T_h263_1998_video],
"application/x-jeol-jdf" => &[&T_x_jeol_jdf_application],
"text/x-forth" => &[&T_x_forth_text],
"application/vnd.vidsoft.vidconference" => &[&T_vnd_vidsoft_vidconference_application],
"image/x-raw-epson" => &[&T_x_raw_epson_image],
"text/x-modula" => &[&T_x_modula_text],
"video/x-ms-wvx" => &[&T_x_ms_wvx_video],
"text/csv" => &[&T_csv_text],
"video/vnd.iptvforum.2dparityfec-2005" => &[&T_vnd_iptvforum_2dparityfec_2005_video],
"application/vnd.acucobol" => &[&T_vnd_acucobol_application],
"application/mp4" => &[&T_mp4_application],
"application/x-sas-dmdb" => &[&T_x_sas_dmdb_application],
"application/x-sas-fdb" => &[&T_x_sas_fdb_application],
"application/x-texinfo" => &[&T_x_texinfo_application],
"text/uri-list" => &[&T_uri_list_text],
"application/pidf-diff+xml" => &[&T_pidf_diff_xml_application],
"application/vnd.wap.slc" => &[&T_vnd_wap_slc_application],
"application/vnd.etsi.iptvsad-npvr+xml" => &[&T_vnd_etsi_iptvsad_npvr_xml_application],
"application/x-zoo" => &[&T_x_zoo_application],
"video/jpeg" => &[&T_jpeg_video],
"application/x-kspread" => &[&T_vnd_kde_kspread_application],
"audio/pcmu" => &[&T_pcmu_audio],
"application/vnd.etsi.cug+xml" => &[&T_vnd_etsi_cug_xml_application],
"application/vnd.swiftview-ics" => &[&T_vnd_swiftview_ics_application],
"text/vnd.si.uricatalogue" => &[&T_vnd_si_uricatalogue_text],
"application/applefile" => &[&T_applefile_application],
"application/vnd.nintendo.snes.rom" => &[&T_x_nesrom_application],
"application/vnd.enliven" => &[&T_vnd_enliven_application],
"image/tiff-fx" => &[&T_tiff_fx_image],
"application/dwg" => &[&T_vnd_dwg_image],
"application/vnd.ms-excel.sheet.binary.macroenabled.12" => &[&T_vnd_ms_excel_sheet_binary_macroenabled_12_application],
"model/x.stl-binary" => &[&T_x_stl_binary_model],
"application/x-7z-compressed" => &[&T_x_7z_compressed_application],
"audio/vnd.nokia.mobile-xmf" => &[&T_vnd_nokia_mobile_xmf_audio],
"application/vnd.tcpdump.pcap" => &[&T_vnd_tcpdump_pcap_application],
"application/x-atari-floppy-disk-image" => &[&T_x_atari_floppy_disk_image_application],
"application/x-x509-cert;format=der" => &[&T_x_x509_cert_format_der_application],
"application/vnd.renlearn.rlprint" => &[&T_vnd_renlearn_rlprint_application],
"image/x-niff" => &[&T_x_niff_image],
"text/iso19139+xml" => &[&T_iso19139_xml_text],
"application/dec-dx" => &[&T_dec_dx_application],
"application/x-authorware-map" => &[&T_x_authorware_map_application],
"application/news-checkgroups" => &[&T_news_checkgroups_application],
"application/x-cdlink" => &[&T_x_cdlink_application],
"application/vnd.vd-study" => &[&T_vnd_vd_study_application],
"application/vnd.spotfire.sfs" => &[&T_vnd_spotfire_sfs_application],
"application/x-bplist" => &[&T_x_bplist_application],
"application/vnd.fujitsu.oasys" => &[&T_vnd_fujitsu_oasys_application],
"application/x-tmx" => &[&T_x_tmx_application],
"application/vnd.ezpix-package" => &[&T_vnd_ezpix_package_application],
"image/vnd.microsoft.icon" => &[&T_vnd_microsoft_icon_image],
"application/x-spss-sav" => &[&T_x_spss_sav_application],
"audio/g726-40" => &[&T_g726_40_audio],
"application/vnd.sealed.ppt" => &[&T_vnd_sealed_ppt_application],
"application/vnd.lotus-1-2-3;version=3" => &[&T_vnd_lotus_1_2_3_version_3_application],
"application/vnd.nokia.catalogs" => &[&T_vnd_nokia_catalogs_application],
"application/x-mobipocket-ebook" => &[&T_x_mobipocket_ebook_application],
"application/vnd.umajin" => &[&T_vnd_umajin_application],
"application/vnd.intu.qbo" => &[&T_vnd_intu_qbo_application],
"application/vnd.oma.poc.detailed-progress-report+xml" => &[&T_vnd_oma_poc_detailed_progress_report_xml_application],
"text/vnd.in3d.spot" => &[&T_vnd_in3d_spot_text],
"application/vnd.xfdl.webform" => &[&T_vnd_xfdl_webform_application],
"application/x-berkeley-db;format=log" => &[&T_x_berkeley_db_format_log_application],
"image/x-raw-canon" => &[&T_x_raw_canon_image],
"text/vnd.motorola.reflex" => &[&T_vnd_motorola_reflex_text],
"application/vnd.groove-vcard" => &[&T_vnd_groove_vcard_application],
"application/vnd.palm" => &[&T_vnd_palm_application],
"application/vnd.oma.dcdc" => &[&T_vnd_oma_dcdc_application],
"application/x-touhou" => &[&T_x_touhou_application],
"application/mspowerpoint" => &[&T_vnd_ms_powerpoint_application],
"application/vnd.oasis.opendocument.presentation" => &[&T_vnd_oasis_opendocument_presentation_application],
"application/vnd.frogans.fnc" => &[&T_vnd_frogans_fnc_application],
"application/vnd.powerbuilder6-s" => &[&T_vnd_powerbuilder6_s_application],
"application/pgp-signature" => &[&T_pgp_signature_application],
"application/vnd.uplanet.bearer-choice-wbxml" => &[&T_vnd_uplanet_bearer_choice_wbxml_application],
"application/vnd.trueapp" => &[&T_vnd_trueapp_application],
"audio/speex" => &[&T_speex_audio],
"text/vnd.net2phone.commcenter.command" => &[&T_vnd_net2phone_commcenter_command_text],
"application/vnd.preminet" => &[&T_vnd_preminet_application],
"application/x-netcdf" => &[&T_x_netcdf_application],
"application/x-vnd.oasis.opendocument.image" => &[&T_vnd_oasis_opendocument_image_application],
"gzip/document" => &[&T_gzip_application],
"message/rfc822" => &[&T_rfc822_message],
"application/vnd.intu.qfx" => &[&T_vnd_intu_qfx_application],
"application/vnd.lotus-screencam" => &[&T_vnd_lotus_screencam_application],
"application/x-spectrum-tzx" => &[&T_x_spectrum_tzx_application],
"application/vnd.ms-excel.sheet.macroenabled.12" => &[&T_vnd_ms_excel_sheet_macroenabled_12_application],
"text/x-rexx" => &[&T_x_rexx_text],
"text/example" => &[&T_example_text],
"application/vnd.oma.poc.invocation-descriptor+xml" => &[&T_vnd_oma_poc_invocation_descriptor_xml_application],
"audio/x-pn-realaudio-plugin" => &[&T_x_pn_realaudio_plugin_audio],
"application/x-bat" => &[&T_x_bat_application],
"application/vnd.ibm.afplinedata" => &[&T_vnd_ibm_afplinedata_application],
"text/x-pascal" => &[&T_x_pascal_text],
"application/pkix-crl" => &[&T_pkix_crl_application],
"application/vnd.sun.xml.calc" => &[&T_vnd_sun_xml_calc_application],
"application/vnd.shp" => &[&T_vnd_shp_application],
"application/vnd.fujixerox.docuworks.binder" => &[&T_vnd_fujixerox_docuworks_binder_application],
"audio/g726-24" => &[&T_g726_24_audio],
"application/vnd.dvb.notif-ia-registration-response+xml" => &[&T_vnd_dvb_notif_ia_registration_response_xml_application],
"application/vnd.tao.intent-module-archive" => &[&T_vnd_tao_intent_module_archive_application],
"application/vnd.etsi.iptvcommand+xml" => &[&T_vnd_etsi_iptvcommand_xml_application],
"application/vnd.android.package-archive" => &[&T_vnd_android_package_archive_application],
"application/vnd.etsi.asic-e+zip" => &[&T_vnd_etsi_asic_e_zip_application],
"application/vnd.ufdl" => &[&T_vnd_ufdl_application],
"application/vnd.oma.bcast.notification+xml" => &[&T_vnd_oma_bcast_notification_xml_application],
"application/x-java-keystore" => &[&T_x_java_keystore_application],
"image/x-xwindowdump" => &[&T_x_xwindowdump_image],
"audio/g719" => &[&T_g719_audio],
"application/vnd.sealed.doc" => &[&T_vnd_sealed_doc_application],
"application/vnd.handheld-entertainment+xml" => &[&T_vnd_handheld_entertainment_xml_application],
"application/x-ustar" => &[&T_x_ustar_application],
"application/zlib" => &[&T_zlib_application],
"image/vnd.wap.wbmp" => &[&T_vnd_wap_wbmp_image],
"application/news-groupinfo" => &[&T_news_groupinfo_application],
"application/wasm" => &[&T_wasm_application],
"application/x-berkeley-db;format=hash" => &[&T_x_berkeley_db_format_hash_application],
"text/rss" => &[&T_rss_xml_application],
"application/csta+xml" => &[&T_csta_xml_application],
"application/vnd.motorola.flexsuite.ttc" => &[&T_vnd_motorola_flexsuite_ttc_application],
"application/x-nesrom" => &[&T_x_nesrom_application],
"video/example" => &[&T_example_video],
"application/vnd.fdsn.mseed" => &[&T_vnd_fdsn_mseed_application],
"application/vnd.ms-word.template.macroenabled.12" => &[&T_vnd_ms_word_template_macroenabled_12_application],
"application/fastinfoset" => &[&T_fastinfoset_application],
"application/vnd.osa.netdeploy" => &[&T_vnd_osa_netdeploy_application],
"application/vnd.medcalcdata" => &[&T_vnd_medcalcdata_application],
"application/vnd.cups-ppd" => &[&T_vnd_cups_ppd_application],
"application/x-mach-o-dylib-stub" => &[&T_x_mach_o_dylib_stub_application],
"application/vnd.ms-outlook" => &[&T_vnd_ms_outlook_application],
"application/vnd.pocketlearn" => &[&T_vnd_pocketlearn_application],
"application/vnd.accpac.simply.aso" => &[&T_vnd_accpac_simply_aso_application],
"image/vnd.dgn;ver=8" => &[&T_vnd_dgn_version_8_image],
"application/vnd.apple.numbers" => &[&T_vnd_apple_numbers_application],
"application/vnd.openofficeorg.extension" => &[&T_vnd_openofficeorg_extension_application],
"video/vnd.motorola.video" => &[&T_vnd_motorola_video_video],
"application/vnd.chemdraw+xml" => &[&T_vnd_chemdraw_xml_application],
"video/x-mng" => &[&T_x_mng_video],
"audio/g726-32" => &[&T_g726_32_audio],
"audio/smv0" => &[&T_smv0_audio],
"application/vnd.hp-pclxl" => &[&T_vnd_hp_pclxl_application],
"image/jpm" => &[&T_jpm_image],
"application/vnd.acucorp" => &[&T_vnd_acucorp_application],
"application/vnd.groove-account" => &[&T_vnd_groove_account_application],
"application/vnd.3m.post-it-notes" => &[&T_vnd_3m_post_it_notes_application],
"image/x-raw-fuji" => &[&T_x_raw_fuji_image],
"model/vnd.gdl" => &[&T_vnd_gdl_model],
"multipart/header-set" => &[&T_header_set_multipart],
"text/x-tika-text-based-message" => &[&T_x_tika_text_based_message_text],
"application/ibe-key-request+xml" => &[&T_ibe_key_request_xml_application],
"application/vnd.hp-hps" => &[&T_vnd_hp_hps_application],
"application/x-grib" => &[&T_x_grib_application],
"application/x-compress" => &[&T_x_compress_application],
"application/onix-message+xml" => &[&T_onix_message_xml_application],
"application/x-memgraph" => &[&T_x_memgraph_application],
"application/vnd.apple.unknown.13" => &[&T_vnd_apple_unknown_13_application],
"audio/red" => &[&T_red_audio],
"audio/tone" => &[&T_tone_audio],
"application/vnd.ms-word.document.macroenabled.12" => &[&T_vnd_ms_word_document_macroenabled_12_application],
"application/vnd.oma.bcast.smartcard-trigger+xml" => &[&T_vnd_oma_bcast_smartcard_trigger_xml_application],
"application/x-silverlight-app" => &[&T_x_silverlight_app_application],
"application/x-guitar-pro" => &[&T_x_guitar_pro_application],
"application/vnd.lotus-1-2-3;version=4" => &[&T_vnd_lotus_1_2_3_version_4_application],
"text/vnd.abc" => &[&T_vnd_abc_text],
"application/ipp" => &[&T_ipp_application],
"application/scvp-vp-response" => &[&T_scvp_vp_response_application],
"text/x-less" => &[&T_x_less_text],
"application/vnd.etsi.iptvsad-bc+xml" => &[&T_vnd_etsi_iptvsad_bc_xml_application],
"audio/l20" => &[&T_l20_audio],
"application/vnd.sss-cod" => &[&T_vnd_sss_cod_application],
"audio/32kadpcm" => &[&T_32kadpcm_audio],
"application/emma+xml" => &[&T_emma_xml_application],
"application/vnd.anser-web-certificate-issue-initiation" => &[&T_vnd_anser_web_certificate_issue_initiation_application],
"application/vnd.gridmp" => &[&T_vnd_gridmp_application],
"application/warc" => &[&T_warc_application],
"application/index.vnd" => &[&T_index_vnd_application],
"application/cals-1840" => &[&T_cals_1840_application],
"application/vnd.nokia.radio-presets" => &[&T_vnd_nokia_radio_presets_application],
"application/qsig" => &[&T_qsig_application],
"application/vnd.hcl-bireports" => &[&T_vnd_hcl_bireports_application],
"application/x-ms-compress-szdd" => &[&T_x_ms_compress_szdd_application],
"application/vnd.dvb.notif-aggregate-root+xml" => &[&T_vnd_dvb_notif_aggregate_root_xml_application],
"video/vnd.dlna.mpeg-tts" => &[&T_vnd_dlna_mpeg_tts_video],
"image/x-raw-red" => &[&T_x_raw_red_image],
"application/vnd.ms-excel.addin.macroenabled.12" => &[&T_vnd_ms_excel_addin_macroenabled_12_application],
"application/vnd.sealed.mht" => &[&T_vnd_sealed_mht_application],
"application/x-object" => &[&T_x_object_application],
"application/vnd.visio" => &[&T_vnd_visio_application],
"application/x-xliff+xml" => &[&T_x_xliff_xml_application],
"application/x-arj-compressed" => &[&T_x_arj_application],
"image/jxr" => &[&T_jxr_image],
"application/vnd.sss-ntf" => &[&T_vnd_sss_ntf_application],
"audio/x-dec-basic" => &[&T_x_dec_basic_audio],
"application/x-x509-key;format=der" => &[&T_x_x509_key_format_der_application],
"application/x-msmetafile" => &[&T_wmf_image],
"font/sfnt" => &[&T_x_font_ttf_application],
"image/x-raw-mamiya" => &[&T_x_raw_mamiya_image],
"text/x-diff" => &[&T_x_diff_text],
"audio/dsr-es201108" => &[&T_dsr_es201108_audio],
"application/mbms-register-response+xml" => &[&T_mbms_register_response_xml_application],
"application/vnd.sealedmedia.softseal.html" => &[&T_vnd_sealedmedia_softseal_html_application],
"application/vnd.etsi.iptvsad-cod+xml" => &[&T_vnd_etsi_iptvsad_cod_xml_application],
"application/vnd.joost.joda-archive" => &[&T_vnd_joost_joda_archive_application],
"image/x-os2-graphics; charset=binary" => &[&T_x_os2_graphics__charset_binary_image],
"application/x-mmm-digisonde" => &[&T_x_mmm_digisonde_application],
"application/x-font-otf" => &[&T_x_font_otf_application],
"application/x-mach-o-universal" => &[&T_x_mach_o_universal_application],
"application/eshop" => &[&T_eshop_application],
"audio/x-m4a" => &[&T_mp4_audio],
"video/jpm" => &[&T_jpm_image],
"application/vnd.irepository.package+xml" => &[&T_vnd_irepository_package_xml_application],
"audio/vnd.3gpp.iufp" => &[&T_vnd_3gpp_iufp_audio],
"application/isup" => &[&T_isup_application],
"application/vnd.sealed.csf" => &[&T_vnd_sealed_csf_application],
"application/vnd.curl.car" => &[&T_vnd_curl_car_application],
"image/x-canon-cr3" => &[&T_x_canon_cr3_image],
"application/x-stuffit" => &[&T_x_stuffit_application],
"application/spirits-event+xml" => &[&T_spirits_event_xml_application],
"audio/vnd.dolby.mps" => &[&T_vnd_dolby_mps_audio],
"application/pls+xml" => &[&T_pls_xml_application],
"application/applixware" => &[&T_applixware_application],
"model/vnd.dwf;version=2" => &[&T_vnd_dwf_version_2_model],
"image/vnd.dxf" => &[&T_vnd_dxf_image],
"message/global-disposition-notification" => &[&T_global_disposition_notification_message],
"application/sereal;version=2" => &[&T_sereal_version_2_application],
"application/vnd.stardivision.writer" => &[&T_vnd_stardivision_writer_application],
"application/x-staroffice-template" => &[&T_x_staroffice_template_application],
"application/x-iso9660-image" => &[&T_x_iso9660_image_application],
"application/x-pkcs7-certificates" => &[&T_x_pkcs7_certificates_application],
"application/pkcs7-mime" => &[&T_pkcs7_mime_application],
"drawing/dwg" => &[&T_vnd_dwg_image],
"application/vnd.ms-wordml" => &[&T_vnd_ms_wordml_application],
"application/macwriteii" => &[&T_macwriteii_application],
"application/x-tika-java-web-archive" => &[&T_x_tika_java_web_archive_application],
"application/slate" => &[&T_slate_application],
"application/vnd.adobe.aftereffects.project" => &[&T_vnd_adobe_aftereffects_project_application],
"audio/ilbc" => &[&T_ilbc_audio],
"application/x-adobe-indesign" => &[&T_x_adobe_indesign_application],
"application/x-java" => &[&T_java_vm_application],
"application/vnd.kde.kontour" => &[&T_vnd_kde_kontour_application],
"application/vnd.mobius.txf" => &[&T_vnd_mobius_txf_application],
"application/vnd.smaf" => &[&T_vnd_smaf_application],
"audio/dsr-es202211" => &[&T_dsr_es202211_audio],
"model/vnd.collada+xml" => &[&T_vnd_collada_xml_model],
"application/vnd.nokia.radio-preset" => &[&T_vnd_nokia_radio_preset_application],
"application/vnd.iptc.g2.newsitem+xml" => &[&T_vnd_iptc_g2_newsitem_xml_application],
"application/vnd.oasis.opendocument.text" => &[&T_vnd_oasis_opendocument_text_application],
"application/vnd.canon-lips" => &[&T_vnd_canon_lips_application],
"application/vnd.ncd.reference" => &[&T_vnd_ncd_reference_application],
"audio/basic" => &[&T_basic_audio],
"audio/vnd.adobe.soundbooth" => &[&T_vnd_adobe_soundbooth_audio],
"video/raw" => &[&T_raw_video],
"application/mosskey-request" => &[&T_mosskey_request_application],
"application/vnd.openxmlformats-officedocument.presentationml.slide" => &[&T_vnd_openxmlformats_officedocument_presentationml_slide_application],
"application/dicom" => &[&T_dicom_application],
"application/vnd.apple.pages" => &[&T_vnd_apple_pages_application],
"application/x-httpd-jsp" => &[&T_x_jsp_text],
"application/vnd.apple.mpegurl" => &[&T_vnd_apple_mpegurl_application],
"text/x-groovy" => &[&T_x_groovy_text],
"application/vnd.mobius.mqy" => &[&T_vnd_mobius_mqy_application],
"audio/ac3" => &[&T_ac3_audio],
"video/vnd.vivo" => &[&T_vnd_vivo_video],
"application/vnd.music-niff" => &[&T_vnd_music_niff_application],
"application/vnd.quark.quarkxpress" => &[&T_vnd_quark_quarkxpress_application],
"text/x-ini" => &[&T_x_ini_text],
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" => &[&T_vnd_openxmlformats_officedocument_spreadsheetml_sheet_application],
"application/x-bzip" => &[&T_x_bzip_application],
"application/quicktime" => &[&T_quicktime_application],
"image/vnd.djvu" => &[&T_vnd_djvu_image],
"audio/evrc0" => &[&T_evrc0_audio],
"application/x-zim" => &[&T_x_zim_application],
"application/vnd.java.hprof.text" => &[&T_vnd_java_hprof_text_application],
"application/vnd.ecowin.seriesupdate" => &[&T_vnd_ecowin_seriesupdate_application],
"application/x-x509-dsa-parameters" => &[&T_x_x509_dsa_parameters_application],
"application/java-vm" => &[&T_java_vm_application],
"application/x-troff-ms" => &[&T_troff_text],
"text/vnd.trolltech.linguist" => &[&T_vnd_trolltech_linguist_text],
"application/vnd.ms-xpsdocument" => &[&T_vnd_ms_xpsdocument_application],
"application/pkcs7-signature" => &[&T_pkcs7_signature_application],
"audio/vnd.dts" => &[&T_vnd_dts_audio],
"application/mbms-register+xml" => &[&T_mbms_register_xml_application],
"application/vnd.oasis.opendocument.tika.flat.document" => &[&T_vnd_oasis_opendocument_tika_flat_document_application],
"application/vnd.ms-excel.workspace.4" => &[&T_vnd_ms_excel_workspace_4_application],
"application/vnd.cinderella" => &[&T_vnd_cinderella_application],
"application/pgp-keys" => &[&T_pgp_keys_application],
"application/pics-rules" => &[&T_pics_rules_application],
"application/x-mif" => &[&T_vnd_mif_application],
"text/x-idl" => &[&T_x_idl_text],
"application/vnd.yamaha.openscoreformat" => &[&T_vnd_yamaha_openscoreformat_application],
"application/vnd.canon-cpdl" => &[&T_vnd_canon_cpdl_application],
"audio/x-mpegurl" => &[&T_x_mpegurl_audio],
"application/vnd.kde.karbon" => &[&T_vnd_kde_karbon_application],
"application/msword" => &[&T_msword_application],
"application/vnd.s3sms" => &[&T_vnd_s3sms_application],
"image/x-pict" => &[&T_x_pict_image],
"image/vnd.sealed.png" => &[&T_vnd_sealed_png_image],
"application/vnd.immervision-ivp" => &[&T_vnd_immervision_ivp_application],
"application/vnd.dolby.mobile.2" => &[&T_vnd_dolby_mobile_2_application],
"application/vnd.dvb.ipdcroaming" => &[&T_vnd_dvb_ipdcroaming_application],
"application/vnd.mseq" => &[&T_vnd_mseq_application],
"application/vnd.sealed.tiff" => &[&T_vnd_sealed_tiff_application],
"application/x-geopackage" => &[&T_x_geopackage_application],
"application/x-tika-visio-ooxml" => &[&T_x_tika_visio_ooxml_application],
"application/x-itunes-bplist" => &[&T_x_itunes_bplist_application],
"audio/vnd.dolby.mlp" => &[&T_vnd_dolby_mlp_audio],
"image/naplps" => &[&T_naplps_image],
"video/x-ogg-yuv" => &[&T_x_oggyuv_video],
"application/x-java-jnlp-file" => &[&T_x_java_jnlp_file_application],
"video/x-ms-wmv" => &[&T_x_ms_wmv_video],
"video/mp4v-es" => &[&T_mp4v_es_video],
"application/vnd.chipnuts.karaoke-mmd" => &[&T_vnd_chipnuts_karaoke_mmd_application],
"application/vnd.kde.kchart" => &[&T_vnd_kde_kchart_application],
"application/x-sibelius" => &[&T_x_sibelius_application],
"application/x-bzip2" => &[&T_x_bzip2_application],
"application/vnd.oma.poc.optimized-progress-report+xml" => &[&T_vnd_oma_poc_optimized_progress_report_xml_application],
"application/vnd.apache.parquet" => &[&T_x_parquet_application],
"application/vnd.mobius.plc" => &[&T_vnd_mobius_plc_application],
"application/vnd.ecowin.seriesrequest" => &[&T_vnd_ecowin_seriesrequest_application],
"model/x3d+xml" => &[&T_x3d_xml_model],
"application/vnd.cab-jscript" => &[&T_vnd_cab_jscript_application],
"application/vnd.oasis.opendocument.text-web" => &[&T_vnd_oasis_opendocument_text_web_application],
"application/vnd.mfmp" => &[&T_vnd_mfmp_application],
"image/x-emf-compressed" => &[&T_x_emf_compressed_image],
"application/vnd.wordperfect;version=5.0" => &[&T_vnd_wordperfect_version_5_0_application],
"application/x-sas-xport" => &[&T_x_sas_xport_application],
"application/mpeg4-generic" => &[&T_mpeg4_generic_application],
"model/vnd.gtw" => &[&T_vnd_gtw_model],
"image/x-gimp-pat" => &[&T_x_gimp_pat_image],
"application/x-msdownload;format=pe-arm7" => &[&T_x_msdownload_format_pe_arm7_application],
"audio/ulpfec" => &[&T_ulpfec_audio],
"multipart/signed" => &[&T_signed_multipart],
"application/x-quattro-pro;version=6" => &[&T_x_quattro_pro_version_6_application],
"application/prs.plucker" => &[&T_prs_plucker_application],
"audio/wave" => &[&T_vnd_wave_audio],
"application/x-bibtex-text-file" => &[&T_x_bibtex_text_file_application],
"text/x-c++src" => &[&T_x_c__src_text],
"application/x-java-jnilib" => &[&T_x_java_jnilib_application],
"video/x-ogg-rgb" => &[&T_x_oggrgb_video],
"application/x-sas-data" => &[&T_x_sas_data_application],
"application/vnd.openofficeorg.autotext" => &[&T_vnd_openofficeorg_autotext_application],
"application/x-wine-extension-inf" => &[&T_inf_application],
"application/timestamped-data" => &[&T_timestamped_data_application],
"model/vnd.dwf;version=6" => &[&T_vnd_dwf_version_6_model],
"application/pgp-encrypted" => &[&T_pgp_encrypted_application],
"application/xslfo+xml" => &[&T_xslfo_xml_application],
"text/x-java" => &[&T_x_java_source_text],
"image/x-xcf" => &[&T_x_xcf_image],
"application/x-ms-wmd" => &[&T_x_ms_wmd_application],
"application/vnd.xmpie.dpkg" => &[&T_vnd_xmpie_dpkg_application],
"application/vnd.mediastation.cdkey" => &[&T_vnd_mediastation_cdkey_application],
"application/vnd.stardivision.draw" => &[&T_vnd_stardivision_draw_application],
"audio/evrc-qcp" => &[&T_evrc_qcp_audio],
"image/x-emf" => &[&T_emf_image],
"application/vnd.claymore" => &[&T_vnd_claymore_application],
"audio/amr-wb+" => &[&T_amr_wb__audio],
"application/vnd.uplanet.list" => &[&T_vnd_uplanet_list_application],
"model/vnd.dwfx+xps" => &[&T_vnd_dwfx_xps_model],
"application/vnd.ms-project" => &[&T_vnd_ms_project_application],
"audio/vnd.everad.plj" => &[&T_vnd_everad_plj_audio],
"application/atomcat+xml" => &[&T_atomcat_xml_application],
"application/x-lharc" => &[&T_x_lharc_application],
"image/ief" => &[&T_ief_image],
"application/dash+xml" => &[&T_dash_xml_application],
"application/resource-lists-diff+xml" => &[&T_resource_lists_diff_xml_application],
"application/x-csh" => &[&T_x_csh_application],
"application/media_control+xml" => &[&T_media_control_xml_application],
"application/vnd.ibm.secure-container" => &[&T_vnd_ibm_secure_container_application],
"text/x-go" => &[&T_x_go_text],
"audio/amr-nb" => &[&T_amr_audio],
"application/vnd.kenameaapp" => &[&T_vnd_kenameaapp_application],
"application/vnd.neurolanguage.nlu" => &[&T_vnd_neurolanguage_nlu_application],
"application/vnd.dvb.iptv.alfec-base" => &[&T_vnd_dvb_iptv_alfec_base_application],
"application/vnd.motorola.flexsuite" => &[&T_vnd_motorola_flexsuite_application],
"audio/aac" => &[&T_x_aac_audio],
"application/vnd.oasis.opendocument.database" => &[&T_vnd_oasis_opendocument_base_application],
"text/x-common-lisp" => &[&T_x_common_lisp_text],
"application/xop+xml" => &[&T_xop_xml_application],
"image/cdr" => &[&T_coreldraw_application],
"application/x-ms-asx" => &[&T_x_ms_asx_application],
"model/mesh" => &[&T_mesh_model],
"image/vnd.mix" => &[&T_vnd_mix_image],
"application/wita" => &[&T_wita_application],
"application/x-zip-compressed" => &[&T_zip_application],
"application/x-berkeley-db;format=hash;version=4" => &[&T_x_berkeley_db_format_hash_version_4_application],
"application/x-tika-msoffice-embedded;format=comp_obj" => &[&T_x_tika_msoffice_embedded_format_comp_obj_application],
"application/vnd.stardivision.impress" => &[&T_vnd_stardivision_impress_application],
"application/vnd.is-xpr" => &[&T_vnd_is_xpr_application],
"audio/x-psf" => &[&T_x_psf_audio],
"image/svg+xml" => &[&T_svg_xml_image],
"video/vnd.sealed.mpeg4" => &[&T_vnd_sealed_mpeg4_video],
"application/vnd.oma.bcast.sgdd+xml" => &[&T_vnd_oma_bcast_sgdd_xml_application],
"multipart/alternative" => &[&T_alternative_multipart],
"image/x-psd" => &[&T_vnd_adobe_photoshop_image],
"application/vnd.minisoft-hp3000-save" => &[&T_vnd_minisoft_hp3000_save_application],
"video/bt656" => &[&T_bt656_video],
"application/vnd.google-earth.kml+xml" => &[&T_vnd_google_earth_kml_xml_application],
"application/x400-bp" => &[&T_x400_bp_application],
"application/vnd.kde.kspread" => &[&T_vnd_kde_kspread_application],
"application/activemessage" => &[&T_activemessage_application],
"application/vnd.3gpp2.sms" => &[&T_vnd_3gpp2_sms_application],
"application/watcherinfo+xml" => &[&T_watcherinfo_xml_application],
"application/vnd.groove-tool-template" => &[&T_vnd_groove_tool_template_application],
"application/vnd.ncd.control" => &[&T_vnd_ncd_control_application],
"application/vnd.nokia.pcd+wbxml" => &[&T_vnd_nokia_pcd_wbxml_application],
"application/cnrp+xml" => &[&T_cnrp_xml_application],
"application/vnd.liberty-request+xml" => &[&T_vnd_liberty_request_xml_application],
"application/x-latex" => &[&T_x_latex_application],
"video/x-matroska" => &[&T_x_matroska_video],
"x-conference/x-cooltalk" => &[&T_x_cooltalk_x_conference],
"application/cdr" => &[&T_coreldraw_application],
"application/vnd.wmf.bootstrap" => &[&T_vnd_wmf_bootstrap_application],
"application/vnd.wordperfect;version=4.2" => &[&T_vnd_wordperfect_version_4_2_application],
"image/x-raw-rawzor" => &[&T_x_raw_rawzor_image],
"audio/sp-midi" => &[&T_sp_midi_audio],
"text/x-coldfusion" => &[&T_x_coldfusion_text],
"application/x-installshield" => &[&T_x_installshield_application],
"image/emf" => &[&T_emf_image],
"application/vnd.fints" => &[&T_vnd_fints_application],
"image/vnd.dxf;format=binary" => &[&T_vnd_dxf_format_binary_image],
"application/vnd.noblenet-web" => &[&T_vnd_noblenet_web_application],
"application/x-stata-dta" => &[&T_x_stata_dta_application],
"application/cu-seeme" => &[&T_cu_seeme_application],
"application/gzip-compressed" => &[&T_gzip_application],
"image/vnd.adobe.premiere" => &[&T_vnd_adobe_premiere_image],
"application/vnd.novadigm.ext" => &[&T_vnd_novadigm_ext_application],
"image/hevc-sequence" => &[&T_heic_sequence_image],
"application/x-dtbresource+xml" => &[&T_x_dtbresource_xml_application],
"application/sdp" => &[&T_sdp_application],
"application/vnd.kde.kivio" => &[&T_vnd_kde_kivio_application],
"application/vnd.shana.informed.formdata" => &[&T_vnd_shana_informed_formdata_application],
"application/x-hwp-v5" => &[&T_x_hwp_v5_application],
"application/vnd.igloader" => &[&T_vnd_igloader_application],
"application/x-matlab-data" => &[&T_x_matlab_data_application],
"audio/mpa-robust" => &[&T_mpa_robust_audio],
"audio/x-ogg-pcm" => &[&T_x_oggpcm_audio],
"application/xml-external-parsed-entity" => &[&T_xml_external_parsed_entity_application],
"application/vnd.micrografx.igx" => &[&T_vnd_micrografx_igx_application],
"text/x-haml" => &[&T_x_haml_text],
"application/vnd.powerbuilder7" => &[&T_vnd_powerbuilder7_application],
"application/x-debian-package" => &[&T_x_debian_package_application],
"application/patch-ops-error+xml" => &[&T_patch_ops_error_xml_application],
"application/x-vnd.datapackage+gz" => &[&T_x_vnd_datapackage_gz_application],
"message/rfc2557" => &[&T_related_multipart],
"text/vnd.dmclientscript" => &[&T_vnd_dmclientscript_text],
"application/gml+xml" => &[&T_gml_xml_application],
"application/ocsp-response" => &[&T_ocsp_response_application],
"application/oebps-package+xml" => &[&T_oebps_package_xml_application],
"audio/amr-wb" => &[&T_amr_wb_audio],
"application/x-gzip-compressed" => &[&T_gzip_application],
"application/java-archive" => &[&T_java_archive_application],
"video/x-oggrgb" => &[&T_x_oggrgb_video],
"audio/aiff" => &[&T_x_aiff_audio],
"video/rtp-enc-aescm128" => &[&T_rtp_enc_aescm128_video],
"audio/pcmu-wb" => &[&T_pcmu_wb_audio],
"multipart/byteranges" => &[&T_byteranges_multipart],
"video/parityfec" => &[&T_parityfec_video],
"application/mac-binhex40" => &[&T_mac_binhex40_application],
"application/vnd.ctc-posml" => &[&T_vnd_ctc_posml_application],
"audio/dvi4" => &[&T_dvi4_audio],
"application/vnd.cirpack.isdn-ext" => &[&T_vnd_cirpack_isdn_ext_application],
"image/jp2" => &[&T_jp2_image],
"audio/dls" => &[&T_dls_audio],
"text/vnd.esmertec.theme-descriptor" => &[&T_vnd_esmertec_theme_descriptor_text],
"application/x-troff-man" => &[&T_troff_text],
"application/vnd.motorola.flexsuite.adsi" => &[&T_vnd_motorola_flexsuite_adsi_application],
"application/vnd.uplanet.list-wbxml" => &[&T_vnd_uplanet_list_wbxml_application],
"application/sbml+xml" => &[&T_sbml_xml_application],
"application/x-msdownload;format=pe-armLE" => &[&T_x_msdownload_format_pe_armLE_application],
"application/xcon-conference-info-diff+xml" => &[&T_xcon_conference_info_diff_xml_application],
"application/x-stata-dta;version=10" => &[&T_x_stata_dta_version_10_application],
"video/x-msvideo" => &[&T_x_msvideo_video],
"application/vnd.motorola.flexsuite.fis" => &[&T_vnd_motorola_flexsuite_fis_application],
"text/x-vcard" => &[&T_x_vcard_text],
"application/vnd.ms-powerpoint.template.macroenabled.12" => &[&T_vnd_ms_powerpoint_template_macroenabled_12_application],
"application/set-registration" => &[&T_set_registration_application],
"application/vnd.f-secure.mobile" => &[&T_vnd_f_secure_mobile_application],
"application/vnd.java.hprof " => &[&T_vnd_java_hprof__application],
"application/vnd.mobius.mbk" => &[&T_vnd_mobius_mbk_application],
"application/vnd.kde.kpresenter" => &[&T_vnd_kde_kpresenter_application],
"application/x-vnd.oasis.opendocument.presentation" => &[&T_vnd_oasis_opendocument_presentation_application],
"application/vnd.3gpp.pic-bw-large" => &[&T_vnd_3gpp_pic_bw_large_application],
"application/vnd.airzip.filesecure.azf" => &[&T_vnd_airzip_filesecure_azf_application],
"image/gif" => &[&T_gif_image],
"application/gzipped" => &[&T_gzip_application],
"audio/x-mpeg" => &[&T_mpeg_audio],
"application/set-payment-initiation" => &[&T_set_payment_initiation_application],
"application/x-pdf" => &[&T_pdf_application],
"application/vnd.openxmlformats-officedocument.presentationml.slideshow" => &[&T_vnd_openxmlformats_officedocument_presentationml_slideshow_application],
"audio/ape" => &[&T_ape_audio],
"application/x-font-framemaker" => &[&T_x_font_framemaker_application],
"application/x-sas-backup" => &[&T_x_sas_backup_application],
"audio/mpegurl" => &[&T_x_mpegurl_audio],
"text/x-properties" => &[&T_x_java_properties_text],
"application/vnd.cosmocaller" => &[&T_vnd_cosmocaller_application],
"image/x-raw-logitech" => &[&T_x_raw_logitech_image],
"audio/vnd.lucent.voice" => &[&T_vnd_lucent_voice_audio],
"audio/vorbis" => &[&T_vorbis_audio],
"image/x-raw-sigma" => &[&T_x_raw_sigma_image],
"application/rlmi+xml" => &[&T_rlmi_xml_application],
"audio/gsm" => &[&T_gsm_audio],
"application/vnd.ms-wpl" => &[&T_vnd_ms_wpl_application],
"video/vnd.hns.video" => &[&T_vnd_hns_video_video],
"audio/vnd.rhetorex.32kadpcm" => &[&T_vnd_rhetorex_32kadpcm_audio],
"model/vnd.parasolid.transmit.binary" => &[&T_vnd_parasolid_transmit_binary_model],
"application/x-vnd.oasis.opendocument.spreadsheet-template" => &[&T_vnd_oasis_opendocument_spreadsheet_template_application],
"application/x-cpio" => &[&T_x_cpio_application],
"application/x-sas-data-index" => &[&T_x_sas_data_index_application],
"application/pkcs10" => &[&T_pkcs10_application],
"application/vnd.osgi.bundle" => &[&T_vnd_osgi_bundle_application],
"application/vnd.ms-tnef" => &[&T_vnd_ms_tnef_application],
"image/x-cmx" => &[&T_x_cmx_image],
"application/vnd.meridian-slingshot" => &[&T_vnd_meridian_slingshot_application],
"application/vnd.wt.stf" => &[&T_vnd_wt_stf_application],
"audio/g729d" => &[&T_g729d_audio],
"image/heic-sequence" => &[&T_heic_sequence_image],
"application/vnd.wrq-hp3000-labelled" => &[&T_vnd_wrq_hp3000_labelled_application],
"application/vnd.lotus-notes" => &[&T_vnd_lotus_notes_application],
"application/vnd.omaloc-supl-init" => &[&T_vnd_omaloc_supl_init_application],
"application/x-xar" => &[&T_x_xar_application],
"application/vnd.spotfire.dxp" => &[&T_vnd_spotfire_dxp_application],
"application/vnd.data-vision.rdz" => &[&T_vnd_data_vision_rdz_application],
"application/vnd.ms-visio" => &[&T_vnd_visio_application],
"application/msonenote" => &[&T_onenote_application],
"application/mathml+xml" => &[&T_mathml_xml_application],
"message/delivery-status" => &[&T_delivery_status_message],
"audio/evrcwb1" => &[&T_evrcwb1_audio],
"application/vnd.dvb.iptv.alfec-enhancement" => &[&T_vnd_dvb_iptv_alfec_enhancement_application],
"image/icns" => &[&T_icns_image],
"text/vnd.wap.wmlscript" => &[&T_vnd_wap_wmlscript_text],
"application/xspf+xml" => &[&T_xspf_xml_application],
"application/x-speex" => &[&T_speex_audio],
"application/vnd.syncml.dm+xml" => &[&T_vnd_syncml_dm_xml_application],
"video/3gpp-tt" => &[&T_3gpp_tt_video],
"image/vnd.xiff" => &[&T_vnd_xiff_image],
"application/hyperstudio" => &[&T_hyperstudio_application],
"audio/vnd.nortel.vbk" => &[&T_vnd_nortel_vbk_audio],
"application/vnd.lotus-1-2-3;version=97+9.x" => &[&T_vnd_lotus_1_2_3_version_97_9_x_application],
"application/vnd.dna" => &[&T_vnd_dna_application],
"text/x-yaml" => &[&T_x_yaml_text],
"application/samlmetadata+xml" => &[&T_samlmetadata_xml_application],
"application/vnd.mophun.certificate" => &[&T_vnd_mophun_certificate_application],
"application/relax-ng-compact-syntax" => &[&T_relax_ng_compact_syntax_application],
"application/rss+xml" => &[&T_rss_xml_application],
"application/vnd.dynageo" => &[&T_vnd_dynageo_application],
"application/vnd.adobe.aftereffects.template" => &[&T_vnd_adobe_aftereffects_template_application],
"application/edifact" => &[&T_edifact_application],
"model/vnd.dwf;version=5" => &[&T_vnd_dwf_version_5_model],
"application/x-tika-iworks-protected" => &[&T_x_tika_iworks_protected_application],
"application/bat" => &[&T_x_bat_application],
"application/vnd.rn-realmedia-vbr" => &[&T_vnd_rn_realmedia_application],
"application/x-plist" => &[&T_x_plist_application],
"text/x-robots" => &[&T_x_robots_text],
"message/x-emlx" => &[&T_x_emlx_message],
"application/vnd.adobe.xfdf" => &[&T_vnd_adobe_xfdf_application],
"application/xml" => &[&T_xml_application],
"application/manifest+json" => &[&T_manifest_json_application],
"application/vnd.japannet-jpnstore-wakeup" => &[&T_vnd_japannet_jpnstore_wakeup_application],
"application/vnd.americandynamics.acc" => &[&T_vnd_americandynamics_acc_application],
"application/vnd.oma.bcast.sgboot" => &[&T_vnd_oma_bcast_sgboot_application],
"application/vnd.immervision-ivu" => &[&T_vnd_immervision_ivu_application],
"application/vnd.nokia.n-gage.data" => &[&T_vnd_nokia_n_gage_data_application],
"application/x-stata-dta;version=8" => &[&T_x_stata_dta_version_8_application],
"text/x-emacs-lisp" => &[&T_x_emacs_lisp_text],
"application/vnd.motorola.flexsuite.wem" => &[&T_vnd_motorola_flexsuite_wem_application],
"application/vnd.font-fontforge-sfd" => &[&T_vnd_font_fontforge_sfd_application],
"application/x-gtar" => &[&T_x_gtar_application],
"video/x-m4v" => &[&T_x_m4v_video],
"application/vnd.sus-calendar" => &[&T_vnd_sus_calendar_application],
"application/vnd.nokia.landmark+wbxml" => &[&T_vnd_nokia_landmark_wbxml_application],
"text/x-erlang" => &[&T_x_erlang_text],
"application/vnd.intertrust.digibox" => &[&T_vnd_intertrust_digibox_application],
"application/vnd.oma.group-usage-list+xml" => &[&T_vnd_oma_group_usage_list_xml_application],
"application/vnd.powerbuilder75" => &[&T_vnd_powerbuilder75_application],
"application/x-endnote-style" => &[&T_x_endnote_style_application],
"application/x-sas-catalog" => &[&T_x_sas_catalog_application],
"video/avi" => &[&T_x_msvideo_video],
"video/x-ms-asf" => &[&T_x_ms_asf_video],
"application/vnd.fujixerox.docuworks" => &[&T_vnd_fujixerox_docuworks_application],
"image/avif" => &[&T_avif_image],
"image/t38" => &[&T_t38_image],
"text/xml" => &[&T_xml_application],
"multipart/report" => &[&T_report_multipart],
"application/dita+xml;format=val" => &[&T_dita_xml_format_val_application],
"application/dif+xml" => &[&T_dif_xml_application],
"video/vc1" => &[&T_vc1_video],
"application/vnd.sealed.net" => &[&T_vnd_sealed_net_application],
"application/msword2" => &[&T_msword2_application],
"application/vnd.sbm.mid2" => &[&T_vnd_sbm_mid2_application],
"application/x-font-vfont" => &[&T_x_font_vfont_application],
"application/vnd.zzazz.deck+xml" => &[&T_vnd_zzazz_deck_xml_application],
"image/cgm" => &[&T_cgm_image],
"application/vnd.marlin.drm.conftoken+xml" => &[&T_vnd_marlin_drm_conftoken_xml_application],
"application/x-msdownload;format=pe64" => &[&T_x_msdownload_format_pe64_application],
"application/x-activemime" => &[&T_x_activemime_application],
"application/vnd.etsi.sci+xml" => &[&T_vnd_etsi_sci_xml_application],
"application/vnd.apple.iwork" => &[&T_vnd_apple_iwork_application],
"application/x-dbf" => &[&T_x_dbf_application],
"application/x-vnd.oasis.opendocument.text-web" => &[&T_vnd_oasis_opendocument_text_web_application],
"application/kpml-response+xml" => &[&T_kpml_response_xml_application],
"video/vnd.sealedmedia.softseal.mov" => &[&T_vnd_sealedmedia_softseal_mov_video],
"application/x-vnd.oasis.opendocument.text" => &[&T_vnd_oasis_opendocument_text_application],
"application/mbms-deregister+xml" => &[&T_mbms_deregister_xml_application],
"audio/telephone-event" => &[&T_telephone_event_audio],
"application/x-font-dos" => &[&T_x_font_dos_application],
"application/xcap-caps+xml" => &[&T_xcap_caps_xml_application],
"chemical/x-xyz" => &[&T_x_xyz_chemical],
"application/vnd.kde.kformula" => &[&T_vnd_kde_kformula_application],
"audio/l24" => &[&T_l24_audio],
"application/x-quattro-pro;version=5" => &[&T_x_quattro_pro_version_5_application],
"application/epp+xml" => &[&T_epp_xml_application],
"application/acad" => &[&T_vnd_dwg_image],
"text/richtext" => &[&T_richtext_text],
"video/vnd.motorola.videop" => &[&T_vnd_motorola_videop_video],
"application/x-berkeley-db;format=hash;version=2" => &[&T_x_berkeley_db_format_hash_version_2_application],
"application/x-x509-key;format=pem" => &[&T_x_x509_key_format_pem_application],
"application/mbms-user-service-description+xml" => &[&T_mbms_user_service_description_xml_application],
"application/fits" => &[&T_fits_application],
"application/x-sas" => &[&T_x_sas_application],
"application/vnd.yamaha.hv-voice" => &[&T_vnd_yamaha_hv_voice_application],
"audio/g7221" => &[&T_g7221_audio],
"image/jpeg" => &[&T_jpeg_image],
"image/prs.btif" => &[&T_prs_btif_image],
"application/poc-settings+xml" => &[&T_poc_settings_xml_application],
"video/bmpeg" => &[&T_bmpeg_video],
"video/x-jng" => &[&T_x_jng_video],
"video/h263" => &[&T_h263_video],
"video/3gp" => &[&T_3gpp_video],
"application/vnd.framemaker" => &[&T_vnd_framemaker_application],
"application/vnd.oasis.opendocument.text-template" => &[&T_vnd_oasis_opendocument_text_template_application],
"application/vnd.ms-wmdrm.lic-chlg-req" => &[&T_vnd_ms_wmdrm_lic_chlg_req_application],
"audio/g7291" => &[&T_g7291_audio],
"application/vnd.mobius.dis" => &[&T_vnd_mobius_dis_application],
"image/x-dpx" => &[&T_x_dpx_image],
"application/x-shar" => &[&T_x_shar_application],
"application/samlassertion+xml" => &[&T_samlassertion_xml_application],
"text/x-vbdotnet" => &[&T_x_vbdotnet_text],
"application/mbms-msk-response+xml" => &[&T_mbms_msk_response_xml_application],
"application/vnd.etsi.aoc+xml" => &[&T_vnd_etsi_aoc_xml_application],
"application/smil" => &[&T_smil_xml_application],
"text/x-stsrc" => &[&T_x_stsrc_text],
"application/vnd.gmx" => &[&T_vnd_gmx_application],
"video/mpeg4-generic" => &[&T_mpeg4_generic_video],
"image/x-raw-olympus" => &[&T_x_raw_olympus_image],
"image/x-targa" => &[&T_x_tga_image],
"application/vnd.fsc.weblaunch" => &[&T_vnd_fsc_weblaunch_application],
"application/vnd.oma.poc.final-report+xml" => &[&T_vnd_oma_poc_final_report_xml_application],
"application/vnd.wap.wmlscriptc" => &[&T_vnd_wap_wmlscriptc_application],
"message/tracking-status" => &[&T_tracking_status_message],
"application/vnd.groove-injector" => &[&T_vnd_groove_injector_application],
"audio/3gpp2" => &[&T_3gpp2_video],
"application/mbms-protection-description+xml" => &[&T_mbms_protection_description_xml_application],
"image/x-cdr" => &[&T_coreldraw_application],
"application/x-vnd.oasis.opendocument.text-template" => &[&T_vnd_oasis_opendocument_text_template_application],
"text/x-vbscript" => &[&T_x_vbscript_text],
"application/vnd.amazon.ebook" => &[&T_vnd_amazon_ebook_application],
"audio/bv16" => &[&T_bv16_audio],
"application/ogg" => &[&T_ogg_application],
"application/vnd.japannet-directory-service" => &[&T_vnd_japannet_directory_service_application],
"application/vnd.ms-cab-compressed" => &[&T_vnd_ms_cab_compressed_application],
"application/vnd.iptc.g2.knowledgeitem+xml" => &[&T_vnd_iptc_g2_knowledgeitem_xml_application],
"application/vnd.osgi.dp" => &[&T_vnd_osgi_dp_application],
"audio/gsm-efr" => &[&T_gsm_efr_audio],
"audio/smv-qcp" => &[&T_smv_qcp_audio],
"audio/midi" => &[&T_midi_audio],
"application/x-troff-me" => &[&T_troff_text],
"application/vnd.wv.csp+wbxml" => &[&T_vnd_wv_csp_wbxml_application],
"application/vnd.accpac.simply.imp" => &[&T_vnd_accpac_simply_imp_application],
"video/vnd.iptvforum.ttsmpeg2" => &[&T_vnd_iptvforum_ttsmpeg2_video],
"application/vnd.scribus" => &[&T_vnd_scribus_application],
"application/vnd.xara" => &[&T_vnd_xara_application],
"application/vnd.ms-excel.sheet.4" => &[&T_vnd_ms_excel_sheet_4_application],
"application/vnd.syncml.dm.notification" => &[&T_vnd_syncml_dm_notification_application],
"audio/evrcb1" => &[&T_evrcb1_audio],
"application/msexcel" => &[&T_vnd_ms_excel_application],
"audio/example" => &[&T_example_audio],
"model/vrml" => &[&T_vrml_model],
"application/x-axcrypt" => &[&T_x_axcrypt_application],
"application/vnd.pwg-multiplexed" => &[&T_vnd_pwg_multiplexed_application],
"image/x-raw-kodak" => &[&T_x_raw_kodak_image],
"application/vnd.sqlite3" => &[&T_x_sqlite3_application],
"text/x-asciidoc" => &[&T_x_asciidoc_text],
"application/vnd.kidspiration" => &[&T_vnd_kidspiration_application],
"application/vnd.oasis.opendocument.chart-template" => &[&T_vnd_oasis_opendocument_chart_template_application],
"image/x-tga" => &[&T_x_tga_image],
"application/vnd.trid.tpt" => &[&T_vnd_trid_tpt_application],
"application/warc+gz" => &[&T_warc_gz_application],
"application/x-font-libgrx" => &[&T_x_font_libgrx_application],
"text/vnd.wap.si" => &[&T_vnd_wap_si_text],
"application/x-mach-o-dylinker" => &[&T_x_mach_o_dylinker_application],
"text/x-yacc" => &[&T_x_yacc_text],
"application/vnd.nokia.isds-radio-presets" => &[&T_vnd_nokia_isds_radio_presets_application],
"application/vnd.oasis.opendocument.chart" => &[&T_vnd_oasis_opendocument_chart_application],
"application/vnd.marlin.drm.actiontoken+xml" => &[&T_vnd_marlin_drm_actiontoken_xml_application],
"application/vnd.omads-folder+xml" => &[&T_vnd_omads_folder_xml_application],
"application/vnd.vsf" => &[&T_vnd_vsf_application],
"application/font-woff2" => &[&T_woff2_font],
"application/x-rar" => &[&T_x_rar_compressed_application],
"application/vnd.fujixerox.hbpl" => &[&T_vnd_fujixerox_hbpl_application],
"image/heif-sequence" => &[&T_heif_sequence_image],
"text/x-scala" => &[&T_x_scala_text],
"application/edi-consent" => &[&T_edi_consent_application],
"model/example" => &[&T_example_model],
"application/x-fossil-checkout" => &[&T_x_fossil_checkout_application],
"application/x-xpinstall" => &[&T_x_xpinstall_application],
"audio/opus" => &[&T_opus_audio],
"text/vnd.iptc.nitf" => &[&T_vnd_iptc_nitf_text],
"application/vnd.mindjet.mindmanager" => &[&T_vnd_mindjet_mindmanager_application],
"application/vnd.fujitsu.oasys2" => &[&T_vnd_fujitsu_oasys2_application],
"application/vnd.oasis.opendocument.graphics-template" => &[&T_vnd_oasis_opendocument_graphics_template_application],
"application/vnd.stardivision.writer-global" => &[&T_vnd_stardivision_writer_global_application],
"audio/mobile-xmf" => &[&T_mobile_xmf_audio],
"multipart/digest" => &[&T_digest_multipart],
"image/vnd.ms-modi" => &[&T_vnd_ms_modi_image],
"application/vnd.truedoc" => &[&T_vnd_truedoc_application],
"application/mbms-associated-procedure-description+xml" => &[&T_mbms_associated_procedure_description_xml_application],
"application/x-sas-mddb" => &[&T_x_sas_mddb_application],
"audio/x-ms-wax" => &[&T_x_ms_wax_audio],
"application/vnd.smart.teacher" => &[&T_vnd_smart_teacher_application],
"application/vnd.3gpp.pic-bw-small" => &[&T_vnd_3gpp_pic_bw_small_application],
"audio/musepack" => &[&T_musepack_audio],
"application/x-mysql-misam-data" => &[&T_x_mysql_misam_data_application],
"image/example" => &[&T_example_image],
"audio/x-mp4a" => &[&T_mp4_audio],
"audio/3gpp" => &[&T_3gpp_video],
"application/x-vnd.oasis.opendocument.chart-template" => &[&T_vnd_oasis_opendocument_chart_template_application],
"application/vnd.llamagraphics.life-balance.exchange+xml" => &[&T_vnd_llamagraphics_life_balance_exchange_xml_application],
"application/vnd.omads-file+xml" => &[&T_vnd_omads_file_xml_application],
"application/vnd.flographit" => &[&T_vnd_flographit_application],
"application/vnd.dvb.esgcontainer" => &[&T_vnd_dvb_esgcontainer_application],
"application/vnd.yamaha.openscoreformat.osfpvg+xml" => &[&T_vnd_yamaha_openscoreformat_osfpvg_xml_application],
"application/x-pkcs7-certreqresp" => &[&T_x_pkcs7_certreqresp_application],
"application/x-msterminal" => &[&T_x_msterminal_application],
"audio/vnd.qcelp" => &[&T_vnd_qcelp_audio],
"application/rdf+xml" => &[&T_rdf_xml_application],
"application/vnd.macports.portpkg" => &[&T_vnd_macports_portpkg_application],
"application/vnd.ms-excel" => &[&T_vnd_ms_excel_application],
"text/vnd.fly" => &[&T_vnd_fly_text],
"application/vnd.webturbo" => &[&T_vnd_webturbo_application],
"video/mp2t" => &[&T_mp2t_video],
"application/vnd.street-stream" => &[&T_vnd_street_stream_application],
"text/x-ruby" => &[&T_x_ruby_text],
"application/vnd.tcpdump.pcapng" => &[&T_vnd_tcpdump_pcapng_application],
"application/x-xfig" => &[&T_x_xfig_application],
"application/x-vnd.sun.xml.writer" => &[&T_vnd_sun_xml_writer_application],
"application/x-windows-installer" => &[&T_x_ms_installer_application],
"text/x-config" => &[&T_x_config_text],
"application/vnd.uplanet.alert" => &[&T_vnd_uplanet_alert_application],
"application/x-tika-msoffice-embedded;format=ole10_native" => &[&T_x_tika_msoffice_embedded_format_ole10_native_application],
"video/vnd.iptvforum.ttsavc" => &[&T_vnd_iptvforum_ttsavc_video],
"application/vnd.clonk.c4group" => &[&T_vnd_clonk_c4group_application],
"application/x-berkeley-db;format=btree;version=4" => &[&T_x_berkeley_db_format_btree_version_4_application],
"application/vividence.scriptfile" => &[&T_vividence_scriptfile_application],
"application/vnd.software602.filler.form-xml-zip" => &[&T_vnd_software602_filler_form_xml_zip_application],
"image/aces" => &[&T_aces_image],
"application/vnd.novadigm.edm" => &[&T_vnd_novadigm_edm_application],
"application/vnd.ms-lrm" => &[&T_vnd_ms_lrm_application],
"application/vnd.sun.xml.impress.template" => &[&T_vnd_sun_xml_impress_template_application],
"application/x-fat-diskimage" => &[&T_x_fat_diskimage_application],
"audio/x-pn-realaudio" => &[&T_x_pn_realaudio_audio],
"image/png" => &[&T_png_image],
"application/vnd.hhe.lesson-player" => &[&T_vnd_hhe_lesson_player_application],
"application/x-mimearchive" => &[&T_related_multipart],
"application/x-mach-o-object" => &[&T_x_mach_o_object_application],
"application/font-tdpfr" => &[&T_font_tdpfr_application],
"text/x-haskell" => &[&T_x_haskell_text],
"application/vnd.uplanet.channel" => &[&T_vnd_uplanet_channel_application],
"application/x-ms-reader" => &[&T_x_ms_reader_application],
"application/vnd.bmi" => &[&T_vnd_bmi_application],
"application/vnd.ms-visio.drawing" => &[&T_vnd_ms_visio_drawing_application],
"application/x-mysql-db" => &[&T_x_mysql_db_application],
"application/timestamp-query" => &[&T_timestamp_query_application],
"application/sldworks" => &[&T_sldworks_application],
"font/ttf" => &[&T_x_font_ttf_application],
"application/vnd.openxmlformats-officedocument.presentationml.template" => &[&T_vnd_openxmlformats_officedocument_presentationml_template_application],
"application/vnd.3gpp.pic-bw-var" => &[&T_vnd_3gpp_pic_bw_var_application],
"application/vnd.mif" => &[&T_vnd_mif_application],
"image/x-raw-casio" => &[&T_x_raw_casio_image],
"application/news-transmission" => &[&T_news_transmission_application],
"application/x-doom" => &[&T_x_doom_application],
"application/x-lz4" => &[&T_x_lz4_application],
"message/sip" => &[&T_sip_message],
"image/x-pc-paintbrush" => &[&T_vnd_zbrush_pcx_image],
"application/x-font-bdf" => &[&T_x_font_bdf_application],
"audio/vnd.sealedmedia.softseal.mpeg" => &[&T_vnd_sealedmedia_softseal_mpeg_audio],
"application/vnd.ecowin.filerequest" => &[&T_vnd_ecowin_filerequest_application],
"image/vnd.dgn;version=7" => &[&T_vnd_dgn_version_7_image],
"application/vnd.emclient.accessrequest+xml" => &[&T_vnd_emclient_accessrequest_xml_application],
"application/vnd.adobe.xdp+xml" => &[&T_vnd_adobe_xdp_xml_application],
"application/vnd.grafeq" => &[&T_vnd_grafeq_application],
"application/x-mach-o" => &[&T_x_mach_o_application],
"application/x-chrome-extension" => &[&T_x_chrome_extension_application],
"application/vnd.shx" => &[&T_vnd_shx_application],
"text/troff" => &[&T_troff_text],
"application/x-vnd.oasis.opendocument.formula-template" => &[&T_vnd_oasis_opendocument_formula_template_application],
"audio/amr" => &[&T_amr_audio],
"text/prs.fallenstein.rst" => &[&T_prs_fallenstein_rst_text],
"application/x-deflate" => &[&T_zlib_application],
"application/vnd.denovo.fcselayout-link" => &[&T_vnd_denovo_fcselayout_link_application],
"application/x-xz" => &[&T_x_xz_application],
"text/yaml" => &[&T_x_yaml_text],
"chemical/x-cdx" => &[&T_x_cdx_chemical],
"text/vnd.curl.mcurl" => &[&T_vnd_curl_mcurl_text],
"application/vnd.multiad.creator.cif" => &[&T_vnd_multiad_creator_cif_application],
"application/vnd.wordperfect;version=5.1" => &[&T_vnd_wordperfect_version_5_1_application],
"application/x-tex" => &[&T_x_tex_application],
"application/vnd.mobius.daf" => &[&T_vnd_mobius_daf_application],
"image/vnd.fujixerox.edmics-rlc" => &[&T_vnd_fujixerox_edmics_rlc_image],
"application/x-berkeley-db;format=btree;version=2" => &[&T_x_berkeley_db_format_btree_version_2_application],
"application/mbms-reception-report+xml" => &[&T_mbms_reception_report_xml_application],
"application/vnd.oasis.opendocument.formula-template" => &[&T_vnd_oasis_opendocument_formula_template_application],
"application/x-webarchive" => &[&T_x_webarchive_application],
"application/vnd.marlin.drm.mdcf" => &[&T_vnd_marlin_drm_mdcf_application],
"application/vnd.dvb.notif-container+xml" => &[&T_vnd_dvb_notif_container_xml_application],
"application/rsd+xml" => &[&T_rsd_xml_application],
"application/vnd.simtech-mindmapper" => &[&T_vnd_simtech_mindmapper_application],
"application/x-vnd.oasis.opendocument.chart" => &[&T_vnd_oasis_opendocument_chart_application],
"application/x-dtbook+xml" => &[&T_x_dtbook_xml_application],
"application/x-sh" => &[&T_x_sh_application],
"text/x-c" => &[&T_x_c_text],
"text/x-cobol" => &[&T_x_cobol_text],
"application/x-uc2-compressed" => &[&T_x_uc2_compressed_application],
"application/vnd.uplanet.alert-wbxml" => &[&T_vnd_uplanet_alert_wbxml_application],
"text/x-jsp" => &[&T_x_jsp_text],
"application/vnd.oma.bcast.associated-procedure-parameter+xml" => &[&T_vnd_oma_bcast_associated_procedure_parameter_xml_application],
"text/x-clojure" => &[&T_x_clojure_text],
"application/atomicmail" => &[&T_atomicmail_application],
"application/x-123" => &[&T_vnd_lotus_1_2_3_application],
"image/jxl" => &[&T_jxl_image],
"text/x-eiffel" => &[&T_x_eiffel_text],
"application/onenote;format=onetoc2" => &[&T_onenote_format_onetoc2_application],
"application/xcon-conference-info+xml" => &[&T_xcon_conference_info_xml_application],
"application/vnd.ms-pki.seccat" => &[&T_vnd_ms_pki_seccat_application],
"application/x-xml" => &[&T_xml_application],
"application/x-tika-ooxml" => &[&T_x_tika_ooxml_application],
"model/vnd.gs.gdl" => &[&T_vnd_gs_gdl_model],
"application/x-tika-old-excel" => &[&T_x_tika_old_excel_application],
"application/vnd.pg.format" => &[&T_vnd_pg_format_application],
"application/andrew-inset" => &[&T_andrew_inset_application],
"application/vnd.mophun.application" => &[&T_vnd_mophun_application_application],
"application/vnd.oma-scws-http-response" => &[&T_vnd_oma_scws_http_response_application],
"application/vnd.powerbuilder7-s" => &[&T_vnd_powerbuilder7_s_application],
"text/x-expect" => &[&T_x_expect_text],
"application/x-shapefile" => &[&T_x_shapefile_application],
"application/vnd.uiq.theme" => &[&T_vnd_uiq_theme_application],
"video/x-theora" => &[&T_theora_video],
"application/ttml+xml" => &[&T_ttml_xml_application],
"audio/rtx" => &[&T_rtx_audio],
"application/x-foxmail" => &[&T_x_foxmail_application],
"audio/evrcwb" => &[&T_evrcwb_audio],
"application/x-asprs" => &[&T_x_asprs_application],
"application/dvcs" => &[&T_dvcs_application],
"application/vnd.oma-scws-http-request" => &[&T_vnd_oma_scws_http_request_application],
"application/vnd.stardivision.math" => &[&T_vnd_stardivision_math_application],
"image/vnd.zbrush.pcx" => &[&T_vnd_zbrush_pcx_image],
"text/x-vbasic" => &[&T_x_vbasic_text],
"video/3gpp" => &[&T_3gpp_video],
"application/vnd.vividence.scriptfile" => &[&T_vnd_vividence_scriptfile_application],
"application/vnd.criticaltools.wbs+xml" => &[&T_vnd_criticaltools_wbs_xml_application],
"image/x-bpg" => &[&T_x_bpg_image],
"audio/x-mod" => &[&T_x_mod_audio],
"application/vnd.fujitsu.oasysprs" => &[&T_vnd_fujitsu_oasysprs_application],
"application/vnd.hp-hpid" => &[&T_vnd_hp_hpid_application],
"application/font-sfnt" => &[&T_x_font_ttf_application],
"application/x-mach-o-dylib" => &[&T_x_mach_o_dylib_application],
"audio/bv32" => &[&T_bv32_audio],
"application/index" => &[&T_index_application],
"application/vnd.svd" => &[&T_vnd_svd_application],
"application/iges" => &[&T_iges_application],
"image/vnd.sealedmedia.softseal.gif" => &[&T_vnd_sealedmedia_softseal_gif_image],
"application/vnd.pg.osasli" => &[&T_vnd_pg_osasli_application],
"text/plain" => &[&T_plain_text],
"application/vnd.mfer" => &[&T_vnd_mfer_application],
"application/vnd.3gpp.bsf+xml" => &[&T_vnd_3gpp_bsf_xml_application],
"application/vnd.motorola.flexsuite.kmr" => &[&T_vnd_motorola_flexsuite_kmr_application],
"application/vnd.ms-powerpoint.slideshow.macroenabled.12" => &[&T_vnd_ms_powerpoint_slideshow_macroenabled_12_application],
"application/xhtml-voice+xml" => &[&T_xhtml_voice_xml_application],
"application/xcap-el+xml" => &[&T_xcap_el_xml_application],
"application/x-sas-access" => &[&T_x_sas_access_application],
"application/vnd.ipunplugged.rcprofile" => &[&T_vnd_ipunplugged_rcprofile_application],
"application/vnd.3gpp.sms" => &[&T_vnd_3gpp_sms_application],
"application/vnd.japannet-registration-wakeup" => &[&T_vnd_japannet_registration_wakeup_application],
"application/vnd.recordare.musicxml+xml" => &[&T_vnd_recordare_musicxml_xml_application],
"audio/vnd.dolby.heaac.2" => &[&T_vnd_dolby_heaac_2_audio],
"video/rtx" => &[&T_rtx_video],
"text/x-dtd" => &[&T_xml_dtd_application],
"application/vnd.wordperfect" => &[&T_vnd_wordperfect_application],
"message/global-delivery-status" => &[&T_global_delivery_status_message],
"text/vnd.curl.scurl" => &[&T_vnd_curl_scurl_text],
"application/vnd.etsi.iptvprofile+xml" => &[&T_vnd_etsi_iptvprofile_xml_application],
"application/vnd.poc.group-advertisement+xml" => &[&T_vnd_poc_group_advertisement_xml_application],
"application/vnd.sun.xml.writer" => &[&T_vnd_sun_xml_writer_application],
"audio/vnd.nuera.ecelp7470" => &[&T_vnd_nuera_ecelp7470_audio],
"application/x-mach-o-core" => &[&T_x_mach_o_core_application],
"text/x-ocaml" => &[&T_x_ocaml_text],
"application/vnd.hydrostatix.sof-data" => &[&T_vnd_hydrostatix_sof_data_application],
"application/vnd.wordperfect;version=6.x" => &[&T_vnd_wordperfect_version_6_x_application],
"application/vnd.fluxtime.clip" => &[&T_vnd_fluxtime_clip_application],
"application/x-elc" => &[&T_x_elc_application],
"application/vnd.dir-bi.plate-dl-nosuffix" => &[&T_vnd_dir_bi_plate_dl_nosuffix_application],
"application/x-dosexec" => &[&T_x_dosexec_application],
"application/x-corelpresentations" => &[&T_x_corelpresentations_application],
"application/vnd.jisp" => &[&T_vnd_jisp_application],
"application/x-vnd.oasis.opendocument.graphics-template" => &[&T_vnd_oasis_opendocument_graphics_template_application],
"application/xv+xml" => &[&T_xv_xml_application],
"audio/x-realaudio" => &[&T_x_pn_realaudio_audio],
"application/vnd.fut-misnet" => &[&T_vnd_fut_misnet_application],
"application/dialog-info+xml" => &[&T_dialog_info_xml_application],
"application/onenote;format=one" => &[&T_onenote_format_one_application],
"application/dns" => &[&T_dns_application],
"application/vnd.fuzzysheet" => &[&T_vnd_fuzzysheet_application],
"text/x-cgi" => &[&T_x_cgi_text],
"application/vnd.etsi.simservs+xml" => &[&T_vnd_etsi_simservs_xml_application],
"text/x-c++hdr" => &[&T_x_c__hdr_text],
"text/x-applescript" => &[&T_x_applescript_text],
"video/x-sgi-movie" => &[&T_x_sgi_movie_video],
"application/onenote; format=package" => &[&T_onenote__format_package_application],
"text/asp" => &[&T_asp_text],
"application/x-bcpio" => &[&T_x_bcpio_application],
"audio/vnd.hns.audio" => &[&T_vnd_hns_audio_audio],
"application/ecmascript" => &[&T_ecmascript_application],
"application/vnd.eszigno3+xml" => &[&T_vnd_eszigno3_xml_application],
"application/x-executable" => &[&T_x_executable_application],
"image/x-gimp-gbr" => &[&T_x_gimp_gbr_image],
"application/vnd.solent.sdkm+xml" => &[&T_vnd_solent_sdkm_xml_application],
"application/vnd.ms-htmlhelp" => &[&T_vnd_ms_htmlhelp_application],
"audio/vmr-wb" => &[&T_vmr_wb_audio],
"application/vnd.ms-opentype" => &[&T_x_font_otf_application],
"application/vnd.ms-pki.stl" => &[&T_vnd_ms_pki_stl_application],
"image/ntf" => &[&T_nitf_image],
"application/x-parquet" => &[&T_x_parquet_application],
"application/x-ace-compressed" => &[&T_x_ace_compressed_application],
"model/vnd.moml+xml" => &[&T_vnd_moml_xml_model],
"application/vnd.ms-works" => &[&T_vnd_ms_works_application],
"application/x-bentley-localization" => &[&T_x_bentley_localization_application],
"image/x-rgb" => &[&T_x_rgb_image],
"message/http" => &[&T_http_message],
"application/fastsoap" => &[&T_fastsoap_application],
"application/vnd.cups-pdf" => &[&T_vnd_cups_pdf_application],
"application/x-lzip" => &[&T_x_lzip_application,&T_lzip_application],
"image/x-raw-adobe" => &[&T_x_raw_adobe_image],
"application/vnd.dxr" => &[&T_vnd_dxr_application],
"text/x-php" => &[&T_x_php_text],
"image/fits" => &[&T_fits_image],
"audio/x-ms-wma" => &[&T_x_ms_wma_audio],
"application/vnd.ms-word" => &[&T_msword_application],
"image/x-raw-leaf" => &[&T_x_raw_leaf_image],
"text/prs.lines.tag" => &[&T_prs_lines_tag_text],
"video/vnd.sealed.swf" => &[&T_vnd_sealed_swf_video],
"text/vnd.yaml" => &[&T_x_yaml_text],
"audio/mpeg" => &[&T_mpeg_audio],
"application/vnd.dvb.notif-generic+xml" => &[&T_vnd_dvb_notif_generic_xml_application],
"application/moss-signature" => &[&T_moss_signature_application],
"application/vnd.ms-excel.workspace.3" => &[&T_vnd_ms_excel_workspace_3_application],
"audio/vnd.cns.anp1" => &[&T_vnd_cns_anp1_audio],
"text/x-awk" => &[&T_x_awk_text],
"text/x-objcsrc" => &[&T_x_objcsrc_text],
"audio/l16" => &[&T_l16_audio],
"application/vnd.recordare.musicxml" => &[&T_vnd_recordare_musicxml_application],
"application/vnd.autopackage" => &[&T_vnd_autopackage_application],
"application/msword5" => &[&T_msword5_application],
"application/vnd.httphone" => &[&T_vnd_httphone_application],
"application/vnd.uplanet.channel-wbxml" => &[&T_vnd_uplanet_channel_wbxml_application],
"application/vnd.ms-artgalry" => &[&T_vnd_ms_artgalry_application],
"application/vnd.etsi.iptvueprofile+xml" => &[&T_vnd_etsi_iptvueprofile_xml_application],
"application/vnd.nokia.pcd+xml" => &[&T_vnd_nokia_pcd_xml_application],
"application/x-quattro-pro;version=1+5" => &[&T_x_quattro_pro_version_1_5_application],
"audio/t38" => &[&T_t38_audio],
"application/x-ebu-stl" => &[&T_x_ebu_stl_application],
"application/mbms-envelope+xml" => &[&T_mbms_envelope_xml_application],
"audio/mpeg4-generic" => &[&T_mpeg4_generic_audio],
"application/vnd.nokia.landmark+xml" => &[&T_vnd_nokia_landmark_xml_application],
"application/x-mach-o-fvmlib" => &[&T_x_mach_o_fvmlib_application],
"application/vnd.informix-visionary" => &[&T_vnd_informix_visionary_application],
"application/x-berkeley-db;format=btree" => &[&T_x_berkeley_db_format_btree_application],
"application/gpx+xml" => &[&T_gpx_xml_application],
"application/vnd.proteus.magazine" => &[&T_vnd_proteus_magazine_application],
"application/xcap-att+xml" => &[&T_xcap_att_xml_application],
"application/x-font-type1" => &[&T_x_font_type1_application],
"application/x-font-snf" => &[&T_x_font_snf_application],
"image/x-ms-bmp" => &[&T_bmp_image],
"application/scvp-vp-request" => &[&T_scvp_vp_request_application],
"application/x-apple-diskimage" => &[&T_x_apple_diskimage_application],
"application/vnd.xmpie.cpkg" => &[&T_vnd_xmpie_cpkg_application],
"audio/vnd.nuera.ecelp9600" => &[&T_vnd_nuera_ecelp9600_audio],
"application/vnd.groove-identity-message" => &[&T_vnd_groove_identity_message_application],
"application/x-fossil-global-conf" => &[&T_x_fossil_global_conf_application],
"application/vnd.ecdis-update" => &[&T_vnd_ecdis_update_application],
"application/vnd.ms-visio.stencil.macroEnabled.12" => &[&T_vnd_ms_visio_stencil_macroEnabled_12_application],
"application/javascript" => &[&T_javascript_text],
"text/x-csrc" => &[&T_x_c_text],
"application/pgp" => &[&T_pgp_encrypted_application],
"application/vnd.hp-pcl" => &[&T_vnd_hp_pcl_application],
"audio/evrc" => &[&T_evrc_audio],
"audio/vnd.vmx.cvsd" => &[&T_vnd_vmx_cvsd_audio],
"application/x-dwg" => &[&T_vnd_dwg_image],
"audio/x-unknown" => &[&T_x_unknown_audio],
"application/vnd.lotus-1-2-3" => &[&T_vnd_lotus_1_2_3_application],
"application/vnd.wap.sic" => &[&T_vnd_wap_sic_application],
"application/vnd.ms-outlook-pst" => &[&T_vnd_ms_outlook_pst_application],
"application/vnd.aether.imp" => &[&T_vnd_aether_imp_application],
"application/x-mswrite" => &[&T_x_mswrite_application],
"video/mj2" => &[&T_mj2_video],
"message/s-http" => &[&T_s_http_message],
"video/nv" => &[&T_nv_video],
"application/x-font-adobe-metric" => &[&T_x_font_adobe_metric_application],
"application/ibe-pkg-reply+xml" => &[&T_ibe_pkg_reply_xml_application],
"audio/webm" => &[&T_webm_audio],
"application/vnd.iptc.g2.planningitem+xml" => &[&T_vnd_iptc_g2_planningitem_xml_application],
"application/mosskey-data" => &[&T_mosskey_data_application],
"application/vnd.lotus-organizer" => &[&T_vnd_lotus_organizer_application],
"application/sieve" => &[&T_sieve_application],
"application/x-tex-tfm" => &[&T_x_tex_tfm_application],
"text/x-java-source" => &[&T_x_java_source_text],
"application/pkixcmp" => &[&T_pkixcmp_application],
"application/x-dtbncx+xml" => &[&T_x_dtbncx_xml_application],
"application/x-itunes-ipa" => &[&T_x_itunes_ipa_application],
"application/x-font-linux-psf" => &[&T_x_font_linux_psf_application],
"application/x-vnd.datapackage+json" => &[&T_x_vnd_datapackage_json_application],
"image/x-dwg" => &[&T_vnd_dwg_image],
"application/x-java-pack200" => &[&T_x_java_pack200_application],
"audio/g729e" => &[&T_g729e_audio],
"video/mp2p" => &[&T_mp2p_video],
"application/vnd.kodak-descriptor" => &[&T_vnd_kodak_descriptor_application],
"application/x-wais-source" => &[&T_x_wais_source_application],
"application/vnd.dvb.ipdcdftnotifaccess" => &[&T_vnd_dvb_ipdcdftnotifaccess_application],
"audio/vnd.audiokoz" => &[&T_vnd_audiokoz_audio],
"application/x-msdownload;format=pe32" => &[&T_x_msdownload_format_pe32_application],
"message/cpim" => &[&T_cpim_message],
"image/vnd.mozilla.apng" => &[&T_vnd_mozilla_apng_image],
"application/vnd.shana.informed.formtemplate" => &[&T_vnd_shana_informed_formtemplate_application],
"video/x-oggyuv" => &[&T_x_oggyuv_video],
"text/xml-external-parsed-entity" => &[&T_xml_external_parsed_entity_application],
"application/vnd.ffsns" => &[&T_vnd_ffsns_application],
"application/mpeg4-iod-xmt" => &[&T_mpeg4_iod_xmt_application],
"application/vnd.ms-powerpoint.presentation.macroenabled.12" => &[&T_vnd_ms_powerpoint_presentation_macroenabled_12_application],
"application/vemmi" => &[&T_vemmi_application],
"application/atom+xml" => &[&T_atom_xml_application],
"application/vnd.oasis.opendocument.image" => &[&T_vnd_oasis_opendocument_image_application],
"application/vnd.seemail" => &[&T_vnd_seemail_application],
"text/calendar" => &[&T_calendar_text],
"audio/flac" => &[&T_x_flac_audio],
"model/x.stl-ascii" => &[&T_x_stl_ascii_model],
"application/vnd.rapid" => &[&T_vnd_rapid_application],
"application/iotp" => &[&T_iotp_application],
"application/vnd.geometry-explorer" => &[&T_vnd_geometry_explorer_application],
"application/vnd.ms-playready.initiator+xml" => &[&T_vnd_ms_playready_initiator_xml_application],
"application/vnd.commerce-battelle" => &[&T_vnd_commerce_battelle_application],
"application/vnd.oma.poc.groups+xml" => &[&T_vnd_oma_poc_groups_xml_application],
"application/vnd.semd" => &[&T_vnd_semd_application],
"application/vnd.pvi.ptid1" => &[&T_vnd_pvi_ptid1_application],
"application/ibe-pp-data" => &[&T_ibe_pp_data_application],
"application/x-chat" => &[&T_x_chat_application],
"application/zstd" => &[&T_zstd_application],
"application/x-rpm" => &[&T_x_rpm_application],
"image/vnd.dgn" => &[&T_vnd_dgn_image],
"text/css" => &[&T_css_text],
"application/vnd.wmc" => &[&T_vnd_wmc_application],
"audio/vnd.cns.inf1" => &[&T_vnd_cns_inf1_audio],
"application/x-matroska" => &[&T_x_matroska_application],
"application/x-tar" => &[&T_x_tar_application],
"video/h263-2000" => &[&T_h263_2000_video],
"application/vnd.ms-powerpoint.addin.macroenabled.12" => &[&T_vnd_ms_powerpoint_addin_macroenabled_12_application],
"video/x-flv" => &[&T_x_flv_video],
"application/im-iscomposing+xml" => &[&T_im_iscomposing_xml_application],
"application/vnd.llamagraphics.life-balance.desktop" => &[&T_vnd_llamagraphics_life_balance_desktop_application],
"application/x-x509-cert" => &[&T_x_x509_cert_application],
"application/vnd.3gpp2.bcmcsinfo+xml" => &[&T_vnd_3gpp2_bcmcsinfo_xml_application],
"application/x-sas-utility" => &[&T_x_sas_utility_application],
"image/x-raw-phaseone" => &[&T_x_raw_phaseone_image],
"image/vnd.net-fpx" => &[&T_vnd_net_fpx_image],
"application/vnd.ibm.rights-management" => &[&T_vnd_ibm_rights_management_application],
"application/ulpfec" => &[&T_ulpfec_application],
"image/jxs" => &[&T_jxs_image],
"text/x-sql" => &[&T_x_sql_text],
"application/x-ms-xbap" => &[&T_x_ms_xbap_application],
"application/x-vnd.oasis.opendocument.spreadsheet" => &[&T_vnd_oasis_opendocument_spreadsheet_application],
"text/x-fortran" => &[&T_x_fortran_text],
"application/vnd.obn" => &[&T_vnd_obn_application],
"application/vnd.amiga.ami" => &[&T_vnd_amiga_ami_application],
"video/daala" => &[&T_daala_video],
"image/vnd.sealedmedia.softseal.jpg" => &[&T_vnd_sealedmedia_softseal_jpg_image],
"application/vnd.crick.clicker.palette" => &[&T_vnd_crick_clicker_palette_application],
"message/imdn+xml" => &[&T_imdn_xml_message],
"application/x-stata-do" => &[&T_x_stata_do_application],
"model/vnd.dwf" => &[&T_vnd_dwf_model],
"application/vnd.wfa.wsc" => &[&T_vnd_wfa_wsc_application],
"application/vnd.commonspace" => &[&T_vnd_commonspace_application],
"application/vnd.qualcomm.brew-app-res" => &[&T_vnd_qualcomm_brew_app_res_application],
"application/x-x509-ec-parameters" => &[&T_x_x509_ec_parameters_application],
"application/x-adobe-indesign-interchange" => &[&T_x_adobe_indesign_interchange_application],
"application/cybercash" => &[&T_cybercash_application],
"application/vnd.ms-excel.sheet.2" => &[&T_vnd_ms_excel_sheet_2_application],
"application/vnd.powerbuilder6" => &[&T_vnd_powerbuilder6_application],
"application/xhtml+xml" => &[&T_xhtml_xml_application],
"application/vnd.geogebra.tool" => &[&T_vnd_geogebra_tool_application],
"application/vnd.openxmlformats-officedocument.spreadsheetml.template" => &[&T_vnd_openxmlformats_officedocument_spreadsheetml_template_application],
"application/mpeg4-iod" => &[&T_mpeg4_iod_application],
"application/vnd.oma.bcast.imd+xml" => &[&T_vnd_oma_bcast_imd_xml_application],
"audio/pcma" => &[&T_pcma_audio],
"application/x-archive" => &[&T_x_archive_application],
"application/x-ms-wmz" => &[&T_x_ms_wmz_application],
"application/vnd.ms-fontobject" => &[&T_vnd_ms_fontobject_application],
"application/vnd.wolfram.wl" => &[&T_vnd_wolfram_wl_application],
"application/vnd.adobe.air-application-installer-package+zip" => &[&T_vnd_adobe_air_application_installer_package_zip_application],
"application/vnd.sun.xml.writer.template" => &[&T_vnd_sun_xml_writer_template_application],
"audio/smv" => &[&T_smv_audio],
"video/vnd.nokia.videovoip" => &[&T_vnd_nokia_videovoip_video],
"video/iso.segment" => &[&T_iso_segment_video],
"audio/ogg" => &[&T_ogg_audio],
"application/vnd.fujixerox.ddd" => &[&T_vnd_fujixerox_ddd_application],
"text/x-prolog" => &[&T_x_prolog_text],
"application/vnd.oasis.opendocument.formula" => &[&T_vnd_oasis_opendocument_formula_application],
"application/http" => &[&T_http_application],
"application/x-tika-staroffice" => &[&T_x_tika_staroffice_application],
"image/x-portable-anymap" => &[&T_x_portable_anymap_image],
"image/vnd.dxf;format=ascii" => &[&T_vnd_dxf_format_ascii_image],
"text/vnd.wap.wml" => &[&T_vnd_wap_wml_text],
"application/vnd.openxmlformats-officedocument.wordprocessingml.document" => &[&T_vnd_openxmlformats_officedocument_wordprocessingml_document_application],
"text/x-matlab" => &[&T_x_matlab_text],
"application/sgml" => &[&T_sgml_application],
"application/whoispp-query" => &[&T_whoispp_query_application],
"application/dita+xml;format=task" => &[&T_dita_xml_format_task_application],
"application/x-tika-msoffice" => &[&T_x_tika_msoffice_application],
"text/rtf" => &[&T_rtf_application],
"application/x-ogg" => &[&T_ogg_application,&T_vorbis_audio],
"application/timestamp-reply" => &[&T_timestamp_reply_application],
"application/x-kword" => &[&T_vnd_kde_kword_application],
"application/x-sas-itemstor" => &[&T_x_sas_itemstor_application],
"application/x-msdownload" => &[&T_x_msdownload_application],
"application/x-lzma" => &[&T_x_lzma_application],
"application/x-msmediaview" => &[&T_x_msmediaview_application],
"application/pidf+xml" => &[&T_pidf_xml_application],
"audio/evrcb0" => &[&T_evrcb0_audio],
"multipart/form-data" => &[&T_form_data_multipart],
"application/vnd.otps.ct-kip+xml" => &[&T_vnd_otps_ct_kip_xml_application],
"application/vnd.ms-visio.template.macroEnabled.12" => &[&T_vnd_ms_visio_template_macroEnabled_12_application],
"application/pdf" => &[&T_pdf_application],
"application/x-gzip" => &[&T_gzip_application],
"application/x-kdelnk" => &[&T_x_kdelnk_application],
"video/x-fli" => &[&T_x_fli_video],
"application/vnd.epson.ssf" => &[&T_vnd_epson_ssf_application],
"application/vnd.rn-realmedia" => &[&T_vnd_rn_realmedia_application],
"text/x-asm" => &[&T_x_assembly_text],
"application/vnd.oma-scws-config" => &[&T_vnd_oma_scws_config_application],
"application/vnd.triscape.mxs" => &[&T_vnd_triscape_mxs_application],
"application/prs.alvestrand.titrax-sheet" => &[&T_prs_alvestrand_titrax_sheet_application],
"application/sereal" => &[&T_sereal_application],
"application/vnd.oma.bcast.simple-symbol-container" => &[&T_vnd_oma_bcast_simple_symbol_container_application],
"application/ccxml+xml" => &[&T_ccxml_xml_application],
"application/x-stata-dta;version=12" => &[&T_x_stata_dta_version_12_application],
"audio/x-dec-adpcm" => &[&T_x_dec_adpcm_audio],
"application/x-sharedlib" => &[&T_x_sharedlib_application],
"application/x-hdf" => &[&T_x_hdf_application],
"application/vnd.contact.cmsg" => &[&T_vnd_contact_cmsg_application],
"application/vnd.yamaha.hv-dic" => &[&T_vnd_yamaha_hv_dic_application],
"application/vnd.sealed.xls" => &[&T_vnd_sealed_xls_application],
"application/moss-keys" => &[&T_moss_keys_application],
"application/x-pkcs12" => &[&T_x_pkcs12_application],
"application/vnd.fujixerox.art4" => &[&T_vnd_fujixerox_art4_application],
"application/vnd.multiad.creator" => &[&T_vnd_multiad_creator_application],
"application/dita+xml" => &[&T_dita_xml_application],
"application/rls-services+xml" => &[&T_rls_services_xml_application],
"audio/evrcb" => &[&T_evrcb_audio],
"application/srgs+xml" => &[&T_srgs_xml_application],
"text/html" => &[&T_html_text],
"image/x-bmp" => &[&T_bmp_image],
"application/prs.nprend" => &[&T_prs_nprend_application],
"application/batch-smtp" => &[&T_batch_smtp_application],
"application/vnd.yellowriver-custom-menu" => &[&T_vnd_yellowriver_custom_menu_application],
"application/x-futuresplash" => &[&T_x_futuresplash_application],
"application/autocad_dwg" => &[&T_vnd_dwg_image],
"application/x-shockwave-flash" => &[&T_x_shockwave_flash_application],
"application/vnd.micrografx.flo" => &[&T_vnd_micrografx_flo_application],
"application/vnd.iptc.g2.newsmessage+xml" => &[&T_vnd_iptc_g2_newsmessage_xml_application],
"chemical/x-csml" => &[&T_x_csml_chemical],
"video/quicktime" => &[&T_quicktime_video],
"application/vnd.yamaha.hv-script" => &[&T_vnd_yamaha_hv_script_application],
"video/vnd.mpegurl" => &[&T_vnd_mpegurl_video],
"application/x-sas-audit" => &[&T_x_sas_audit_application],
"application/index.obj" => &[&T_index_obj_application],
"message/vnd.si.simp" => &[&T_vnd_si_simp_message],
"application/x-vnd.oasis.opendocument.text-master" => &[&T_vnd_oasis_opendocument_text_master_application],
"application/dita+xml;format=topic" => &[&T_dita_xml_format_topic_application],
"application/cpl+xml" => &[&T_cpl_xml_application],
"application/soap+fastinfoset" => &[&T_soap_fastinfoset_application],
"application/vnd.previewsystems.box" => &[&T_vnd_previewsystems_box_application],
"application/vnd.tmobile-livetv" => &[&T_vnd_tmobile_livetv_application],
"application/x-brotli" => &[&T_x_brotli_application],
"application/mathematica" => &[&T_mathematica_application],
"application/vnd.antix.game-component" => &[&T_vnd_antix_game_component_application],
"application/vnd.ms-powerpoint.slide.macroenabled.12" => &[&T_vnd_ms_powerpoint_slide_macroenabled_12_application],
"application/vnd.japannet-verification-wakeup" => &[&T_vnd_japannet_verification_wakeup_application],
"application/vnd.wv.ssp+xml" => &[&T_vnd_wv_ssp_xml_application],
"application/x-endnote-refer" => &[&T_x_endnote_refer_application],
"application/x-font-ghostscript" => &[&T_x_font_ghostscript_application],
"application/x-mach-o-preload" => &[&T_x_mach_o_preload_application],
"application/x-arj" => &[&T_x_arj_application],
"application/x-mspublisher" => &[&T_x_mspublisher_application],
"application/x-pds" => &[&T_x_pds_application],
"application/x-kpresenter" => &[&T_vnd_kde_kpresenter_application],
"application/x-rar-compressed;version=5" => &[&T_x_rar_compressed_version_5_application],
"application/vnd.blueice.multipass" => &[&T_vnd_blueice_multipass_application],
"application/vnd.openxmlformats-officedocument.presentationml.presentation" => &[&T_vnd_openxmlformats_officedocument_presentationml_presentation_application],
"text/x-tex" => &[&T_x_tex_application],
"application/vnd.debian.binary-package" => &[&T_x_debian_package_application],
"video/x-f4v" => &[&T_x_f4v_video],
"application/vnd.sss-dtf" => &[&T_vnd_sss_dtf_application],
"text/x-makefile" => &[&T_x_makefile_text],
"multipart/related" => &[&T_related_multipart],
"application/vnd.ms-package.3dmanufacturing-3dmodel+xml" => &[&T_vnd_ms_package_3dmanufacturing_3dmodel_xml_application],
"application/index.cmd" => &[&T_index_cmd_application],
"application/mbox" => &[&T_mbox_application],
"application/vnd.dolby.mobile.1" => &[&T_vnd_dolby_mobile_1_application],
"image/x-canon-cr2" => &[&T_x_canon_cr2_image],
"font/woff" => &[&T_woff_font],
"application/vnd.ms-excel.sheet.3" => &[&T_vnd_ms_excel_sheet_3_application],
"application/x-geopackage; version=1.1Or1.0" => &[&T_x_geopackage__version_1_1Or1_0_application],
"video/x-ogguvs" => &[&T_x_ogguvs_video],
"application/tve-trigger" => &[&T_tve_trigger_application],
"application/vnd.zul" => &[&T_vnd_zul_application],
"application/vnd.dvb.ipdcesgaccess" => &[&T_vnd_dvb_ipdcesgaccess_application],
"application/mikey" => &[&T_mikey_application],
"audio/x-sap" => &[&T_x_sap_audio],
"image/jpx" => &[&T_jpx_image],
"application/cbor" => &[&T_cbor_application],
"text/x-scss" => &[&T_x_scss_text],
"text/dns" => &[&T_dns_text],
"text/javascript" => &[&T_javascript_text],
"application/x-msdownload;format=pe" => &[&T_x_msdownload_format_pe_application],
"audio/x-aac" => &[&T_x_aac_audio],
"application/vnd.fdf" => &[&T_vnd_fdf_application],
"application/vnd.japannet-setstore-wakeup" => &[&T_vnd_japannet_setstore_wakeup_application],
"audio/qcelp" => &[&T_qcelp_audio],
"application/vnd.sun.xml.draw" => &[&T_vnd_sun_xml_draw_application],
"text/x-lex" => &[&T_x_lex_text],
"application/wsdl+xml" => &[&T_wsdl_xml_application],
"application/vnd.sun.xml.draw.template" => &[&T_vnd_sun_xml_draw_template_application],
"image/bpg" => &[&T_bpg_image],
"application/vnd.genomatix.tuxedo" => &[&T_vnd_genomatix_tuxedo_application],
"application/vnd.wv.csp+xml" => &[&T_vnd_wv_csp_xml_application],
"application/vnd.isac.fcs" => &[&T_vnd_isac_fcs_application],
"application/x-sas-data-v6" => &[&T_x_sas_data_v6_application],
"text/vnd.graphviz" => &[&T_vnd_graphviz_text],
"application/vnd.ecowin.chart" => &[&T_vnd_ecowin_chart_application],
"text/vtt" => &[&T_vtt_text],
"font/otf" => &[&T_x_font_otf_application],
"application/vnd.ms-ims" => &[&T_vnd_ms_ims_application],
"application/x-yml" => &[&T_x_yaml_text],
"application/rtf" => &[&T_rtf_application],
"application/x-font-ttf" => &[&T_x_font_ttf_application],
"text/x-ml" => &[&T_x_ml_text],
"application/vnd.oasis.opendocument.image-template" => &[&T_vnd_oasis_opendocument_image_template_application],
"application/x-amf" => &[&T_x_amf_application],
"application/vnd.oasis.opendocument.flat.presentation" => &[&T_vnd_oasis_opendocument_flat_presentation_application],
"application/x-authorware-seg" => &[&T_x_authorware_seg_application],
"audio/g726-16" => &[&T_g726_16_audio],
"application/x-troff" => &[&T_troff_text],
"application/prs.cww" => &[&T_prs_cww_application],
"application/vnd.ecowin.fileupdate" => &[&T_vnd_ecowin_fileupdate_application],
"application/vnd.paos.xml" => &[&T_vnd_paos_xml_application],
"application/atomsvc+xml" => &[&T_atomsvc_xml_application],
"model/vnd.gs-gdl" => &[&T_vnd_gs_gdl_model],
"message/sipfrag" => &[&T_sipfrag_message],
"application/vnd.lotus-1-2-3;version=2" => &[&T_vnd_lotus_1_2_3_version_2_application],
"application/vnd.groove-tool-message" => &[&T_vnd_groove_tool_message_application],
"application/vnd.ibm.modcap" => &[&T_vnd_ibm_modcap_application],
"text/x-tcl" => &[&T_x_tcl_text],
"application/wordperfect5.1" => &[&T_wordperfect5_1_application],
"image/xcf" => &[&T_x_xcf_image],
"text/x-assembly" => &[&T_x_assembly_text],
"application/xquery" => &[&T_xquery_application],
"application/vnd.dreamfactory" => &[&T_vnd_dreamfactory_application],
"application/x-msschedule" => &[&T_x_msschedule_application],
"application/oxps" => &[&T_vnd_ms_xpsdocument_application],
"multipart/voice-message" => &[&T_voice_message_multipart],

};

pub static EXT_MAP: phf::Map<&'static str, &[&'static dyn MimeTypeChecker]> = phf_map! {
"*.xport" => &[&T_x_sas_xport_application],
"*.fst" => &[&T_vnd_fst_image],
"*.hpgl" => &[&T_vnd_hp_hpgl_application],
"*.onetmp" => &[&T_onenote_application],
"*.trm" => &[&T_x_msterminal_application],
"*.sldprt" => &[&T_sldworks_application],
"*.book" => &[&T_vnd_framemaker_application],
"*.jpf" => &[&T_jpx_image],
"*.gz" => &[&T_gzip_application],
"*.ft11" => &[&T_x_freehand_image],
"*.hfa" => &[&T_x_erdas_hfa_application],
"*.ghf" => &[&T_vnd_groove_help_application],
"*.irp" => &[&T_vnd_irepository_package_xml_application],
"*.raw" => &[&T_x_raw_panasonic_image],
"*.ml" => &[&T_x_ml_text],
"*.lbd" => &[&T_vnd_llamagraphics_life_balance_desktop_application],
"*.mb" => &[&T_mathematica_application],
"*.aep" => &[&T_vnd_adobe_aftereffects_project_application],
"*.hwpx" => &[&T_hwp_zip_application],
"*.grxml" => &[&T_srgs_xml_application],
"*.fh" => &[&T_x_freehand_image],
"*.pcap" => &[&T_vnd_tcpdump_pcap_application],
"*.tld" => &[&T_plain_text],
"*.clkk" => &[&T_vnd_crick_clicker_keyboard_application],
"*.rnx" => &[&T_plain_text],
"*.mid" => &[&T_midi_audio],
"*.edx" => &[&T_vnd_novadigm_edx_application],
"*.ogv" => &[&T_ogg_video],
"*.owl" => &[&T_rdf_xml_application,&T_owl_xml_application],
"*.fh11" => &[&T_x_freehand_image],
"*.wkq" => &[&T_x_quattro_pro_application,&T_x_quattro_pro_version_1_4_application,&T_x_quattro_pro_version_5_application],
"*.rw2" => &[&T_x_raw_panasonic_image],
"*.acutc" => &[&T_vnd_acucorp_application],
"*.cer" => &[&T_pkix_cert_application],
"*.ims" => &[&T_vnd_ms_ims_application],
"*.rpss" => &[&T_vnd_nokia_radio_presets_application],
"*.fodt" => &[&T_vnd_oasis_opendocument_flat_text_application],
"*.mxl" => &[&T_vnd_recordare_musicxml_application],
"*.cod" => &[&T_vnd_rim_cod_application],
"*.sdc" => &[&T_vnd_stardivision_calc_application],
"*.rpm" => &[&T_x_rpm_application],
"*.xwd" => &[&T_x_xwindowdump_image],
"*.pef" => &[&T_x_raw_pentax_image],
"*.grm" => &[&T_plain_text],
"*.gpg" => &[&T_pgp_encrypted_application],
"*.clj" => &[&T_x_clojure_text],
"*.dbase3" => &[&T_x_dbf_application],
"*.al" => &[&T_x_perl_text],
"*.svgz" => &[&T_svg_xml_image],
"*.wb3" => &[&T_x_quattro_pro_application],
"*.xer" => &[&T_patch_ops_error_xml_application],
"*.mpd" => &[&T_dash_xml_application],
"*.st" => &[&T_x_stsrc_text],
"*.mpt" => &[&T_vnd_ms_project_application],
"*.plc" => &[&T_vnd_mobius_plc_application],
"*.xcat" => &[&T_plain_text],
"*.t" => &[&T_troff_text],
"*.spot" => &[&T_vnd_in3d_spot_text],
"*.stw" => &[&T_vnd_sun_xml_writer_template_application],
"*.h261" => &[&T_h261_video],
"*.l" => &[&T_x_lex_text],
"*.snd" => &[&T_basic_audio],
"*.3fr" => &[&T_x_raw_hasselblad_image],
"*.mpn" => &[&T_vnd_mophun_application_application],
"*.iso19139" => &[&T_iso19139_xml_text],
"*.rlc" => &[&T_vnd_fujixerox_edmics_rlc_image],
"*.nsf" => &[&T_vnd_lotus_notes_application],
"*.conf" => &[&T_x_config_text],
"*.e" => &[&T_x_eiffel_text],
"*.lzma" => &[&T_x_lzma_application],
"*.cfml" => &[&T_x_coldfusion_text],
"*.php3" => &[&T_x_php_text],
"*.acu" => &[&T_vnd_acucobol_application],
"*.otf" => &[&T_x_font_otf_application],
"*.uris" => &[&T_uri_list_text],
"*.midi" => &[&T_midi_audio],
"*.ens" => &[&T_x_endnote_style_application],
"*.mobi" => &[&T_x_mobipocket_ebook_application],
"*.see" => &[&T_vnd_seemail_application],
"*.accdb" => &[&T_x_msaccess_application],
"*.ra" => &[&T_x_pn_realaudio_audio],
"*.mkd" => &[&T_x_web_markdown_text],
"Makefile" => &[&T_x_makefile_text],
"*.qxd" => &[&T_vnd_quark_quarkxpress_application],
"*.p7r" => &[&T_x_pkcs7_certreqresp_application],
"*.flx" => &[&T_vnd_fmi_flexstor_text],
"*.wbmp" => &[&T_vnd_wap_wbmp_image],
"*.osfpvg" => &[&T_vnd_yamaha_openscoreformat_osfpvg_xml_application],
"*.jpe" => &[&T_jpeg_image],
"*.hxx" => &[&T_x_c__hdr_text],
"*.bpm" => &[&T_bizagi_modeler_application],
"*.rsd" => &[&T_rsd_xml_application],
"*.tar" => &[&T_x_tar_application],
"*.pkg" => &[&T_octet_stream_application],
"*.ext" => &[&T_vnd_novadigm_ext_application],
"*.dib" => &[&T_bmp_image],
"*.classpath" => &[&T_plain_text],
"*.rl" => &[&T_resource_lists_xml_application],
"*.unityweb" => &[&T_vnd_unity_application],
"*.gqs" => &[&T_vnd_grafeq_application],
"*.nml" => &[&T_vnd_enliven_application],
"*.potm" => &[&T_vnd_ms_powerpoint_template_macroenabled_12_application],
"*.mxs" => &[&T_vnd_triscape_mxs_application],
"*.au" => &[&T_basic_audio],
"*.indd" => &[&T_x_adobe_indesign_application],
"*.cla" => &[&T_vnd_claymore_application],
"*.rcprofile" => &[&T_vnd_ipunplugged_rcprofile_application],
"*.dis" => &[&T_vnd_mobius_dis_application],
"*.psf" => &[&T_x_font_linux_psf_application],
"*.wrl" => &[&T_vrml_model],
"*.m14" => &[&T_x_msmediaview_application],
"*.junit" => &[&T_plain_text],
"*.bas" => &[&T_x_basic_text],
"*.cww" => &[&T_prs_cww_application],
"*.cpio" => &[&T_x_cpio_application],
"i_*.txt" => &[&T_x_isatab_investigation_application],
"*.cpp" => &[&T_x_c__src_text],
"*.f" => &[&T_x_fortran_text],
"*.glb" => &[&T_gltf_binary_model],
"*.xgrm" => &[&T_plain_text],
"*.mrc" => &[&T_marc_application],
"*.ram" => &[&T_x_pn_realaudio_audio],
"*.voc" => &[&T_x_unknown_audio],
"*.gim" => &[&T_vnd_groove_identity_message_application],
"*.MYI" => &[&T_x_mysql_misam_compressed_index_application],
"*.sas7bacs" => &[&T_x_sas_access_application],
"*.igs" => &[&T_iges_model],
"*.jl" => &[&T_x_common_lisp_text],
"*.f90" => &[&T_x_fortran_text],
"*.lnk" => &[&T_x_ms_shortcut_application],
"*.txf" => &[&T_vnd_mobius_txf_application],
"*.oga" => &[&T_ogg_audio],
"*.xif" => &[&T_vnd_xiff_image],
"*.wbs" => &[&T_vnd_criticaltools_wbs_xml_application],
"*.vcg" => &[&T_vnd_groove_vcard_application],
"*.cdf" => &[&T_x_netcdf_application],
"*.sxw" => &[&T_vnd_sun_xml_writer_application],
"*.parquet" => &[&T_x_parquet_application],
"*.sqlite" => &[&T_x_sqlite3_application],
"*.x3d" => &[&T_vnd_hzn_3d_crossword_application],
"*.spq" => &[&T_scvp_vp_request_application],
"*.bcpio" => &[&T_x_bcpio_application],
"*.rs" => &[&T_rls_services_xml_application],
"*.dtd" => &[&T_xml_dtd_application],
"*.jfi" => &[&T_jpeg_image],
"*.jad" => &[&T_vnd_sun_j2me_app_descriptor_text],
"*.rif" => &[&T_reginfo_xml_application],
"*.susp" => &[&T_vnd_sus_calendar_application],
"*.sas7bbak" => &[&T_x_sas_backup_application],
"*.m4u" => &[&T_vnd_mpegurl_video],
"*.ecelp9600" => &[&T_vnd_nuera_ecelp9600_audio],
"*.p7c" => &[&T_pkcs7_mime_application],
"*.stk" => &[&T_hyperstudio_application],
"*.ifo" => &[&T_x_dvd_ifo_application],
"*.eot" => &[&T_vnd_ms_fontobject_application],
"*.dotm" => &[&T_vnd_ms_word_template_macroenabled_12_application],
"*.utz" => &[&T_vnd_uiq_theme_application],
"*.wb2" => &[&T_x_quattro_pro_application,&T_x_quattro_pro_version_6_application],
"*.urls" => &[&T_uri_list_text],
"*.rms" => &[&T_vnd_jcp_javame_midlet_rms_application],
"*.enw" => &[&T_x_endnote_refer_application],
"*.for" => &[&T_x_fortran_text],
"*.prc" => &[&T_x_mobipocket_ebook_application],
"*.dxr" => &[&T_x_director_application],
"*.qps" => &[&T_vnd_publishare_delta_tree_application],
"*.emma" => &[&T_emma_xml_application],
"*.pwn" => &[&T_vnd_3m_post_it_notes_application],
"*.ivu" => &[&T_vnd_immervision_ivu_application],
"*.odc" => &[&T_vnd_oasis_opendocument_chart_application],
"*.icns" => &[&T_icns_image],
"*.properties" => &[&T_x_java_properties_text],
"*.lua" => &[&T_x_lua_text],
"*.icb" => &[&T_x_tga_image],
"*.xbd" => &[&T_vnd_fujixerox_docuworks_binder_application],
"*.fp7" => &[&T_x_filemaker_application],
"*.pbd" => &[&T_vnd_powerbuilder6_application],
"*.gsf" => &[&T_x_font_ghostscript_application],
"*.emf" => &[&T_emf_image],
"*.svg" => &[&T_svg_xml_image],
"*.caf" => &[&T_x_caf_audio],
"*.gtw" => &[&T_vnd_gtw_model],
"*.lyr" => &[&T_x_esri_layer_application],
"*.vssx" => &[&T_vnd_ms_visio_stencil_application],
"*.3mf" => &[&T_vnd_ms_package_3dmanufacturing_3dmodel_xml_application],
"*.mg" => &[&T_x_modula_text],
"*.hprof.txt" => &[&T_vnd_java_hprof_text_application],
"*.gex" => &[&T_vnd_geometry_explorer_application],
"*.xmp" => &[&T_rdf_xml_application],
"*.ppam" => &[&T_vnd_ms_powerpoint_addin_macroenabled_12_application],
"*.sxi" => &[&T_vnd_sun_xml_impress_application],
"*.mmr" => &[&T_vnd_fujixerox_edmics_mmr_image],
"*.erl" => &[&T_x_erlang_text],
"*.cbl" => &[&T_x_cobol_text],
"*.vcs" => &[&T_x_vcalendar_text],
"*.rss" => &[&T_rss_xml_application],
"*.wk3" => &[&T_vnd_lotus_1_2_3_application,&T_vnd_lotus_1_2_3_version_3_application],
"*.pgn" => &[&T_x_chess_pgn_application],
"*.xbm" => &[&T_x_xbitmap_image],
"*.applescript" => &[&T_x_applescript_text],
"*.dsp" => &[&T_plain_text],
"*.MF" => &[&T_plain_text],
"*.ots" => &[&T_vnd_oasis_opendocument_spreadsheet_template_application],
"*.twds" => &[&T_vnd_simtech_mindmapper_application],
"*.as" => &[&T_x_actionscript_text],
"*.su7" => &[&T_x_sas_utility_application],
"*.srt" => &[&T_x_subrip_application],
"*.xls" => &[&T_vnd_ms_excel_application],
"*.kil" => &[&T_x_killustrator_application],
"*.ig" => &[&T_x_modula_text],
"*.sz" => &[&T_x_snappy_framed_application],
"*.ptx" => &[&T_x_raw_pentax_image],
"*.slt" => &[&T_vnd_epson_salt_application],
"*.am" => &[&T_plain_text],
"*.idml" => &[&T_vnd_adobe_indesign_idml_package_application],
"*.k25" => &[&T_x_raw_kodak_image],
"*.xpm" => &[&T_x_xpixmap_image],
"*.wmlc" => &[&T_vnd_wap_wmlc_application],
"LICENSE" => &[&T_plain_text],
"*.xpt" => &[&T_x_sas_xport_application],
"*.oxps" => &[&T_vnd_ms_xpsdocument_application],
"*.wp6" => &[&T_vnd_wordperfect_application],
"*.vsdm" => &[&T_vnd_ms_visio_drawing_macroEnabled_12_application],
"*.ez3" => &[&T_vnd_ezpix_package_application],
"*.wbxml" => &[&T_vnd_wap_wbxml_application],
"*.java" => &[&T_x_java_source_text],
"*.mag" => &[&T_vnd_ecowin_chart_application],
"*.sldx" => &[&T_vnd_openxmlformats_officedocument_presentationml_slide_application],
"*.aart" => &[&T_plain_text],
"*.wasm" => &[&T_wasm_application],
"*.m4" => &[&T_plain_text],
"*.rb" => &[&T_x_ruby_text],
"*.BAS" => &[&T_x_basic_text],
"*.cmd" => &[&T_x_bat_application],
"*.otp" => &[&T_vnd_oasis_opendocument_presentation_template_application],
"*.adf" => &[&T_x_amiga_disk_format_application],
"*.xmind" => &[&T_x_xmind_application],
"*.ei6" => &[&T_vnd_pg_osasli_application],
"*.azs" => &[&T_vnd_airzip_filesecure_azs_application],
"*.ac3" => &[&T_ac3_audio],
"*.jxl" => &[&T_jxl_image],
"*.flc" => &[&T_x_flc_video],
"*.ntf" => &[&T_nitf_image],
"*.xlsx" => &[&T_vnd_openxmlformats_officedocument_spreadsheetml_sheet_application],
"*.less" => &[&T_x_less_text],
"*.CLS" => &[&T_x_vbasic_text],
"*.semd" => &[&T_vnd_semd_application],
"*.cil" => &[&T_vnd_ms_artgalry_application],
"*.iso" => &[&T_x_iso9660_image_application],
"*.xvm" => &[&T_xv_xml_application],
"*.pbm" => &[&T_x_portable_bitmap_image],
"*.cr3" => &[&T_x_canon_cr3_image],
"*.mdo" => &[&T_plain_text],
"*.mp4v" => &[&T_mp4_video],
"*.clkt" => &[&T_vnd_crick_clicker_template_application],
"*.aw" => &[&T_applixware_application],
"*.hx" => &[&T_x_haxe_text],
"*.p7m" => &[&T_pkcs7_mime_application],
"*.rtf" => &[&T_rtf_application],
"*.ads" => &[&T_x_ada_text],
"*.jpgm" => &[&T_jpm_image],
"*.rwz" => &[&T_x_raw_rawzor_image],
"abs-linkmap" => &[&T_plain_text],
"*.deploy" => &[&T_octet_stream_application],
"*.ttf" => &[&T_x_font_ttf_application],
"*.accde" => &[&T_x_msaccess_application],
"*.scd" => &[&T_x_msschedule_application],
"*.lvp" => &[&T_vnd_lucent_voice_audio],
"*.dxb" => &[&T_vnd_dxb_image],
"*.nroff" => &[&T_troff_text],
"*.js" => &[&T_javascript_text],
"*.jmx" => &[&T_plain_text],
"*.diff" => &[&T_x_diff_text],
"*.123" => &[&T_vnd_lotus_1_2_3_application,&T_vnd_lotus_1_2_3_version_97_9_x_application],
"*.psd" => &[&T_vnd_adobe_photoshop_image],
"*.dwg" => &[&T_vnd_dwg_image],
"*.mp4a" => &[&T_mp4_audio],
"*.mseq" => &[&T_vnd_mseq_application],
"*.ssf" => &[&T_vnd_epson_ssf_application],
"*.m4a" => &[&T_mp4_audio],
"*.mbox" => &[&T_mbox_application],
"*.webm" => &[&T_webm_video],
"*.sm7" => &[&T_x_sas_mddb_application],
"*.mts" => &[&T_vnd_mts_model],
"*.mf" => &[&T_plain_text],
"*.ini" => &[&T_x_ini_text],
"*.dna" => &[&T_vnd_dna_application],
"*.fits" => &[&T_fits_application],
"*.fly" => &[&T_vnd_fly_text],
"*.aifc" => &[&T_x_aiff_audio],
"*.jx" => &[&T_plain_text],
"*.F" => &[&T_x_fortran_text],
"*.gtm" => &[&T_vnd_groove_tool_message_application],
"*.pyv" => &[&T_vnd_ms_playready_media_pyv_video],
"*.ace" => &[&T_x_ace_compressed_application],
"*.ad.txt" => &[&T_x_asciidoc_text],
"*.wmv" => &[&T_x_ms_wmv_video],
"*.dir" => &[&T_x_director_application],
"*.sc7" => &[&T_x_sas_catalog_application],
"*.nar" => &[&T_vnd_iptc_g2_newsmessage_xml_application],
"*.c" => &[&T_x_c_text],
"*.apk" => &[&T_vnd_android_package_archive_application],
"*.pict" => &[&T_x_pict_image],
"*.iif" => &[&T_vnd_shana_informed_interchange_application],
"*.lrf" => &[&T_octet_stream_application],
"*.f4v" => &[&T_x_f4v_video],
"*.sc" => &[&T_vnd_ibm_secure_container_application],
"abs-menulinks" => &[&T_plain_text],
"*.cob" => &[&T_x_cobol_text],
"*.sas" => &[&T_x_sas_application],
"*.cc" => &[&T_x_c__src_text],
"*.wk4" => &[&T_vnd_lotus_1_2_3_application,&T_vnd_lotus_1_2_3_version_4_application],
"*.gnumeric" => &[&T_x_gnumeric_application],
"*.maker" => &[&T_vnd_framemaker_application],
"*.htm" => &[&T_html_text],
"*.dmp" => &[&T_vnd_tcpdump_pcap_application],
"*.aso" => &[&T_vnd_accpac_simply_aso_application],
"*.xvml" => &[&T_xv_xml_application],
"*.ppm" => &[&T_x_portable_pixmap_image],
"*.numbers" => &[&T_vnd_apple_numbers_application],
"*.avif" => &[&T_avif_image],
"*.kwt" => &[&T_vnd_kde_kword_application],
"*.tzx" => &[&T_x_spectrum_tzx_application],
"*.bib" => &[&T_x_bibtex_text_file_application],
"*.shx" => &[&T_vnd_shx_application],
"*.daf" => &[&T_vnd_mobius_daf_application],
"*.mhtml" => &[&T_related_multipart],
"*.sas7butl" => &[&T_x_sas_utility_application],
"*.fzs" => &[&T_vnd_fuzzysheet_application],
"*.gdl" => &[&T_vnd_gdl_model],
"*.rq" => &[&T_sparql_query_application],
"*.tao" => &[&T_vnd_tao_intent_module_archive_application],
"*.pat" => &[&T_x_gimp_pat_image],
"*.war" => &[&T_x_tika_java_web_archive_application],
"*.ft12" => &[&T_x_freehand_image],
"*.CPP" => &[&T_x_c__src_text],
"*.tpt" => &[&T_vnd_trid_tpt_application],
"*.grb" => &[&T_x_grib_application],
"*.pqa" => &[&T_vnd_palm_application],
"*.h5" => &[&T_x_hdf_application],
"*.skm" => &[&T_vnd_koan_application],
"*.dvb" => &[&T_vnd_dvb_file_video],
"*.mos" => &[&T_x_raw_leaf_image],
"a_*.txt" => &[&T_x_isatab_assay_application],
"*.esf" => &[&T_vnd_epson_esf_application],
"*.cmx" => &[&T_x_cmx_image],
"*.adp" => &[&T_adpcm_audio],
"*.sh" => &[&T_x_sh_application],
"*.bpg" => &[&T_x_bpg_image,&T_bpg_image],
"*.arj" => &[&T_x_arj_application],
"*.xsamples" => &[&T_plain_text],
"*.n-gage" => &[&T_vnd_nokia_n_gage_symbian_install_application],
"*.cdy" => &[&T_vnd_cinderella_application],
"*.tcl" => &[&T_x_tcl_text],
"*.cii" => &[&T_vnd_anser_web_certificate_issue_initiation_application],
"*.pcurl" => &[&T_vnd_curl_pcurl_application],
"*.c++" => &[&T_x_c__src_text],
"*.bau" => &[&T_vnd_openofficeorg_autotext_application],
"*.mbk" => &[&T_vnd_mobius_mbk_application],
"*.eps" => &[&T_postscript_application],
"*.in" => &[&T_plain_text],
"*.rng" => &[&T_plain_text],
"*.pgm" => &[&T_x_portable_graymap_image],
"*.dpr" => &[&T_x_pascal_text],
"*.bmp" => &[&T_bmp_image],
"*.me" => &[&T_troff_text],
"*.stf" => &[&T_vnd_wt_stf_application],
"*.xliff" => &[&T_x_xliff_xml_application],
"*.ccxml" => &[&T_ccxml_xml_application],
"*.cmp" => &[&T_vnd_yellowriver_custom_menu_application],
"*.exe" => &[&T_x_dosexec_application],
"*.dtshd" => &[&T_vnd_dts_hd_audio],
"*.plb" => &[&T_vnd_3gpp_pic_bw_large_application],
"*.wmf" => &[&T_wmf_image],
"*.dng" => &[&T_x_raw_adobe_image],
"*.atomsvc" => &[&T_atomsvc_xml_application],
"*.xlm" => &[&T_vnd_ms_excel_application],
"*.flac" => &[&T_x_flac_audio],
"*.afm" => &[&T_x_font_adobe_metric_application],
"*.m2v" => &[&T_mpeg_video],
"*.atom" => &[&T_atom_xml_application],
"*.ssml" => &[&T_ssml_xml_application],
"*.pfb" => &[&T_x_font_type1_application],
"*.p7s" => &[&T_pkcs7_signature_application],
"*.std" => &[&T_vnd_sun_xml_draw_template_application],
"*.wml" => &[&T_vnd_wap_wml_text],
"*.list3820" => &[&T_vnd_ibm_modcap_application],
"*.uri" => &[&T_uri_list_text],
"*.pm" => &[&T_x_perl_text],
"*.rld" => &[&T_resource_lists_diff_xml_application],
"*.gslib" => &[&T_x_psf_audio],
"*.atc" => &[&T_vnd_acucorp_application],
"*.et3" => &[&T_vnd_eszigno3_xml_application],
"*.xquery" => &[&T_xquery_application],
"*.dfac" => &[&T_vnd_dreamfactory_application],
"*.vf" => &[&T_x_tex_virtual_font_application],
"*.PAS" => &[&T_x_pascal_text],
"*.lz4" => &[&T_x_lz4_application],
"*.anpa" => &[&T_vnd_iptc_anpa_text],
"*.amf" => &[&T_x_amf_application],
"*.minigsf" => &[&T_x_psf_audio],
"*.tmo" => &[&T_vnd_tmobile_livetv_application],
"*.xyz" => &[&T_x_xyz_chemical],
"*.kpr" => &[&T_vnd_kde_kpresenter_application],
"*.fit" => &[&T_fits_application],
"*.azw" => &[&T_vnd_amazon_ebook_application],
"*.htke" => &[&T_vnd_kenameaapp_application],
"*.webmanifest" => &[&T_manifest_json_application],
"*.onetoc2" => &[&T_onenote_format_onetoc2_application],
"*.ktz" => &[&T_vnd_kahootz_application],
"*.xht" => &[&T_xhtml_xml_application],
"*.pdb" => &[&T_x_pdb_chemical],
"*.dcm" => &[&T_dicom_application],
"*.key" => &[&T_vnd_apple_keynote_application],
"*.Bas" => &[&T_x_basic_text],
"*.ar" => &[&T_x_archive_application],
"*.heic" => &[&T_heic_image],
"*.hqx" => &[&T_mac_binhex40_application],
"*.gv" => &[&T_vnd_graphviz_text],
"*.egrm" => &[&T_plain_text],
"*.yml" => &[&T_x_yaml_text],
"*.jxr" => &[&T_jxr_image],
"*.cmdf" => &[&T_x_cmdf_chemical],
"*.vox" => &[&T_x_authorware_bin_application],
"*.mli" => &[&T_x_ocaml_text],
"*.gml" => &[&T_gml_xml_application],
"*.xroles" => &[&T_plain_text],
"*.hvd" => &[&T_vnd_yamaha_hv_dic_application],
"*.ktr" => &[&T_vnd_kahootz_application],
"*.data" => &[&T_plain_text],
"*.otg" => &[&T_vnd_oasis_opendocument_graphics_template_application],
"*.man" => &[&T_troff_text],
"*.mdi" => &[&T_vnd_ms_modi_image],
"*.npx" => &[&T_vnd_net_fpx_image],
"*.ft8" => &[&T_x_freehand_image],
"*.i3" => &[&T_x_modula_text],
"*.sxd" => &[&T_vnd_sun_xml_draw_application],
"*.wdb" => &[&T_vnd_ms_works_application],
"*.br" => &[&T_x_brotli_application],
"*.pcapng" => &[&T_vnd_tcpdump_pcapng_application],
"*.wk1" => &[&T_vnd_lotus_1_2_3_application,&T_vnd_lotus_1_2_3_version_2_application],
"*.odf" => &[&T_vnd_oasis_opendocument_formula_application],
"*.mmp" => &[&T_vnd_mindjet_mindmanager_application],
"*.ief" => &[&T_ief_image],
"*.asx" => &[&T_x_ms_asx_application],
"*.qfx" => &[&T_vnd_intu_qfx_application],
"*.mvb" => &[&T_x_msmediaview_application],
"*.aaf" => &[&T_octet_stream_application],
"*.dcr" => &[&T_x_director_application],
"*.zipx" => &[&T_zip_application],
"*.sit" => &[&T_x_stuffit_application],
"*.mpeg" => &[&T_mpeg_video],
"*.def" => &[&T_plain_text],
"*.dsc" => &[&T_prs_lines_tag_text],
"*.mmat" => &[&T_vnd_mindjet_mindmanager_application],
"*.uoml" => &[&T_vnd_uoml_xml_application],
"*.vstx" => &[&T_vnd_ms_visio_template_application],
"*.sas7bfdb" => &[&T_x_sas_fdb_application],
"*.xpw" => &[&T_vnd_intercon_formnet_application],
"*.atx" => &[&T_vnd_antix_game_component_application],
"*.tex" => &[&T_x_tex_application],
"*.viv" => &[&T_vnd_vivo_video],
"*.tcsh" => &[&T_x_csh_application],
"^owl$" => &[&T_rdf_xml_application],
"*.mdb" => &[&T_x_msaccess_application],
"*.j2c" => &[&T_x_jp2_codestream_image],
"*.stl" => &[&T_x_stl_binary_model],
"*.xtest" => &[&T_plain_text],
"README" => &[&T_plain_text],
"*.fh7" => &[&T_x_freehand_image],
"*.asp" => &[&T_asp_text],
"*.nnd" => &[&T_vnd_noblenet_directory_application],
"*.arc" => &[&T_x_internet_archive_application],
"*.svd" => &[&T_vnd_svd_application],
"*.grv" => &[&T_vnd_groove_injector_application],
"*.jlt" => &[&T_vnd_hp_jlyt_application],
"*.nb" => &[&T_mathematica_application],
"*.twd" => &[&T_vnd_simtech_mindmapper_application],
"*.handlers" => &[&T_plain_text],
"*.irm" => &[&T_vnd_ibm_rights_management_application],
"*.chrt" => &[&T_vnd_kde_kchart_application],
"*.seed" => &[&T_vnd_fdsn_seed_application],
"*.vsdx" => &[&T_vnd_ms_visio_drawing_application],
"*.sas7bdmd" => &[&T_x_sas_dmdb_application],
"*.7z" => &[&T_x_7z_compressed_application],
"*.mjp2" => &[&T_mj2_video],
"*.pl" => &[&T_x_perl_text],
"*.mqv" => &[&T_quicktime_video],
"*.acfm" => &[&T_x_font_adobe_metric_application],
"*.3xd" => &[&T_x3d_xml_model],
"*.crt" => &[&T_x_x509_cert_application],
"*.xpr" => &[&T_vnd_is_xpr_application],
"*.wps" => &[&T_vnd_ms_works_application],
"*.oti" => &[&T_vnd_oasis_opendocument_image_template_application],
"*.sr7" => &[&T_x_sas_itemstor_application],
"*.lha" => &[&T_octet_stream_application],
"*.distz" => &[&T_octet_stream_application],
"*.xlc" => &[&T_vnd_ms_excel_application],
"*.mfm" => &[&T_vnd_mfmp_application],
"*.xlam" => &[&T_vnd_ms_excel_addin_macroenabled_12_application],
"*.c4g" => &[&T_vnd_clonk_c4group_application],
"*.wav" => &[&T_vnd_wave_audio],
"*.mscml" => &[&T_mediaservercontrol_xml_application],
"*.srf" => &[&T_x_raw_sony_image],
"*.log" => &[&T_x_log_text],
"*.rst" => &[&T_x_rst_text],
"*.bin" => &[&T_octet_stream_application],
"*.avi" => &[&T_x_msvideo_video],
"*.movie" => &[&T_x_sgi_movie_video],
"*.odp" => &[&T_vnd_oasis_opendocument_presentation_application],
"*.ifm" => &[&T_vnd_shana_informed_formdata_application],
"*.msg" => &[&T_vnd_ms_outlook_application],
"*.hpp" => &[&T_x_c__hdr_text],
"*.knp" => &[&T_vnd_kinar_application],
"*.sas7bdat" => &[&T_x_sas_data_application],
"*.sldasm" => &[&T_sldworks_application],
"*.stx" => &[&T_x_sas_transport_application],
"*.icc" => &[&T_vnd_iccprofile_application],
"*.sti" => &[&T_vnd_sun_xml_impress_template_application],
"*.vm" => &[&T_plain_text],
"*.dcurl" => &[&T_vnd_curl_dcurl_text],
"*.tiff" => &[&T_tiff_image],
"*.bdf" => &[&T_x_font_bdf_application],
"*.dgnlib" => &[&T_vnd_dgn_image],
"*.ksp" => &[&T_vnd_kde_kspread_application],
"*.com" => &[&T_x_msdownload_application],
"*.cdkey" => &[&T_vnd_mediastation_cdkey_application],
"*.oth" => &[&T_vnd_oasis_opendocument_text_web_application],
"*.ddd" => &[&T_vnd_fujixerox_ddd_application],
"*.thmx" => &[&T_vnd_openxmlformats_officedocument_presentationml_presentation_application],
"*.jisp" => &[&T_vnd_jisp_application],
"*.jif" => &[&T_jpeg_image],
"*.raf" => &[&T_x_raw_fuji_image],
"*.pclxl" => &[&T_vnd_hp_pclxl_application],
"*.qxt" => &[&T_vnd_quark_quarkxpress_application],
"*.dwfx" => &[&T_vnd_dwfx_xps_model],
"*.xld" => &[&T_vnd_ms_excel_application],
"*.wax" => &[&T_x_ms_wax_audio],
"*.cu" => &[&T_cu_seeme_application],
"*.smf" => &[&T_vnd_stardivision_math_application],
"*.asf" => &[&T_x_ms_asf_video],
"*.dita" => &[&T_dita_xml_format_topic_application],
"*.pki" => &[&T_pkixcmp_application],
"*.abw" => &[&T_x_abiword_application],
"*.deb" => &[&T_x_debian_package_application],
"*.wmd" => &[&T_x_ms_wmd_application],
"*.grb2" => &[&T_x_grib_application],
"*.ltf" => &[&T_vnd_frogans_ltf_application],
"*.mpc" => &[&T_vnd_mophun_certificate_application,&T_musepack_audio],
"*.sda" => &[&T_vnd_stardivision_draw_application],
"*.torrent" => &[&T_x_bittorrent_application],
"*.wb1" => &[&T_x_quattro_pro_application,&T_x_quattro_pro_version_1_5_application],
"*.mxf" => &[&T_mxf_application],
"*.texinfo" => &[&T_x_texinfo_application],
".htaccess" => &[&T_plain_text],
"*.haml" => &[&T_x_haml_text],
"*.ent" => &[&T_plain_text],
"*.azf" => &[&T_vnd_airzip_filesecure_azf_application],
"*.clp" => &[&T_x_msclip_application],
"*.hdr" => &[&T_vnd_radiance_image],
"*.exp" => &[&T_x_expect_text],
"*.udeb" => &[&T_x_debian_package_application],
"*.he5" => &[&T_x_hdf_application],
"*.pct" => &[&T_x_pict_image],
"*.skd" => &[&T_vnd_koan_application],
"*.nef" => &[&T_x_raw_nikon_image],
"*.nitf" => &[&T_nitf_image],
"*.asc" => &[&T_pgp_signature_application],
"*.oda" => &[&T_oda_application],
"*.cl" => &[&T_x_common_lisp_text],
"*.minipsf1" => &[&T_x_psf_audio],
"*.pro" => &[&T_x_prolog_text],
"*.fg5" => &[&T_vnd_fujitsu_oasysgp_application],
"*.sfdu" => &[&T_x_sfdu_application],
"*.e57" => &[&T_e57_model],
"*.m2a" => &[&T_mpeg_audio],
"^rdf$" => &[&T_rdf_xml_application],
"*.ibooks" => &[&T_x_ibooks_zip_application],
"*.mqy" => &[&T_vnd_mobius_mqy_application],
"*.mov" => &[&T_quicktime_video],
"*.dbf" => &[&T_x_dbf_application],
"*.air" => &[&T_vnd_adobe_air_application_installer_package_zip_application],
"*.w3d" => &[&T_x_director_application],
"*.st7" => &[&T_x_sas_audit_application],
"*.m3a" => &[&T_mpeg_audio],
"*.vis" => &[&T_vnd_visionary_application],
"*.el" => &[&T_x_emacs_lisp_text],
"*.epub" => &[&T_epub_zip_application],
"*.gmx" => &[&T_vnd_gmx_application],
"*.wspolicy" => &[&T_wspolicy_xml_application],
"*.pic" => &[&T_x_pict_image],
"*.mmpt" => &[&T_vnd_mindjet_mindmanager_application],
"*.ss7" => &[&T_x_sas_program_data_application],
"*.ocaml" => &[&T_x_ocaml_text],
"*.webarchive" => &[&T_x_webarchive_application],
"*.mpga" => &[&T_mpeg_audio],
"*.eml" => &[&T_rfc822_message],
"*.text" => &[&T_plain_text],
"*.dist" => &[&T_octet_stream_application],
"*.ggb" => &[&T_vnd_geogebra_file_application],
"*.uue" => &[&T_x_uuencode_text],
"*.qxl" => &[&T_vnd_quark_quarkxpress_application],
"*.memgraph" => &[&T_x_memgraph_application],
"*.rpst" => &[&T_vnd_nokia_radio_preset_application],
"*.mpg4" => &[&T_mp4_video],
"*.org" => &[&T_vnd_lotus_organizer_application],
"*.otc" => &[&T_vnd_oasis_opendocument_chart_template_application],
"*.srx" => &[&T_sparql_results_xml_application],
"*.xspf" => &[&T_xspf_xml_application],
"*.ma" => &[&T_mathematica_application],
"*.lbe" => &[&T_vnd_llamagraphics_life_balance_exchange_xml_application],
"*.s" => &[&T_x_assembly_text],
"*.sse" => &[&T_vnd_kodak_descriptor_application],
"*.iges" => &[&T_iges_model],
"*.cfg" => &[&T_x_config_text],
"*.project" => &[&T_plain_text],
"*.apt" => &[&T_plain_text],
"*.FRM" => &[&T_x_vbasic_text],
"*.shf" => &[&T_shf_xml_application],
"*.flo" => &[&T_vnd_micrografx_flo_application],
"*.msl" => &[&T_vnd_mobius_msl_application],
"*.mp4" => &[&T_mp4_video],
"*.fvt" => &[&T_vnd_fvt_video],
"*.jam" => &[&T_vnd_jam_application],
"*.m3u" => &[&T_x_mpegurl_audio],
"*.mef" => &[&T_x_raw_mamiya_image],
"*.sdw" => &[&T_vnd_stardivision_writer_application],
"*.smil" => &[&T_smil_xml_application],
"*.odi" => &[&T_vnd_oasis_opendocument_image_application],
"*.zip" => &[&T_zip_application],
"*.vbs" => &[&T_x_vbscript_text],
"*.aif" => &[&T_x_aiff_audio],
"*.drf" => &[&T_x_raw_kodak_image],
"*.ogx" => &[&T_ogg_application],
"*.etx" => &[&T_x_setext_text],
"*.p10" => &[&T_pkcs10_application],
"*.CBL" => &[&T_x_cobol_text],
"*.opus" => &[&T_opus_audio],
"*.aas" => &[&T_x_authorware_seg_application],
"*.xegrm" => &[&T_plain_text],
"*.clkw" => &[&T_vnd_crick_clicker_wordbank_application],
"*.hp" => &[&T_x_c__hdr_text],
"*.msh" => &[&T_mesh_model],
"*.mde" => &[&T_x_msaccess_application],
"*.mny" => &[&T_x_msmoney_application],
"*.iiq" => &[&T_x_raw_phaseone_image],
"*.S" => &[&T_x_assembly_text],
"*.woff" => &[&T_woff_font],
"*.car" => &[&T_vnd_curl_car_application],
"*.xbap" => &[&T_x_ms_xbap_application],
"*.onetoc" => &[&T_onenote_format_onetoc2_application],
"*.hvs" => &[&T_vnd_yamaha_hv_script_application],
"*.xfdf" => &[&T_vnd_adobe_xfdf_application],
"*.msi" => &[&T_x_ms_installer_application],
"*.sas7bitm" => &[&T_x_sas_itemstor_application],
"*.srl" => &[&T_sereal_application],
"*.xop" => &[&T_xop_xml_application],
"*.awk" => &[&T_x_awk_text],
"*.md" => &[&T_x_web_markdown_text],
"*.woff2" => &[&T_woff2_font],
"*.gif" => &[&T_gif_image],
"*.groovy" => &[&T_x_groovy_text],
"*.xweb" => &[&T_plain_text],
"*.sas7bvew" => &[&T_x_sas_view_application],
"*.g3" => &[&T_g3fax_image],
"*.tbz2" => &[&T_x_bzip2_application],
"*.y" => &[&T_x_yacc_text],
"*.xpx" => &[&T_vnd_intercon_formnet_application],
"*.lwp" => &[&T_vnd_lotus_wordpro_application],
"*.sdkd" => &[&T_vnd_solent_sdkm_xml_application],
"*.fh40" => &[&T_x_freehand_image],
"*.fh9" => &[&T_x_freehand_image],
"*.minipsf" => &[&T_x_psf_audio],
"*.ft7" => &[&T_x_freehand_image],
"*.nrw" => &[&T_x_raw_nikon_image],
"*.las" => &[&T_x_asprs_application],
"*.dpx" => &[&T_x_dpx_image],
"*.atomcat" => &[&T_atomcat_xml_application],
"*.pem" => &[&T_x_x509_cert_format_pem_application],
"*.xsd" => &[&T_xml_application],
"*.sap" => &[&T_x_sap_audio],
"*.vtt" => &[&T_vtt_text],
"*.ppt" => &[&T_vnd_ms_powerpoint_application],
"*.adoc.txt" => &[&T_x_asciidoc_text],
"*.pml" => &[&T_vnd_ctc_posml_application],
"*.ser" => &[&T_java_serialized_object_application],
"*.gqf" => &[&T_vnd_grafeq_application],
"*.drc" => &[&T_x_dirac_video],
"*.ggt" => &[&T_vnd_geogebra_tool_application],
"*.do" => &[&T_x_stata_do_application],
"*.dvi" => &[&T_x_dvi_application],
"*.saf" => &[&T_vnd_yamaha_smaf_audio_application],
"*.gph" => &[&T_vnd_flographit_application],
"*.rdf" => &[&T_rdf_xml_application],
"*.chat" => &[&T_x_chat_application],
"*.spx" => &[&T_speex_audio],
"*.ecelp7470" => &[&T_vnd_nuera_ecelp7470_audio],
"*.cel" => &[&T_vnd_dgn_image],
"*.aj" => &[&T_x_aspectj_text],
"*.fcs" => &[&T_vnd_isac_fcs_application],
"*.xpi" => &[&T_x_xpinstall_application],
"*.png" => &[&T_png_image],
"GNUMakefile" => &[&T_x_makefile_text],
"*.dsw" => &[&T_plain_text],
"*.tr" => &[&T_troff_text],
"*.ditamap" => &[&T_dita_xml_format_map_application],
"*.edm" => &[&T_vnd_novadigm_edm_application],
"*.aet" => &[&T_vnd_adobe_aftereffects_template_application],
"*.ott" => &[&T_vnd_oasis_opendocument_text_template_application],
"*.qam" => &[&T_vnd_epson_quickanime_application],
"*.3ds" => &[&T_x_3ds_image],
"*.fpx" => &[&T_vnd_fpx_image],
"*.imp" => &[&T_vnd_accpac_simply_imp_application],
"*.crx" => &[&T_x_chrome_package_application,&T_x_chrome_extension_application],
"*.btif" => &[&T_prs_btif_image],
"*.shar" => &[&T_x_shar_application],
"*.dxf" => &[&T_vnd_dxf_image],
"*.ppz" => &[&T_vnd_ms_powerpoint_application],
"*.tga" => &[&T_x_tga_image],
"*.wl" => &[&T_vnd_wolfram_wl_application],
"*.jnlp" => &[&T_x_java_jnlp_file_application],
"*.ft9" => &[&T_x_freehand_image],
"*.sdp" => &[&T_sdp_application],
"*.cdbcmsg" => &[&T_vnd_contact_cmsg_application],
"*.vstm" => &[&T_vnd_ms_visio_template_macroEnabled_12_application],
"*.wm" => &[&T_x_ms_wm_video],
"s_*.txt" => &[&T_x_isatab_application],
"*.slddrw" => &[&T_sldworks_application],
"*.sf7" => &[&T_x_sas_fdb_application],
"*.ogg" => &[&T_vorbis_audio],
"*.xlsb" => &[&T_vnd_ms_excel_sheet_binary_macroenabled_12_application],
"*.pst" => &[&T_vnd_ms_outlook_pst_application],
"*.mst" => &[&T_x_ms_installer_application],
"*.es3" => &[&T_vnd_eszigno3_xml_application],
"*.snf" => &[&T_x_font_snf_application],
"*.dcs" => &[&T_x_raw_kodak_image],
"*.wks" => &[&T_vnd_ms_works_application],
"*.mdtext" => &[&T_x_web_markdown_text],
"*.jxs" => &[&T_jxs_image],
"*.mmd" => &[&T_vnd_chipnuts_karaoke_mmd_application],
"*.xsl" => &[&T_xml_application],
"*.3g2" => &[&T_3gpp2_video],
"*.vrml" => &[&T_vrml_model],
"*.wmx" => &[&T_x_ms_wmx_video],
"*.ecma" => &[&T_ecmascript_application],
"*.skt" => &[&T_vnd_koan_application],
"*.zaz" => &[&T_vnd_zzazz_deck_xml_application],
"*.p" => &[&T_x_pascal_text],
"*.dotx" => &[&T_vnd_openxmlformats_officedocument_wordprocessingml_template_application],
"*.mp2a" => &[&T_mpeg_audio],
"*.fh5" => &[&T_x_freehand_image],
"*.fh12" => &[&T_x_freehand_image],
"*.mrw" => &[&T_x_raw_minolta_image],
"*.m3u8" => &[&T_vnd_apple_mpegurl_application],
"*.sas7bmdb" => &[&T_x_sas_mddb_application],
"*.dcl" => &[&T_plain_text],
"*.d" => &[&T_x_d_text],
"*.swa" => &[&T_x_director_application],
"*.qpw" => &[&T_x_quattro_pro_application],
"*.sis" => &[&T_vnd_symbian_install_application],
"*.xlsm" => &[&T_vnd_ms_excel_sheet_macroenabled_12_application],
"*.pfx" => &[&T_x_pkcs12_application],
"*.texi" => &[&T_x_texinfo_application],
"*.ods" => &[&T_vnd_oasis_opendocument_spreadsheet_application],
"*.pam" => &[&T_x_portable_arbitrarymap_image],
"*.ms" => &[&T_troff_text],
"*.qcp" => &[&T_qcelp_audio],
"*.shp" => &[&T_x_shapefile_application,&T_vnd_shp_application],
"*.pcx" => &[&T_vnd_zbrush_pcx_image],
"*.cfc" => &[&T_x_coldfusion_text],
"*.vss" => &[&T_vnd_visio_application],
"*.uu" => &[&T_x_uuencode_text],
"*.sass" => &[&T_x_sass_text],
"*.txt" => &[&T_plain_text],
"*.config" => &[&T_x_config_text],
"*.xul" => &[&T_vnd_mozilla_xul_xml_application],
"*.m4v" => &[&T_x_m4v_video],
"*.ice" => &[&T_x_cooltalk_x_conference],
"*.dpg" => &[&T_vnd_dpgraph_application],
"*.php" => &[&T_x_php_text],
"*.kpt" => &[&T_vnd_kde_kpresenter_application],
"*.m3" => &[&T_x_modula_text],
"*.mpkg" => &[&T_vnd_apple_installer_xml_application],
"*.ustar" => &[&T_x_ustar_application],
"*.docm" => &[&T_vnd_ms_word_document_macroenabled_12_application],
"*.silo" => &[&T_mesh_model],
"*.sfs" => &[&T_vnd_spotfire_sfs_application],
"*.bibtex" => &[&T_x_bibtex_text_file_application],
"*.arw" => &[&T_x_raw_sony_image],
"*.aiff" => &[&T_x_aiff_audio],
"*.mod" => &[&T_x_mod_audio],
"*.vor" => &[&T_x_staroffice_template_application],
"*.4th" => &[&T_x_forth_text],
"*.hdf" => &[&T_x_hdf_application],
"*.fods" => &[&T_vnd_oasis_opendocument_flat_spreadsheet_application],
"*.der" => &[&T_x_x509_cert_format_der_application],
"*.vmdk" => &[&T_x_vmdk_application],
"*.umj" => &[&T_vnd_umajin_application],
"*.xla" => &[&T_vnd_ms_excel_application],
"*.jdf" => &[&T_x_jeol_jdf_application],
"*.ncx" => &[&T_x_dtbncx_xml_application],
"*.rmi" => &[&T_midi_audio],
"*.toast" => &[&T_x_roxio_toast_application],
"*.vsw" => &[&T_vnd_visio_application],
"*.cdx" => &[&T_x_cdx_chemical],
"*.erf" => &[&T_x_raw_epson_image],
"*.roff" => &[&T_troff_text],
"*.mng" => &[&T_x_mng_video],
"*.xlog" => &[&T_plain_text],
"*.xml" => &[&T_xml_application],
"*.dcx" => &[&T_vnd_zbrush_dcx_image],
"*.pre" => &[&T_vnd_lotus_freelance_application],
"*.lz" => &[&T_x_lzip_application,&T_lzip_application],
"*.application" => &[&T_x_ms_application_application],
"*.fgd" => &[&T_x_director_application],
"*.kwd" => &[&T_vnd_kde_kword_application],
"*.brotli" => &[&T_x_brotli_application],
"NOTICE" => &[&T_plain_text],
"*.sbml" => &[&T_sbml_xml_application],
"*.ipa" => &[&T_x_itunes_ipa_application],
"*.meta" => &[&T_plain_text],
"*.kdc" => &[&T_x_raw_kodak_image],
"*.dms" => &[&T_octet_stream_application],
"*.bat" => &[&T_x_bat_application],
"*.ez" => &[&T_andrew_inset_application],
"*.msp" => &[&T_x_ms_installer_application],
"*.s7m" => &[&T_x_sas_dmdb_application],
"*.cnd" => &[&T_plain_text],
"*.zir" => &[&T_vnd_zul_application],
"*.kia" => &[&T_vnd_kidspiration_application],
"*.tra" => &[&T_vnd_trueapp_application],
"*.vda" => &[&T_x_tga_image],
"*.z" => &[&T_x_compress_application],
"*.odg" => &[&T_vnd_oasis_opendocument_graphics_application],
"*.tmx" => &[&T_x_tmx_application],
"*.oa2" => &[&T_vnd_fujitsu_oasys2_application],
"*.xhvml" => &[&T_xv_xml_application],
"*.ez2" => &[&T_vnd_ezpix_album_application],
"*.xlex" => &[&T_plain_text],
"*.wsdd" => &[&T_plain_text],
"*.vssm" => &[&T_vnd_ms_visio_stencil_macroEnabled_12_application],
"*.crw" => &[&T_x_raw_canon_image],
"*.jbig2" => &[&T_x_jbig2_image],
"*.ditaval" => &[&T_dita_xml_format_val_application],
"*.wpl" => &[&T_vnd_ms_wpl_application],
"*.ft10" => &[&T_x_freehand_image],
"*.mpm" => &[&T_vnd_blueice_multipass_application],
"*.sr2" => &[&T_x_raw_sony_image],
"*.fts" => &[&T_fits_application],
"*.types" => &[&T_plain_text],
"*.sv7" => &[&T_x_sas_view_application],
"*.bmi" => &[&T_vnd_bmi_application],
"*.nc" => &[&T_x_netcdf_application],
"*.tcap" => &[&T_vnd_3gpp2_tcap_application],
"*.wvx" => &[&T_x_ms_wvx_video],
"*.listafp" => &[&T_vnd_ibm_modcap_application],
"*.cif" => &[&T_x_cif_chemical],
"*.cwk" => &[&T_x_appleworks_application],
"*.sib" => &[&T_x_sibelius_application],
"*.eol" => &[&T_vnd_digital_winds_audio],
"*.pxn" => &[&T_x_raw_logitech_image],
"*.lhs" => &[&T_x_haskell_text],
"*.ics" => &[&T_calendar_text],
"*.dmg" => &[&T_x_apple_diskimage_application],
"*.pdf" => &[&T_pdf_application],
"*.xdw" => &[&T_vnd_fujixerox_docuworks_application],
"*.mpy" => &[&T_vnd_ibm_minipay_application],
"*.vsl" => &[&T_plain_text],
"*.pom" => &[&T_plain_text],
"*.ppsx" => &[&T_vnd_openxmlformats_officedocument_presentationml_slideshow_application],
"*.tfm" => &[&T_x_tex_tfm_application],
"*.pp" => &[&T_x_pascal_text],
"*.ft" => &[&T_plain_text],
"*.pen" => &[&T_plain_text],
"*.mmas" => &[&T_vnd_mindjet_mindmanager_application],
"*.xlw" => &[&T_vnd_ms_excel_application],
"*.gbr" => &[&T_x_gimp_gbr_image],
"*.mathml" => &[&T_mathml_xml_application],
"*.hps" => &[&T_vnd_hp_hps_application],
"*.amr" => &[&T_amr_audio],
"*.pfa" => &[&T_x_font_type1_application],
"*.portpkg" => &[&T_vnd_macports_portpkg_application],
"*.xhtml" => &[&T_xhtml_xml_application],
"*.hvp" => &[&T_vnd_yamaha_hv_voice_application],
"*.ifb" => &[&T_calendar_text],
"*.clkp" => &[&T_vnd_crick_clicker_palette_application],
"*.xps" => &[&T_vnd_ms_xpsdocument_application],
"*.hpid" => &[&T_vnd_hp_hpid_application],
"*.oxt" => &[&T_vnd_openofficeorg_extension_application],
"*.dex" => &[&T_x_dex_application],
"*.fig" => &[&T_x_xfig_application],
"*.vb" => &[&T_x_vbdotnet_text],
"*.sxm" => &[&T_vnd_sun_xml_math_application],
"*.hh" => &[&T_x_c__hdr_text],
"*.qxb" => &[&T_vnd_quark_quarkxpress_application],
"*.ppsm" => &[&T_vnd_ms_powerpoint_slideshow_macroenabled_12_application],
"*.c4u" => &[&T_vnd_clonk_c4group_application],
"*.sitx" => &[&T_x_stuffitx_application],
"*.psflib" => &[&T_x_psf_audio],
"*.wqd" => &[&T_vnd_wqd_application],
"*.mlp" => &[&T_vnd_dolby_mlp_application],
"*.ivp" => &[&T_vnd_immervision_ivp_application],
"*.wcm" => &[&T_vnd_ms_works_application],
"*.hprof" => &[&T_vnd_java_hprof__application],
"*.les" => &[&T_vnd_hhe_lesson_player_application],
"*.mesh" => &[&T_mesh_model],
"*.bz2" => &[&T_x_bzip2_application],
"*.pptm" => &[&T_vnd_ms_powerpoint_presentation_macroenabled_12_application],
"*.psb" => &[&T_vnd_3gpp_pic_bw_small_application],
"*.fh50" => &[&T_x_freehand_image],
"*.lisp" => &[&T_x_common_lisp_text],
"*.ico" => &[&T_vnd_microsoft_icon_image],
"*.lzh" => &[&T_octet_stream_application],
"*.elc" => &[&T_octet_stream_application,&T_x_elc_application],
"*.msty" => &[&T_vnd_muvee_style_application],
"*.odt" => &[&T_vnd_oasis_opendocument_text_application],
"*.jpm" => &[&T_jpm_image],
"*.emlx" => &[&T_x_emlx_message],
"*.mka" => &[&T_x_matroska_audio],
"*.link66" => &[&T_vnd_route66_link66_xml_application],
"*.sldm" => &[&T_vnd_ms_powerpoint_slide_macroenabled_12_application],
"*.frame" => &[&T_vnd_framemaker_application],
"*.prt" => &[&T_x_prt_application],
"*.kml" => &[&T_vnd_google_earth_kml_xml_application],
"*.msf" => &[&T_vnd_epson_msf_application],
"*.epsi" => &[&T_postscript_application],
"*.mime" => &[&T_rfc822_message],
"*.qwt" => &[&T_vnd_quark_quarkxpress_application],
"*.mmmp" => &[&T_vnd_mindjet_mindmanager_application],
"*.spf" => &[&T_vnd_yamaha_smaf_phrase_application],
"*.h" => &[&T_x_chdr_text],
"*.xo" => &[&T_vnd_olpc_sugar_application],
"*.COB" => &[&T_x_cobol_text],
"*.sd7" => &[&T_x_sas_data_application],
"*.msa" => &[&T_vnd_msa_disk_image_application],
"*.fh8" => &[&T_x_freehand_image],
"*.css" => &[&T_css_text],
"*.fn" => &[&T_plain_text],
"*.idl" => &[&T_x_idl_text],
"*.m" => &[&T_x_objcsrc_text],
"*.dgn" => &[&T_vnd_dgn_image],
"*.aac" => &[&T_x_aac_audio],
"*.mpe" => &[&T_mpeg_video],
"*.ape" => &[&T_ape_audio],
"*.curl" => &[&T_vnd_curl_text],
"*.xhtml2" => &[&T_xhtml_xml_application],
"*.musicxml" => &[&T_vnd_recordare_musicxml_xml_application],
"*.vcx" => &[&T_vnd_vcx_application],
"*.igl" => &[&T_vnd_igloader_application],
"*.sas7baud" => &[&T_x_sas_audit_application],
"*.xargs" => &[&T_plain_text],
"*.xlt" => &[&T_vnd_ms_excel_application],
"*.xwelcome" => &[&T_plain_text],
"*.HPP" => &[&T_x_c__hdr_text],
"*.rgb" => &[&T_x_rgb_image],
"*.pfm" => &[&T_x_font_printer_metric_application],
"*.go" => &[&T_x_go_text],
"*.cls" => &[&T_x_vbasic_text],
"*.xar" => &[&T_vnd_xara_application,&T_x_xar_application],
"*.wmlsc" => &[&T_vnd_wap_wmlscriptc_application],
"*.scala" => &[&T_x_scala_text],
"*.mmf" => &[&T_vnd_smaf_application],
"*.semf" => &[&T_vnd_semf_application],
"*.xenc" => &[&T_xenc_xml_application],
"*.opf" => &[&T_oebps_package_xml_application],
"*.list" => &[&T_plain_text],
"*.h264" => &[&T_h264_video],
"*.qt" => &[&T_quicktime_video],
"*.dae" => &[&T_vnd_collada_xml_model],
"*.sus" => &[&T_vnd_sus_calendar_application],
"*.cbor" => &[&T_cbor_application],
"*.ftc" => &[&T_vnd_fluxtime_clip_application],
"*.vxml" => &[&T_voicexml_xml_application],
"*.itk" => &[&T_x_tcl_text],
"*.schemas" => &[&T_plain_text],
"*.dtb" => &[&T_x_dtbook_xml_application],
"*.g" => &[&T_plain_text],
"*.wq2" => &[&T_x_quattro_pro_application,&T_x_quattro_pro_version_5_application],
"*.csml" => &[&T_x_csml_chemical],
"*.gnucash" => &[&T_x_gnucash_application],
"*.coffee" => &[&T_x_coffeescript_text],
"*.htc" => &[&T_plain_text],
"*.h++" => &[&T_x_c__hdr_text],
"*.djvu" => &[&T_vnd_djvu_image],
"*.m13" => &[&T_x_msmediaview_application],
"*.h263" => &[&T_h263_video],
"*.cdxml" => &[&T_vnd_chemdraw_xml_application],
"*.spl" => &[&T_x_futuresplash_application],
"*.apr" => &[&T_vnd_lotus_approach_application],
"*.lsp" => &[&T_x_common_lisp_text],
"*.shw" => &[&T_x_corelpresentations_application],
"*.tsd" => &[&T_timestamped_data_application],
"*.lrm" => &[&T_vnd_ms_lrm_application],
"*.3dml" => &[&T_vnd_in3d_3dml_text],
"*.py" => &[&T_x_python_text],
"*.sgml" => &[&T_sgml_text],
"*.xdp" => &[&T_vnd_adobe_xdp_xml_application],
"*.asics" => &[&T_vnd_etsi_asic_s_zip_application],
"*.flv" => &[&T_x_flv_video],
"*.bpk" => &[&T_octet_stream_application],
"*.json" => &[&T_json_application],
"*.djv" => &[&T_vnd_djvu_image],
"*.ras" => &[&T_x_cmu_raster_image],
"*.wad" => &[&T_x_doom_application],
"*.sv4cpio" => &[&T_x_sv4cpio_application],
"*.ost" => &[&T_vnd_ms_outlook_pst_application],
"*.cap" => &[&T_vnd_tcpdump_pcap_application],
"*.ppa" => &[&T_vnd_ms_powerpoint_application],
"*.cwiki" => &[&T_plain_text],
"*.x3f" => &[&T_x_raw_sigma_image],
"*.mc1" => &[&T_vnd_medcalcdata_application],
"*.fh4" => &[&T_x_freehand_image],
"*.xltm" => &[&T_vnd_ms_excel_template_macroenabled_12_application],
"*.cgm" => &[&T_cgm_image],
"*.pcf" => &[&T_x_font_pcf_application],
"*.ps" => &[&T_postscript_application],
"*.qwd" => &[&T_vnd_quark_quarkxpress_application],
"*.mjs" => &[&T_javascript_text],
"*.ptid" => &[&T_vnd_pvi_ptid1_application],
"*.m4s" => &[&T_iso_segment_video],
"*.cml" => &[&T_x_cml_chemical],
"*.odft" => &[&T_vnd_oasis_opendocument_formula_template_application],
"*.sd2" => &[&T_x_sas_data_v6_application],
"*.cr2" => &[&T_x_canon_cr2_image],
"*.so" => &[&T_octet_stream_application],
"*.bay" => &[&T_x_raw_casio_image],
"*.vsd" => &[&T_vnd_visio_application],
"*.csh" => &[&T_x_csh_application],
"*.psf1" => &[&T_x_psf_audio],
"*.pages" => &[&T_vnd_apple_pages_application],
"*.fff" => &[&T_x_raw_imacon_image],
"*.f77" => &[&T_x_fortran_text],
"*.xsp" => &[&T_plain_text],
"*.dump" => &[&T_octet_stream_application],
"*.sgm" => &[&T_sgml_text],
"*.ami" => &[&T_vnd_amiga_ami_application],
"*.warc.gz" => &[&T_warc_gz_application],
"*.sa7" => &[&T_x_sas_access_application],
"*.swi" => &[&T_vnd_arastra_swi_application],
"*.sxg" => &[&T_vnd_sun_xml_writer_global_application],
"*.exr" => &[&T_aces_image],
"*.ipk" => &[&T_vnd_shana_informed_package_application],
"*.osf" => &[&T_vnd_yamaha_openscoreformat_application],
"*.mkv" => &[&T_x_matroska_video],
"*.w60" => &[&T_vnd_wordperfect_application],
"*.ogm" => &[&T_x_ogm_video],
"*.xlf" => &[&T_x_xliff_xml_application],
"*.gre" => &[&T_vnd_geometry_explorer_application],
"*.webp" => &[&T_webp_image],
"*.mht" => &[&T_related_multipart],
"*.jfif" => &[&T_jpeg_image],
"*.pps" => &[&T_vnd_ms_powerpoint_application],
"*.wmls" => &[&T_vnd_wap_wmlscript_text],
"*.C" => &[&T_x_c__src_text],
"*.3gp" => &[&T_3gpp_video],
"*.src" => &[&T_x_wais_source_application],
"*.bash" => &[&T_x_sh_application],
"*.rar" => &[&T_x_rar_compressed_application],
"*.mpg" => &[&T_mpeg_video],
"*.mwf" => &[&T_vnd_mfer_application],
"*.rep" => &[&T_vnd_businessobjects_application],
"*.scss" => &[&T_x_scss_text],
"*.itp" => &[&T_vnd_shana_informed_formtemplate_application],
"*.m4b" => &[&T_mp4_audio],
"*.ttml" => &[&T_ttml_xml_application],
"*.stc" => &[&T_vnd_sun_xml_calc_template_application],
"*.mp2" => &[&T_mpeg_audio],
"*.sxc" => &[&T_vnd_sun_xml_calc_application],
"*.sisx" => &[&T_vnd_symbian_install_application],
"*.acc" => &[&T_vnd_americandynamics_acc_application],
"*.bsh" => &[&T_plain_text],
"*.oas" => &[&T_vnd_fujitsu_oasys_application],
"*.flw" => &[&T_vnd_kde_kivio_application],
"*.yaml" => &[&T_x_yaml_text],
"*.cpt" => &[&T_mac_compactpro_application],
"*.csp" => &[&T_vnd_commonspace_application],
"*.jar" => &[&T_java_archive_application],
"*.php4" => &[&T_x_php_text],
"*.fnc" => &[&T_vnd_frogans_fnc_application],
"*.obd" => &[&T_x_msbinder_application],
"*.frm" => &[&T_x_vbasic_text],
"*.p7b" => &[&T_x_pkcs7_certificates_application],
"*.fo" => &[&T_xslfo_xml_application],
"*.rm" => &[&T_vnd_rn_realmedia_application],
"*.zirz" => &[&T_vnd_zul_application],
"*.pya" => &[&T_vnd_ms_playready_media_pya_audio],
"*.xconf" => &[&T_x_config_text],
"*.fv" => &[&T_plain_text],
"*.jpeg" => &[&T_jpeg_image],
"*.sv4crc" => &[&T_x_sv4crc_application],
"*.pgp" => &[&T_pgp_encrypted_application],
"*.sml" => &[&T_smil_xml_application],
"*.xq" => &[&T_xquery_application],
"*.cxx" => &[&T_x_c__src_text],
"*.otm" => &[&T_vnd_oasis_opendocument_text_master_application],
"*.jpgv" => &[&T_jpeg_video],
"*.clkx" => &[&T_vnd_crick_clicker_application],
"*.jng" => &[&T_x_jng_video],
"*.csv" => &[&T_csv_text],
"*.geo" => &[&T_vnd_dynageo_application],
"*.fm" => &[&T_vnd_framemaker_application],
"*.MYD" => &[&T_x_mysql_misam_data_application],
"*.mp3" => &[&T_mpeg_audio],
"*.gpx" => &[&T_gpx_xml_application],
"*.dd2" => &[&T_vnd_oma_dd2_xml_application],
"*.axx" => &[&T_x_axcrypt_application],
"*.tsv" => &[&T_tab_separated_values_text],
"*.xlz" => &[&T_x_xliff_zip_application],
"*.jb2" => &[&T_x_jbig2_image],
"*.cmc" => &[&T_vnd_cosmocaller_application],
"*.dif" => &[&T_dif_xml_application],
"*.xz" => &[&T_x_xz_application],
"*.xslt" => &[&T_xslt_xml_application],
"*.fsc" => &[&T_vnd_fsc_weblaunch_application],
"*.skp" => &[&T_vnd_koan_application],
"*.jp2" => &[&T_jp2_image],
"*.m1v" => &[&T_mpeg_video],
"*.bz" => &[&T_x_bzip_application],
"*.H" => &[&T_x_c__hdr_text],
"*.a" => &[&T_x_archive_application],
"*.scs" => &[&T_scvp_cv_response_application],
"*.swf" => &[&T_x_shockwave_flash_application],
"*.pls" => &[&T_pls_xml_application],
"*.pod" => &[&T_plain_text],
"*.dot" => &[&T_msword_application],
"*.aam" => &[&T_x_authorware_map_application],
"*.vst" => &[&T_vnd_visio_application],
"*.crd" => &[&T_x_mscardfile_application],
"*.zoo" => &[&T_x_zoo_application],
"*.tpl" => &[&T_vnd_groove_tool_template_application],
"*.Cob" => &[&T_x_cobol_text],
"*.wmz" => &[&T_x_ms_wmz_application],
"*.adb" => &[&T_x_ada_text],
"*.asice" => &[&T_vnd_etsi_asic_e_zip_application],
"*.hs" => &[&T_x_haskell_text],
"*.sig" => &[&T_pgp_signature_application],
"*.fhc" => &[&T_x_freehand_image],
"*.vhdl" => &[&T_x_vhdl_text],
"*.teacher" => &[&T_vnd_smart_teacher_application],
"*.xap" => &[&T_x_silverlight_app_application],
"*.pnm" => &[&T_x_portable_anymap_image],
"*.smi" => &[&T_smil_xml_application],
"*.dll" => &[&T_x_msdownload_application],
"*.Cbl" => &[&T_x_cobol_text],
"*.mj2" => &[&T_mj2_video],
"*.vhd" => &[&T_x_vhdl_text],
"*.cat" => &[&T_vnd_ms_pki_seccat_application],
"*.ngdat" => &[&T_vnd_nokia_n_gage_data_application],
"*.pvb" => &[&T_vnd_3gpp_pic_bw_var_application],
"*.si7" => &[&T_x_sas_data_index_application],
"*.latex" => &[&T_x_latex_application],
"*.wma" => &[&T_x_ms_wma_audio],
"*.markdown" => &[&T_x_web_markdown_text],
"*.bh2" => &[&T_vnd_fujitsu_oasysprs_application],
"*.sdd" => &[&T_vnd_stardivision_impress_application],
"*.xfdl" => &[&T_vnd_xfdl_application],
"*.res" => &[&T_x_dtbresource_xml_application],
"*.scad" => &[&T_x_openscad_application],
"*.str" => &[&T_vnd_pg_format_application],
"*.pot" => &[&T_vnd_ms_powerpoint_application],
"*.gpkg" => &[&T_x_geopackage_application,&T_x_geopackage__version_1_1Or1_0_application],
"*.ttc" => &[&T_x_font_ttf_application,&T_collection_font],
"*.jks" => &[&T_x_java_keystore_application],
"*.amfm" => &[&T_x_font_adobe_metric_application],
"*.ecelp4800" => &[&T_vnd_nuera_ecelp4800_audio],
"*.fbs" => &[&T_vnd_fastbidsheet_image],
"*.ac" => &[&T_plain_text],
"*.pcl" => &[&T_vnd_hp_pcl_application],
"*.kne" => &[&T_vnd_kinar_application],
"*.igx" => &[&T_vnd_micrografx_igx_application],
"*.ihtml" => &[&T_plain_text],
"*.jsp" => &[&T_x_jsp_text],
"*.restx" => &[&T_x_rst_text],
"*.fb2" => &[&T_x_fictionbook_xml_application],
"*.scurl" => &[&T_vnd_curl_scurl_text],
"*.epsf" => &[&T_postscript_application],
"*.adoc" => &[&T_x_asciidoc_text],
"*.docx" => &[&T_vnd_openxmlformats_officedocument_wordprocessingml_document_application],
"*.rest" => &[&T_x_rst_text],
"*.sp7" => &[&T_x_sas_putility_application],
"*.fh10" => &[&T_x_freehand_image],
"*.dts" => &[&T_vnd_dts_audio],
"*.xll" => &[&T_vnd_ms_excel_application],
"*.ad" => &[&T_x_asciidoc_text],
"*.mpx" => &[&T_x_project_application],
"*.ear" => &[&T_x_tika_java_enterprise_archive_application],
"*.cs" => &[&T_x_csharp_text],
"*.rnc" => &[&T_relax_ng_compact_syntax_application],
"*-gz" => &[&T_gzip_application],
"*.xslfo" => &[&T_xslfo_xml_application],
"*.sql" => &[&T_x_sql_text],
"*.pfr" => &[&T_font_tdpfr_application],
"*.onepkg" => &[&T_onenote__format_package_application],
"*.fdf" => &[&T_vnd_fdf_application],
"*.wk2" => &[&T_vnd_lotus_1_2_3_application,&T_vnd_lotus_1_2_3_version_2_application],
"*.gac" => &[&T_vnd_groove_account_application],
"*.chm" => &[&T_vnd_ms_htmlhelp_application],
"*.pub" => &[&T_x_mspublisher_application],
"*.xltx" => &[&T_vnd_openxmlformats_officedocument_spreadsheetml_template_application],
"*.nns" => &[&T_vnd_noblenet_sealer_application],
"*.rmp" => &[&T_x_pn_realaudio_plugin_audio],
"*.setreg" => &[&T_set_registration_initiation_application],
"*.mat" => &[&T_x_matlab_data_application],
"*.sed" => &[&T_x_sed_text],
"*.Frm" => &[&T_x_vbasic_text],
"*.sdkm" => &[&T_vnd_solent_sdkm_xml_application],
"*.lit" => &[&T_x_ms_reader_application],
"*.pkipath" => &[&T_pkix_pkipath_application],
"*.html" => &[&T_html_text],
"*.boz" => &[&T_x_bzip2_application],
"*.n3" => &[&T_plain_text],
"*.u32" => &[&T_x_authorware_bin_application],
"*.uc2" => &[&T_x_uc2_compressed_application],
"*.xcf" => &[&T_x_xcf_image],
"*.sfd-hdstx" => &[&T_vnd_hydrostatix_sof_data_application],
"*.afp" => &[&T_vnd_ibm_modcap_application],
"*.wp5" => &[&T_vnd_wordperfect_application],
"*.roles" => &[&T_plain_text],
"*.setpay" => &[&T_set_payment_initiation_application],
"*.mmap" => &[&T_vnd_mindjet_mindmanager_application],
"*.fe_launch" => &[&T_vnd_denovo_fcselayout_link_application],
"*.kfo" => &[&T_vnd_kde_kformula_application],
"*.xdm" => &[&T_vnd_syncml_dm_xml_application],
"*.zmm" => &[&T_vnd_handheld_entertainment_xml_application],
"tzfile" => &[&T_tzif_application],
"*.ppd" => &[&T_vnd_cups_ppd_application],
"*.plf" => &[&T_vnd_pocketlearn_application],
"*.doc" => &[&T_msword_application],
"*.heif" => &[&T_heif_image],
"*.manifest" => &[&T_plain_text],
"*.Cls" => &[&T_x_vbasic_text],
"*.gtar" => &[&T_x_gtar_application],
"*.oa3" => &[&T_vnd_fujitsu_oasys3_application],
"*.laz" => &[&T_x_asprs_application],
"*.tif" => &[&T_tiff_image],
"*.v" => &[&T_x_verilog_text],
"*.sema" => &[&T_vnd_sema_application],
"*.jnilib" => &[&T_x_java_jnilib_application],
"*.crl" => &[&T_pkix_crl_application],
"*.hlp" => &[&T_winhlp_application],
"*.oprc" => &[&T_vnd_palm_application],
"*.mgz" => &[&T_vnd_proteus_magazine_application],
"*.r3d" => &[&T_x_raw_red_image],
"*.odb" => &[&T_vnd_oasis_opendocument_base_application],
"*.vcd" => &[&T_x_cdlink_application],
"*.vcf" => &[&T_x_vcard_text],
"*.one" => &[&T_onenote_format_one_application],
"*.lostxml" => &[&T_lost_xml_application],
"*.box" => &[&T_vnd_previewsystems_box_application],
"*.sav" => &[&T_x_spss_sav_application],
"*.asm" => &[&T_x_assembly_text],
"*.mcurl" => &[&T_vnd_curl_mcurl_text],
"*.inx" => &[&T_x_adobe_indesign_interchange_application],
"*.wpd" => &[&T_vnd_wordperfect_application],
"*.efif" => &[&T_vnd_picsel_application],
"*.mxu" => &[&T_vnd_mpegurl_video],
"*.bdm" => &[&T_vnd_syncml_dm_wbxml_application],
"*.warc" => &[&T_warc_application],
"*.wri" => &[&T_x_mswrite_application],
"*.cab" => &[&T_vnd_ms_cab_compressed_application],
"*.spc" => &[&T_x_pkcs7_certificates_application],
"*.xmap" => &[&T_plain_text],
"*.perl" => &[&T_x_perl_text],
"*.mcd" => &[&T_vnd_mcd_application],
"*.ada" => &[&T_x_ada_text],
"*.tk" => &[&T_x_tcl_text],
"*.dta" => &[&T_x_stata_dta_application],
"*.potx" => &[&T_vnd_openxmlformats_officedocument_presentationml_template_application],
"*.xsm" => &[&T_vnd_syncml_xml_application],
"*.dwf" => &[&T_vnd_dwf_model],
"*.mp4s" => &[&T_mp4_application],
"*.cgi" => &[&T_x_cgi_text],
"*.gp4" => &[&T_x_guitar_pro_application],
"*.fti" => &[&T_vnd_anser_web_funds_transfer_initiation_application],
"*.txd" => &[&T_vnd_genomatix_tuxedo_application],
"*.jpg" => &[&T_jpeg_image],
"*.emz" => &[&T_x_emf_compressed_image],
"*.mseed" => &[&T_vnd_fdsn_mseed_application],
"*.joda" => &[&T_vnd_joost_joda_archive_application],
"*.wsdl" => &[&T_wsdl_xml_application],
"*.prf" => &[&T_pics_rules_application],
"*.pack" => &[&T_x_java_pack200_application],
"*.sas7bcat" => &[&T_x_sas_catalog_application],
"*.karbon" => &[&T_vnd_kde_karbon_application],
"*.sgl" => &[&T_vnd_stardivision_writer_global_application],
"*.wp" => &[&T_vnd_wordperfect_application],
"KEYS" => &[&T_plain_text],
"*.r" => &[&T_x_rsrc_text],
"*.zst" => &[&T_zstd_application],
"*.aab" => &[&T_x_authorware_bin_application],
"*.tbz" => &[&T_x_bzip_application],
"*.p12" => &[&T_x_pkcs12_application],
"*.enr" => &[&T_x_endnote_refer_application],
"*.tcx" => &[&T_vnd_garmin_tcx_xml_application],
"*.asnd" => &[&T_vnd_adobe_soundbooth_audio],
"*.vtu" => &[&T_vnd_vtu_model],
"*.spp" => &[&T_scvp_vp_response_application],
"*.sas7bput" => &[&T_x_sas_putility_application],
"*.nnw" => &[&T_vnd_noblenet_web_application],
"*.ufdl" => &[&T_vnd_ufdl_application],
"*.wq1" => &[&T_x_quattro_pro_application,&T_x_quattro_pro_version_1_4_application],
"*.ppj" => &[&T_vnd_adobe_premiere_image],
"*.cfm" => &[&T_x_coldfusion_text],
"*.davmount" => &[&T_davmount_xml_application],
"*.scq" => &[&T_scvp_cv_request_application],
"*.dataless" => &[&T_vnd_fdsn_seed_application],
"*.bup" => &[&T_x_dvd_ifo_application],
"*.x32" => &[&T_x_authorware_bin_application],
"*.cxt" => &[&T_x_director_application],
"*.ufd" => &[&T_vnd_ufdl_application],
"*.class" => &[&T_java_vm_application],
"*.mpp" => &[&T_vnd_ms_project_application],
"*.dp" => &[&T_vnd_osgi_dp_application],
"*.cst" => &[&T_x_director_application],
"*.grb1" => &[&T_x_grib_application],
"*.rtx" => &[&T_richtext_text],
"*.cct" => &[&T_x_director_application],
"*.kon" => &[&T_vnd_kde_kontour_application],
"*.kmz" => &[&T_vnd_google_earth_kmz_application],
"*.pptx" => &[&T_vnd_openxmlformats_officedocument_presentationml_presentation_application],
"*.hbci" => &[&T_vnd_hbci_application],
"*.tgz" => &[&T_gzip_application],
"*.c4p" => &[&T_vnd_clonk_c4group_application],
"*.mus" => &[&T_vnd_musician_application],
"*.wp61" => &[&T_vnd_wordperfect_application],
"*.asciidoc" => &[&T_x_asciidoc_text],
"*.aspx" => &[&T_aspdotnet_text],
"*.nes" => &[&T_x_nesrom_application],
"*.rdz" => &[&T_vnd_data_vision_rdz_application],
"*.patch" => &[&T_x_diff_text],
"*.fli" => &[&T_x_fli_video],
"*.c4f" => &[&T_vnd_clonk_c4group_application],
"*.qbo" => &[&T_vnd_intu_qbo_application],
"*.fodp" => &[&T_vnd_oasis_opendocument_flat_presentation_application],
"*.sas7bpgm" => &[&T_x_sas_program_data_application],
"*.cdr" => &[&T_coreldraw_application],
"*.gram" => &[&T_srgs_application],
"*.ai" => &[&T_illustrator_application],
"*.nlu" => &[&T_vnd_neurolanguage_nlu_application],
"*.dxp" => &[&T_vnd_spotfire_dxp_application],
"INSTALL" => &[&T_plain_text],
"*.wtb" => &[&T_vnd_webturbo_application],
"*.vsf" => &[&T_vnd_vsf_application],
"*.wpt" => &[&T_vnd_wordperfect_application],
"*.mxml" => &[&T_xv_xml_application],
"*.kar" => &[&T_midi_audio],
"*.c4d" => &[&T_vnd_clonk_c4group_application],
"*.icm" => &[&T_vnd_iccprofile_application],
"*.mif" => &[&T_vnd_mif_application],
"*.pas" => &[&T_x_pascal_text],
"*.dbase" => &[&T_x_dbf_application],
"*.scm" => &[&T_x_scheme_text],
"*.orf" => &[&T_x_raw_olympus_image],
"*.rexx" => &[&T_x_rexx_text],
"*.sas7bndx" => &[&T_x_sas_data_index_application],

};
