mediatek-optical 1.0.1

//! Receiver-bound scratch-header transfer contracts.
use core::ops::Range;

/// A recognized header-only AES receiver and its boot-preserving write spans.
/// This describes wire representation, not a promise that a target is accepted.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MixedContract {
    programmed: [Range<usize>; 2],
}
impl MixedContract {
    /// The only encrypted range in the uploaded staging image.
    pub fn header_range(&self) -> Range<usize> {
        0x3000..0x3010
    }
    /// Bytes programmed by this receiver when PREPARE preserves boot.
    pub fn programmed_ranges(&self) -> &[Range<usize>] {
        &self.programmed
    }
    /// Plaintext descriptor byte the receiver requires to equal 0xDE.
    pub fn descriptor_byte(&self) -> usize {
        0x1ec056
    }
}

// These are bounded instruction signatures for the two observed compiler
// forms, not image hashes or model/version identifiers. The complete handler
// includes its switch tables, branches, flag stores and literal operands. A
// different instruction or operand is deliberately not treated as equivalent.
// In particular, a scratch AES call alone cannot select mixed transfer.
use super::{analysis::ApplicationAnalysis, decoding::branch_link, entry::application};

struct Form {
    application: &'static [u16],
    header_call: u32,
    selection: u32,
    program_call: u32,
    boot_check_call: u32,
    wrapper: &'static [u16],
    integrity: &'static [u16],
    program: &'static [u16],
    skip_start: u32,
    skip_length: u32,
    skip_final: u32,
}

/// A matched handler whose out-of-line programming code must still be read.
pub(super) struct Candidate {
    form: &'static Form,
    pub(super) wrapper_address: u32,
    pub(super) integrity_address: u32,
}

fn words_match(bytes: &[u8], base: u32, start: u32, expected: &[u16]) -> bool {
    let Some(offset) = start.checked_sub(base).map(|x| x as usize) else {
        return false;
    };
    let Some(end) = offset.checked_add(expected.len() * 2) else {
        return false;
    };
    bytes.get(offset..end).is_some_and(|actual| {
        actual
            .chunks_exact(2)
            .zip(expected)
            .all(|(a, e)| u16::from_le_bytes([a[0], a[1]]) == *e)
    })
}

impl Candidate {
    pub(super) fn inspect(bytes: &[u8], base: u32, analysis: &ApplicationAnalysis) -> Option<Self> {
        if analysis.conflicting_arguments()
            || !analysis.bulk_decoders().is_empty()
            || analysis.scratch_decoders().len() != 1
        {
            return None;
        }
        let handler = application::inspect(bytes, base)?;
        let prologue = application::inspect_prologue(bytes, base, &handler)?;
        application::inspect_flags(bytes, base, &handler, &prologue)?;
        application::inspect_mode_six(bytes, base, &handler, &prologue)?;
        // Both compiler forms place the tag/marker helpers directly before
        // WRITE BUFFER. Their entire code and operands belong to the signature.
        let start = prologue.start.checked_sub(0xdc)?;
        let mut matches = FORMS
            .iter()
            .filter(|form| words_match(bytes, base, start, form.application));
        let form = matches.next()?;
        if matches.next().is_some() {
            return None;
        }
        let header = &analysis.scratch_decoders()[0];
        if header.address != start.checked_add(form.header_call)? {
            return None;
        }
        let range = analysis
            .ranges()
            .iter()
            .find(|r| r.selection.address == start + form.selection)?;
        let signature = range.signature?;
        if signature.offset != 0x10600 || signature.length != 8 {
            return None;
        }
        let wrapper_address = branch_link(bytes, base, start.checked_add(form.program_call)?)?;
        let integrity_address = branch_link(bytes, base, start.checked_add(form.boot_check_call)?)?;
        Some(Self {
            form,
            wrapper_address,
            integrity_address,
        })
    }

    pub(super) fn wrapper_bytes(&self) -> usize {
        self.form.wrapper.len() * 2
    }
    pub(super) fn integrity_bytes(&self) -> usize {
        self.form.integrity.len() * 2
    }
    pub(super) fn program_bytes(&self) -> usize {
        self.form.program.len() * 2
    }

    /// The matched wrapper preserves incoming r0/r1/r2 across setup, stores
    /// destination/source/remaining into the loop's cells and calls its mode-3
    /// loop. Read the actual call target; the two forms use different locations.
    pub(super) fn program_address(&self, wrapper: &[u8]) -> Option<u32> {
        if !words_match(
            wrapper,
            self.wrapper_address,
            self.wrapper_address,
            self.form.wrapper,
        ) {
            return None;
        }
        branch_link(
            wrapper,
            self.wrapper_address,
            self.wrapper_address.checked_add(0x13e)?,
        )
    }

    pub(super) fn bind(
        &self,
        wrapper: &[u8],
        integrity: &[u8],
        program: &[u8],
    ) -> Option<MixedContract> {
        self.program_address(wrapper)?;
        if !words_match(integrity, 0, 0, self.form.integrity)
            || !words_match(program, 0, 0, self.form.program)
        {
            return None;
        }
        // Decode the loop's MOV/LSL operands after matching the complete loop,
        // including its pointer setup, both erase sizes, increments and exits.
        // The signature includes the byte-copy/program helper and its literal
        // operands, binding raw staging bytes to the hardware program buffer.
        // One form preserves 0x1d0000..0x1ec000, the other
        // 0x1c8000..0x1ec000: this must never be a single model-based constant.
        let first = shifted_immediate(program, self.form.skip_start)? as usize;
        let length = shifted_immediate(program, self.form.skip_length)? as usize;
        let final_start = shifted_immediate(program, self.form.skip_final)? as usize;
        let second = first.checked_add(length)?;
        if !(0x10000 < first && first < second && second < final_start && final_start < 0x200000) {
            return None;
        }
        Some(MixedContract {
            programmed: [0x10000..first, second..final_start],
        })
    }
}

fn shifted_immediate(bytes: &[u8], offset: u32) -> Option<u32> {
    let pair = bytes.get(offset as usize..offset as usize + 4)?;
    let mov = u16::from_le_bytes([pair[0], pair[1]]);
    let shift = u16::from_le_bytes([pair[2], pair[3]]);
    let reg = (mov >> 8) & 7;
    if mov & 0xf800 != 0x2000 || shift & 0xf800 != 0 || shift & 7 != reg || (shift >> 3) & 7 != reg
    {
        return None;
    }
    u32::from(mov & 255).checked_shl(u32::from((shift >> 6) & 31))
}

// Bounds below follow the handler's instruction/literal extent. The secure
// service called during acceptance remains opaque: matching this code proves
// representation and write spans, not its return value or hardware success.
#[rustfmt::skip]
const COMPACT_APPLICATION: &[u16] = &[
    0x49ab, 0xb530, 0x680b, 0x4cab, 0x4aa8, 0x2000, 0x1901, 0x0209, 0x0a09, 0x18c9, 0x7809, 0x5c15, // +0000
    0x42a9, 0xd001, 0x2000, 0xbd30, 0x1c40, 0x2808, 0xd3f2, 0x2001, 0xbd30, 0xb5f0, 0x4ca2, 0xb085, // +0018
    0xcc2e, 0xa801, 0xc02e, 0x4da1, 0x3810, 0x2100, 0x2400, 0x002e, 0x2000, 0x00ca, 0xab01, 0x18d2, // +0030
    0x5c33, 0x5c17, 0x42bb, 0xd104, 0x1c40, 0x0600, 0x0e00, 0x2808, 0xd3f6, 0x2808, 0xd102, 0x4d97, // +0048
    0x2401, 0xe006, 0x1c49, 0x0609, 0x0e09, 0x2902, 0xd3e8, 0x2c00, 0xd015, 0x498f, 0x4b8f, 0x680a, // +0060
    0x2000, 0x3b08, 0x18c1, 0x1889, 0x7809, 0x5c2e, 0x42b1, 0xd004, 0x488d, 0xf02e, 0xf837, 0x2400, // +0078
    0xe01e, 0x1c40, 0x0600, 0x0e00, 0x2808, 0xd3ef, 0xe018, 0x7930, 0x7971, 0x79b2, 0x0600, 0x0409, // +0090
    0x4308, 0x0211, 0x4308, 0x79f3, 0x0002, 0x7830, 0x7871, 0x431a, 0x78b3, 0x0600, 0x0409, 0x4308, // +00a8
    0x0219, 0x78f5, 0x4308, 0x0001, 0x487e, 0x4329, 0xf02e, 0xf816, 0x2001, 0x2c00, 0xd100, 0x2000, // +00c0
    0xb005, 0xbdf0, 0x4b67, 0xb5f0, 0x7899, 0xb08f, 0x7858, 0x06c0, 0x0ec0, 0xf7fe, 0xfffe, 0x2501, // +00d8
    0x4f75, 0x2800, 0xd06c, 0x7859, 0x0018, 0x06cb, 0x0edb, 0x2204, 0x4c72, 0x4e73, 0x2100, 0xf09f, // +00f0
    0xe80c, 0x6309, 0x2706, 0x2d63, 0xf4f5, 0xf363, 0x0063, 0x496f, 0x698b, 0x091b, 0x011b, 0x618b, // +0108
    0x7a43, 0x07db, 0xd002, 0x698b, 0x432b, 0x618b, 0x7a43, 0x079b, 0xd503, 0x698b, 0x2402, 0x4323, // +0120
    0x618b, 0x7a43, 0x075b, 0xd502, 0x698b, 0x431a, 0x618a, 0x7a40, 0x0700, 0xd503, 0x6988, 0x2208, // +0138
    0x4310, 0x6188, 0xb00f, 0xbdf0, 0x485f, 0xf02d, 0xffcf, 0xf00e, 0xfcba, 0xe7f7, 0x7983, 0x469c, // +0150
    0x79c3, 0x7a02, 0x469e, 0x4663, 0x041b, 0x4319, 0x4673, 0x021b, 0x4319, 0x4311, 0x910c, 0x7880, // +0168
    0x28a0, 0xd017, 0x28a2, 0xd067, 0x28a4, 0xd1ea, 0xf074, 0xff9b, 0x2800, 0xd0af, 0x2401, 0x0324, // +0180
    0x0022, 0x2100, 0x2000, 0xf7a3, 0xfa47, 0x210b, 0x0349, 0x0022, 0x2000, 0x2301, 0xf0a3, 0xfe0d, // +0198
    0x484a, 0xe3e0, 0xf074, 0xff87, 0x2800, 0xd09b, 0x482c, 0x7800, 0x2800, 0xd105, 0x990c, 0x29ac, // +01b0
    0xd003, 0x2200, 0x211a, 0xe119, 0xe3ec, 0x20ac, 0x8030, 0x4e42, 0x0030, 0xf7fb, 0xfb81, 0xf79e, // +01c8
    0xfe72, 0x4c3a, 0x2101, 0x6820, 0x1984, 0x0689, 0x6808, 0x114a, 0x4390, 0x6008, 0x4e2e, 0x6830, // +01e0
    0x1820, 0x0001, 0xf074, 0xfe31, 0x2015, 0x0200, 0x22a4, 0x0021, 0x1820, 0xf005, 0xf96d, 0x22a4, // +01f8
    0x0021, 0x0020, 0x3020, 0x900e, 0xf005, 0xf966, 0x0020, 0xf09d, 0xfde5, 0x2800, 0xd001, 0x482f, // +0210
    0xe06f, 0x4c2f, 0x22a4, 0x0021, 0x980e, 0x2301, 0xf0a3, 0xfdc9, 0x22a4, 0x0021, 0x2000, 0xf0a3, // +0228
    0xfd79, 0x4822, 0x2220, 0x6801, 0x4828, 0x6834, 0x1809, 0x188b, 0x2000, 0x0216, 0x0a36, 0xe04e, // +0240
    0xe06d, 0x0000, 0xbdb6, 0x01ff, 0xc08c, 0x01ff, 0xbd01, 0x01ff, 0x9dbc, 0x01ff, 0xbfda, 0x01ff, // +0258
    0x9e00, 0x01ff, 0x9a50, 0x01ff, 0x0b04, 0x0200, 0x0cf4, 0x0200, 0x96b5, 0x01ff, 0x96b4, 0x01ff, // +0270
    0xbd12, 0x01ff, 0xbe19, 0x01ff, 0x0c9a, 0x0200, 0x9830, 0x01ff, 0x0c96, 0x0200, 0xbdc0, 0x01ff, // +0288
    0x0c28, 0x0200, 0x0c3c, 0x0200, 0xc18c, 0x01ff, 0x05c8, 0x0001, 0x0c34, 0x0200, 0x05c8, 0x0001, // +02a0
    0x2b08, 0x0015, 0x05c0, 0x0001, 0x00aa, 0x2fba, 0x08fa, 0x2fbb, 0x0c22, 0x0200, 0x0c38, 0x0200, // +02b8
    0x0c2e, 0x0200, 0x2040, 0x0400, 0x00aa, 0x2fbd, 0x00aa, 0x2fc1, 0xd9e0, 0x0000, 0x00aa, 0x2fbe, // +02d0
    0x8400, 0x001e, 0xeee0, 0x0000, 0xe394, 0xe1e3, 0xe023, 0x1936, 0x7836, 0x46b4, 0x021e, 0x0a36, // +02e8
    0x1936, 0x7836, 0x45b4, 0xd003, 0x48fd, 0xf02d, 0xfef7, 0xe389, 0x1c40, 0x0600, 0x0e00, 0x1c52, // +0300
    0x1c5b, 0x2884, 0xd399, 0x2220, 0x2020, 0xf005, 0xf8e1, 0x2000, 0xf09d, 0xfd69, 0x2800, 0xd100, // +0318
    0xe717, 0x48f4, 0xe7e9, 0x2200, 0x211d, 0x200e, 0xe063, 0x7885, 0x230b, 0x025b, 0x2d01, 0xd174, // +0330
    0x4fef, 0x78f8, 0x793d, 0x797f, 0x0400, 0x4308, 0x0229, 0x4308, 0x0005, 0x2001, 0x0300, 0x433d, // +0348
    0x4285, 0xd300, 0x0005, 0x4fe8, 0x79f9, 0x7a3f, 0x0209, 0x4339, 0x8031, 0x8831, 0x4299, 0xd85b, // +0360
    0x0031, 0x8836, 0x19ab, 0x4283, 0xd302, 0x1b40, 0x0406, 0x0c36, 0x8808, 0x2804, 0xd200, 0x800a, // +0378
    0x8808, 0x07c0, 0xd002, 0x8808, 0x1c40, 0x8008, 0x48db, 0xf7fb, 0xfa9f, 0xf79e, 0xfd90, 0x48da, // +0390
    0x4285, 0xd101, 0x2e0a, 0xd00f, 0x48d7, 0x300a, 0x4285, 0xd101, 0x2e12, 0xd009, 0x203d, 0x03c0, // +03a8
    0x1829, 0x6820, 0x4bd1, 0x0032, 0x18c0, 0x2301, 0xf0a3, 0xfcfd, 0x6821, 0x4fd0, 0x4bcd, 0x1948, // +03c0
    0x19c0, 0x0032, 0x18c9, 0xf005, 0xf883, 0x2013, 0x0180, 0x4285, 0xd104, 0x6820, 0x1940, 0x19c0, // +03d8
    0xf004, 0xf934, 0x2045, 0x00c0, 0x4285, 0xd199, 0x4fc6, 0x2400, 0xae02, 0xe003, 0x2005, 0xf005, // +03f0
    0xfdfe, 0xe6a3, 0x1928, 0x0400, 0x0c00, 0xf7bc, 0xfd56, 0x0002, 0x0021, 0x5530, 0x0038, 0xf02d, // +0408
    0xfe6d, 0x1c64, 0x0624, 0x0e24, 0x2c28, 0xd3ef, 0xe692, 0xe000, 0xe098, 0x0005, 0x7880, 0x2804, // +0420
    0xd14b, 0x48b8, 0x6824, 0x6800, 0x78ef, 0x1900, 0x4cb1, 0x1904, 0x46bc, 0x792f, 0x7968, 0x46be, // +0438
    0x4667, 0x043f, 0x4339, 0x4677, 0x023f, 0x4339, 0x4308, 0x0007, 0x79e8, 0x2101, 0x0689, 0x430f, // +0450
    0x7a29, 0x0200, 0x4308, 0x8030, 0x8830, 0x4298, 0xd876, 0x8835, 0x8830, 0x2804, 0xd200, 0x8032, // +0468
    0x8830, 0x07c0, 0xd002, 0x8830, 0x1c40, 0x8030, 0x489f, 0xf7fb, 0xfa27, 0xf79e, 0xfd18, 0x0028, // +0480
    0x4338, 0x0780, 0xd1c6, 0xe012, 0x0081, 0x19ca, 0x5861, 0x26ff, 0x0236, 0x0a0b, 0x4033, 0x060d, // +0498
    0x431d, 0x020b, 0x0236, 0x4033, 0x432b, 0x0e09, 0x4319, 0x6011, 0x1c40, 0x0400, 0x0c00, 0x4e96, // +04b0
    0x8831, 0x0889, 0x4281, 0xd8e7, 0xe640, 0x78a8, 0x2805, 0xd170, 0x4890, 0x6823, 0x6800, 0x18c0, // +04c8
    0x4b8a, 0x18c4, 0x78eb, 0x0028, 0x7905, 0x7947, 0x041b, 0x4319, 0x022b, 0x4319, 0x000d, 0x433d, // +04e0
    0x2709, 0x033f, 0x2dff, 0xd803, 0x0629, 0x0e09, 0x19cd, 0xe008, 0x2101, 0x0249, 0x428d, 0xd204, // +04f8
    0x0629, 0x230b, 0x031b, 0x0e09, 0x18cd, 0x79c1, 0x7a00, 0x0209, 0x4301, 0x0030, 0x8031, 0x8806, // +0510
    0x8801, 0x2904, 0xd200, 0x8002, 0x8801, 0x07c9, 0xd003, 0x0001, 0x8800, 0x1c40, 0x8008, 0x4873, // +0528
    0xf7fb, 0xf9ce, 0xf79e, 0xfcbf, 0x4876, 0x7800, 0x2800, 0xd1bf, 0x2709, 0x033f, 0x2303, 0x031b, // +0540
    0x1be8, 0x4298, 0xd22e, 0x2700, 0x0876, 0xe027, 0xe098, 0x1978, 0x0400, 0x0c00, 0x0a01, 0x29b8, // +0558
    0xd102, 0x2101, 0x02c9, 0x4388, 0x0a01, 0x29a0, 0xd104, 0x0600, 0x2109, 0x0309, 0x0e00, 0x1840, // +0570
    0x4967, 0x1841, 0x290b, 0xd903, 0x4966, 0x1841, 0x29dd, 0xd802, 0x0079, 0x5a61, 0xe000, 0x2100, // +0588
    0x020a, 0x0a09, 0x4311, 0x0409, 0x0c09, 0xf7bc, 0xfa73, 0x1c7f, 0x043f, 0x0c3f, 0x42be, 0xd8d6, // +05a0
    0xe5cc, 0xe018, 0x2001, 0x0300, 0x4285, 0xd2f9, 0x2700, 0x0876, 0xe00e, 0x0079, 0x5a61, 0x1978, // +05b8
    0x0400, 0x020a, 0x0a09, 0x4311, 0x0409, 0x0c00, 0x0c09, 0xf7bc, 0xfa81, 0x1c7f, 0x043f, 0x0c3f, // +05d0
    0x42be, 0xd8ee, 0xe5b2, 0x78a8, 0x2806, 0xd146, 0x4849, 0x6824, 0x6800, 0x1900, 0x4c43, 0x1900, // +05e8
    0x9000, 0x78e8, 0x792c, 0x796f, 0x0400, 0x4308, 0x0221, 0x4308, 0x4338, 0x900c, 0x79e8, 0x7a29, // +0600
    0x0200, 0x4308, 0x8030, 0x8830, 0x4298, 0xd839, 0x8830, 0x9001, 0x8830, 0x2804, 0xd200, 0x8032, // +0618
    0x8830, 0x07c0, 0xd002, 0x8830, 0x1c40, 0x8030, 0x4833, 0xf7fb, 0xf94f, 0xf79e, 0xfc40, 0x2002, // +0630
    0xf7f3, 0xf9b0, 0x0680, 0x0f86, 0x2400, 0xe012, 0x980c, 0x1907, 0x05f8, 0x0f85, 0x42ae, 0xd003, // +0648
    0x0028, 0xf7f3, 0xf9cd, 0x002e, 0x9800, 0x5d01, 0x0678, 0x0e40, 0xf0ad, 0xf8a4, 0x1c64, 0x0424, // +0660
    0x0c24, 0x9801, 0x4284, 0xd3e9, 0xe568, 0x78a8, 0x2820, 0xd1fb, 0x79e8, 0x7a29, 0x0200, 0x4308, // +0678
    0x8030, 0x8830, 0x4298, 0xd902, 0x2200, 0x2121, 0xe6b2, 0x8835, 0x4e1a, 0x0030, 0xf7fb, 0xf91c, // +0690
    0xf79e, 0xfc0d, 0x6820, 0x002a, 0x1980, 0x491f, 0x2301, 0xf0a3, 0xfb88, 0xe54b, 0x7882, 0x2a00, // +06a8
    0xd178, 0x4811, 0x78c2, 0x7903, 0x7946, 0x2100, 0x0412, 0x4311, 0x021a, 0x4b18, 0x4311, 0x4331, // +06c0
    0x6019, 0x7981, 0x79c2, 0x7a00, 0x0409, 0x2600, 0x4331, 0x0212, 0x4e13, 0x4311, 0x4308, 0x6030, // +06d8
    0x6818, 0x2800, 0xd024, 0x6818, 0x2101, 0x0409, 0xe01e, 0x0000, 0x00aa, 0x2fbf, 0x00aa, 0x2fc0, // +06f0
    0x0cf4, 0x0200, 0xd9e0, 0x0000, 0x04d2, 0x0000, 0xf490, 0x0001, 0x020a, 0x2fc2, 0x0c34, 0x0200, // +0708
    0x0c2e, 0x0200, 0xbd0b, 0x01ff, 0x4fc0, 0xffff, 0x6ff0, 0xffff, 0x8228, 0x001e, 0x0c60, 0x0200, // +0720
    0x0c6c, 0x0200, 0x4288, 0xd104, 0xf005, 0xfb95, 0x2011, 0xf7a2, 0xfd78, 0x48f6, 0x7a01, 0x07c9, // +0738
    0xd002, 0x6831, 0x1c49, 0x6031, 0x49f3, 0x6809, 0x6832, 0x1889, 0x2201, 0x0552, 0x4291, 0xd802, // +0750
    0x6831, 0x2900, 0xd106, 0x2200, 0x2121, 0x2005, 0xf005, 0xfc47, 0x48ec, 0xe0fc, 0x78c1, 0x7902, // +0768
    0x0409, 0x7940, 0x0212, 0x1889, 0x1808, 0x49e9, 0x6288, 0x6830, 0x4ae8, 0x6823, 0x6a8c, 0x18d2, // +0780
    0x4be7, 0x18d3, 0x1824, 0x4294, 0xd90a, 0x6a8c, 0x429c, 0xd207, 0x6a8c, 0x4294, 0xd203, 0x6a88, // +0798
    0x1a10, 0xe001, 0xe130, 0x628b, 0x49e0, 0x6148, 0xf79e, 0xfb83, 0x48d9, 0x6800, 0x4ede, 0x6831, // +07b0
    0x4cde, 0x1840, 0x6020, 0x48de, 0x7800, 0x2800, 0xd146, 0x4cd4, 0x6820, 0x2800, 0xd142, 0x6830, // +07c8
    0x2101, 0x0389, 0x4288, 0xd33d, 0xa0d8, 0xc84e, 0xac09, 0xc44e, 0x48da, 0x2303, 0x6800, 0x031b, // +07e0
    0x2210, 0x18c0, 0xa905, 0xf7fd, 0xfdc9, 0x4ed7, 0x2400, 0xa905, 0xe019, 0x2c06, 0xd117, 0x466b, // +07f8
    0x7e9a, 0x7831, 0x48d3, 0xf02d, 0xfc71, 0x466b, 0x7e98, 0x2820, 0xd017, 0x7831, 0x4288, 0xd806, // +0810
    0x49cf, 0x6988, 0x0840, 0x0040, 0x6188, 0x48ce, 0xe000, 0x48ce, 0xf02d, 0xfc60, 0xe009, 0xa809, // +0828
    0xa905, 0x5d09, 0x5d00, 0x4288, 0xd003, 0x48ca, 0xf02d, 0xfc56, 0xe004, 0x1c64, 0x0624, 0x0e24, // +0840
    0x2c10, 0xd3d6, 0x2c10, 0xd101, 0x48b9, 0x7005, 0x48c4, 0x7880, 0x2800, 0xd000, 0xe725, 0x4cb5, // +0858
    0x6820, 0x2201, 0x0552, 0x4290, 0xd3f8, 0x48b3, 0x7801, 0x2901, 0xd3f4, 0x2103, 0x7001, 0xf0a3, // +0870
    0xfa37, 0x20c0, 0xf762, 0xeeda, 0x900d, 0x48b5, 0x6980, 0x07c0, 0xd006, 0x49a3, 0x2000, 0x6008, // +0888
    0x49b6, 0x6008, 0x6820, 0xe007, 0x489f, 0x2101, 0x0409, 0x6001, 0x48b2, 0x6001, 0x6820, 0x1a40, // +08a0
    0x4ea1, 0x6030, 0x2201, 0x0692, 0x6810, 0x2110, 0x4388, 0x6010, 0x4c97, 0x6820, 0x2283, 0x0252, // +08b8
    0x4290, 0xd853, 0x6820, 0x6831, 0x1840, 0x49a9, 0x4288, 0xd94d, 0x489e, 0x2100, 0x6800, 0x0213, // +08d0
    0x4ea6, 0x0a1b, 0x181b, 0x781b, 0x5c76, 0x42b3, 0xd13d, 0x1c49, 0x0609, 0x0e09, 0x1c52, 0x2908, // +08e8
    0xd3f1, 0x1c53, 0xd035, 0x499e, 0x39f0, 0x1809, 0x489e, 0x6001, 0x6801, 0x1c4a, 0x6002, 0x7809, // +0900
    0xab08, 0x7419, 0x6801, 0x1c4a, 0x6002, 0x7809, 0x7459, 0x6801, 0x1c4a, 0x6002, 0x7809, 0x7499, // +0918
    0x6801, 0x1c4a, 0x6002, 0x7809, 0x74d9, 0x6801, 0x1c4a, 0x6002, 0x7809, 0x7319, 0x6801, 0x1c4a, // +0930
    0x6002, 0x7809, 0x7359, 0x6801, 0x1c4a, 0x6002, 0x7809, 0x7399, 0x6801, 0x1c4a, 0x6002, 0x7808, // +0948
    0x4a87, 0x73d8, 0x980c, 0x990b, 0x3ae8, 0xf09c, 0xf99d, 0x2800, 0xd104, 0x703d, 0x4885, 0xf02d, // +0960
    0xfbc1, 0xe546, 0x2201, 0x0692, 0x6810, 0x2110, 0x4388, 0x6010, 0x4877, 0x6980, 0x07c0, 0xd003, // +0978
    0xf0a3, 0xf931, 0x2801, 0xd102, 0x2001, 0xf0a3, 0xf93b, 0x2800, 0xd105, 0x487b, 0xf02d, 0xfbaa, // +0990
    0x2202, 0xe01e, 0xe03a, 0xf7ff, 0xfb3c, 0x2800, 0xd103, 0x4877, 0xf02d, 0xfba0, 0xe00a, 0x4967, // +09a8
    0x4875, 0x6809, 0x1840, 0x7801, 0x29de, 0xd006, 0x4873, 0x22de, 0xf02d, 0xfb94, 0x2200, 0x2124, // +09c0
    0xe514, 0xf7ff, 0xfb11, 0x2800, 0xd105, 0x486f, 0xf02d, 0xfb8a, 0x2203, 0x2126, 0xe50a, 0xf79e, // +09d8
    0xfc3b, 0x2107, 0x2000, 0xf003, 0xfc32, 0x7838, 0x2801, 0xd007, 0x4e4f, 0x6832, 0x6821, 0x485d, // +09f0
    0x6800, 0x2303, 0xf0a3, 0xf9dd, 0x980d, 0xf762, 0xee14, 0xe4f8, 0x7880, 0xe4f6, 0xf074, 0xfcff, // +0a08
    0x2800, 0xd1fa, 0x703d, 0xe4f0, 0xb5f8, 0x4a3e, 0x2004, 0x7851, 0x06c9, 0x0ec9, 0x2401, 0x2901, // +0a20
    0xd001, 0x485a, 0xe145, 0x4d5a, 0x7829, 0x0989, 0x2903, 0xd01c, 0x7829, 0x22e8, 0x4011, 0x2968, // +0a38
    0xd10a, 0x4956, 0x7809, 0x0749, 0xd413, 0x4955, 0x7809, 0x0789, 0xd510, 0xf0ae, 0xeeee, 0xe00c, // +0a50
    0x7829, 0x4011, 0x2960, 0xd008, 0x7829, 0x0909, 0x2905, 0xd004, 0x7829, 0x22e4, 0x4011, 0x2924, // +0a68
    0xd100, 0x2010, 0x4a4b, 0x0001, 0x7892, 0x23ff, 0x021b, 0x4e4a, 0x2a00, 0xd002, 0x6971, 0x4399, // +0a80
    0xe009, 0x07ca, 0xd002, 0x1c49, 0x0609, 0x0e09, 0x6972, 0x4321, 0x0209, 0x439a, 0x4311, 0x6171, // +0a98
    0x4941, 0x2200, 0x3920, 0x720a, 0x720a, 0x720a, 0x1f03, 0x720b, 0x782b, 0x099f, 0x4b25, 0x4e3d, // +0ab0
    0x2f03, 0xd11e, 0x782d, 0x096d, 0x2d07, 0xd112, 0x4d36, 0x782d, 0x07ad, 0xd50e, 0x681b, 0x6835, // +0ac8
    0x18ad, 0x3564, 0x022d, 0x0a2d, 0x18ed, 0x782d, 0x720d, 0x1c52, 0x0612, 0x0e12, 0x2a0c, 0xd3f2, // +0ae0
    0xe0d6, 0x2300, 0x720a, 0x1c5b, 0x061b, 0x0e1b, 0x2b0c, 0xd3f9, 0xe0ce, 0x4d27, 0x782f, 0x25e8, // +0af8
    0x403d, 0x2d68, 0xd164, 0x4d2a, 0x2200, 0x681b, 0x682d, 0x1f06, 0xe05b, 0x0000, 0x0cf4, 0x0200, // +0b10
    0x0c60, 0x0200, 0x00aa, 0x2fc3, 0x00c0, 0x0403, 0x8590, 0x0000, 0x2a60, 0x0000, 0x2140, 0x0404, // +0b28
    0x0c6c, 0x0200, 0xbd88, 0x01ff, 0xbd30, 0x01ff, 0x544d, 0x3931, 0x3935, 0x4220, 0x6f6f, 0x2074, // +0b40
    0x424a, 0x2038, 0x0c34, 0x0200, 0x3006, 0x0000, 0x020a, 0x2fc4, 0x2040, 0x0400, 0x00aa, 0x2fc5, // +0b58
    0x00aa, 0x2fc6, 0x00aa, 0x2fc7, 0x0c3c, 0x0200, 0x0c68, 0x0200, 0x0700, 0x0001, 0x0600, 0x0001, // +0b70
    0x0c88, 0x0200, 0x00aa, 0x2fcc, 0x00aa, 0x2fcd, 0x00aa, 0x2fce, 0xc056, 0x001e, 0x053a, 0x2fcf, // +0b88
    0x00aa, 0x2fd0, 0x0c22, 0x0200, 0x9e00, 0x01ff, 0x96b8, 0x01ff, // +0ba0
];
#[rustfmt::skip]
const COMPACT_WRAPPER: &[u16] = &[
    0xb5ff, 0x000e, 0x0015, 0x001c, 0x2b04, 0xb081, 0xd302, 0x2000, 0xb005, 0xbdf0, 0x20c0, 0xf6bf, // +0000
    0xec30, 0x9000, 0xf762, 0xf842, 0x2011, 0xf6ff, 0xfa25, 0xf7ff, 0xffaf, 0xf7ff, 0xf876, 0x2800, // +0018
    0xd033, 0x49b2, 0x7808, 0x28ff, 0xd02f, 0x78c8, 0x2804, 0xd22c, 0x4bb0, 0x6918, 0x2203, 0x0312, // +0030
    0x4390, 0x139a, 0x1880, 0x6118, 0x2c01, 0xd15a, 0x9801, 0x01d2, 0x1a80, 0x4290, 0xd904, 0x9801, // +0048
    0x1940, 0x1a80, 0x4290, 0xd804, 0x48a7, 0x9901, 0xf78a, 0xf961, 0xe013, 0x6889, 0x1970, 0x1e4b, // +0060
    0x0037, 0x439f, 0x4218, 0xd002, 0x4398, 0x1840, 0xe000, 0x4398, 0x1bc4, 0x4294, 0xd801, 0x2c00, // +0078
    0xd107, 0x489d, 0x0021, 0xf78a, 0xf94c, 0x9800, 0xf6bf, 0xebea, 0xe7b5, 0x42b7, 0xd101, 0x42ac, // +0090
    0xd01e, 0x2201, 0x04d2, 0x0023, 0x4897, 0x0039, 0xf78a, 0xf93d, 0x0022, 0x0039, 0x2001, 0x04c0, // +00a8
    0xf7ff, 0xff53, 0x2201, 0x04d2, 0x1bf0, 0x1886, 0x002b, 0x4890, 0x9901, 0x0032, 0xf78a, 0xf92d, // +00c0
    0x002a, 0x9901, 0x0030, 0xf761, 0xfb1e, 0x2001, 0x04c0, 0x9001, 0x0023, 0x488a, 0x9901, 0x003a, // +00d8
    0xf78a, 0xf91f, 0x4989, 0x4889, 0xf75f, 0xfe2c, 0xf75f, 0xfe0e, 0x0022, 0x0039, 0x9801, 0x2301, // +00f0
    0xe035, 0x2c03, 0xd11a, 0x2001, 0x0680, 0x6801, 0x2210, 0x4391, 0x6001, 0x69c1, 0x0909, 0x0109, // +0108
    0x310a, 0x61c1, 0x497f, 0x9801, 0x6008, 0x487e, 0x6006, 0x487e, 0x6005, 0x4979, 0x487a, 0xf75f, // +0120
    0xfe0d, 0xf75f, 0xfdef, 0xf6d6, 0xfa32, 0xe01a, 0x2c00, 0xd10a, 0x4974, 0x4874, 0xf75f, 0xfe02, // +0138
    0xf75f, 0xfde4, 0x002a, 0x0031, 0x9801, 0x2300, 0xe00b, 0x2c02, 0xd10b, 0x496d, 0x486e, 0xf75f, // +0150
    0xfdf5, 0xf75f, 0xfdd7, 0x9801, 0x002a, 0x0031, 0x2302, 0xf6d6, 0xfe22, 0xf7ff, 0xfef0, 0xf75f, // +0168
    0xfda8, 0x4b5f, 0x6918, 0x2203, 0x0312, 0x4310, 0x6118, 0x9800, 0xf6bf, 0xeb70, 0x2001, 0xe73b, // +0180
    0x4951, 0xb570, 0x6808, 0x2201, 0x4310, 0x6008, 0x4a50, 0x7810, 0x285a, 0xd13f, 0x7850, 0x28a5, // +0198
    0xd13c, 0x7893, 0x0010, 0x2b46, 0xd138, 0x78c2, 0x2a4c, 0xd135, 0x4c4a, 0x6962, 0x7903, 0x0852, // +01b0
    0x0052, 0x07db, 0x0fdb, 0x431a, 0x6162, 0x4a46, 0x7813, 0x069b, 0x0e9b, 0x7013, 0x7983, 0x7814, // +01c8
    0x099b, 0x019b, 0x4323, 0x7013, 0x79c4, 0x4a41, 0x4d42, 0x6813, 0x195b, 0x021d, 0x4b3b, 0x0a2d, // +01e0
    0x681e, 0x19ad, 0x702c, 0x7a04, 0x4e3d, 0x6815, 0x3632, 0x19ad, 0x681e, 0x022d, 0x0a2d, 0x19ad, // +01f8
    0x702c, 0x7a44, 0x4d38, 0x6812, 0x351f, 0x1952, 0x681b, 0x0212, 0x0a12, 0x18d2, 0x7014, 0x7a80, // +0210
    0x4a34, 0x7010, 0x6808, 0x0840, 0x0040, 0x6008, 0xbd70, 0x482e, 0xb510, 0x6800, 0x4b3c, 0x2201, // +0228
    0x213d, 0x03c9, 0x0292, 0x18c0, 0x2301, 0xf7ff, 0xfed9, 0x4838, 0xf78a, 0xf86f, 0xbd10, 0x4826, // +0240
    0x4b35, 0x6800, 0x2201, 0x213d, 0x03c9, 0x0312, 0x18c0, 0x2301, 0xe6ca, 0x4821, 0x4b30, 0x6800, // +0258
    0x2201, 0x213d, 0x03c9, 0x0312, 0x18c0, 0xe676, 0x492c, 0x1840, 0x491c, 0x6809, 0x1808, 0x4916, // +0270
    0x0200, 0x6809, 0x0a00, 0x1840, 0x7800, 0x4770, 0x2201, 0x0292, 0x4290, 0xd20a, 0x4a24, 0x1880, // +0288
    0x4a14, 0x6812, 0x1810, 0x4a0e, 0x0200, 0x6812, 0x0a00, 0x1880, 0x7001, 0x4770, 0xb5f0, 0x4f20, // +02a0
    0x4e1f, 0x4d0d, 0x4c09, 0x2000, 0x19c1, 0x682b, 0x5c32, 0x1859, 0x6823, 0x0209, 0x0a09, 0x1c40, // +02b8
    0x0600, 0x18c9, 0x0e00, 0x2810, 0x700a, 0xd3f1, 0xbdf0, 0x0000, 0x0402, 0x0c34, 0x0200, 0x1200, // +02d0
    0x0200, 0x00c0, 0x0404, 0x0c23, 0x0200, 0x0c38, 0x0200, 0xb06f, 0x0000, 0xbd1b, 0x01ff, 0xc320, // +02e8
    0x01ff, 0x2240, 0x0400, 0x08fa, 0x3052, 0x04ea, 0x3053, 0x0cfe, 0x3054, 0x0cfe, 0x3055, 0x0cfe, // +0300
    0x3056, 0x1bfc, 0x0000, 0x7001, 0x0001, 0x0c68, 0x0200, 0x0c60, 0x0200, 0x0c6c, 0x0200, 0xf490, // +0318
];
#[rustfmt::skip]
const COMPACT_INTEGRITY: &[u16] = &[
    0xb510, 0xf6d7, 0xfbd3, 0x4834, 0x4935, 0x6800, 0x2301, 0x1842, 0x1e49, 0x1841, 0x031b, 0x18c0, // +0000
    0xf7ff, 0xff25, 0xbd10, 0xb5f1, 0x482e, 0x2241, 0x6800, 0x0292, 0x2501, 0x1886, 0xf6d7, 0xfbbe, // +0018
    0x2400, 0x271c, 0x4367, 0x59f0, 0x1c43, 0xd103, 0x4829, 0xf78a, 0xfa62, 0xe03b, 0x9900, 0x4208, // +0030
    0xd033, 0x4826, 0x0021, 0xf78a, 0xfa5a, 0x19bd, 0x6869, 0x4824, 0xf78a, 0xfa55, 0x4824, 0x68a9, // +0048
    0xf78a, 0xfa51, 0x59f1, 0x4822, 0xf78a, 0xfa4d, 0x68a9, 0x2001, 0x0540, 0x4281, 0xd304, 0x6868, // +0060
    0x2241, 0x0292, 0x4290, 0xd10f, 0x4816, 0x686b, 0x6800, 0x002a, 0x320c, 0x1809, 0x1818, 0xf7ff, // +0078
    0xfeea, 0x0005, 0xd109, 0x4817, 0x0021, 0xf78a, 0xfa34, 0xe00d, 0x4816, 0x0021, 0xf78a, 0xfa2f, // +0090
    0x2501, 0x4814, 0x0021, 0xf78a, 0xfa2a, 0x1c64, 0x0624, 0x0e24, 0x2c10, 0xd3ba, 0x0028, 0xbdf8, // +00a8
    0x0000, 0x3000, 0x0406, 0x0400, 0x0001, 0x0580, 0x0001, 0x05af, 0x0001, 0x012a, 0x3047, 0x00aa, // +00c0
    0x3049, 0x0c34, 0x0200, 0xfff0, 0x0000, 0x00aa, 0x304a, 0x012a, 0x304b, 0x04ea, 0x304c, 0x04ea, // +00d8
    0x304d, 0x04ea, 0x304e, 0x012a, 0x3050, 0x012a, 0x304f, 0x012a, 0x3051, 0xb510, 0x2002, 0xf762, // +00f0
    0xf8c5, 0xf762, 0xf8b5, 0x2011, 0xf6ff, 0xfa98, 0x2400, 0x43e4, 0x0021, 0x2001, 0xf700, 0xf8f6, // +0108
    0x0c21, 0x2002, 0xf700, 0xf8f2, 0x0021, 0x2003, 0xf700, 0xf8ee, 0xbd10, 0x48df, 0x6801, 0x0849, // +0120
    0x0049, // +0138
];
#[rustfmt::skip]
const COMPACT_PROGRAM: &[u16] = &[
    0xb5f8, 0x48ce, 0x6841, 0x1482, 0x4311, 0x6041, 0x6841, 0x1442, 0x4311, 0x6041, 0x6841, 0x0052, // +0000
    0x4311, 0x6041, 0x49c8, 0x6808, 0x2480, 0x4320, 0x6008, 0x4ac6, 0x3280, 0x6890, 0x07c0, 0xd0fc, // +0018
    0x4ac3, 0x68d0, 0x2104, 0x4308, 0x60d0, 0x48c1, 0x3040, 0x6901, 0x0849, 0x0049, 0x6101, 0x4dbf, // +0030
    0x69a8, 0x2140, 0x4308, 0x61a8, 0x48bd, 0xe145, 0x4fbc, 0x6839, 0x48bc, 0xf000, 0xf9b3, 0x4ebc, // +0048
    0x6831, 0x48ba, 0x1c40, 0xf000, 0xf9ad, 0x6829, 0x48b7, 0x1c80, 0xf000, 0xf9a8, 0xf000, 0xfea1, // +0060
    0x6838, 0x211d, 0x0409, 0x4288, 0xd10b, 0x6839, 0x2007, 0x0380, 0x1809, 0x6039, 0x6831, 0x1809, // +0078
    0x6031, 0x6829, 0x1a08, 0x6028, 0xe00d, 0x6838, 0x211f, 0x0409, 0x4288, 0xd108, 0x6838, 0x1900, // +0090
    0x6038, 0x6830, 0x1900, 0x6030, 0x2300, 0x602b, 0xe0e0, 0x6838, 0x0400, 0xd06e, 0x6839, 0x003c, // +00a8
    0x48a2, 0x1cc0, 0xf000, 0xf97e, 0x6831, 0x48a0, 0x1d00, 0xf000, 0xf979, 0x6829, 0x2081, 0x00c0, // +00c0
    0xf000, 0xf974, 0xf000, 0xfa8f, 0x4a9c, 0x2006, 0x7010, 0x4996, 0x6888, 0x0a80, 0x0280, 0x1c40, // +00d8
    0x6088, 0x2300, 0x604b, 0x68c8, 0x2702, 0x4338, 0x60c8, 0x7c08, 0x0780, 0xd5fc, 0x7c08, 0x07c0, // +00f0
    0xd1fc, 0x68c8, 0x43b8, 0x60c8, 0x2020, 0x7010, 0x78a0, 0x7050, 0x7860, 0x7090, 0x7820, 0x70d0, // +0108
    0x6888, 0x0a80, 0x0280, 0x1d00, 0x6088, 0x604b, 0x68c8, 0x4338, 0x60c8, 0x7c08, 0x0780, 0xd5fc, // +0120
    0x7c08, 0x07c0, 0xd1fc, 0x68c8, 0x000b, 0x0039, 0x43b8, 0x60d8, 0x2005, 0x7010, 0x6898, 0x0a80, // +0138
    0x0280, 0x1c40, 0x6098, 0x2001, 0x6058, 0x68d8, 0x4308, 0x60d8, 0x7c18, 0x0780, 0xd5fc, 0x7c18, // +0150
    0x07c0, 0xd1fc, 0x68d8, 0x4388, 0x60d8, 0x7850, 0x07c0, 0xd1f0, 0x2701, 0x6831, 0x033f, 0x003a, // +0168
    0x6820, 0xf000, 0xf940, 0x6820, 0x19c0, 0x6020, 0x6830, 0x19c0, 0x6030, 0x6828, 0x1bc0, 0xe06c, // +0180
    0xe7ff, 0x6839, 0x486b, 0x1d80, 0xf000, 0xf910, 0x4e6a, 0x6831, 0x4868, 0x1dc0, 0xf000, 0xf90a, // +0198
    0x6829, 0x4866, 0x3008, 0xf000, 0xf905, 0xf000, 0xfa20, 0x4a65, 0x2006, 0x7010, 0x495e, 0x6888, // +01b0
    0x0a80, 0x0280, 0x1c40, 0x6088, 0x2300, 0x604b, 0x68c8, 0x2602, 0x4330, 0x60c8, 0x7c08, 0x0780, // +01c8
    0xd5fc, 0x7c08, 0x07c0, 0xd1fc, 0x68c8, 0x43b0, 0x60c8, 0x20d8, 0x7010, 0x78b8, 0x7050, 0x7878, // +01e0
    0x7090, 0x7838, 0x70d0, 0x6888, 0x0a80, 0x0280, 0x1d00, 0x6088, 0x604b, 0x68c8, 0x4330, 0x60c8, // +01f8
    0x7c08, 0x0780, 0xd5fc, 0x7c08, 0x07c0, 0xd1fc, 0x68c8, 0x000b, 0x0031, 0x43b0, 0x60d8, 0x2005, // +0210
    0x7010, 0x6898, 0x0a80, 0x0280, 0x1c40, 0x6098, 0x2001, 0x6058, 0x68d8, 0x4308, 0x60d8, 0x7c18, // +0228
    0x0780, 0xd5fc, 0x7c18, 0x07c0, 0xd1fc, 0x68d8, 0x4388, 0x60d8, 0x7850, 0x07c0, 0xd1f0, 0x4e3e, // +0240
    0x0022, 0x6831, 0x6838, 0xf000, 0xf8d2, 0x6838, 0x1900, 0x6038, 0x6830, 0x1900, 0x6030, 0x6828, // +0258
    0x1b00, 0x6028, 0xe000, 0x4d38, 0x6828, 0x2401, 0x0424, 0x42a0, 0xd300, 0xe6e7, 0x4835, 0x6801, // +0270
    0x4830, 0x3009, 0xf000, 0xf89a, 0x01e0, 0x4c2f, 0x6020, 0x4d2b, 0xe001, 0xf000, 0xfd8e, 0x69a8, // +0288
    0x0680, 0xd404, 0x6820, 0x1e40, 0x6020, 0x2800, 0xd1f5, 0x69a9, 0x4826, 0x300e, 0xf000, 0xf886, // +02a0
    0x6821, 0x4824, 0x300f, 0xf000, 0xf881, 0x4827, 0x7802, 0x78c1, 0x0612, 0x4311, 0x7842, 0x7880, // +02b8
    0x0412, 0x0200, 0x4310, 0x4301, 0x481c, 0x3010, 0xf000, 0xf872, 0x4f19, 0x6838, 0x2101, 0x0549, // +02d0
    0x4288, 0xd3c4, 0x4d15, 0x69a8, 0x2480, 0x4320, 0x61a8, 0x69a9, 0x4814, 0x3011, 0xf000, 0xf862, // +02e8
    0xf000, 0xf832, 0xf000, 0xf83b, 0xf000, 0xf849, 0x04e0, 0x6801, 0x2210, 0x4391, 0x6001, 0x69c1, // +0300
    0x0909, 0x0109, 0x310a, 0x61c1, 0x4907, 0x6808, 0x43a0, 0x6008, 0x68c8, 0x2204, 0x4390, 0x60c8, // +0318
    0x490c, 0x6808, 0x4310, 0x6008, 0xbdf8, 0x0000, 0x1f00, 0x0401, 0x1000, 0x0401, 0x2040, 0x0400, // +0330
    0x0c60, 0x0200, 0x0403, 0x0000, 0x0c68, 0x0200, 0x1000, 0x0200, 0x0c6c, 0x0200, 0xbd88, 0x01ff, // +0348
    0xca93, 0x01ff, 0x1000, 0x0400, 0x4a14, 0x6850, 0x2104, 0x4388, 0x6050, 0x060a, 0x6890, 0x0689, // +0360
    0x4308, 0x6090, 0x4770, 0x2001, 0x0680, 0x6881, 0x1482, 0x4311, 0x6081, 0x6801, 0x0142, 0x4311, // +0378
    0x6001, 0x6981, 0x2209, 0x0212, 0x4391, 0x6181, 0x4770, 0x4808, 0xb510, 0x6801, 0x2308, 0x4319, // +0390
    0x6001, 0x0384, 0x68a1, 0x1482, 0x4391, 0x60a1, 0x6801, 0x4399, 0x6001, 0xbd10, 0xc000, 0x0420, // +03a8
    0x1000, 0x0400, 0xb530, 0x4cfd, 0x2501, 0x2200, 0x042d, 0x68a3, 0x05db, 0xd503, 0x0013, 0x1c52, // +03c0
    0x42ab, 0xd3f8, 0x22e7, 0x7022, 0x0a02, 0x7022, 0x7020, 0x20ea, 0x7020, 0x0e08, 0x7020, 0x0c08, // +03d8
    0x7020, 0x0a08, 0x7020, 0x7021, 0x2018, 0x7020, 0x7a60, 0x2101, 0x4308, 0x7260, 0xbd30, 0xb5f8, // +03f0
    0x0016, 0x0005, 0x000c, 0x0001, 0x48eb, 0xf7ff, 0xffd7, 0x48ea, 0x0021, 0x1c40, 0xf7ff, 0xffd2, // +0408
    0x48e7, 0x0031, 0x1c80, 0xf7ff, 0xffcd, 0x0032, 0x4ee5, 0x9500, 0xe0e1, 0x9800, 0x0400, 0xd405, // +0420
    0x4be3, 0x6918, 0x2103, 0x0309, 0x4308, 0xe006, 0x4be0, 0x6918, 0x2103, 0x0309, 0x4388, 0x1399, // +0438
    0x1840, 0x6118, 0x49dd, 0x0220, 0x6809, 0x0a00, 0x1847, 0x6037, 0x49db, 0x2000, 0x6833, 0x1c5d, // +0450
    0x6035, 0x781b, 0x1845, 0x712b, 0x1c40, 0x0600, 0x0e00, 0xd1f5, 0x2006, 0x7008, 0x4bd5, 0x6898, // +0468
    0x0a80, 0x0280, 0x1c40, 0x6098, 0x2000, 0x6058, 0x68d8, 0x2502, 0x4328, 0x60d8, 0x7c18, 0x0780, // +0480
    0xd5fc, 0x7c18, 0x07c0, 0xd1fc, 0x0018, 0x68db, 0x43ab, 0x60c3, 0x700d, 0x466b, 0x789b, 0x704b, // +0498
    0x466b, 0x785b, 0x708b, 0x466b, 0x781b, 0x70cb, 0x6883, 0x0a9b, 0x029b, 0x33ff, 0x1d5b, 0x6083, // +04b0
    0x2300, 0x6043, 0x68c3, 0x432b, 0x60c3, 0x7c03, 0x079b, 0xd5fc, 0x0003, 0x7c18, 0x07c0, 0xd1fc, // +04c8
    0x68d8, 0x43a8, 0x60d8, 0x2005, 0x7008, 0x6898, 0x0a80, 0x0280, 0x1c40, 0x6098, 0x2001, 0x6058, // +04e0
    0x68d8, 0x4328, 0x60d8, 0x7c18, 0x0780, 0xd5fc, 0x7c18, 0x07c0, 0xd1fc, 0x68d8, 0x43a8, 0x60d8, // +04f8
    0x7848, 0x07c0, 0xd1f0, 0x49ae, 0x2004, 0x7008, 0x6898, 0x0019, 0x0a80, 0x0280, 0x1c40, 0x6088, // +0510
    0x2000, 0x6048, 0x68c8, 0x4328, 0x60c8, 0x7c08, 0x0780, 0xd5fc, 0x7c08, 0x07c0, 0xd1fc, 0x68c8, // +0528
    0x43a8, 0x60c8, 0x4ba2, 0x2004, 0x7018, 0x6888, 0x0a80, 0x0280, 0x1c40, 0x6088, 0x2000, 0x6048, // +0540
    0x68c8, 0x4328, 0x60c8, 0x7c08, 0x0780, 0xd5fc, 0x7c08, 0x07c0, 0xd1fc, 0x0008, 0x68c9, 0x2502, // +0558
    0x43a9, 0x60c1, 0x210b, 0x001d, 0x7019, 0x466b, 0x7899, 0x7069, 0x7859, 0x70a9, 0x7819, 0x70e9, // +0570
    0x6881, 0x0a89, 0x0289, 0x1d49, 0x6081, 0x21ff, 0x1c49, 0x6041, 0x68c1, 0x2302, 0x4319, 0x60c1, // +0588
    0x0001, 0x7c08, 0x0780, 0xd5fc, 0x7c08, 0x07c0, 0xd1fc, 0x68c8, 0x2302, 0x4398, 0x60c8, 0x6037, // +05a0
    0x2100, 0x6830, 0x1c43, 0x6033, 0x194b, 0x795b, 0x7800, 0x4298, 0xd009, 0x4b83, 0x6998, 0x2240, // +05b8
    0x4390, 0x6198, 0x487a, 0x1d80, 0xf7ff, 0xfef4, 0xbdf8, 0x1c49, 0x0609, 0x0e09, 0xd1e9, 0x9800, // +05d0
    0x34ff, 0x30ff, 0x1c40, 0x1c64, 0x3aff, 0x1e52, 0x9000, 0x2a00, 0xd000, 0xe71a, 0xbdf8, 0xb5f0, // +05e8
    0x4e73, 0x2105, 0x7031, 0x4d73, 0x68a8, 0x0a80, 0x0280, 0x1c40, 0x60a8, 0x2701, 0x606f, 0x2402, // +0600
    0x68e8, 0x4320, 0x60e8, 0x0029, 0x7c08, 0x0780, 0xd5fc, 0x7c08, 0x07c0, 0xd1fc, 0x68c8, 0x43a0, // +0618
    0x60c8, 0x7870, 0x07c0, 0xd1ef, 0x7870, 0x4968, 0x0200, 0x7809, 0x4301, 0x485f, 0x3009, 0xf7ff, // +0630
    0xfebd, 0x4964, 0x7809, 0x2000, 0x29ef, 0xd16d, 0x2135, 0x7031, 0x68a9, 0x0a89, 0x0289, 0x1c49, // +0648
    0x60a9, 0x606f, 0x68e9, 0x0022, 0x4321, 0x60e9, 0x7c29, 0x0789, 0xd5fc, 0x0029, 0x7c0b, 0x07db, // +0660
    0xd1fc, 0x68cb, 0x4393, 0x60cb, 0x7873, 0x4013, 0x2406, 0x7034, 0x688d, 0x0aad, 0x02ad, 0x1c6d, // +0678
    0x608d, 0x6048, 0x68cd, 0x4315, 0x60cd, 0x7c0d, 0x07ad, 0xd5fc, 0x7c0d, 0x07ed, 0xd1fc, 0x68cd, // +0690
    0x4395, 0x60cd, 0x7034, 0x688c, 0x0aa4, 0x02a4, 0x1c64, 0x608c, 0x6048, 0x68cc, 0x4314, 0x60cc, // +06a8
    0x7c0c, 0x07a4, 0xd5fc, 0x7c0c, 0x07e4, 0xd1fc, 0x68cc, 0x4394, 0x60cc, 0x7037, 0x7070, 0x70b3, // +06c0
    0x688b, 0x0a9b, 0x029b, 0x1cdb, 0x608b, 0x6048, 0x68c8, 0x4310, 0x60c8, 0x7c08, 0x0780, 0xd5fc, // +06d8
    0x0008, 0x7c03, 0x07d9, 0xd1fc, 0x68c1, 0x4391, 0x60c1, 0x2105, 0x7031, 0x6881, 0x0a89, 0x0289, // +06f0
    0x1c49, 0x6081, 0x6047, 0x68c1, 0x4311, 0x60c1, 0x7c01, 0x0789, 0xd5fc, 0x7c01, 0x07c9, 0xd1fc, // +0708
    0x68c1, 0x4391, 0x60c1, 0x7871, 0x07c9, 0xd1f0, 0xbdf0, 0xe7ff, 0x492a, 0x7809, 0x29c2, 0xd1f9, // +0720
    0x2105, 0x7031, 0x68aa, 0x0a92, 0x0292, 0x1c52, 0x60aa, 0x606f, 0x68ea, 0x4322, 0x60ea, 0x002b, // +0738
    0x7c1a, 0x0792, 0xd5fc, 0x7c1a, 0x07d2, 0xd1fc, 0x68da, 0x43a2, 0x60da, 0x7872, 0x07d2, 0xd1ef, // +0750
    0x7872, 0x2340, 0x401a, 0x2306, 0x7033, 0x68ab, 0x0a9b, 0x029b, 0x1c5b, 0x60ab, 0x6068, 0x68eb, // +0768
    0x4323, 0x60eb, 0x7c2b, 0x079b, 0xd5fc, 0x7c2b, 0x07db, 0xd1fc, 0x002b, 0x68ed, 0x43a5, 0x60dd, // +0780
    0x0035, 0x7037, 0x706a, 0x689a, 0x0a92, 0x0292, 0x1c92, 0x609a, 0x6058, 0x68d8, 0x4320, 0x60d8, // +0798
    0x7c18, 0x0780, 0xd5fc, 0x0018, 0x7c02, 0xe011, 0x0000, 0x0401, 0x0415, 0x0000, 0x0c88, 0x0200, // +07b0
    0x2240, 0x0400, 0x0c34, 0x0200, 0x1000, 0x0200, 0x1000, 0x0401, 0x2040, 0x0400, 0xc320, 0x01ff, // +07c8
];
#[rustfmt::skip]
const WIDE_APPLICATION: &[u16] = &[
    0x4979, 0xb530, 0x680b, 0x4c79, 0x4a76, 0x2000, 0x1901, 0x0209, 0x0a09, 0x18c9, 0x7809, 0x5c15, // +0000
    0x42a9, 0xd001, 0x2000, 0xbd30, 0x1c40, 0x2808, 0xd3f2, 0x2001, 0xbd30, 0xb5f0, 0x4c70, 0xb085, // +0018
    0xcc2e, 0xa801, 0xc02e, 0x4d6f, 0x3810, 0x2100, 0x2400, 0x002e, 0x2000, 0x00ca, 0xab01, 0x18d2, // +0030
    0x5c33, 0x5c17, 0x42bb, 0xd104, 0x1c40, 0x0600, 0x0e00, 0x2808, 0xd3f6, 0x2808, 0xd102, 0x4d65, // +0048
    0x2401, 0xe006, 0x1c49, 0x0609, 0x0e09, 0x2902, 0xd3e8, 0x2c00, 0xd015, 0x495d, 0x4b5d, 0x680a, // +0060
    0x2000, 0x3b08, 0x18c1, 0x1889, 0x7809, 0x5c2e, 0x42b1, 0xd004, 0x485b, 0xf02e, 0xfea1, 0x2400, // +0078
    0xe01e, 0x1c40, 0x0600, 0x0e00, 0x2808, 0xd3ef, 0xe018, 0x7930, 0x7971, 0x79b2, 0x0600, 0x0409, // +0090
    0x4308, 0x0211, 0x4308, 0x79f3, 0x0002, 0x7830, 0x7871, 0x431a, 0x78b3, 0x0600, 0x0409, 0x4308, // +00a8
    0x0219, 0x78f5, 0x4308, 0x0001, 0x484c, 0x4329, 0xf02e, 0xfe80, 0x2001, 0x2c00, 0xd100, 0x2000, // +00c0
    0xb005, 0xbdf0, 0x4b36, 0xb5f0, 0x7899, 0xb091, 0x7858, 0x06c0, 0x0ec0, 0xf7fe, 0xffdd, 0x2501, // +00d8
    0x4e43, 0x2800, 0xd009, 0x7859, 0x0018, 0x06cb, 0x0edb, 0x2100, 0x2204, 0x4c40, 0x4f40, 0x2b0b, // +00f0
    0xd300, 0xe0ff, 0x005b, 0x447b, 0x889b, 0x005b, 0x449f, 0x053e, 0x0358, 0x001d, 0x053e, 0x0023, // +0108
    0x016a, 0x0355, 0x053e, 0x053a, 0x053e, 0x014e, 0x7a43, 0x079b, 0xd503, 0x698b, 0x2402, 0x4323, // +0120
    0x618b, 0x7a43, 0x075b, 0xd468, 0x7a40, 0x0700, 0xd503, 0x6988, 0x2208, 0x4310, 0x6188, 0xb011, // +0138
    0xbdf0, 0x482e, 0xf02e, 0xfe3c, 0xf00e, 0xfeb0, 0xe7f7, 0x7983, 0x469c, 0x79c3, 0x469e, 0x7a03, // +0150
    0x930d, 0x4663, 0x041b, 0x4319, 0x4673, 0x021b, 0x4319, 0x9b0d, 0x4319, 0x910e, 0x7883, 0x3ba0, // +0168
    0xe046, 0x0000, 0x9830, 0x01ff, 0x0b01, 0x0200, 0x0b0b, 0x0200, 0x9e04, 0x01ff, 0xbd54, 0x01ff, // +0180
    0xbd2b, 0x01ff, 0xbe1d, 0x01ff, 0x4200, 0x0003, 0xbdf2, 0x01ff, 0xc0a0, 0x01ff, 0xbd29, 0x01ff, // +0198
    0xbff2, 0x01ff, 0x9a50, 0x01ff, 0x0d40, 0x0200, 0x96b5, 0x01ff, 0x96b4, 0x01ff, 0xbd3b, 0x01ff, // +01b0
    0xbe55, 0x01ff, 0x0cde, 0x0200, 0x0cda, 0x0200, 0xbdfc, 0x01ff, 0x0c6c, 0x0200, 0x0c80, 0x0200, // +01c8
    0xc180, 0x01ff, 0x05c8, 0x0001, 0x0c78, 0x0200, 0x05c8, 0x0001, 0x0c5c, 0x0015, 0x05c0, 0x0001, // +01e0
    0x00aa, 0x3386, 0x08fa, 0x3387, 0x0c66, 0x0200, 0x0c7c, 0x0200, 0x0c72, 0x0200, 0x00aa, 0x3389, // +01f8
    0xe000, 0xe2e6, 0xf09d, 0xe962, 0x070a, 0x7606, 0x7b06, 0x0606, 0x8f06, 0x06bd, 0xe79a, 0xf072, // +0210
    0xf864, 0x2800, 0xd06e, 0x48f9, 0x7800, 0x2800, 0xd16a, 0x990e, 0x29ac, 0xd002, 0x2200, 0x211a, // +0228
    0xe137, 0x20ac, 0x8038, 0x4ff4, 0x0038, 0xf7fb, 0xfb19, 0xf7a1, 0xfa0a, 0x4cf2, 0x2101, 0x6820, // +0240
    0x19c4, 0x0689, 0x6808, 0x114a, 0x4390, 0x6008, 0x4fee, 0x6838, 0x1820, 0x0001, 0xf071, 0xfef3, // +0258
    0x2015, 0x0200, 0x22a4, 0x0021, 0x1820, 0xf005, 0xfa09, 0x22a4, 0x0021, 0x0020, 0x3020, 0x9010, // +0270
    0xf005, 0xfa02, 0x0020, 0xf09b, 0xff78, 0x2800, 0xd001, 0x48e3, 0xe01f, 0x4ce3, 0x22a4, 0x0021, // +0288
    0x9810, 0x2301, 0xf0a1, 0xffa3, 0x22a4, 0x0021, 0x2000, 0xf0a1, 0xff53, 0x48da, 0x2220, 0x6801, // +02a0
    0x48dc, 0x683c, 0x1809, 0x188b, 0x2000, 0x0217, 0x0a3f, 0x193f, 0x783f, 0x46bc, 0x021f, 0x0a3f, // +02b8
    0x193f, 0x783f, 0x45bc, 0xd003, 0x48d5, 0xf02e, 0xfd79, 0xe714, 0x1c40, 0x0600, 0x0e00, 0x1c52, // +02d0
    0x1c5b, 0x2884, 0xd3e9, 0x2220, 0x2020, 0xf005, 0xf9cd, 0x2000, 0xf09b, 0xff4c, 0x2800, 0xd091, // +02e8
    0x48cc, 0xe7ea, 0x2200, 0x211d, 0x200e, 0xe0d3, 0xe3ee, 0xf071, 0xfff0, 0x2800, 0xd0e3, 0x2401, // +0300
    0x0324, 0x0022, 0x2100, 0x2000, 0xf7a5, 0xfdc6, 0x2119, 0x0309, 0x0022, 0x2000, 0x2301, 0xf0a1, // +0318
    0xff5e, 0x48c1, 0xe397, 0xf071, 0xffdc, 0x2800, 0xd0cf, 0x48b5, 0x7800, 0x2800, 0xd1cb, 0x990e, // +0330
    0x20ff, 0x3055, 0x4281, 0xd000, 0xe774, 0x990e, 0x8039, 0x4fb0, 0x0038, 0xf7fb, 0xfa91, 0xf7a1, // +0348
    0xf982, 0x6820, 0x2201, 0x19c0, 0x0692, 0x6811, 0x1153, 0x4399, 0x6011, 0x49ab, 0x6809, 0x1840, // +0360
    0x0001, 0xf071, 0xfeb3, 0x48af, 0xf02e, 0xfd26, 0x2001, 0xf09b, 0xff31, 0x2800, 0xd0b7, 0x48ac, // +0378
    0xe7a3, 0x803a, 0x48a0, 0xf7fb, 0xfa73, 0xf7a1, 0xf964, 0x2000, 0xf005, 0xf8f1, 0xf09b, 0xfffb, // +0390
    0x2800, 0xd001, 0x48a5, 0xe794, 0x48a5, 0xe358, 0x7982, 0x79c3, 0x7a00, 0x0412, 0x4311, 0x021a, // +03a8
    0x4311, 0x4308, 0x21ff, 0x3111, 0x4288, 0xd1c1, 0x8038, 0x4892, 0xf7fb, 0xfa56, 0xf7a1, 0xf947, // +03c0
    0x489c, 0xf02e, 0xfcf9, 0x2000, 0xf09b, 0xff04, 0x2800, 0xd08a, 0x4899, 0xe776, 0x7885, 0x230b, // +03d8
    0x025b, 0x2d01, 0xd174, 0x4e97, 0x78f0, 0x7935, 0x7976, 0x0400, 0x4308, 0x0229, 0x4308, 0x0005, // +03f0
    0x2001, 0x0300, 0x4335, 0x4285, 0xd300, 0x0005, 0x4e8f, 0x79f1, 0x7a36, 0x0209, 0x4331, 0x8039, // +0408
    0x8839, 0x4299, 0xd85b, 0x883e, 0x19a9, 0x4281, 0xd302, 0x1b40, 0x0406, 0x0c36, 0x8838, 0x2804, // +0420
    0xd200, 0x803a, 0x8838, 0x07c0, 0xd002, 0x8838, 0x1c40, 0x8038, 0x4873, 0xf7fb, 0xfa19, 0xf7a1, // +0438
    0xf90a, 0x4881, 0x4285, 0xd101, 0x2e0a, 0xd00f, 0x487e, 0x300a, 0x4285, 0xd101, 0x2e12, 0xd009, // +0450
    0x203d, 0x03c0, 0x1829, 0x6820, 0x4b69, 0x0032, 0x18c0, 0x2301, 0xf0a1, 0xfeb9, 0x6821, 0x4f77, // +0468
    0x4b65, 0x1948, 0x19c0, 0x0032, 0x18c9, 0xf005, 0xf901, 0x2013, 0x0180, 0x4285, 0xd104, 0x6820, // +0480
    0x1940, 0x19c0, 0xf004, 0xf97c, 0x2011, 0x0140, 0x4285, 0xd000, 0xe658, 0x4f6d, 0x2400, 0xae02, // +0498
    0xe003, 0x2005, 0xf005, 0xfe7f, 0xe649, 0x1928, 0x0400, 0x0c00, 0xf7be, 0xffc5, 0x0002, 0x0021, // +04b0
    0x5530, 0x0038, 0xf02e, 0xfc80, 0x1c64, 0x0624, 0x0e24, 0x2c30, 0xd3ef, 0xe638, 0xe000, 0xe098, // +04c8
    0x0005, 0x7880, 0x2804, 0xd14b, 0x484d, 0x6824, 0x6800, 0x78ee, 0x1900, 0x4c49, 0x1904, 0x46b4, // +04e0
    0x792e, 0x7968, 0x46b6, 0x4666, 0x0436, 0x4331, 0x4676, 0x0236, 0x4331, 0x4308, 0x0006, 0x79e8, // +04f8
    0x2101, 0x0689, 0x430e, 0x7a29, 0x0200, 0x4308, 0x8038, 0x8838, 0x4298, 0xd876, 0x883d, 0x8838, // +0510
    0x2804, 0xd200, 0x803a, 0x8838, 0x07c0, 0xd002, 0x8838, 0x1c40, 0x8038, 0x4837, 0xf7fb, 0xf9a0, // +0528
    0xf7a1, 0xf891, 0x0028, 0x4330, 0x0780, 0xd1c6, 0xe012, 0x0081, 0x198a, 0x5861, 0x27ff, 0x023f, // +0540
    0x0a0b, 0x403b, 0x060d, 0x431d, 0x020b, 0x023f, 0x403b, 0x432b, 0x0e09, 0x4319, 0x6011, 0x1c40, // +0558
    0x0400, 0x0c00, 0x4f3b, 0x8839, 0x0889, 0x4281, 0xd8e7, 0xe5e6, 0x78a8, 0x2805, 0xd172, 0x4826, // +0570
    0x6823, 0x6800, 0x18c0, 0x4b22, 0x18c4, 0x78eb, 0x0028, 0x7905, 0x7946, 0x041b, 0x4319, 0x022b, // +0588
    0x4319, 0x000d, 0x4335, 0x2609, 0x0336, 0x2dff, 0xd803, 0x0629, 0x0e09, 0x198d, 0xe008, 0x2101, // +05a0
    0x0249, 0x428d, 0xd204, 0x0629, 0x230b, 0x031b, 0x0e09, 0x18cd, 0x79c1, 0x7a00, 0x0209, 0x4301, // +05b8
    0x0038, 0x8039, 0x8807, 0x8801, 0x2904, 0xd200, 0x8002, 0x8801, 0x07c9, 0xd003, 0x0001, 0x8800, // +05d0
    0x1c40, 0x8008, 0x480a, 0xf7fb, 0xf947, 0xf7a1, 0xf838, 0x481c, 0x7800, 0x2800, 0xd1bf, 0x2609, // +05e8
    0x0336, 0x2303, 0x031b, 0x1ba8, 0x4298, 0xd25a, 0x2600, 0x087f, 0xe054, 0xe0c4, 0x9e04, 0x01ff, // +0600
    0xdc80, 0x0000, 0x0c7c, 0x0200, 0x0c78, 0x0200, 0x00aa, 0x338a, 0x8400, 0x001e, 0xf180, 0x0000, // +0618
    0x00aa, 0x338b, 0x00aa, 0x338c, 0x00aa, 0x338d, 0x00aa, 0x338e, 0x00aa, 0x338f, 0x00aa, 0x3390, // +0630
    0x00aa, 0x3391, 0x00aa, 0x3392, 0x00aa, 0x3393, 0x0d40, 0x0200, 0x04d2, 0x0000, 0xf9a0, 0x0001, // +0648
    0x020a, 0x3394, 0x0c72, 0x0200, 0xbd34, 0x01ff, 0xe042, 0x1970, 0x0400, 0x0c00, 0x0a01, 0x29b8, // +0660
    0xd102, 0x2101, 0x02c9, 0x4388, 0x0a01, 0x29a0, 0xd104, 0x0600, 0x2109, 0x0309, 0x0e00, 0x1840, // +0678
    0x49f7, 0x1841, 0x290b, 0xd903, 0x49f6, 0x1841, 0x29dd, 0xd802, 0x0071, 0x5a61, 0xe000, 0x2100, // +0690
    0x020a, 0x0a09, 0x4311, 0x0409, 0x0c09, 0xf7be, 0xfcb5, 0x1c76, 0x0436, 0x0c36, 0x42b7, 0xd8d6, // +06a8
    0xe545, 0x2001, 0x0300, 0x4285, 0xd2fa, 0x2600, 0x087f, 0xe00e, 0x0071, 0x5a61, 0x1970, 0x0400, // +06c0
    0x020a, 0x0a09, 0x4311, 0x0409, 0x0c00, 0x0c09, 0xf7be, 0xfcc4, 0x1c76, 0x0436, 0x0c36, 0x42b7, // +06d8
    0xd8ee, 0xe52c, 0x78a8, 0x2806, 0xd146, 0x48df, 0x6824, 0x6800, 0x1900, 0x4cde, 0x1900, 0x9000, // +06f0
    0x78e8, 0x792c, 0x796e, 0x0400, 0x4308, 0x0221, 0x4308, 0x4330, 0x900e, 0x79e8, 0x7a29, 0x0200, // +0708
    0x4308, 0x8038, 0x8838, 0x4298, 0xd839, 0x8838, 0x9001, 0x8838, 0x2804, 0xd200, 0x803a, 0x8838, // +0720
    0x07c0, 0xd002, 0x8838, 0x1c40, 0x8038, 0x48ce, 0xf7fb, 0xf89c, 0xf7a0, 0xff8d, 0x2002, 0xf7f3, // +0738
    0xf94f, 0x0680, 0x0f86, 0x2400, 0xe012, 0x980e, 0x1907, 0x05f8, 0x0f85, 0x42ae, 0xd003, 0x0028, // +0750
    0xf7f3, 0xf96c, 0x002e, 0x9800, 0x5d01, 0x0678, 0x0e40, 0xf0ab, 0xf813, 0x1c64, 0x0424, 0x0c24, // +0768
    0x9801, 0x4284, 0xd3e9, 0xe4e2, 0x78a8, 0x2820, 0xd1fb, 0x79e8, 0x7a29, 0x0200, 0x4308, 0x8038, // +0780
    0x8838, 0x4298, 0xd902, 0x2200, 0x2121, 0xe686, 0x883d, 0x4fb5, 0x0038, 0xf7fb, 0xf869, 0xf7a0, // +0798
    0xff5a, 0x6820, 0x002a, 0x19c0, 0x49b1, 0x2301, 0xf0a1, 0xfd17, 0xe4c5, 0x7883, 0x2b67, 0xd110, // +07b0
    0x49ae, 0x698b, 0x091b, 0x011b, 0x618b, 0x7a43, 0x07db, 0xd100, 0xe4a8, 0x698b, 0x432b, 0x618b, // +07c8
    0xe4a4, 0x698b, 0x431a, 0x618a, 0xe4aa, 0x7882, 0x2a00, 0xd179, 0x48a5, 0x78c2, 0x7903, 0x7947, // +07e0
    0x2100, 0x0412, 0x4311, 0x021a, 0x4ba2, 0x4311, 0x4339, 0x6019, 0x7981, 0x79c2, 0x7a00, 0x0409, // +07f8
    0x2700, 0x4339, 0x0212, 0x4f9e, 0x4311, 0x4308, 0x6038, 0x6818, 0x2800, 0xd004, 0x6818, 0x2101, // +0810
    0x0409, 0x4288, 0xd104, 0xf005, 0xfbf4, 0x2011, 0xf7a5, 0xf941, 0x4893, 0x7a01, 0x07c9, 0xd002, // +0828
    0x6839, 0x1c49, 0x6039, 0x4991, 0x6809, 0x683a, 0x1889, 0x2201, 0x0552, 0x4291, 0xd802, 0x6839, // +0840
    0x2900, 0xd106, 0x2200, 0x2121, 0x2005, 0xf005, 0xfca8, 0x488b, 0xe0fd, 0x78c1, 0x7902, 0x0409, // +0858
    0x7940, 0x0212, 0x1889, 0x1808, 0x4987, 0x6288, 0x6838, 0x4a87, 0x6823, 0x6a8c, 0x18d2, 0x4b86, // +0870
    0x18d3, 0x1824, 0x4294, 0xd909, 0x6a8c, 0x429c, 0xd206, 0x6a8c, 0x4294, 0xd202, 0x6a88, 0x1a10, // +0888
    0xe000, 0x628b, 0x497f, 0x6148, 0xf7a0, 0xfedd, 0x4877, 0x6800, 0x4f77, 0x6839, 0x4c7c, 0x1840, // +08a0
    0x6020, 0x487c, 0x7800, 0x2800, 0xd148, 0x4c72, 0x6820, 0x2800, 0xd144, 0x6838, 0x2101, 0x0389, // +08b8
    0x4288, 0xd33f, 0xa076, 0xc88e, 0xac0b, 0xc48e, 0x4866, 0x2210, 0xa907, 0xe000, 0xe150, 0x6800, // +08d0
    0x2303, 0x031b, 0x18c0, 0xf7fd, 0xfd09, 0x4f73, 0x2400, 0xa907, 0xe019, 0x2c06, 0xd117, 0xab08, // +08e8
    0x789a, 0x7839, 0x486f, 0xf02e, 0xfa63, 0xab08, 0x7898, 0x2820, 0xd017, 0x7839, 0x4288, 0xd806, // +0900
    0x495a, 0x6988, 0x0840, 0x0040, 0x6188, 0x4869, 0xe000, 0x4869, 0xf02e, 0xfa52, 0xe009, 0xa80b, // +0918
    0xa907, 0x5d09, 0x5d00, 0x4288, 0xd003, 0x4865, 0xf02e, 0xfa48, 0xe004, 0x1c64, 0x0624, 0x0e24, // +0930
    0x2c10, 0xd3d6, 0x2c10, 0xd101, 0x4856, 0x7005, 0x485f, 0x7880, 0x2800, 0xd000, 0xe730, 0x4c52, // +0948
    0x6820, 0x2201, 0x0552, 0x4290, 0xd3f8, 0x4850, 0x7801, 0x2901, 0xd3f4, 0x2103, 0x7001, 0xf0a1, // +0960
    0xfbd1, 0x20c0, 0xf762, 0xef2a, 0x900f, 0x4840, 0x6980, 0x07c0, 0xd006, 0x4940, 0x2000, 0x6008, // +0978
    0x4951, 0x6008, 0x6820, 0xe007, 0x483c, 0x2101, 0x0409, 0x6001, 0x484d, 0x6001, 0x6820, 0x1a40, // +0990
    0x4f39, 0x6038, 0x2201, 0x0692, 0x6810, 0x2110, 0x4388, 0x6010, 0x4c34, 0x6820, 0x2283, 0x0252, // +09a8
    0x4290, 0xd853, 0x6820, 0x6839, 0x1840, 0x4944, 0x4288, 0xd94d, 0x4829, 0x2100, 0x6800, 0x0213, // +09c0
    0x4f41, 0x0a1b, 0x181b, 0x781b, 0x5c7f, 0x42bb, 0xd13d, 0x1c49, 0x0609, 0x0e09, 0x1c52, 0x2908, // +09d8
    0xd3f1, 0x1c53, 0xd035, 0x4939, 0x39f0, 0x1809, 0x4839, 0x6001, 0x6801, 0x1c4a, 0x6002, 0x7809, // +09f0
    0xab08, 0x7619, 0x6801, 0x1c4a, 0x6002, 0x7809, 0x7659, 0x6801, 0x1c4a, 0x6002, 0x7809, 0x7699, // +0a08
    0x6801, 0x1c4a, 0x6002, 0x7809, 0x76d9, 0x6801, 0x1c4a, 0x6002, 0x7809, 0x7519, 0x6801, 0x1c4a, // +0a20
    0x6002, 0x7809, 0x7559, 0x6801, 0x1c4a, 0x6002, 0x7809, 0x7599, 0x6801, 0x1c4a, 0x6002, 0x7808, // +0a38
    0x4a22, 0x75d8, 0x980e, 0x990d, 0x3ae8, 0xf09a, 0xf808, 0x2800, 0xd145, 0x7035, 0x4820, 0xf02e, // +0a50
    0xf9b3, 0xe525, 0xe03f, 0x0000, 0x4fc0, 0xffff, 0x6ff0, 0xffff, 0x0c78, 0x0200, 0xdc80, 0x0000, // +0a68
    0x8220, 0x001e, 0x2040, 0x0400, 0x0d40, 0x0200, 0x0ca4, 0x0200, 0x0cb0, 0x0200, 0x00aa, 0x3395, // +0a80
    0x00c0, 0x0403, 0x85b0, 0x0000, 0x2cc8, 0x0000, 0x2140, 0x0404, 0xbdc4, 0x01ff, 0xbd5c, 0x01ff, // +0a98
    0x544d, 0x3931, 0x3935, 0x4220, 0x6f6f, 0x2074, 0x5542, 0x2035, 0x3006, 0x0000, 0x020a, 0x3396, // +0ab0
    0x00aa, 0x3397, 0x00aa, 0x3398, 0x00aa, 0x3399, 0x0c80, 0x0200, 0x0cac, 0x0200, 0x0700, 0x0001, // +0ac8
    0x0600, 0x0001, 0x0ccc, 0x0200, 0x00aa, 0x339e, 0xe052, 0x2201, 0x0692, 0x6810, 0x2110, 0x4388, // +0ae0
    0x6010, 0x48fc, 0x6980, 0x07c0, 0xd003, 0xf0a1, 0xfa8a, 0x2801, 0xd102, 0x2001, 0xf0a1, 0xfa94, // +0af8
    0x2800, 0xd104, 0x48f6, 0xf02e, 0xf95b, 0x2202, 0xe01d, 0xf7ff, 0xfa84, 0x2800, 0xd103, 0x48f3, // +0b10
    0xf02e, 0xf952, 0xe00a, 0x49f3, 0x48f1, 0x6809, 0x1840, 0x7801, 0x29de, 0xd006, 0x48f0, 0x22de, // +0b28
    0xf02e, 0xf946, 0x2200, 0x2124, 0xe4b3, 0xf7ff, 0xfa59, 0x2800, 0xd105, 0x48ec, 0xf02e, 0xf93c, // +0b40
    0x2203, 0x2126, 0xe4a9, 0xf7a0, 0xff94, 0x2107, 0x2000, 0xf003, 0xfc18, 0x7830, 0x2801, 0xd007, // +0b58
    0x4fe5, 0x683a, 0x6821, 0x48e5, 0x6800, 0x2303, 0xf0a1, 0xfb37, 0x980f, 0xf762, 0xee24, 0xe497, // +0b70
    0x7880, 0xe495, 0xf071, 0xfd5d, 0x2800, 0xd1fa, 0x7035, 0xe48f, 0xb5f8, 0x4add, 0x2004, 0x7851, // +0b88
    0x06c9, 0x0ec9, 0x2401, 0x2901, 0xd001, 0x48da, 0xe0f4, 0x4dda, 0x7829, 0x0989, 0x2903, 0xd01c, // +0ba0
    0x7829, 0x22e8, 0x4011, 0x2968, 0xd10a, 0x49d6, 0x7809, 0x0749, 0xd413, 0x49d5, 0x7809, 0x0789, // +0bb8
    0xd510, 0xf0ac, 0xee66, 0xe00c, 0x7829, 0x4011, 0x2960, 0xd008, 0x7829, 0x0909, 0x2905, 0xd004, // +0bd0
    0x7829, 0x22e4, 0x4011, 0x2924, 0xd100, 0x2010, 0x4acb, 0x0001, 0x7892, 0x23ff, 0x021b, 0x4eca, // +0be8
    0x2a00, 0xd002, 0x6971, 0x4399, 0xe009, 0x07ca, 0xd002, 0x1c49, 0x0609, 0x0e09, 0x6972, 0x4321, // +0c00
    0x0209, 0x439a, 0x4311, 0x6171, 0x49c1, 0x2200, 0x3920, 0x720a, 0x720a, 0x720a, 0x1f03, 0x720b, // +0c18
    0x782b, 0x099f, 0x4bb1, 0x4ebd, 0x2f03, 0xd11e, 0x782d, 0x096d, 0x2d07, 0xd112, 0x4db6, 0x782d, // +0c30
    0x07ad, 0xd50e, 0x681b, 0x6835, 0x18ad, 0x3564, 0x022d, 0x0a2d, 0x18ed, 0x782d, 0x720d, 0x1c52, // +0c48
    0x0612, 0x0e12, 0x2a0c, 0xd3f2, 0xe085, 0x2300, 0x720a, 0x1c5b, 0x061b, 0x0e1b, 0x2b0c, 0xd3f9, // +0c60
    0xe07d, 0x4da7, 0x782f, 0x25e8, 0x403d, 0x2d68, 0xd113, 0x4daa, 0x2200, 0x681b, 0x682d, 0x1f06, // +0c78
    0xe00a, 0x4fa8, 0x19d7, 0x19ef, 0x023f, 0x0a3f, 0x18ff, 0x783f, 0x720f, 0x1c52, 0x0612, 0x0e12, // +0c90
    0x42b2, 0xdbf2, 0xe063, 0x4f9a, 0x783d, 0x27e8, 0x403d, 0x2d60, 0xd116, 0x6832, 0x3211, 0x681b, // +0ca8
    0x0212, 0x0a12, 0x18d2, 0x4b9c, 0x601a, 0x2200, 0x681d, 0x1c6e, 0x601e, 0x1f96, 0x782d, 0x2e02, // +0cc0
    0xd300, 0x720d, 0x1c52, 0x0612, 0x0e12, 0x2a0e, 0xd3f2, 0xe046, 0x4f8b, 0x783d, 0x092d, 0x2d05, // +0cd8
    0xd126, 0x4e8e, 0x6832, 0x3231, 0x0215, 0x681a, 0x0a2d, 0x18ab, 0x4d8d, 0x602b, 0x2300, 0x682e, // +0cf0
    0x1c77, 0x602f, 0x7836, 0x720e, 0x1c5b, 0x061b, 0x0e1b, 0x2b04, 0xd3f5, 0x4e84, 0x6833, 0x3361, // +0d08
    0x021b, 0x0a1b, 0x189a, 0x602a, 0x2204, 0x682b, 0x1c5e, 0x602e, 0x781b, 0x720b, 0x1c52, 0x0612, // +0d20
    0x0e12, 0x2a0c, 0xd3f5, 0xe01a, 0x783b, 0x25e4, 0x402b, 0x2b24, 0xd115, 0x4b7c, 0x781d, 0x720d, // +0d38
    0x789d, 0x720d, 0x785d, 0x720d, 0x720a, 0x78dd, 0x720d, 0x791d, 0x720d, 0x795d, 0x720d, 0x720a, // +0d50
    0x799d, 0x720d, 0x79dd, 0x720d, 0x7a1b, 0x720b, 0x720a, 0x4a66, 0x7991, 0x4b71, 0x2900, 0xd109, // +0d68
    0x79d1, 0x2900, 0xd106, 0x7a11, 0x2900, 0xd103, 0x7a51, 0x4281, 0xd800, 0x7a50, 0x8018, 0x486b, // +0d80
    0x7004, 0xbdf8, 0xb510, 0x4c6a, 0x62a0, 0x4867, 0x8801, 0x4a69, 0x4291, 0xd102, 0x8801, 0x1e49, // +0d98
    0x8001, 0x7801, 0x07c9, 0xd002, 0x8801, 0x1c49, 0x8001, 0x8801, 0x4a5b, 0x4863, 0x6812, 0x6aa3, // +0db0
    0x1880, 0x4a62, 0x1882, 0x185b, 0x4283, 0xd909, 0x6aa3, 0x4293, 0xd206, 0x6aa3, 0x4283, 0xd202, // +0dc8
    0x6aa1, 0x1a41, 0xe000, 0x62a2, 0x485b, 0x6141, 0x4955, 0x2001, 0x7008, 0xbd10, 0x4959, 0xb5f0, // +0de0
    0x780a, 0xb085, 0x4858, 0x2a00, 0xd000, 0x7802, 0x780a, 0x2a00, 0xd16a, 0x7805, 0x2401, 0x4840, // +0df8
    0x4b54, 0x2d00, 0xd065, 0x781d, 0x9504, 0x4d4a, 0x782e, 0x9603, 0x4e51, 0x7837, 0x494d, 0x9702, // +0e10
    0x780f, 0x9701, 0x4f4f, 0x783f, 0x9700, 0x701a, 0x702a, 0x7032, 0x700c, 0x494d, 0x7889, 0x2901, // +0e28
    0xd001, 0x2903, 0xd101, 0x4f49, 0x703c, 0x4831, 0x7800, 0x2803, 0xd102, 0xf7fe, 0xf9b8, 0xe270, // +0e40
    0x2200, 0x2100, 0x2000, 0xf005, 0xf9aa, 0x4b2b, 0x7818, 0x4e2b, 0x4d42, 0x4943, 0x4f2a, 0x2855, // +0e58
    0xd038, 0xdc38, 0x2825, 0xd037, 0xdc20, 0x281b, 0xd07e, 0xdc0e, 0x2800, 0xd07c, 0x2812, 0xd17b, // +0e70
    0x4f38, 0x7838, 0x2800, 0xd103, 0x2200, 0x2100, 0xf005, 0xf98f, 0xf7fc, 0xf825, 0xe24d, 0x281e, // +0e88
    0xd06f, 0x2823, 0xd1ef, 0x2000, 0xf0a0, 0xff55, 0x2800, 0xd0d2, 0x7828, 0x2800, 0xd179, 0xf7fe, // +0ea0
    0xf90b, 0xe23e, 0x284a, 0xd075, 0xdc60, 0x2843, 0xd073, 0x2846, 0xd1dd, 0x4f28, 0x7838, 0x2800, // +0eb8
    0xd103, 0x2200, 0x2100, 0xf005, 0xf96e, 0xf7fa, 0xfcfe, 0xe22c, 0xe23f, 0xe263, 0xe1fd, 0xe068, // +0ed0
    0xe10b, 0x0000, 0x2040, 0x0400, 0x00aa, 0x339f, 0x00aa, 0x33a0, 0xc056, 0x001e, 0x0c78, 0x0200, // +0ee8
    0x053a, 0x33a1, 0x00aa, 0x33a2, 0x0cb0, 0x0200, 0x0cac, 0x0200, 0x0d40, 0x0200, 0x0c66, 0x0200, // +0f00
    0x9e04, 0x01ff, 0x96b8, 0x01ff, // +0f18
];
#[rustfmt::skip]
const WIDE_WRAPPER: &[u16] = &[
    0xb5ff, 0x000e, 0x0015, 0x001c, 0x2b04, 0xb081, 0xd302, 0x2000, 0xb005, 0xbdf0, 0x20c0, 0xf6c1, // +0000
    0xeae6, 0x9000, 0xf763, 0xff06, 0x2011, 0xf703, 0xfc53, 0xf7ff, 0xffaf, 0xf7ff, 0xf860, 0x2800, // +0018
    0xd033, 0x49b2, 0x7808, 0x28ff, 0xd02f, 0x78c8, 0x2804, 0xd22c, 0x4bb0, 0x6918, 0x2203, 0x0312, // +0030
    0x4390, 0x139a, 0x1880, 0x6118, 0x2c01, 0xd15a, 0x9801, 0x01d2, 0x1a80, 0x4290, 0xd904, 0x9801, // +0048
    0x1940, 0x1a80, 0x4290, 0xd804, 0x48a7, 0x9901, 0xf78c, 0xfdb9, 0xe013, 0x6889, 0x1970, 0x1e4b, // +0060
    0x0037, 0x439f, 0x4218, 0xd002, 0x4398, 0x1840, 0xe000, 0x4398, 0x1bc4, 0x4294, 0xd801, 0x2c00, // +0078
    0xd107, 0x489d, 0x0021, 0xf78c, 0xfda4, 0x9800, 0xf6c1, 0xeaa0, 0xe7b5, 0x42b7, 0xd101, 0x42ac, // +0090
    0xd01e, 0x2201, 0x04d2, 0x0023, 0x4897, 0x0039, 0xf78c, 0xfd95, 0x0022, 0x0039, 0x2001, 0x04c0, // +00a8
    0xf7ff, 0xff53, 0x2201, 0x04d2, 0x1bf0, 0x1886, 0x002b, 0x4890, 0x9901, 0x0032, 0xf78c, 0xfd85, // +00c0
    0x002a, 0x9901, 0x0030, 0xf763, 0xf9e0, 0x2001, 0x04c0, 0x9001, 0x0023, 0x488a, 0x9901, 0x003a, // +00d8
    0xf78c, 0xfd77, 0x4989, 0x4889, 0xf761, 0xfcb8, 0xf761, 0xfc9a, 0x0022, 0x0039, 0x9801, 0x2301, // +00f0
    0xe035, 0x2c03, 0xd11a, 0x2001, 0x0680, 0x6801, 0x2210, 0x4391, 0x6001, 0x69c1, 0x0909, 0x0109, // +0108
    0x310a, 0x61c1, 0x497f, 0x9801, 0x6008, 0x487e, 0x6006, 0x487e, 0x6005, 0x4979, 0x487a, 0xf761, // +0120
    0xfc99, 0xf761, 0xfc7b, 0xf6db, 0xf8e8, 0xe01a, 0x2c00, 0xd10a, 0x4974, 0x4874, 0xf761, 0xfc8e, // +0138
    0xf761, 0xfc70, 0x002a, 0x0031, 0x9801, 0x2300, 0xe00b, 0x2c02, 0xd10b, 0x496d, 0x486e, 0xf761, // +0150
    0xfc81, 0xf761, 0xfc63, 0x9801, 0x002a, 0x0031, 0x2302, 0xf6db, 0xfcee, 0xf7ff, 0xfef0, 0xf761, // +0168
    0xfc34, 0x4b5f, 0x6918, 0x2203, 0x0312, 0x4310, 0x6118, 0x9800, 0xf6c1, 0xea26, 0x2001, 0xe73b, // +0180
    0x4951, 0xb570, 0x6808, 0x2201, 0x4310, 0x6008, 0x4a50, 0x7810, 0x285a, 0xd13f, 0x7850, 0x28a5, // +0198
    0xd13c, 0x7893, 0x0010, 0x2b46, 0xd138, 0x78c2, 0x2a4c, 0xd135, 0x4c4a, 0x6962, 0x7903, 0x0852, // +01b0
    0x0052, 0x07db, 0x0fdb, 0x431a, 0x6162, 0x4a46, 0x7813, 0x069b, 0x0e9b, 0x7013, 0x7983, 0x7814, // +01c8
    0x099b, 0x019b, 0x4323, 0x7013, 0x79c4, 0x4a41, 0x4d42, 0x6813, 0x195b, 0x021d, 0x4b3b, 0x0a2d, // +01e0
    0x681e, 0x19ad, 0x702c, 0x7a04, 0x4e3d, 0x6815, 0x3632, 0x19ad, 0x681e, 0x022d, 0x0a2d, 0x19ad, // +01f8
    0x702c, 0x7a44, 0x4d38, 0x6812, 0x351f, 0x1952, 0x681b, 0x0212, 0x0a12, 0x18d2, 0x7014, 0x7a80, // +0210
    0x4a34, 0x7010, 0x6808, 0x0840, 0x0040, 0x6008, 0xbd70, 0x482e, 0xb510, 0x6800, 0x4b3c, 0x2201, // +0228
    0x213d, 0x03c9, 0x0292, 0x18c0, 0x2301, 0xf7ff, 0xfed9, 0x4838, 0xf78c, 0xfcc7, 0xbd10, 0x4826, // +0240
    0x4b35, 0x6800, 0x2201, 0x213d, 0x03c9, 0x0312, 0x18c0, 0x2301, 0xe6ca, 0x4821, 0x4b30, 0x6800, // +0258
    0x2201, 0x213d, 0x03c9, 0x0312, 0x18c0, 0xe676, 0x492c, 0x1840, 0x491c, 0x6809, 0x1808, 0x4916, // +0270
    0x0200, 0x6809, 0x0a00, 0x1840, 0x7800, 0x4770, 0x2201, 0x0292, 0x4290, 0xd20a, 0x4a24, 0x1880, // +0288
    0x4a14, 0x6812, 0x1810, 0x4a0e, 0x0200, 0x6812, 0x0a00, 0x1880, 0x7001, 0x4770, 0xb5f0, 0x4f20, // +02a0
    0x4e1f, 0x4d0d, 0x4c09, 0x2000, 0x19c1, 0x682b, 0x5c32, 0x1859, 0x6823, 0x0209, 0x0a09, 0x1c40, // +02b8
    0x0600, 0x18c9, 0x0e00, 0x2810, 0x700a, 0xd3f1, 0xbdf0, 0x0000, 0x0402, 0x0c78, 0x0200, 0x1200, // +02d0
    0x0200, 0x00c0, 0x0404, 0x0c67, 0x0200, 0x0c7c, 0x0200, 0xb2ff, 0x0000, 0xbd45, 0x01ff, 0xc328, // +02e8
    0x01ff, 0x2240, 0x0400, 0x08fa, 0x3475, 0x04ea, 0x3476, 0x0cfe, 0x3477, 0x0cfe, 0x3478, 0x0cfe, // +0300
    0x3479, 0x1bfc, 0x0000, 0xa001, 0x0001, 0x0cac, 0x0200, 0x0ca4, 0x0200, 0x0cb0, 0x0200, 0xf9a0, // +0318
];
#[rustfmt::skip]
const WIDE_INTEGRITY: &[u16] = &[
    0xb510, 0xf6dc, 0xfa9f, 0x4834, 0x4935, 0x6800, 0x2301, 0x1842, 0x1e49, 0x1841, 0x031b, 0x18c0, // +0000
    0xf7ff, 0xff25, 0xbd10, 0xb5f1, 0x482e, 0x2241, 0x6800, 0x0292, 0x2501, 0x1886, 0xf6dc, 0xfa8a, // +0018
    0x2400, 0x271c, 0x4367, 0x59f0, 0x1c43, 0xd103, 0x4829, 0xf78c, 0xfeba, 0xe03b, 0x9900, 0x4208, // +0030
    0xd033, 0x4826, 0x0021, 0xf78c, 0xfeb2, 0x19bd, 0x6869, 0x4824, 0xf78c, 0xfead, 0x4824, 0x68a9, // +0048
    0xf78c, 0xfea9, 0x59f1, 0x4822, 0xf78c, 0xfea5, 0x68a9, 0x2001, 0x0540, 0x4281, 0xd304, 0x6868, // +0060
    0x2241, 0x0292, 0x4290, 0xd10f, 0x4816, 0x686b, 0x6800, 0x002a, 0x320c, 0x1809, 0x1818, 0xf7ff, // +0078
    0xfeea, 0x0005, 0xd109, 0x4817, 0x0021, 0xf78c, 0xfe8c, 0xe00d, 0x4816, 0x0021, 0xf78c, 0xfe87, // +0090
    0x2501, 0x4814, 0x0021, 0xf78c, 0xfe82, 0x1c64, 0x0624, 0x0e24, 0x2c10, 0xd3ba, 0x0028, 0xbdf8, // +00a8
    0x0000, 0x3000, 0x0406, 0x0400, 0x0001, 0x0580, 0x0001, 0x05af, 0x0001, 0x012a, 0x3411, 0x00aa, // +00c0
    0x3413, 0x0c78, 0x0200, 0xfff0, 0x0000, 0x00aa, 0x3414, 0x012a, 0x3415, 0x04ea, 0x3416, 0x04ea, // +00d8
    0x3417, 0x04ea, 0x3418, 0x012a, 0x341a, 0x012a, 0x3419, 0x012a, 0x341b, 0xb510, 0x2002, 0xf763, // +00f0
    0xff89, 0xf763, 0xff79, 0x2011, 0xf703, 0xfcc6, 0x2400, 0x43e4, 0x0021, 0x2001, 0xf704, 0xfb24, // +0108
    0x0c21, 0x2002, 0xf704, 0xfb20, 0x0021, 0x2003, 0xf704, 0xfb1c, 0xbd10, 0x48df, 0x6801, 0x0849, // +0120
    0x0049, // +0138
];
#[rustfmt::skip]
const WIDE_PROGRAM: &[u16] = &[
    0xb5f8, 0x48d7, 0x6841, 0x0889, 0x0089, 0x6041, 0x4ad5, 0x6b10, 0x213c, 0x4388, 0x6310, 0x48d4, // +0000
    0x6841, 0x1482, 0x4311, 0x6041, 0x6841, 0x1442, 0x4311, 0x6041, 0x6841, 0x0052, 0x4311, 0x6041, // +0018
    0x49ce, 0x6808, 0x2480, 0x4320, 0x6008, 0x4acc, 0x3280, 0x6890, 0x07c0, 0xd0fc, 0x49c9, 0x68c8, // +0030
    0x2104, 0x4308, 0x49c7, 0x60c8, 0x48c6, 0x3040, 0x6901, 0x0849, 0x0049, 0x6101, 0x4dc4, 0x69a8, // +0048
    0x2140, 0x4308, 0x61a8, 0x48c3, 0xe14d, 0x4fc2, 0x6839, 0x48c2, 0xf000, 0xf9be, 0x4ec1, 0x6831, // +0060
    0x48bf, 0x1c40, 0xf000, 0xf9b8, 0x6829, 0x48bd, 0x1c80, 0xf000, 0xf9b3, 0xf000, 0xfeac, 0x6838, // +0078
    0x2239, 0x03d2, 0x4290, 0xd10b, 0x6839, 0x2009, 0x0380, 0x1809, 0x6039, 0x6831, 0x1809, 0x6031, // +0090
    0x6829, 0x1a08, 0x6028, 0xe00d, 0x6838, 0x211f, 0x0409, 0x4288, 0xd108, 0x6838, 0x1900, 0x6038, // +00a8
    0x6830, 0x1900, 0x6030, 0x2300, 0x602b, 0xe0e8, 0x6838, 0x0400, 0xd107, 0x6838, 0x4290, 0xd273, // +00c0
    0x6838, 0x2137, 0x03c9, 0x4288, 0xd96e, 0x6839, 0x003c, 0x48a4, 0x1cc0, 0xf000, 0xf981, 0x6831, // +00d8
    0x48a1, 0x1d00, 0xf000, 0xf97c, 0x6829, 0x2081, 0x00c0, 0xf000, 0xf977, 0xf000, 0xfa92, 0x4a9e, // +00f0
    0x2006, 0x7010, 0x4997, 0x6888, 0x0a80, 0x0280, 0x1c40, 0x6088, 0x2300, 0x604b, 0x68c8, 0x2702, // +0108
    0x4338, 0x60c8, 0x7c08, 0x0780, 0xd5fc, 0x7c08, 0x07c0, 0xd1fc, 0x68c8, 0x43b8, 0x60c8, 0x2020, // +0120
    0x7010, 0x78a0, 0x7050, 0x7860, 0x7090, 0x7820, 0x70d0, 0x6888, 0x0a80, 0x0280, 0x1d00, 0x6088, // +0138
    0x604b, 0x68c8, 0x4338, 0x60c8, 0x7c08, 0x0780, 0xd5fc, 0x7c08, 0x07c0, 0xd1fc, 0x68c8, 0x000b, // +0150
    0x0039, 0x43b8, 0x60d8, 0x2005, 0x7010, 0x6898, 0x0a80, 0x0280, 0x1c40, 0x6098, 0x2001, 0x6058, // +0168
    0x68d8, 0x4308, 0x60d8, 0x7c18, 0x0780, 0xd5fc, 0x7c18, 0x07c0, 0xd1fc, 0x68d8, 0x4388, 0x60d8, // +0180
    0x7850, 0x07c0, 0xd1f0, 0x2701, 0x6831, 0x033f, 0x003a, 0x6820, 0xf000, 0xf943, 0x6820, 0x19c0, // +0198
    0x6020, 0x6830, 0x19c0, 0x6030, 0x6828, 0x1bc0, 0xe06c, 0xe7ff, 0x6839, 0x486d, 0x1d80, 0xf000, // +01b0
    0xf913, 0x4e6c, 0x6831, 0x486a, 0x1dc0, 0xf000, 0xf90d, 0x6829, 0x4867, 0x3008, 0xf000, 0xf908, // +01c8
    0xf000, 0xfa23, 0x4a66, 0x2006, 0x7010, 0x4960, 0x6888, 0x0a80, 0x0280, 0x1c40, 0x6088, 0x2300, // +01e0
    0x604b, 0x68c8, 0x2602, 0x4330, 0x60c8, 0x7c08, 0x0780, 0xd5fc, 0x7c08, 0x07c0, 0xd1fc, 0x68c8, // +01f8
    0x43b0, 0x60c8, 0x20d8, 0x7010, 0x78b8, 0x7050, 0x7878, 0x7090, 0x7838, 0x70d0, 0x6888, 0x0a80, // +0210
    0x0280, 0x1d00, 0x6088, 0x604b, 0x68c8, 0x4330, 0x60c8, 0x7c08, 0x0780, 0xd5fc, 0x7c08, 0x07c0, // +0228
    0xd1fc, 0x68c8, 0x000b, 0x0031, 0x43b0, 0x60d8, 0x2005, 0x7010, 0x6898, 0x0a80, 0x0280, 0x1c40, // +0240
    0x6098, 0x2001, 0x6058, 0x68d8, 0x4308, 0x60d8, 0x7c18, 0x0780, 0xd5fc, 0x7c18, 0x07c0, 0xd1fc, // +0258
    0x68d8, 0x4388, 0x60d8, 0x7850, 0x07c0, 0xd1f0, 0x4e3f, 0x0022, 0x6831, 0x6838, 0xf000, 0xf8d5, // +0270
    0x6838, 0x1900, 0x6038, 0x6830, 0x1900, 0x6030, 0x6828, 0x1b00, 0x6028, 0xe000, 0x4d39, 0x6828, // +0288
    0x2401, 0x0424, 0x42a0, 0xd300, 0xe6df, 0x4837, 0x6801, 0x4832, 0x3009, 0xf000, 0xf89d, 0x01e0, // +02a0
    0x4c30, 0x6020, 0x4d2c, 0xe001, 0xf000, 0xfd91, 0x69a8, 0x0680, 0xd404, 0x6820, 0x1e40, 0x6020, // +02b8
    0x2800, 0xd1f5, 0x69a9, 0x4828, 0x300e, 0xf000, 0xf889, 0x6821, 0x4825, 0x300f, 0xf000, 0xf884, // +02d0
    0x4828, 0x7802, 0x78c1, 0x0612, 0x4311, 0x7842, 0x7880, 0x0412, 0x0200, 0x4310, 0x4301, 0x481e, // +02e8
    0x3010, 0xf000, 0xf875, 0x4f1b, 0x6838, 0x2101, 0x0549, 0x4288, 0xd3c4, 0x4d17, 0x69a8, 0x2480, // +0300
    0x4320, 0x61a8, 0x69a9, 0x4816, 0x3011, 0xf000, 0xf865, 0xf000, 0xf835, 0xf000, 0xf83e, 0xf000, // +0318
    0xf84c, 0x04e0, 0x6801, 0x2210, 0x4391, 0x6001, 0x69c1, 0x0909, 0x0109, 0x310a, 0x61c1, 0x4909, // +0330
    0x6808, 0x43a0, 0x6008, 0x68c8, 0x2204, 0x4390, 0x60c8, 0x490e, 0x6808, 0x4310, 0x6008, 0xbdf8, // +0348
    0x0080, 0x0404, 0x1080, 0x0404, 0x1f00, 0x0401, 0x1000, 0x0401, 0x2040, 0x0400, 0x0ca4, 0x0200, // +0360
    0x0403, 0x0000, 0x0cac, 0x0200, 0x1000, 0x0200, 0x0cb0, 0x0200, 0xbdc4, 0x01ff, 0xc6df, 0x01ff, // +0378
    0x1000, 0x0400, 0x4a14, 0x6850, 0x2104, 0x4388, 0x6050, 0x060a, 0x6890, 0x0689, 0x4308, 0x6090, // +0390
    0x4770, 0x2001, 0x0680, 0x6881, 0x1482, 0x4311, 0x6081, 0x6801, 0x0142, 0x4311, 0x6001, 0x6981, // +03a8
    0x2209, 0x0212, 0x4391, 0x6181, 0x4770, 0x4808, 0xb510, 0x6801, 0x2308, 0x4319, 0x6001, 0x0384, // +03c0
    0x68a1, 0x1482, 0x4391, 0x60a1, 0x6801, 0x4399, 0x6001, 0xbd10, 0xc000, 0x0420, 0x1000, 0x0400, // +03d8
    0xb530, 0x4cfd, 0x2501, 0x2200, 0x042d, 0x68a3, 0x05db, 0xd503, 0x0013, 0x1c52, 0x42ab, 0xd3f8, // +03f0
    0x22e7, 0x7022, 0x0a02, 0x7022, 0x7020, 0x20ea, 0x7020, 0x0e08, 0x7020, 0x0c08, 0x7020, 0x0a08, // +0408
    0x7020, 0x7021, 0x2018, 0x7020, 0x7a60, 0x2101, 0x4308, 0x7260, 0xbd30, 0xb5f8, 0x0016, 0x0005, // +0420
    0x000c, 0x0001, 0x48eb, 0xf7ff, 0xffd7, 0x48ea, 0x0021, 0x1c40, 0xf7ff, 0xffd2, 0x48e7, 0x0031, // +0438
    0x1c80, 0xf7ff, 0xffcd, 0x0032, 0x4ee5, 0x9500, 0xe0e1, 0x9800, 0x0400, 0xd405, 0x4be3, 0x6918, // +0450
    0x2103, 0x0309, 0x4308, 0xe006, 0x4be0, 0x6918, 0x2103, 0x0309, 0x4388, 0x1399, 0x1840, 0x6118, // +0468
    0x49dd, 0x0220, 0x6809, 0x0a00, 0x1847, 0x6037, 0x49db, 0x2000, 0x6833, 0x1c5d, 0x6035, 0x781b, // +0480
    0x1845, 0x712b, 0x1c40, 0x0600, 0x0e00, 0xd1f5, 0x2006, 0x7008, 0x4bd5, 0x6898, 0x0a80, 0x0280, // +0498
    0x1c40, 0x6098, 0x2000, 0x6058, 0x68d8, 0x2502, 0x4328, 0x60d8, 0x7c18, 0x0780, 0xd5fc, 0x7c18, // +04b0
    0x07c0, 0xd1fc, 0x0018, 0x68db, 0x43ab, 0x60c3, 0x700d, 0x466b, 0x789b, 0x704b, 0x466b, 0x785b, // +04c8
    0x708b, 0x466b, 0x781b, 0x70cb, 0x6883, 0x0a9b, 0x029b, 0x33ff, 0x1d5b, 0x6083, 0x2300, 0x6043, // +04e0
    0x68c3, 0x432b, 0x60c3, 0x7c03, 0x079b, 0xd5fc, 0x0003, 0x7c18, 0x07c0, 0xd1fc, 0x68d8, 0x43a8, // +04f8
    0x60d8, 0x2005, 0x7008, 0x6898, 0x0a80, 0x0280, 0x1c40, 0x6098, 0x2001, 0x6058, 0x68d8, 0x4328, // +0510
    0x60d8, 0x7c18, 0x0780, 0xd5fc, 0x7c18, 0x07c0, 0xd1fc, 0x68d8, 0x43a8, 0x60d8, 0x7848, 0x07c0, // +0528
    0xd1f0, 0x49ae, 0x2004, 0x7008, 0x6898, 0x0019, 0x0a80, 0x0280, 0x1c40, 0x6088, 0x2000, 0x6048, // +0540
    0x68c8, 0x4328, 0x60c8, 0x7c08, 0x0780, 0xd5fc, 0x7c08, 0x07c0, 0xd1fc, 0x68c8, 0x43a8, 0x60c8, // +0558
    0x4ba2, 0x2004, 0x7018, 0x6888, 0x0a80, 0x0280, 0x1c40, 0x6088, 0x2000, 0x6048, 0x68c8, 0x4328, // +0570
    0x60c8, 0x7c08, 0x0780, 0xd5fc, 0x7c08, 0x07c0, 0xd1fc, 0x0008, 0x68c9, 0x2502, 0x43a9, 0x60c1, // +0588
    0x210b, 0x001d, 0x7019, 0x466b, 0x7899, 0x7069, 0x7859, 0x70a9, 0x7819, 0x70e9, 0x6881, 0x0a89, // +05a0
    0x0289, 0x1d49, 0x6081, 0x21ff, 0x1c49, 0x6041, 0x68c1, 0x2302, 0x4319, 0x60c1, 0x0001, 0x7c08, // +05b8
    0x0780, 0xd5fc, 0x7c08, 0x07c0, 0xd1fc, 0x68c8, 0x2302, 0x4398, 0x60c8, 0x6037, 0x2100, 0x6830, // +05d0
    0x1c43, 0x6033, 0x194b, 0x795b, 0x7800, 0x4298, 0xd009, 0x4b83, 0x6998, 0x2240, 0x4390, 0x6198, // +05e8
    0x487a, 0x1d80, 0xf7ff, 0xfef4, 0xbdf8, 0x1c49, 0x0609, 0x0e09, 0xd1e9, 0x9800, 0x34ff, 0x30ff, // +0600
    0x1c40, 0x1c64, 0x3aff, 0x1e52, 0x9000, 0x2a00, 0xd000, 0xe71a, 0xbdf8, 0xb5f0, 0x4e73, 0x2105, // +0618
    0x7031, 0x4d73, 0x68a8, 0x0a80, 0x0280, 0x1c40, 0x60a8, 0x2701, 0x606f, 0x2402, 0x68e8, 0x4320, // +0630
    0x60e8, 0x0029, 0x7c08, 0x0780, 0xd5fc, 0x7c08, 0x07c0, 0xd1fc, 0x68c8, 0x43a0, 0x60c8, 0x7870, // +0648
    0x07c0, 0xd1ef, 0x7870, 0x4968, 0x0200, 0x7809, 0x4301, 0x485f, 0x3009, 0xf7ff, 0xfebd, 0x4964, // +0660
    0x7809, 0x2000, 0x29ef, 0xd16d, 0x2135, 0x7031, 0x68a9, 0x0a89, 0x0289, 0x1c49, 0x60a9, 0x606f, // +0678
    0x68e9, 0x0022, 0x4321, 0x60e9, 0x7c29, 0x0789, 0xd5fc, 0x0029, 0x7c0b, 0x07db, 0xd1fc, 0x68cb, // +0690
    0x4393, 0x60cb, 0x7873, 0x4013, 0x2406, 0x7034, 0x688d, 0x0aad, 0x02ad, 0x1c6d, 0x608d, 0x6048, // +06a8
    0x68cd, 0x4315, 0x60cd, 0x7c0d, 0x07ad, 0xd5fc, 0x7c0d, 0x07ed, 0xd1fc, 0x68cd, 0x4395, 0x60cd, // +06c0
    0x7034, 0x688c, 0x0aa4, 0x02a4, 0x1c64, 0x608c, 0x6048, 0x68cc, 0x4314, 0x60cc, 0x7c0c, 0x07a4, // +06d8
    0xd5fc, 0x7c0c, 0x07e4, 0xd1fc, 0x68cc, 0x4394, 0x60cc, 0x7037, 0x7070, 0x70b3, 0x688b, 0x0a9b, // +06f0
    0x029b, 0x1cdb, 0x608b, 0x6048, 0x68c8, 0x4310, 0x60c8, 0x7c08, 0x0780, 0xd5fc, 0x0008, 0x7c03, // +0708
    0x07d9, 0xd1fc, 0x68c1, 0x4391, 0x60c1, 0x2105, 0x7031, 0x6881, 0x0a89, 0x0289, 0x1c49, 0x6081, // +0720
    0x6047, 0x68c1, 0x4311, 0x60c1, 0x7c01, 0x0789, 0xd5fc, 0x7c01, 0x07c9, 0xd1fc, 0x68c1, 0x4391, // +0738
    0x60c1, 0x7871, 0x07c9, 0xd1f0, 0xbdf0, 0xe7ff, 0x492a, 0x7809, 0x29c2, 0xd1f9, 0x2105, 0x7031, // +0750
    0x68aa, 0x0a92, 0x0292, 0x1c52, 0x60aa, 0x606f, 0x68ea, 0x4322, 0x60ea, 0x002b, 0x7c1a, 0x0792, // +0768
    0xd5fc, 0x7c1a, 0x07d2, 0xd1fc, 0x68da, 0x43a2, 0x60da, 0x7872, 0x07d2, 0xd1ef, 0x7872, 0x2340, // +0780
    0x401a, 0x2306, 0x7033, 0x68ab, 0x0a9b, 0x029b, 0x1c5b, 0x60ab, 0x6068, 0x68eb, 0x4323, 0x60eb, // +0798
    0x7c2b, 0x079b, 0xd5fc, 0x7c2b, 0x07db, 0xd1fc, 0x002b, 0x68ed, 0x43a5, 0x60dd, 0x0035, 0x7037, // +07b0
    0x706a, 0x689a, 0x0a92, 0x0292, 0x1c92, 0x609a, 0x6058, 0x68d8, 0x4320, 0x60d8, 0x7c18, 0x0780, // +07c8
    0xd5fc, 0x0018, 0x7c02, 0xe011, 0x0000, 0x0401, 0x0415, 0x0000, 0x0ccc, 0x0200, 0x2240, 0x0400, // +07e0
    0x0c78, 0x0200, 0x1000, 0x0200, 0x1000, 0x0401, 0x2040, 0x0400, 0xc328, 0x01ff, // +07f8
];
static FORMS: &[Form] = &[
    Form {
        application: COMPACT_APPLICATION,
        header_call: 0x7fe,
        selection: 0x892,
        program_call: 0xa0c,
        boot_check_call: 0x990,
        wrapper: COMPACT_WRAPPER,
        integrity: COMPACT_INTEGRITY,
        program: COMPACT_PROGRAM,
        skip_start: 0x7a,
        skip_length: 0x84,
        skip_final: 0x9c,
    },
    Form {
        application: WIDE_APPLICATION,
        header_call: 0x8ee,
        selection: 0x982,
        program_call: 0xb7c,
        boot_check_call: 0xb02,
        wrapper: WIDE_WRAPPER,
        integrity: WIDE_INTEGRITY,
        program: WIDE_PROGRAM,
        skip_start: 0x90,
        skip_length: 0x9a,
        skip_final: 0xb2,
    },
];

#[cfg(test)]
mod tests {
    use super::*;
    use sha2::{Digest, Sha256};
    use std::path::PathBuf;

    fn held(digest: &str, name: &str) -> Vec<u8> {
        let root = PathBuf::from(std::env::var("MTK_HOARD_ROOT").expect("set MTK_HOARD_ROOT"));
        let bytes = std::fs::read(root.join("originals").join(digest).join(name)).unwrap();
        assert_eq!(format!("{:x}", Sha256::digest(&bytes)), digest);
        bytes
    }

    #[test]
    #[ignore = "requires private MTK_HOARD_ROOT"]
    fn held_mixed_receivers_bind_flag_header_integrity_and_programming_code() {
        for (digest, name, expected_start, critical) in [
            (
                "c3a18eed17251d1508964647e833ffdfe01b13c28dff9a717dfac6336e7c70e6",
                "BH16NS40_INTM_c3a18eed.bin",
                0x1d0000,
                [
                    0x9cdb0, 0x9d48c, 0x9d4bc, 0x9d528, 0x9d584, 0x9d61e, 0x9d658, 0x9d69a,
                ],
            ),
            (
                "29ad302647148e270c15a5a4542aa4796ee9ba25ea9fbf9f2be9465c01c139a7",
                "BU40N_INTM_29ad3026.bin",
                0x1c8000,
                [
                    0x9cc2c, 0x9d3e0, 0x9d41c, 0x9d488, 0x9d4e4, 0x9d600, 0x9d638, 0x9d67a,
                ],
            ),
        ] {
            let bytes = held(digest, name);
            let app = &bytes[0x98000..0xb4000];
            let analysis = ApplicationAnalysis::inspect(app, 0x98000).unwrap();
            let candidate = Candidate::inspect(app, 0x98000, &analysis).expect(name);
            let wrapper_start = candidate.wrapper_address as usize;
            let wrapper = &bytes[wrapper_start..wrapper_start + candidate.wrapper_bytes()];
            let program_start = candidate.program_address(wrapper).unwrap() as usize;
            let program = &bytes[program_start..program_start + candidate.program_bytes()];
            let integrity_start = candidate.integrity_address as usize;
            let integrity = &bytes[integrity_start..integrity_start + candidate.integrity_bytes()];
            let contract = candidate.bind(wrapper, integrity, program).unwrap();
            assert_eq!(contract.header_range(), 0x3000..0x3010);
            assert_eq!(
                contract.programmed_ranges(),
                &[0x10000..expected_start, 0x1ec000..0x1f0000]
            );
            assert_eq!(contract.descriptor_byte(), 0x1ec056);
            // Cached discovery cannot license changed flag, AES destination,
            // range, direct signature, CMAC policy, DE check or program mode.
            for address in critical {
                let mut changed = app.to_vec();
                changed[address - 0x98000] ^= 1;
                assert!(
                    Candidate::inspect(&changed, 0x98000, &analysis).is_none(),
                    "{name}: {address:#x}"
                );
            }
            // Poison each independently significant argument copy/store in the
            // out-of-line wrapper, and both reserved-region skip constants.
            for offset in [2, 4, 6, 0x128, 0x12c, 0x130] {
                let mut changed = wrapper.to_vec();
                changed[offset] ^= 1;
                assert!(
                    candidate.bind(&changed, integrity, program).is_none(),
                    "wrapper {offset:#x}"
                );
            }
            for offset in [
                candidate.form.skip_start,
                candidate.form.skip_length,
                candidate.form.skip_final,
            ] {
                let mut changed = program.to_vec();
                changed[offset as usize] ^= 1;
                assert!(
                    candidate.bind(wrapper, integrity, &changed).is_none(),
                    "program {offset:#x}"
                );
            }
            let mut changed = integrity.to_vec();
            changed[0x48] ^= 1;
            assert!(candidate.bind(wrapper, &changed, program).is_none());
            assert!(candidate
                .bind(&wrapper[..wrapper.len() - 1], integrity, program)
                .is_none());
            assert!(candidate
                .bind(wrapper, integrity, &program[..program.len() - 1])
                .is_none());
        }
    }
}