let _padding = ctxt.read_u16be()?;

                KernTableVersion::KernTableVersion1

            _ => return Err(ParseError::BadVersion),

            KernTableVersion::KernTableVersion1 => ctxt.read_u32be()?,

                        2 => Self::read_format2(&mut ctxt, start, length).map(KernData::Format2)?,

                        _ => return Err(ParseError::BadValue),

                    let length = usize::try_from(ctxt.read_u32be()?)?;

                    let coverage = ctxt.read_u16be()?;

                    let _tuple_index = ctxt.read_u16be()?;

                    let format = coverage & 0x00FF;

                    let data = match format {

                        0 => Self::read_format0(&mut ctxt).map(KernData::Format0)?,

                        1 => Self::read_format1(&mut ctxt, length).map(KernData::Format1)?,

                        2 => Self::read_format2(&mut ctxt, start, length).map(KernData::Format2)?,

                        3 => Self::read_format3(&mut ctxt, length).map(KernData::Format3)?,

                        _ => return Err(ParseError::BadValue),

                    Ok(KernSubtable {

                        coverage: KernCoverage::KernCoverageVersion1(coverage),

                        data,

                    })

    fn read_format1(ctxt: &mut ReadCtxt<'a>, length: usize) -> Result<KernFormat1<'a>, ParseError> {

        let sub_body_length = length.checked_sub(8).ok_or(ParseError::BadEof)?;

        let mut sub_ctxt = ctxt.read_scope(sub_body_length)?.ctxt();

        let start = sub_ctxt.scope();

        let state_size = sub_ctxt.read_u16be()?;

        let class_table_offset = sub_ctxt.read_u16be()?;

        let state_array_offset = sub_ctxt.read_u16be()?;

        let entry_table_offset = sub_ctxt.read_u16be()?;

        let value_table_offset = sub_ctxt.read_u16be()?;

        let class_table = start

            .offset(usize::from(class_table_offset))

            .read::<ClassTableFormat1<'_>>()?;

        let state_array = start

            .offset(usize::from(state_array_offset))

            .read_dep::<StateArray<'_>>((state_size, state_array_offset))?;

        let entry_table = start

            .offset(usize::from(entry_table_offset))

            .read::<VecTable<ContextualEntry>>()?;

        let value_table = ValueTable {

            offset: value_table_offset,

            values: start.offset(usize::from(value_table_offset)).data(),

        };

        Ok(KernFormat1 {

            class_table,

            state_array,

            entry_table,

            value_table,

        })

    }

    fn read_format2(

        ctxt: &mut ReadCtxt<'a>,

        start: ReadScope<'a>,

        length: usize,

    ) -> Result<KernFormat2<'a>, ParseError> {

        let _row_width = ctxt.read_u16be()?;

        let left_class_offset = ctxt.read_u16be()?;

        let right_class_offset = ctxt.read_u16be()?;

        let kerning_array_offset = usize::from(ctxt.read_u16be()?);

        let left_table = start

            .offset(usize::from(left_class_offset))

            .read::<ClassTableFormat2<'_>>()?;

        let right_table = start

            .offset(usize::from(right_class_offset))

            .read::<ClassTableFormat2<'_>>()?;

        let kerning_array_length = length

            .checked_sub(kerning_array_offset)

            .ok_or(ParseError::BadEof)?;

        let kerning_array = start

            .offset(kerning_array_offset)

            .ctxt()

            .read_slice(kerning_array_length)?;

        Ok(KernFormat2 {

            left_table,

            right_table,

            kerning_array,

        })

    }

    fn read_format3(ctxt: &mut ReadCtxt<'a>, length: usize) -> Result<KernFormat3<'a>, ParseError> {

        let sub_body_length = length.checked_sub(8).ok_or(ParseError::BadEof)?;

        let mut sub_ctxt = ctxt.read_scope(sub_body_length)?.ctxt();

        let glyph_count = usize::from(sub_ctxt.read_u16be()?);

        let kern_value_count = usize::from(sub_ctxt.read_u8()?);

        let left_class_count = usize::from(sub_ctxt.read_u8()?);

        let right_class_count = usize::from(sub_ctxt.read_u8()?);

        let _flags = sub_ctxt.read_u8()?;

        let kern_value_table = sub_ctxt.read_array(kern_value_count)?;

        let left_class_table = sub_ctxt.read_array(glyph_count)?;

        let right_class_table = sub_ctxt.read_array(glyph_count)?;

        let kern_index_table = sub_ctxt.read_array(left_class_count * right_class_count)?;

        Ok(KernFormat3 {

            kern_value_table,

            left_class_table,

            right_class_table,

            right_class_count,

            kern_index_table,

        })

    }

    fn from(kern: &'a owned::KernTable) -> Self {

        KernTable {

            version: kern.version,

            table_count: kern.table_count,

            data: &kern.data,

        }

    }

            KernCoverage::KernCoverageVersion1(c) => c & 0x8000 == 0,

            KernCoverage::KernCoverageVersion1(_) => false,

            KernCoverage::KernCoverageVersion1(c) => c & 0x4000 != 0,

            KernCoverage::KernCoverageVersion1(_) => false,

    fn has_variation(&self) -> bool {

        match self.coverage {

            KernCoverage::KernCoverageVersion0(_) => false,

            KernCoverage::KernCoverageVersion1(c) => c & 0x2000 != 0,

    }

    fn read_dep<'a>(

        ctxt: &mut ReadCtxt<'a>,

        (state_size, offset): (u16, u16),

    ) -> Result<Self::HostType<'a>, ParseError> {

        let mut state_array: Vec<ReadArray<'a, U8>> = Vec::new();

            match ctxt.read_array::<U8>(usize::from(state_size)) {

                Ok(array) => state_array.push(array),

                Err(ParseError::BadEof) => break,

                Err(err) => return Err(err),

        Ok(StateArray {

            state_size,

            offset,

            states: state_array,

        })

    }

    fn read<'a>(ctxt: &mut ReadCtxt<'a>) -> Result<Self::HostType<'a>, ParseError> {

        let first_glyph = ctxt.read_u16be()?;

        let n_glyphs = ctxt.read_u16be()?;

        let class_array = ctxt.read_array(usize::from(n_glyphs))?;

        Ok(ClassTableFormat1 {

            first_glyph,

            class_array,

        })

    }

    fn read<'a>(ctxt: &mut ReadCtxt<'a>) -> Result<Self::HostType<'a>, ParseError> {

        let first_glyph = ctxt.read_u16be()?;

        let n_glyphs = ctxt.read_u16be()?;

        let values = ctxt.read_array(usize::from(n_glyphs))?;

        Ok(ClassTableFormat2 {

            first_glyph,

            values,

        })

    }

    fn push(&self) -> bool {

        self.flags & 0x8000 != 0

    }

    fn dont_advance(&self) -> bool {

        self.flags & 0x4000 != 0

    }

    fn value_offset(&self) -> u16 {

        self.flags & 0x3FFF

    }

    fn read_from((new_state, flags): (u16, u16)) -> Self {

        ContextualEntry { new_state, flags }

    }

    fn new(infos: &'a mut [Info], new_state: u16) -> ContextualContext<'a> {

        ContextualContext {

            max_ops: MAX_OPS,

            infos,

            new_state,

            stack: TinyVec::new(),

        }

    }

    fn process(

        &mut self,

        is_cross_stream: bool,

        subtable: &KernFormat1<'_>,

    ) -> Result<(), ParseError> {

        let mut i = 0;

        while i <= self.infos.len() {

            let class = match self.infos.get(i) {

                Some(info) => {

                    let glyph_id = info.get_glyph_index();

                    if glyph_id == DELETED_GLYPH {

                        CLASS_CODE_DELETED

                        subtable

                            .class_table

                            .get(glyph_id)

                            .map(u16::from)

                            .unwrap_or(CLASS_CODE_OOB)

                None => CLASS_CODE_EOT,

            let entry_table_index = subtable

                .state_array

                .get(class, self.new_state)

                .ok_or(ParseError::BadIndex)?;

            let entry = subtable

                .entry_table

                .0

                .get(usize::from(entry_table_index))

                .ok_or(ParseError::BadIndex)?;

            self.new_state = entry.new_state;

            if entry.push() {

                if class == CLASS_CODE_EOT {

                    // `i` points to one past the buffer, so don't push it.

                } else if self.stack.last() == Some(&i) {

                    // When DONT_ADVANCE == true, avoid pushing the same index twice.

                } else {

                    self.stack.push(i)

            }

            let mut value_offset = entry.value_offset();

            if value_offset != 0 {

                    let value = subtable

                        .value_table

                        .get(value_offset)

                        .ok_or(ParseError::BadIndex)?;

                    let popped_i = match self.stack.pop() {

                        Some(popped_i) => popped_i,

                        None => break 'stack, // Stack underflow.

                    let info = &mut self.infos[popped_i];

                    let kerning = value.kerning();

                    if is_cross_stream {

                        if kerning == -0x8000 {

                            info.reset_cross_stream = true;

                            info.placement = match info.placement {

                                Placement::Distance(dx, _dy) => Placement::Distance(dx, 0),

                                _ => Placement::None,

                        } else if !info.reset_cross_stream {

                            info.placement.combine_distance(0, i32::from(kerning));

                        }

                    } else {

                        info.kerning += kerning;

                        info.placement.combine_distance(i32::from(kerning), 0);

                    }

                    if value.end_of_list() {

                        break 'stack;

                    }

                    value_offset = value_offset

                        .checked_add(u16::try_from(size_of::<i16>())?)

                        .ok_or(ParseError::BadIndex)?;

            }

            if class == CLASS_CODE_EOT {

                break;

            }

            self.max_ops -= 1;

            if !entry.dont_advance() || self.max_ops <= 0 {

                i += 1;

            }

        Ok(())

    }

            KernData::Format1(_) => None,

            KernData::Format2(x) => {

                let left_class = x.left_table.get(left)?;

                let right_class = x.right_table.get(right)?;

                ReadScope::new(x.kerning_array)

                    .offset(usize::from(left_class) + usize::from(right_class))

                    .read::<I16Be>()

                    .ok()

            KernData::Format3(x) => {

                let left_class = x.left_class_table.get_item(usize::from(left))?;

                let right_class = x.right_class_table.get_item(usize::from(right))?;

                let kern_index = x.kern_index_table.get_item(

                    usize::from(left_class) * x.right_class_count + usize::from(right_class),

                )?;

                x.kern_value_table.get_item(usize::from(kern_index))

    fn apply_format_1(&self, is_cross_stream: bool, infos: &mut [Info]) -> Result<(), ParseError> {

        match self {

            KernData::Format1(x) => {

                let mut context = ContextualContext::new(infos, x.state_array.offset);

                context.process(is_cross_stream, x)

            _ => Ok(()),

    }

        return Ok(has_cross_stream);

        accumulate_cross_stream_offsets(infos);

        if !sub_table.is_horizontal() {

            return Ok(());

        }

        kern_data.apply_format_1(sub_table.is_cross_stream(), infos)

            return Ok(());

            return Ok(());

                    value

                    left.kerning.min(value)

fn accumulate_cross_stream_offsets(infos: &mut [Info]) {

    let mut iter = infos.iter_mut();

    let Some(mut left) = iter.next() else {

        return;

    for right in iter {

        if let Placement::Distance(_dx, dy) = left.placement {

            if !right.reset_cross_stream {

                right.placement.combine_distance(0, dy);

            }

        }

        left = right;

}

    fn get(&self, glyph_id: u16) -> Option<u8> {

        let index = glyph_id.checked_sub(self.first_glyph).map(usize::from)?;

        self.class_array.get_item(index)

    }

    fn get(&self, glyph_id: u16) -> Option<u16> {

        let index = glyph_id.checked_sub(self.first_glyph).map(usize::from)?;

        self.values.get_item(index)

    }

    fn get(&self, class: u16, new_state: u16) -> Option<u8> {

        let row_index = new_state.checked_sub(self.offset)? / self.state_size;

        self.states

            .get(usize::from(row_index))

            .and_then(|s| s.get_item(usize::from(class)))

    }

    fn get(&self, value_offset: u16) -> Option<Value> {

        let index = value_offset.checked_sub(self.offset).map(usize::from)?;

        ReadScope::new(self.values)

            .offset(index)

            .read::<I16Be>()

            .map(Value)

            .ok()

    }

    fn end_of_list(&self) -> bool {

        self.0 & 1 == 1

    }

    fn kerning(&self) -> i16 {

        self.0 & !1

    }