use {
    bstr::{BString, ByteSlice},
    std::{
        cell::RefCell,
        fmt::{Debug, Formatter},
        rc::Rc,
    },
    thiserror::Error,
};

trait BitflagsExt {
    fn contains(self, other: Self) -> bool;
}

impl BitflagsExt for u8 {
    fn contains(self, other: Self) -> bool {
        self & other == other
    }
}

struct Stack<T>(RefCell<Vec<T>>);

impl<T> Default for Stack<T> {
    fn default() -> Self {
        Self(Default::default())
    }
}

impl<T> Stack<T> {
    fn push(&self, v: T) {
        self.0.borrow_mut().push(v);
    }

    fn pop(&self) -> Option<T> {
        self.0.borrow_mut().pop()
    }

    fn to_vec(&self) -> Vec<T>
    where
        T: Clone,
    {
        self.0.borrow().clone()
    }
}

#[derive(Copy, Clone, Debug)]
pub enum ColorBitDepth {
    Undefined,
    Bits6,
    Bits8,
    Bits10,
    Bits12,
    Bits14,
    Bits16,
    Reserved,
}

#[derive(Copy, Clone, Debug)]
pub enum DigitalVideoInterfaceStandard {
    Undefined,
    Dvi,
    HdmiA,
    HdmiB,
    MDDI,
    DisplayPort,
    Unknown(u8),
}

#[derive(Copy, Clone)]
pub struct SignalLevelStandard(u8);

impl Debug for SignalLevelStandard {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        let s = match self.0 {
            0 => "+0.7/−0.3 V",
            1 => "+0.714/−0.286 V",
            2 => "+1.0/−0.4 V",
            _ => "+0.7/0 V",
        };
        Debug::fmt(s, f)
    }
}

#[derive(Copy, Clone, Debug)]
pub enum VideoInputDefinition {
    Analog {
        signal_level_standard: SignalLevelStandard,
        blank_to_black_setup_or_pedestal: bool,
        separate_h_v_sync_supported: bool,
        composite_sync_on_horizontal_supported: bool,
        composite_sync_on_green_supported: bool,
        serration_on_vertical_sync_supported: bool,
    },
    Digital {
        bit_depth: ColorBitDepth,
        video_interface: DigitalVideoInterfaceStandard,
    },
}

#[derive(Copy, Clone, Debug)]
pub struct ScreenDimensions {
    pub horizontal_screen_size_cm: Option<u8>,
    pub vertical_screen_size_cm: Option<u8>,
    pub landscape_aspect_ration: Option<f64>,
    pub portrait_aspect_ration: Option<f64>,
}

#[derive(Copy, Clone, Debug)]
pub struct ChromaticityCoordinates {
    pub red_x: u16,
    pub red_y: u16,
    pub green_x: u16,
    pub green_y: u16,
    pub blue_x: u16,
    pub blue_y: u16,
    pub white_x: u16,
    pub white_y: u16,
}

#[derive(Copy, Clone, Debug)]
pub struct EstablishedTimings {
    pub s_720x400_70: bool,
    pub s_720x400_88: bool,
    pub s_640x480_60: bool,
    pub s_640x480_67: bool,
    pub s_640x480_72: bool,
    pub s_640x480_75: bool,
    pub s_800x600_56: bool,
    pub s_800x600_60: bool,
    pub s_800x600_72: bool,
    pub s_800x600_75: bool,
    pub s_832x624_75: bool,
    pub s_1024x768_87: bool,
    pub s_1024x768_60: bool,
    pub s_1024x768_70: bool,
    pub s_1024x768_75: bool,
    pub s_1280x1024_75: bool,
    pub s_1152x870_75: bool,
}

#[derive(Copy, Clone, Debug)]
pub enum AspectRatio {
    A1_1,
    A16_10,
    A4_3,
    A5_4,
    A16_9,
}

#[derive(Copy, Clone, Debug)]
pub struct StandardTiming {
    pub x_resolution: u16,
    pub aspect_ratio: AspectRatio,
    pub vertical_frequency: u8,
}

#[derive(Copy, Clone, Debug)]
pub enum AnalogSyncType {
    AnalogComposite,
    BipolarAnalogComposite,
}

#[derive(Copy, Clone, Debug)]
pub enum SyncSignal {
    Analog {
        ty: AnalogSyncType,
        with_serrations: bool,
        sync_on_all_signals: bool,
    },
    DigitalComposite {
        with_serration: bool,
        horizontal_sync_is_positive: bool,
    },
    DigitalSeparate {
        vertical_sync_is_positive: bool,
        horizontal_sync_is_positive: bool,
    },
}

#[derive(Copy, Clone)]
pub enum StereoViewingSupport {
    None,
    FieldSequentialRightDuringStereoSync,
    FieldSequentialLeftDuringStereoSync,
    TwoWayInterleavedRightImageOnEvenLines,
    TwoWayInterleavedLeftImageOnEvenLines,
    FourWayInterleaved,
    SideBySideInterleaved,
}

impl Debug for StereoViewingSupport {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        let msg = match *self {
            StereoViewingSupport::None => "none",
            StereoViewingSupport::FieldSequentialRightDuringStereoSync => {
                "field sequential, right during stereo sync"
            }
            StereoViewingSupport::FieldSequentialLeftDuringStereoSync => {
                "field sequential, left during stereo sync"
            }
            StereoViewingSupport::TwoWayInterleavedRightImageOnEvenLines => {
                "2-way interleaved, right image on even lines"
            }
            StereoViewingSupport::TwoWayInterleavedLeftImageOnEvenLines => {
                "2-way interleaved, left image on even lines"
            }
            StereoViewingSupport::FourWayInterleaved => "4-way interleaved",
            StereoViewingSupport::SideBySideInterleaved => "side-by-side interleaved",
        };
        write!(f, "\"{}\"", msg)
    }
}

#[derive(Copy, Clone, Debug)]
pub struct DisplayRangeLimitsAndAdditionalTiming {
    pub vertical_field_rate_min: u16,
    pub vertical_field_rate_max: u16,
    pub horizontal_field_rate_min: u16,
    pub horizontal_field_rate_max: u16,
    pub maximum_pixel_clock_mhz: u16,
    pub extended_timing_information: ExtendedTimingInformation,
}

#[derive(Copy, Clone, Debug)]
pub enum AspectRatioPreference {
    A4_3,
    A16_9,
    A16_10,
    A5_4,
    A15_9,
    Unknown(u8),
}

#[derive(Copy, Clone, Debug)]
pub enum ExtendedTimingInformation {
    DefaultGtf,
    NoTimingInformation,
    SecondaryGtf {
        start_frequency: u16,
        c_value: u16,
        m_value: u16,
        k_value: u8,
        j_value: u16,
    },
    Cvt {
        cvt_major_version: u8,
        cvt_minor_version: u8,
        additional_clock_precision: u8,
        maximum_active_pixels_per_line: Option<u16>,
        ar_4_3: bool,
        ar_16_9: bool,
        ar_16_10: bool,
        ar_5_4: bool,
        ar_15_9: bool,
        ar_preference: AspectRatioPreference,
        cvt_rb_reduced_blanking_preferred: bool,
        cvt_standard_blanking: bool,
        scaling_support_horizontal_shrink: bool,
        scaling_support_horizontal_stretch: bool,
        scaling_support_vertical_shrink: bool,
        scaling_support_vertical_stretch: bool,
        preferred_vertical_refresh_rate_hz: u8,
    },
    Unknown(u8),
}

#[derive(Copy, Clone, Debug, Default)]
pub struct ColorPoint {
    pub white_point_index: u8,
    pub white_point_x: u16,
    pub white_point_y: u16,
    pub gamma: Option<f64>,
}

#[derive(Copy, Clone, Debug)]
pub struct EstablishedTimings3 {
    pub s640x350_85: bool,
    pub s640x400_85: bool,
    pub s720x400_85: bool,
    pub s640x480_85: bool,
    pub s848x480_60: bool,
    pub s800x600_85: bool,
    pub s1024x768_85: bool,
    pub s1152x864_75: bool,
    pub s1280x768_60_rb: bool,
    pub s1280x768_60: bool,
    pub s1280x768_75: bool,
    pub s1280x768_85: bool,
    pub s1280x960_60: bool,
    pub s1280x960_85: bool,
    pub s1280x1024_60: bool,
    pub s1280x1024_85: bool,
    pub s1360x768_60: bool,
    pub s1440x900_60_rb: bool,
    pub s1440x900_60: bool,
    pub s1440x900_75: bool,
    pub s1440x900_85: bool,
    pub s1400x1050_60_rb: bool,
    pub s1400x1050_60: bool,
    pub s1400x1050_75: bool,
    pub s1400x1050_85: bool,
    pub s1680x1050_60_rb: bool,
    pub s1680x1050_60: bool,
    pub s1680x1050_75: bool,
    pub s1680x1050_85: bool,
    pub s1600x1200_60: bool,
    pub s1600x1200_65: bool,
    pub s1600x1200_70: bool,
    pub s1600x1200_75: bool,
    pub s1600x1200_85: bool,
    pub s1792x1344_60: bool,
    pub s1792x1344_75: bool,
    pub s1856x1392_60: bool,
    pub s1856x1392_75: bool,
    pub s1920x1200_60_rb: bool,
    pub s1920x1200_60: bool,
    pub s1920x1200_75: bool,
    pub s1920x1200_85: bool,
    pub s1920x1440_60: bool,
    pub s1920x1440_75: bool,
}

#[derive(Copy, Clone, Debug)]
pub struct ColorManagementData {
    pub red_a3: u16,
    pub red_a2: u16,
    pub green_a3: u16,
    pub green_a2: u16,
    pub blue_a3: u16,
    pub blue_a2: u16,
}

#[derive(Copy, Clone, Debug)]
pub enum CvtAspectRatio {
    A4_3,
    A16_9,
    A16_10,
    A15_9,
}

#[derive(Copy, Clone, Debug)]
pub enum CvtPreferredVerticalRate {
    R50,
    R60,
    R75,
    R85,
}

#[derive(Copy, Clone, Debug)]
pub struct Cvt3ByteCode {
    pub addressable_lines_per_field: u16,
    pub aspect_ration: CvtAspectRatio,
    pub preferred_vertical_rate: CvtPreferredVerticalRate,
    pub r50: bool,
    pub r60: bool,
    pub r75: bool,
    pub r85: bool,
    pub r60_reduced_blanking: bool,
}

#[derive(Copy, Clone, Debug)]
pub struct DetailedTimingDescriptor {
    pub pixel_clock_khz: u32,
    pub horizontal_addressable_pixels: u16,
    pub horizontal_blanking_pixels: u16,
    pub vertical_addressable_lines: u16,
    pub vertical_blanking_lines: u16,
    pub horizontal_front_porch_pixels: u16,
    pub horizontal_sync_pulse_pixels: u16,
    pub vertical_front_porch_lines: u8,
    pub vertical_sync_pulse_lines: u8,
    pub horizontal_addressable_mm: u16,
    pub vertical_addressable_mm: u16,
    pub horizontal_left_border_pixels: u8,
    pub vertical_top_border_pixels: u8,
    pub interlaced: bool,
    pub stereo_viewing_support: StereoViewingSupport,
    pub sync: SyncSignal,
}

#[derive(Clone, Debug)]
pub enum Descriptor {
    Unknown(u8),
    DetailedTimingDescriptor(DetailedTimingDescriptor),
    DisplayProductSerialNumber(String),
    AlphanumericDataString(String),
    DisplayProductName(String),
    DisplayRangeLimitsAndAdditionalTiming(DisplayRangeLimitsAndAdditionalTiming),
    EstablishedTimings3(EstablishedTimings3),
    ColorManagementData(ColorManagementData),
    StandardTimingIdentifier([Option<StandardTiming>; 6]),
    ColorPoint(ColorPoint, Option<ColorPoint>),
    Cvt3ByteCode([Cvt3ByteCode; 4]),
}

type EdidContext = (usize, EdidParseContext);

struct EdidParser<'a> {
    data: &'a [u8],
    pos: usize,
    context: Rc<Stack<EdidContext>>,
    saved_ctx: Vec<EdidContext>,
    errors: Vec<(EdidError, Vec<EdidContext>)>,
}

macro_rules! bail {
    ($slf:expr, $err:expr) => {{
        $slf.saved_ctx = $slf.context.to_vec();
        return Err($err);
    }};
}

#[derive(Clone, Debug)]
pub enum EdidParseContext {
    ReadingBytes(usize),
    BaseBlock,
    Descriptors,
    Descriptor,
    ChromaticityCoordinates,
    EstablishedTimings,
    StandardTimings,
    ScreenDimensions,
    Gamma,
    FeatureSupport,
    Magic,
    Extension,
    IdManufacturerName,
    VideoInputDefinition,
}

struct EdidPushedContext {
    stack: Rc<Stack<(usize, EdidParseContext)>>,
}

impl Drop for EdidPushedContext {
    fn drop(&mut self) {
        self.stack.pop();
    }
}

impl<'a> EdidParser<'a> {
    fn push_ctx(&self, pc: EdidParseContext) -> EdidPushedContext {
        self.context.push((self.pos, pc));
        EdidPushedContext {
            stack: self.context.clone(),
        }
    }

    fn nest(&self, data: &'a [u8]) -> Self {
        Self {
            data,
            pos: 0,
            context: self.context.clone(),
            saved_ctx: vec![],
            errors: vec![],
        }
    }

    fn store_error(&mut self, error: EdidError) {
        self.errors.push((error, self.saved_ctx.clone()));
    }

    fn is_empty(&self) -> bool {
        self.pos >= self.data.len()
    }

    fn read_n<const N: usize>(&mut self) -> Result<&'a [u8; N], EdidError> {
        let _ctx = self.push_ctx(EdidParseContext::ReadingBytes(N));
        if self.data.len() - self.pos < N {
            bail!(self, EdidError::UnexpectedEof);
        }
        let v = self.data[self.pos..self.pos + N].try_into().unwrap();
        self.pos += N;
        Ok(v)
    }

    fn read_var_n(&mut self, n: usize) -> Result<&'a [u8], EdidError> {
        let _ctx = self.push_ctx(EdidParseContext::ReadingBytes(n));
        if self.data.len() - self.pos < n {
            bail!(self, EdidError::UnexpectedEof);
        }
        let v = &self.data[self.pos..self.pos + n];
        self.pos += n;
        Ok(v)
    }

    fn read_u8(&mut self) -> Result<u8, EdidError> {
        let &[a] = self.read_n()?;
        Ok(a)
    }

    fn read_u16(&mut self) -> Result<u16, EdidError> {
        let &[lo, hi] = self.read_n()?;
        Ok(((hi as u16) << 8) + lo as u16)
    }

    fn read_u32(&mut self) -> Result<u32, EdidError> {
        let &[a, b, c, d] = self.read_n()?;
        Ok(((d as u32) << 24) + ((c as u32) << 16) + ((b as u32) << 8) + a as u32)
    }

    fn parse_magic(&mut self) -> Result<(), EdidError> {
        let _ctx = self.push_ctx(EdidParseContext::Magic);
        let magic = self.read_n::<8>()?;
        if magic != &[0, 255, 255, 255, 255, 255, 255, 0] {
            bail!(self, EdidError::InvalidMagic(magic.as_bstr().to_owned()));
        }
        Ok(())
    }

    fn parse_id_manufacturer_name(&mut self) -> Result<BString, EdidError> {
        let _ctx = self.push_ctx(EdidParseContext::IdManufacturerName);
        let name = self.read_n::<2>()?;
        let a = (name[0] >> 2) & 0b11111;
        let b = ((name[0] & 0b11) << 3) | (name[1] >> 5);
        let c = name[1] & 0b11111;
        let name = [a + b'@', b + b'@', c + b'@'].as_bstr().to_owned();
        Ok(name)
    }

    fn parse_video_input_definition(&mut self) -> Result<VideoInputDefinition, EdidError> {
        let _ctx = self.push_ctx(EdidParseContext::VideoInputDefinition);
        let val = self.read_u8()?;
        let res = if val.contains(0x80) {
            VideoInputDefinition::Digital {
                bit_depth: match (val >> 4) & 0b111 {
                    0b000 => ColorBitDepth::Undefined,
                    0b001 => ColorBitDepth::Bits6,
                    0b010 => ColorBitDepth::Bits8,
                    0b011 => ColorBitDepth::Bits10,
                    0b100 => ColorBitDepth::Bits12,
                    0b101 => ColorBitDepth::Bits14,
                    0b110 => ColorBitDepth::Bits16,
                    _ => ColorBitDepth::Reserved,
                },
                video_interface: match val & 0b1111 {
                    0b0000 => DigitalVideoInterfaceStandard::Undefined,
                    0b0001 => DigitalVideoInterfaceStandard::Dvi,
                    0b0010 => DigitalVideoInterfaceStandard::HdmiA,
                    0b0011 => DigitalVideoInterfaceStandard::HdmiB,
                    0b0100 => DigitalVideoInterfaceStandard::MDDI,
                    0b0101 => DigitalVideoInterfaceStandard::DisplayPort,
                    n => DigitalVideoInterfaceStandard::Unknown(n),
                },
            }
        } else {
            VideoInputDefinition::Analog {
                signal_level_standard: SignalLevelStandard((val >> 5) & 0b11),
                blank_to_black_setup_or_pedestal: (val >> 4).contains(1),
                separate_h_v_sync_supported: (val >> 3).contains(1),
                composite_sync_on_horizontal_supported: (val >> 2).contains(1),
                composite_sync_on_green_supported: (val >> 1).contains(1),
                serration_on_vertical_sync_supported: (val >> 0).contains(1),
            }
        };
        Ok(res)
    }

    fn parse_screen_dimensions(&mut self) -> Result<ScreenDimensions, EdidError> {
        let _ctx = self.push_ctx(EdidParseContext::ScreenDimensions);
        let &[hor, vert] = self.read_n()?;
        let mut res = ScreenDimensions {
            horizontal_screen_size_cm: None,
            vertical_screen_size_cm: None,
            landscape_aspect_ration: None,
            portrait_aspect_ration: None,
        };
        if hor != 0 && vert != 0 {
            res.horizontal_screen_size_cm = Some(hor);
            res.vertical_screen_size_cm = Some(vert);
        } else if vert != 0 {
            res.portrait_aspect_ration = Some(100.0 / (vert as f64 + 99.0));
        } else if hor != 0 {
            res.landscape_aspect_ration = Some((hor as f64 + 99.0) / 100.0);
        }
        Ok(res)
    }

    fn parse_gamma(&mut self) -> Result<Option<f64>, EdidError> {
        let _ctx = self.push_ctx(EdidParseContext::Gamma);
        let val = self.read_u8()?;
        if val == 0xff {
            Ok(None)
        } else {
            Ok(Some((val as f64 + 100.0) / 100.0))
        }
    }

    fn parse_feature_support(&mut self, digital: bool) -> Result<FeatureSupport, EdidError> {
        let _ctx = self.push_ctx(EdidParseContext::FeatureSupport);
        let val = self.read_u8()?;
        Ok(FeatureSupport {
            standby_supported: val.contains(0x80),
            suspend_supported: val.contains(0x40),
            active_off_supported: val.contains(0x20),
            features: if digital {
                FeatureSupport2::Digital {
                    rgb444_supported: true,
                    ycrcb422_supported: val.contains(0x10),
                    ycrcb444_supported: val.contains(0x08),
                }
            } else {
                FeatureSupport2::Analog {
                    display_color_type: match (val >> 3) & 0b11 {
                        0b00 => DisplayColorType::Monochrome,
                        0b01 => DisplayColorType::Rgb,
                        0b10 => DisplayColorType::NonRgb,
                        _ => DisplayColorType::Undefined,
                    },
                }
            },
            srgb_is_default_color_space: val.contains(0x04),
            preferred_mode_is_native: val.contains(0x02),
            display_is_continuous_frequency: val.contains(0x01),
        })
    }

    fn parse_chromaticity_coordinates(&mut self) -> Result<ChromaticityCoordinates, EdidError> {
        let _ctx = self.push_ctx(EdidParseContext::ChromaticityCoordinates);
        let b = self.read_n::<10>()?;
        let rx = ((b[0] as u16 >> 6) & 0b11) + ((b[2] as u16) << 2);
        let ry = ((b[0] as u16 >> 4) & 0b11) + ((b[3] as u16) << 2);
        let gx = ((b[0] as u16 >> 2) & 0b11) + ((b[4] as u16) << 2);
        let gy = ((b[0] as u16 >> 0) & 0b11) + ((b[5] as u16) << 2);
        let bx = ((b[1] as u16 >> 6) & 0b11) + ((b[6] as u16) << 2);
        let by = ((b[1] as u16 >> 4) & 0b11) + ((b[7] as u16) << 2);
        let wx = ((b[1] as u16 >> 2) & 0b11) + ((b[8] as u16) << 2);
        let wy = ((b[1] as u16 >> 0) & 0b11) + ((b[9] as u16) << 2);
        Ok(ChromaticityCoordinates {
            red_x: rx,
            red_y: ry,
            green_x: gx,
            green_y: gy,
            blue_x: bx,
            blue_y: by,
            white_x: wx,
            white_y: wy,
        })
    }

    fn parse_established_timings(&mut self) -> Result<EstablishedTimings, EdidError> {
        let _ctx = self.push_ctx(EdidParseContext::EstablishedTimings);
        let b = self.read_n::<3>()?;
        Ok(EstablishedTimings {
            s_720x400_70: b[0].contains(0x80),
            s_720x400_88: b[0].contains(0x40),
            s_640x480_60: b[0].contains(0x20),
            s_640x480_67: b[0].contains(0x10),
            s_640x480_72: b[0].contains(0x08),
            s_640x480_75: b[0].contains(0x04),
            s_800x600_56: b[0].contains(0x02),
            s_800x600_60: b[0].contains(0x01),
            s_800x600_72: b[0].contains(0x80),
            s_800x600_75: b[0].contains(0x40),
            s_832x624_75: b[0].contains(0x20),
            s_1024x768_87: b[0].contains(0x10),
            s_1024x768_60: b[0].contains(0x08),
            s_1024x768_70: b[0].contains(0x04),
            s_1024x768_75: b[0].contains(0x02),
            s_1280x1024_75: b[0].contains(0x01),
            s_1152x870_75: b[0].contains(0x80),
        })
    }

    fn parse_standard_timing(&mut self, revision: u8, a: u8, b: u8) -> Option<StandardTiming> {
        if a == 0 {
            return None;
        }
        Some(StandardTiming {
            x_resolution: (a as u16 + 31) * 8,
            aspect_ratio: match b >> 6 {
                0b00 if revision < 3 => AspectRatio::A1_1,
                0b00 => AspectRatio::A16_10,
                0b01 => AspectRatio::A4_3,
                0b10 => AspectRatio::A5_4,
                _ => AspectRatio::A16_9,
            },
            vertical_frequency: 60 + (b & 0b111111),
        })
    }

    fn parse_standard_timings2(
        &mut self,
        revision: u8,
        b: &[u8; 18],
    ) -> [Option<StandardTiming>; 6] {
        let mut res = [None; 6];
        for i in 0..6 {
            let x = b[5 + 2 * i];
            let y = b[5 + 2 * i + 1];
            res[i] = self.parse_standard_timing(revision, x, y);
        }
        res
    }

    fn parse_color_point(&mut self, b: &[u8; 18]) -> (ColorPoint, Option<ColorPoint>) {
        let mut res = [Default::default(); 2];
        for n in 0..2 {
            let b = &b[5 * (n + 1)..];
            res[n] = ColorPoint {
                white_point_index: b[0],
                white_point_x: ((b[2] as u16) << 2) | ((b[1] as u16) >> 2),
                white_point_y: ((b[3] as u16) << 2) | ((b[1] as u16) & 0b11),
                gamma: if b[4] == 0xff {
                    None
                } else {
                    Some((b[5] as f64 + 100.0) / 100.0)
                },
            };
        }
        let second = if res[1].white_point_index != 0 {
            Some(res[1])
        } else {
            None
        };
        (res[0], second)
    }

    fn parse_standard_timings(
        &mut self,
        revision: u8,
    ) -> Result<[Option<StandardTiming>; 8], EdidError> {
        let _ctx = self.push_ctx(EdidParseContext::StandardTimings);
        let bytes = self.read_n::<16>()?;
        let mut res = [None; 8];
        for i in 0..8 {
            let a = bytes[2 * i];
            let b = bytes[2 * i + 1];
            if (a, b) != (1, 1) {
                res[i] = self.parse_standard_timing(revision, a, b);
            }
        }
        Ok(res)
    }

    fn parse_detailed_timing_descriptor(&self, b: &[u8; 18]) -> DetailedTimingDescriptor {
        let l = b[17];
        DetailedTimingDescriptor {
            pixel_clock_khz: u16::from_le_bytes([b[0], b[1]]) as u32 * 10_000,
            horizontal_addressable_pixels: u16::from_le_bytes([b[2], b[4] >> 4]),
            horizontal_blanking_pixels: u16::from_le_bytes([b[3], b[4] & 0b1111]),
            vertical_addressable_lines: u16::from_le_bytes([b[5], b[7] >> 4]),
            vertical_blanking_lines: u16::from_le_bytes([b[6], b[7] & 0b1111]),
            horizontal_front_porch_pixels: u16::from_le_bytes([b[8], b[11] >> 6]),
            horizontal_sync_pulse_pixels: u16::from_le_bytes([b[9], (b[11] >> 4) & 0b11]),
            vertical_front_porch_lines: (b[10] >> 4) | ((b[11] & 0b1100) << 2),
            vertical_sync_pulse_lines: (b[10] & 0b1111) | ((b[11] & 0b11) << 4),
            horizontal_addressable_mm: u16::from_le_bytes([b[12], b[14] >> 4]),
            vertical_addressable_mm: u16::from_le_bytes([b[13], b[14] & 0b1111]),
            horizontal_left_border_pixels: b[15],
            vertical_top_border_pixels: b[16],
            interlaced: l.contains(0x80),
            stereo_viewing_support: match ((l >> 4) & 0b110) | (l & 0b1) {
                0b010 => StereoViewingSupport::FieldSequentialRightDuringStereoSync,
                0b100 => StereoViewingSupport::FieldSequentialLeftDuringStereoSync,
                0b011 => StereoViewingSupport::TwoWayInterleavedRightImageOnEvenLines,
                0b101 => StereoViewingSupport::TwoWayInterleavedLeftImageOnEvenLines,
                0b110 => StereoViewingSupport::FourWayInterleaved,
                0b111 => StereoViewingSupport::SideBySideInterleaved,
                _ => StereoViewingSupport::None,
            },
            sync: if l.contains(0b10000) {
                if l.contains(0b01000) {
                    SyncSignal::DigitalSeparate {
                        vertical_sync_is_positive: l.contains(0b100),
                        horizontal_sync_is_positive: l.contains(0b10),
                    }
                } else {
                    SyncSignal::DigitalComposite {
                        with_serration: l.contains(0b100),
                        horizontal_sync_is_positive: l.contains(0b10),
                    }
                }
            } else {
                SyncSignal::Analog {
                    ty: if l.contains(0b1000) {
                        AnalogSyncType::BipolarAnalogComposite
                    } else {
                        AnalogSyncType::AnalogComposite
                    },
                    with_serrations: l.contains(0b100),
                    sync_on_all_signals: l.contains(0b10),
                }
            },
        }
    }

    fn parse_display_range_limits_and_additional_timing(
        &self,
        b: &[u8; 18],
    ) -> DisplayRangeLimitsAndAdditionalTiming {
        let min_vert_off = b[4].contains(0b0001);
        let max_vert_off = min_vert_off || b[4].contains(0b0010);
        let min_horz_off = b[4].contains(0b0100);
        let max_horz_off = min_horz_off || b[4].contains(0b1000);
        DisplayRangeLimitsAndAdditionalTiming {
            vertical_field_rate_min: b[5] as u16 + if min_vert_off { 255 } else { 0 },
            vertical_field_rate_max: b[6] as u16 + if max_vert_off { 255 } else { 0 },
            horizontal_field_rate_min: b[7] as u16 + if min_horz_off { 255 } else { 0 },
            horizontal_field_rate_max: b[8] as u16 + if max_horz_off { 255 } else { 0 },
            maximum_pixel_clock_mhz: b[9] as u16 * 10,
            extended_timing_information: match b[10] {
                0x0 => ExtendedTimingInformation::DefaultGtf,
                0x1 => ExtendedTimingInformation::NoTimingInformation,
                0x2 => ExtendedTimingInformation::SecondaryGtf {
                    start_frequency: b[12] as u16,
                    c_value: b[13] as u16,
                    m_value: u16::from_le_bytes([b[14], b[15]]),
                    k_value: b[16],
                    j_value: b[17] as u16,
                },
                0x4 => ExtendedTimingInformation::Cvt {
                    cvt_major_version: b[11] >> 4,
                    cvt_minor_version: b[11] & 0b1111,
                    additional_clock_precision: b[12] >> 2,
                    maximum_active_pixels_per_line: if b[13] == 0 {
                        None
                    } else {
                        Some((((b[12] as u16 & 0b11) << 8) | b[13] as u16) * 8)
                    },
                    ar_4_3: b[14].contains(0x80),
                    ar_16_9: b[14].contains(0x40),
                    ar_16_10: b[14].contains(0x20),
                    ar_5_4: b[14].contains(0x10),
                    ar_15_9: b[14].contains(0x08),
                    ar_preference: match b[15] >> 5 {
                        0b000 => AspectRatioPreference::A4_3,
                        0b001 => AspectRatioPreference::A16_9,
                        0b010 => AspectRatioPreference::A16_10,
                        0b011 => AspectRatioPreference::A5_4,
                        0b100 => AspectRatioPreference::A15_9,
                        n => AspectRatioPreference::Unknown(n),
                    },
                    cvt_rb_reduced_blanking_preferred: b[15].contains(0b10000),
                    cvt_standard_blanking: b[15].contains(0b1000),
                    scaling_support_horizontal_shrink: b[16].contains(0x80),
                    scaling_support_horizontal_stretch: b[16].contains(0x40),
                    scaling_support_vertical_shrink: b[16].contains(0x20),
                    scaling_support_vertical_stretch: b[16].contains(0x10),
                    preferred_vertical_refresh_rate_hz: b[17],
                },
                n => ExtendedTimingInformation::Unknown(n),
            },
        }
    }

    fn parse_established_timings3(&self, b: &[u8; 18]) -> EstablishedTimings3 {
        EstablishedTimings3 {
            s640x350_85: b[6].contains(0x80),
            s640x400_85: b[6].contains(0x40),
            s720x400_85: b[6].contains(0x20),
            s640x480_85: b[6].contains(0x10),
            s848x480_60: b[6].contains(0x08),
            s800x600_85: b[6].contains(0x04),
            s1024x768_85: b[6].contains(0x02),
            s1152x864_75: b[6].contains(0x01),
            s1280x768_60_rb: b[7].contains(0x80),
            s1280x768_60: b[7].contains(0x40),
            s1280x768_75: b[7].contains(0x20),
            s1280x768_85: b[7].contains(0x10),
            s1280x960_60: b[7].contains(0x08),
            s1280x960_85: b[7].contains(0x04),
            s1280x1024_60: b[7].contains(0x02),
            s1280x1024_85: b[7].contains(0x01),
            s1360x768_60: b[8].contains(0x80),
            s1440x900_60_rb: b[8].contains(0x40),
            s1440x900_60: b[8].contains(0x20),
            s1440x900_75: b[8].contains(0x10),
            s1440x900_85: b[8].contains(0x08),
            s1400x1050_60_rb: b[8].contains(0x04),
            s1400x1050_60: b[8].contains(0x02),
            s1400x1050_75: b[8].contains(0x01),
            s1400x1050_85: b[9].contains(0x80),
            s1680x1050_60_rb: b[9].contains(0x40),
            s1680x1050_60: b[9].contains(0x20),
            s1680x1050_75: b[9].contains(0x10),
            s1680x1050_85: b[9].contains(0x08),
            s1600x1200_60: b[9].contains(0x04),
            s1600x1200_65: b[9].contains(0x02),
            s1600x1200_70: b[9].contains(0x01),
            s1600x1200_75: b[10].contains(0x80),
            s1600x1200_85: b[10].contains(0x40),
            s1792x1344_60: b[10].contains(0x20),
            s1792x1344_75: b[10].contains(0x10),
            s1856x1392_60: b[10].contains(0x08),
            s1856x1392_75: b[10].contains(0x04),
            s1920x1200_60_rb: b[10].contains(0x02),
            s1920x1200_60: b[10].contains(0x01),
            s1920x1200_75: b[11].contains(0x80),
            s1920x1200_85: b[11].contains(0x40),
            s1920x1440_60: b[11].contains(0x20),
            s1920x1440_75: b[11].contains(0x10),
        }
    }

    fn parse_color_management_data(&self, b: &[u8; 18]) -> ColorManagementData {
        ColorManagementData {
            red_a3: u16::from_le_bytes([b[6], b[7]]),
            red_a2: u16::from_le_bytes([b[8], b[9]]),
            green_a3: u16::from_le_bytes([b[10], b[11]]),
            green_a2: u16::from_le_bytes([b[12], b[13]]),
            blue_a3: u16::from_le_bytes([b[14], b[15]]),
            blue_a2: u16::from_le_bytes([b[16], b[17]]),
        }
    }

    fn parse_cvt3_byte_codes(&self, b: &[u8; 18]) -> [Cvt3ByteCode; 4] {
        let parse = |n: usize| {
            let b = &b[6 + 3 * n..];
            Cvt3ByteCode {
                addressable_lines_per_field: u16::from_le_bytes([b[0], b[1] >> 4]),
                aspect_ration: match (b[1] >> 2) & 0b11 {
                    0 => CvtAspectRatio::A4_3,
                    1 => CvtAspectRatio::A16_9,
                    2 => CvtAspectRatio::A16_10,
                    _ => CvtAspectRatio::A15_9,
                },
                preferred_vertical_rate: match (b[2] >> 5) & 0b11 {
                    0 => CvtPreferredVerticalRate::R50,
                    1 => CvtPreferredVerticalRate::R60,
                    2 => CvtPreferredVerticalRate::R75,
                    _ => CvtPreferredVerticalRate::R85,
                },
                r50: b[2].contains(0b10000),
                r60: b[2].contains(0b01000),
                r75: b[2].contains(0b00100),
                r85: b[2].contains(0b00010),
                r60_reduced_blanking: b[2].contains(0b00001),
            }
        };
        [parse(0), parse(1), parse(2), parse(3)]
    }

    fn parse_descriptor(&mut self, revision: u8) -> Result<Option<Descriptor>, EdidError> {
        let _ctx = self.push_ctx(EdidParseContext::Descriptor);
        let b = self.read_n::<18>()?;
        let str = || {
            let mut s = &b[5..];
            if let Some(n) = s.find_byte(b'\n') {
                s = &s[..n];
            };
            let mut res = String::new();
            for &b in s {
                res.push_str(CP437[b as usize]);
            }
            res
        };
        let res = if (b[0], b[1]) == (0, 0) {
            match b[3] {
                0xff => Descriptor::DisplayProductSerialNumber(str()),
                0xfe => Descriptor::AlphanumericDataString(str()),
                0xfd => Descriptor::DisplayRangeLimitsAndAdditionalTiming(
                    self.parse_display_range_limits_and_additional_timing(b),
                ),
                0xfc => Descriptor::DisplayProductName(str()),
                0xfb => {
                    let (first, second) = self.parse_color_point(b);
                    Descriptor::ColorPoint(first, second)
                }
                0xfa => {
                    Descriptor::StandardTimingIdentifier(self.parse_standard_timings2(revision, b))
                }
                0xf9 => Descriptor::ColorManagementData(self.parse_color_management_data(b)),
                0xf8 => Descriptor::Cvt3ByteCode(self.parse_cvt3_byte_codes(b)),
                0xf7 => Descriptor::EstablishedTimings3(self.parse_established_timings3(b)),
                0x10 => return Ok(None),
                n => Descriptor::Unknown(n),
            }
        } else {
            Descriptor::DetailedTimingDescriptor(self.parse_detailed_timing_descriptor(b))
        };
        Ok(Some(res))
    }

    fn parse_descriptors(&mut self, revision: u8) -> Result<[Option<Descriptor>; 4], EdidError> {
        let _ctx = self.push_ctx(EdidParseContext::Descriptors);
        let mut res = [None, None, None, None];
        for res in &mut res {
            *res = self.parse_descriptor(revision)?;
        }
        Ok(res)
    }

    fn parse_base_block(&mut self) -> Result<EdidBaseBlock, EdidError> {
        let _ctx = self.push_ctx(EdidParseContext::BaseBlock);
        self.parse_magic()?;
        let id_manufacturer_name = self.parse_id_manufacturer_name()?;
        let id_product_code = self.read_u16()?;
        let id_serial_number = self.read_u32()?;
        let mut week_of_manufacture = None;
        let mut model_year = None;
        let mut year_of_manufacture = None;
        {
            let &[a, b] = self.read_n()?;
            if matches!(a, 1..=0x36) {
                week_of_manufacture = Some(a);
            }
            let year = b as u16 + 1990;
            if a == 0xff {
                model_year = Some(year);
            } else {
                year_of_manufacture = Some(year);
            }
        }
        let &[edid_version, edid_revision] = self.read_n()?;
        let video_input_definition = self.parse_video_input_definition()?;
        let is_digital = matches!(video_input_definition, VideoInputDefinition::Digital { .. });
        let screen_dimensions = self.parse_screen_dimensions()?;
        let gamma = self.parse_gamma()?;
        let feature_support = self.parse_feature_support(is_digital)?;
        let chromaticity_coordinates = self.parse_chromaticity_coordinates()?;
        let established_timings = self.parse_established_timings()?;
        let standard_timings = self.parse_standard_timings(edid_revision)?;
        let descriptors = self.parse_descriptors(edid_revision)?;
        let num_extensions = self.read_u8()?;
        let _checksum = self.read_u8()?;
        Ok(EdidBaseBlock {
            id_manufacturer_name,
            id_product_code,
            id_serial_number,
            week_of_manufacture,
            model_year,
            year_of_manufacture,
            edid_version,
            edid_revision,
            video_input_definition,
            screen_dimensions,
            gamma,
            feature_support,
            chromaticity_coordinates,
            established_timings,
            standard_timings,
            descriptors,
            num_extensions,
        })
    }

    fn parse_cta_amd_vendor_data_block(&mut self) -> Result<CtaDataBlock, EdidError> {
        let _ = self.read_n::<2>()?;
        Ok(CtaDataBlock::VendorAmd(CtaAmdVendorDataBlock {
            minimum_refresh_hz: self.read_u8()?,
            maximum_refresh_hz: self.read_u8()?,
        }))
    }

    fn parse_cta_vendor_data_block(&mut self) -> Result<CtaDataBlock, EdidError> {
        match self.read_n::<3>()? {
            [0x1A, 0x00, 0x00] => self.parse_cta_amd_vendor_data_block(),
            _ => Ok(CtaDataBlock::Unknown),
        }
    }

    fn parse_cta_colorimetry_data_block(&mut self) -> Result<CtaDataBlock, EdidError> {
        let [lo, hi] = *self.read_n::<2>()?;
        Ok(CtaDataBlock::Colorimetry(CtaColorimetryDataBlock {
            bt2020_rgb: lo.contains(0x80),
            bt2020_ycc: lo.contains(0x40),
            bt2020_cycc: lo.contains(0x20),
            op_rgb: lo.contains(0x10),
            op_ycc_601601: lo.contains(0x08),
            s_ycc_601: lo.contains(0x04),
            xv_ycc_709: lo.contains(0x02),
            xv_ycc_601: lo.contains(0x01),
            dci_p3: hi.contains(0x80),
        }))
    }

    fn parse_cta_hdr_static_metadata_data_block(&mut self) -> Result<CtaDataBlock, EdidError> {
        let et = self.read_u8()?;
        let _ = self.read_u8()?;
        let mut read_luminance = |min: bool| {
            let v = self.read_u8().unwrap_or_default();
            if v == 0 {
                None
            } else if min {
                Some((v as f64 / 255.0).powi(2) / 100.0)
            } else {
                Some(50.0 * 2.0f64.powf(v as f64 / 32.0))
            }
        };
        Ok(CtaDataBlock::StaticHdrMetadata(
            CtaStaticHdrMetadataDataBlock {
                traditional_gamma_sdr_luminance: et.contains(0x01),
                traditional_gamma_hdr_luminance: et.contains(0x02),
                smpte_st_2084: et.contains(0x04),
                hlg: et.contains(0x08),
                max_luminance: read_luminance(false),
                max_frame_average_luminance: read_luminance(false),
                min_luminance: read_luminance(true),
            },
        ))
    }

    fn parse_cta_extended_data_block(&mut self) -> Result<CtaDataBlock, EdidError> {
        match self.read_u8()? {
            0x5 => self.parse_cta_colorimetry_data_block(),
            0x6 => self.parse_cta_hdr_static_metadata_data_block(),
            _ => Ok(CtaDataBlock::Unknown),
        }
    }

    fn parse_cta_data_block(&mut self, tag: u8) -> Result<CtaDataBlock, EdidError> {
        match tag {
            0x3 => self.parse_cta_vendor_data_block(),
            0x7 => self.parse_cta_extended_data_block(),
            _ => Ok(CtaDataBlock::Unknown),
        }
    }

    fn parse_cta_extension_v3(&mut self) -> Result<EdidExtension, EdidError> {
        let detailed_timing_descriptors_offset = self.read_u8()? as usize;
        let _ = self.read_u8()?;
        let mut data_blocks = vec![];
        while self.pos < detailed_timing_descriptors_offset {
            let b1 = self.read_u8()?;
            let data = self.read_var_n(b1 as usize & 0x1f)?;
            let mut parser = self.nest(data);
            match parser.parse_cta_data_block(b1 >> 5) {
                Ok(d) => data_blocks.push(d),
                Err(e) => {
                    self.saved_ctx = parser.saved_ctx;
                    self.store_error(e);
                }
            }
        }
        Ok(EdidExtension::CtaV3(CtaExtensionV3 { data_blocks }))
    }

    fn parse_cta_extension(&mut self) -> Result<EdidExtension, EdidError> {
        // https://web.archive.org/web/20171201033424/https://standards.cta.tech/kwspub/published_docs/CTA-861-G_FINAL_revised_2017.pdf
        match self.read_u8()? {
            0x3 => self.parse_cta_extension_v3(),
            _ => Ok(EdidExtension::Unknown),
        }
    }

    fn parse_extension_impl(&mut self) -> Result<EdidExtension, EdidError> {
        match self.read_u8()? {
            0x2 => self.parse_cta_extension(),
            _ => Ok(EdidExtension::Unknown),
        }
    }

    fn parse_extension(&mut self) -> Result<EdidExtension, EdidError> {
        let _ctx = self.push_ctx(EdidParseContext::Extension);
        let data = self.read_n::<128>()?;
        let mut parser = self.nest(data);
        let res = parser.parse_extension_impl();
        if res.is_err() {
            self.saved_ctx = parser.saved_ctx;
        }
        res
    }

    fn parse(&mut self) -> Result<EdidFile, EdidError> {
        let bb = self.parse_base_block()?;
        let mut exts = vec![];
        while !self.is_empty() {
            match self.parse_extension() {
                Ok(e) => exts.push(e),
                Err(e) => self.store_error(e),
            }
        }
        Ok(EdidFile {
            base_block: bb,
            extension_blocks: exts,
        })
    }
}

#[derive(Debug)]
pub enum DisplayColorType {
    Monochrome,
    Rgb,
    NonRgb,
    Undefined,
}

#[derive(Debug)]
pub enum FeatureSupport2 {
    Analog {
        display_color_type: DisplayColorType,
    },
    Digital {
        rgb444_supported: bool,
        ycrcb444_supported: bool,
        ycrcb422_supported: bool,
    },
}

#[derive(Debug)]
pub struct FeatureSupport {
    pub standby_supported: bool,
    pub suspend_supported: bool,
    pub active_off_supported: bool,
    pub features: FeatureSupport2,
    pub srgb_is_default_color_space: bool,
    pub preferred_mode_is_native: bool,
    pub display_is_continuous_frequency: bool,
}

#[derive(Debug)]
pub struct EdidBaseBlock {
    pub id_manufacturer_name: BString,
    pub id_product_code: u16,
    pub id_serial_number: u32,
    pub week_of_manufacture: Option<u8>,
    pub model_year: Option<u16>,
    pub year_of_manufacture: Option<u16>,
    pub edid_version: u8,
    pub edid_revision: u8,
    pub video_input_definition: VideoInputDefinition,
    pub screen_dimensions: ScreenDimensions,
    pub gamma: Option<f64>,
    pub feature_support: FeatureSupport,
    pub chromaticity_coordinates: ChromaticityCoordinates,
    pub established_timings: EstablishedTimings,
    pub standard_timings: [Option<StandardTiming>; 8],
    pub descriptors: [Option<Descriptor>; 4],
    pub num_extensions: u8,
}

#[derive(Debug)]
pub enum EdidExtension {
    Unknown,
    CtaV3(CtaExtensionV3),
}

#[derive(Debug)]
pub struct CtaExtensionV3 {
    pub data_blocks: Vec<CtaDataBlock>,
}

#[derive(Debug)]
pub enum CtaDataBlock {
    Unknown,
    VendorAmd(CtaAmdVendorDataBlock),
    Colorimetry(CtaColorimetryDataBlock),
    StaticHdrMetadata(CtaStaticHdrMetadataDataBlock),
}

#[derive(Debug)]
pub struct CtaAmdVendorDataBlock {
    pub minimum_refresh_hz: u8,
    pub maximum_refresh_hz: u8,
}

#[derive(Copy, Clone, Debug)]
pub struct CtaColorimetryDataBlock {
    pub bt2020_rgb: bool,
    pub bt2020_ycc: bool,
    pub bt2020_cycc: bool,
    pub op_rgb: bool,
    pub op_ycc_601601: bool,
    pub s_ycc_601: bool,
    pub xv_ycc_709: bool,
    pub xv_ycc_601: bool,
    pub dci_p3: bool,
}

#[derive(Copy, Clone, Debug)]
pub struct CtaStaticHdrMetadataDataBlock {
    pub traditional_gamma_sdr_luminance: bool,
    pub traditional_gamma_hdr_luminance: bool,
    pub smpte_st_2084: bool,
    pub hlg: bool,
    pub max_luminance: Option<f64>,
    pub max_frame_average_luminance: Option<f64>,
    pub min_luminance: Option<f64>,
}

#[derive(Debug)]
pub struct EdidFile {
    pub base_block: EdidBaseBlock,
    pub extension_blocks: Vec<EdidExtension>,
}

#[derive(Debug, Error)]
pub enum EdidError {
    #[error("Unexpected end-of-file")]
    UnexpectedEof,
    #[error("Invalid magic header")]
    InvalidMagic(BString),
}

pub fn parse(data: &[u8]) -> Result<EdidFile, EdidError> {
    let mut parser = EdidParser {
        data,
        pos: 0,
        context: Rc::new(Default::default()),
        saved_ctx: vec![],
        errors: vec![],
    };
    parser.parse()
}

const CP437: &[&str] = &[
    "\u{0}", "☺", "☻", "♥", "♦", "♣", "♠", "•", "◘", "○", "◙", "♂", "♀", "♪", "♫", "☼", "►", "◄",
    "↕", "‼", "¶", "§", "▬", "↨", "↑", "↓", "→", "←", "∟", "↔", "▲", "▼", " ", "!", "\"", "#", "$",
    "%", "&", "'", "(", ")", "*", "+", ",", "-", ".", "/", "0", "1", "2", "3", "4", "5", "6", "7",
    "8", "9", ":", ";", "<", "=", ">", "?", "@", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J",
    "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "[", "\\", "]",
    "^", "_", "`", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p",
    "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "{", "|", "}", "~", "⌂", "Ç", "ü", "é", "â",
    "ä", "à", "å", "ç", "ê", "ë", "è", "ï", "î", "ì", "Ä", "Å", "É", "æ", "Æ", "ô", "ö", "ò", "û",
    "ù", "ÿ", "Ö", "Ü", "¢", "£", "¥", "₧", "ƒ", "á", "í", "ó", "ú", "ñ", "Ñ", "ª", "º", "¿", "⌐",
    "¬", "½", "¼", "¡", "«", "»", "░", "▒", "▓", "│", "┤", "╡", "╢", "╖", "╕", "╣", "║", "╗", "╝",
    "╜", "╛", "┐", "└", "┴", "┬", "├", "─", "┼", "╞", "╟", "╚", "╔", "╩", "╦", "╠", "═", "╬", "╧",
    "╨", "╤", "╥", "╙", "╘", "╒", "╓", "╫", "╪", "┘", "┌", "█", "▄", "▌", "▐", "▀", "α", "ß", "Γ",
    "π", "Σ", "σ", "µ", "τ", "Φ", "Θ", "Ω", "δ", "∞", "φ", "ε", "∩", "≡", "±", "≥", "≤", "⌠", "⌡",
    "÷", "≈", "°", "∙", "·", "√", "ⁿ", "²", "■", "\u{a0}",
];