mathtex-portable-engine-generated 0.2.0

//! XeTeX engine functions, group `h`.
//! Generated by `cargo run -p mathtex-web2c-import --bin patch_engine`.

#![allow(dead_code, non_camel_case_types, non_snake_case, unused_assignments, unused_mut, unused_variables)]

use crate::runtime::*;

impl<'resources> PortableTexEngine<'resources> {

    pub(crate) unsafe fn handlerightbrace(&mut self) -> EngineFlow<()> {
        let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
        let eqtb = self.state.zeqtb.as_mut_ptr();
        let mut p: halfword = 0;
        let mut q: halfword = 0;
        let mut d: scaled = 0;
        let mut f_0: integer = 0;
        match self.state.curgroup as i32 {
            1 => {
                (&mut *(self as *mut PortableTexEngine<'_>)).unsave()?;
            }
            0 => {
                if self.state.filelineerrorstylep != 0 {
                    (&mut *(self as *mut PortableTexEngine<'_>)).printfileline();
                } else {
                    (&mut *(self as *mut PortableTexEngine<'_>))
                        .zprintnl(65544 as i64 as strnumber);
                }
                (&mut *(self as *mut PortableTexEngine<'_>))
                    .zprint(66477 as i64 as integer);
                self.state.helpptr = 2 as eightbits;
                self.state.helpline[1 as i32 as usize] = 66478 as i64 as strnumber;
                self.state.helpline[0 as i32 as usize] = 66479 as i64 as strnumber;
                (&mut *(self as *mut PortableTexEngine<'_>)).error()?;
            }
            14 | 15 | 16 => {
                (&mut *(self as *mut PortableTexEngine<'_>)).extrarightbrace()?;
            }
            2 => {
                (&mut *(self as *mut PortableTexEngine<'_>))
                    .zpackage(0 as i32 as smallnumber)?;
            }
            3 => {
                self.state.adjusttail = (self.state.memtop as i32 - 5 as i32)
                    as halfword;
                self.state.preadjusttail = (self.state.memtop as i32 - 14 as i32)
                    as halfword;
                (&mut *(self as *mut PortableTexEngine<'_>))
                    .zpackage(0 as i32 as smallnumber)?;
            }
            4 => {
                if (*eqtb.offset(7892323 as i64 as isize)).u.CINT > 0 as i32
                    && self.state.curlist.modefield as i32 == 105 as i32
                {
                    (&mut *(self as *mut PortableTexEngine<'_>)).backinput()?;
                    self.state.curtok = self.state.partoken;
                    (&mut *(self as *mut PortableTexEngine<'_>)).backinput()?;
                    self.state.curinput.indexfield = 5 as quarterword;
                } else {
                    (&mut *(self as *mut PortableTexEngine<'_>)).endgraf()?;
                    (&mut *(self as *mut PortableTexEngine<'_>))
                        .zpackage(0 as i32 as smallnumber)?;
                }
            }
            5 => {
                if (*eqtb.offset(7892323 as i64 as isize)).u.CINT > 0 as i32
                    && self.state.curlist.modefield as i32 == 105 as i32
                {
                    (&mut *(self as *mut PortableTexEngine<'_>)).backinput()?;
                    self.state.curtok = self.state.partoken;
                    (&mut *(self as *mut PortableTexEngine<'_>)).backinput()?;
                    self.state.curinput.indexfield = 5 as quarterword;
                } else {
                    (&mut *(self as *mut PortableTexEngine<'_>)).endgraf()?;
                    (&mut *(self as *mut PortableTexEngine<'_>))
                        .zpackage(4 as i32 as smallnumber)?;
                }
            }
            11 => {
                if (*eqtb.offset(7892323 as i64 as isize)).u.CINT > 1 as i32
                    && self.state.curlist.modefield as i32 == 105 as i32
                {
                    (&mut *(self as *mut PortableTexEngine<'_>)).backinput()?;
                    self.state.curtok = self.state.partoken;
                    (&mut *(self as *mut PortableTexEngine<'_>)).backinput()?;
                    self.state.curinput.indexfield = 5 as quarterword;
                } else {
                    (&mut *(self as *mut PortableTexEngine<'_>)).endgraf()?;
                    q = (*eqtb.offset(1205774 as i64 as isize)).hh.v.RH;
                    let ref mut fresh183 = (*mem.offset(q as isize)).hh.v.RH;
                    *fresh183 += 1;
                    d = (*eqtb.offset(9006725 as i64 as isize)).u.CINT as scaled;
                    f_0 = (*eqtb.offset(7892306 as i64 as isize)).u.CINT;
                    (&mut *(self as *mut PortableTexEngine<'_>)).unsave()?;
                    self.state.saveptr = (self.state.saveptr as i32 - 2 as i32)
                        as integer;
                    p = (&mut *(self as *mut PortableTexEngine<'_>))
                        .zvpackage(
                            (*mem.offset(self.state.curlist.headfield as isize)).hh.v.RH,
                            0 as i32,
                            1 as i32 as smallnumber,
                            1073741823 as i64 as scaled,
                        )?;
                    (&mut *(self as *mut PortableTexEngine<'_>)).popnest();
                    if (*self
                        .state
                        .savestack
                        .offset((self.state.saveptr as i32 + 0 as i32) as isize))
                        .u
                        .CINT < 255 as i32
                    {
                        (*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
                            as *mut PortableTexEngine<'_>))
                            .zgetnode(5 as i32)?;
                        self.state.curlist.tailfield = (*mem
                            .offset(self.state.curlist.tailfield as isize))
                            .hh
                            .v
                            .RH;
                        (*mem.offset(self.state.curlist.tailfield as isize)).hh.u.B0 = 3
                            as i16;
                        (*mem.offset(self.state.curlist.tailfield as isize)).hh.u.B1 = (*self
                            .state
                            .savestack
                            .offset((self.state.saveptr as i32 + 0 as i32) as isize))
                            .u
                            .CINT as i16;
                        (*mem
                            .offset(
                                (self.state.curlist.tailfield as i32 + 3 as i32) as isize,
                            ))
                            .u
                            .CINT = (*mem.offset((p as i32 + 3 as i32) as isize)).u.CINT
                            + (*mem.offset((p as i32 + 2 as i32) as isize)).u.CINT;
                        (*mem
                            .offset(
                                (self.state.curlist.tailfield as i32 + 4 as i32) as isize,
                            ))
                            .hh
                            .v
                            .LH = (*mem.offset((p as i32 + 5 as i32) as isize)).hh.v.RH;
                        (*mem
                            .offset(
                                (self.state.curlist.tailfield as i32 + 4 as i32) as isize,
                            ))
                            .hh
                            .v
                            .RH = q;
                        (*mem
                            .offset(
                                (self.state.curlist.tailfield as i32 + 2 as i32) as isize,
                            ))
                            .u
                            .CINT = d as integer;
                        (*mem
                            .offset(
                                (self.state.curlist.tailfield as i32 + 1 as i32) as isize,
                            ))
                            .u
                            .CINT = f_0;
                    } else {
                        (*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
                            as *mut PortableTexEngine<'_>))
                            .zgetnode(2 as i32)?;
                        self.state.curlist.tailfield = (*mem
                            .offset(self.state.curlist.tailfield as isize))
                            .hh
                            .v
                            .RH;
                        (*mem.offset(self.state.curlist.tailfield as isize)).hh.u.B0 = 5
                            as i16;
                        (*mem.offset(self.state.curlist.tailfield as isize)).hh.u.B1 = (*self
                            .state
                            .savestack
                            .offset((self.state.saveptr as i32 + 1 as i32) as isize))
                            .u
                            .CINT as i16;
                        (*mem
                            .offset(
                                (self.state.curlist.tailfield as i32 + 1 as i32) as isize,
                            ))
                            .u
                            .CINT = (*mem.offset((p as i32 + 5 as i32) as isize)).hh.v.RH
                            as integer;
                        (&mut *(self as *mut PortableTexEngine<'_>)).zdeleteglueref(q);
                    }
                    (&mut *(self as *mut PortableTexEngine<'_>)).zfreenode(p, 7 as i32);
                    if self.state.nestptr == 0 as i32 {
                        Self::boundary_build_page(self as *mut PortableTexEngine<'_>);
                    }
                }
            }
            8 => {
                if (*eqtb.offset(7892323 as i64 as isize)).u.CINT > 1 as i32
                    && self.state.curlist.modefield as i32 == 105 as i32
                {
                    (&mut *(self as *mut PortableTexEngine<'_>)).backinput()?;
                    self.state.curtok = self.state.partoken;
                    (&mut *(self as *mut PortableTexEngine<'_>)).backinput()?;
                    self.state.curinput.indexfield = 5 as quarterword;
                } else {
                    while self.state.curinput.statefield as i32 == 0 as i32
                        && self.state.curinput.locfield as i64 == -(268435455 as i64)
                        && self.state.curinput.indexfield as i32 == 3 as i32
                    {
                        (&mut *(self as *mut PortableTexEngine<'_>)).endtokenlist()?;
                    }
                    if self.state.curinput.statefield as i32 != 0 as i32
                        || self.state.curinput.locfield as i64 != -(268435455 as i64)
                        || self.state.curinput.indexfield as i32 != 7 as i32
                    {
                        if self.state.filelineerrorstylep != 0 {
                            (&mut *(self as *mut PortableTexEngine<'_>)).printfileline();
                        } else {
                            (&mut *(self as *mut PortableTexEngine<'_>))
                                .zprintnl(65544 as i64 as strnumber);
                        }
                        (&mut *(self as *mut PortableTexEngine<'_>))
                            .zprint(65923 as i64 as integer);
                        self.state.helpptr = 2 as eightbits;
                        self.state.helpline[1 as i32 as usize] = 66446 as i64
                            as strnumber;
                        self.state.helpline[0 as i32 as usize] = 66447 as i64
                            as strnumber;
                        (&mut *(self as *mut PortableTexEngine<'_>)).error()?;
                        loop {
                            (&mut *(self as *mut PortableTexEngine<'_>)).gettoken()?;
                            if self.state.curinput.locfield as i64 == -(268435455 as i64)
                            {
                                break;
                            }
                        }
                    }
                    self.state.outputcanend = true_0 as boolean;
                    (&mut *(self as *mut PortableTexEngine<'_>)).endtokenlist()?;
                    self.state.outputcanend = false_0 as boolean;
                    (&mut *(self as *mut PortableTexEngine<'_>)).endgraf()?;
                    (&mut *(self as *mut PortableTexEngine<'_>)).unsave()?;
                    self.state.outputactive = false_0 as boolean;
                    self.state.insertpenalties = 0 as i32 as integer;
                    if (*eqtb.offset(1206822 as i64 as isize)).hh.v.RH as i64
                        != -(268435455 as i64)
                    {
                        if self.state.filelineerrorstylep != 0 {
                            (&mut *(self as *mut PortableTexEngine<'_>)).printfileline();
                        } else {
                            (&mut *(self as *mut PortableTexEngine<'_>))
                                .zprintnl(65544 as i64 as strnumber);
                        }
                        (&mut *(self as *mut PortableTexEngine<'_>))
                            .zprint(66448 as i64 as integer);
                        (&mut *(self as *mut PortableTexEngine<'_>))
                            .zprintesc(65709 as i64 as strnumber);
                        (&mut *(self as *mut PortableTexEngine<'_>))
                            .zprintint(255 as i32);
                        self.state.helpptr = 3 as eightbits;
                        self.state.helpline[2 as i32 as usize] = 66449 as i64
                            as strnumber;
                        self.state.helpline[1 as i32 as usize] = 66450 as i64
                            as strnumber;
                        self.state.helpline[0 as i32 as usize] = 66451 as i64
                            as strnumber;
                        (&mut *(self as *mut PortableTexEngine<'_>))
                            .zboxerror(255 as i32 as eightbits)?;
                    }
                    if self.state.curlist.tailfield != self.state.curlist.headfield {
                        (*mem.offset(self.state.pagetail as isize)).hh.v.RH = (*mem
                            .offset(self.state.curlist.headfield as isize))
                            .hh
                            .v
                            .RH;
                        self.state.pagetail = self.state.curlist.tailfield;
                    }
                    if (*mem.offset((self.state.memtop as i32 - 2 as i32) as isize))
                        .hh
                        .v
                        .RH as i64 != -(268435455 as i64)
                    {
                        if (*mem.offset((self.state.memtop as i32 - 1 as i32) as isize))
                            .hh
                            .v
                            .RH as i64 == -(268435455 as i64)
                        {
                            (*self.state.nest.offset(0 as i32 as isize)).tailfield = self
                                .state
                                .pagetail;
                        }
                        (*mem.offset(self.state.pagetail as isize)).hh.v.RH = (*mem
                            .offset((self.state.memtop as i32 - 1 as i32) as isize))
                            .hh
                            .v
                            .RH;
                        (*mem.offset((self.state.memtop as i32 - 1 as i32) as isize))
                            .hh
                            .v
                            .RH = (*mem
                            .offset((self.state.memtop as i32 - 2 as i32) as isize))
                            .hh
                            .v
                            .RH;
                        (*mem.offset((self.state.memtop as i32 - 2 as i32) as isize))
                            .hh
                            .v
                            .RH = -(268435455 as i64) as halfword;
                        self.state.pagetail = (self.state.memtop as i32 - 2 as i32)
                            as halfword;
                    }
                    (&mut *(self as *mut PortableTexEngine<'_>))
                        .zflushnodelist(self.state.discptr[2 as i32 as usize])?;
                    self.state.discptr[2 as i32 as usize] = -(268435455 as i64)
                        as halfword;
                    (&mut *(self as *mut PortableTexEngine<'_>)).popnest();
                    Self::boundary_build_page(self as *mut PortableTexEngine<'_>);
                }
            }
            10 => {
                (&mut *(self as *mut PortableTexEngine<'_>)).builddiscretionary()?;
            }
            6 => {
                (&mut *(self as *mut PortableTexEngine<'_>)).backinput()?;
                self.state.curtok = 34749082 as i64 as halfword;
                if self.state.filelineerrorstylep != 0 {
                    (&mut *(self as *mut PortableTexEngine<'_>)).printfileline();
                } else {
                    (&mut *(self as *mut PortableTexEngine<'_>))
                        .zprintnl(65544 as i64 as strnumber);
                }
                (&mut *(self as *mut PortableTexEngine<'_>))
                    .zprint(65958 as i64 as integer);
                (&mut *(self as *mut PortableTexEngine<'_>))
                    .zprintesc(66327 as i64 as strnumber);
                (&mut *(self as *mut PortableTexEngine<'_>))
                    .zprint(65959 as i64 as integer);
                self.state.helpptr = 1 as eightbits;
                self.state.helpline[0 as i32 as usize] = 66560 as i64 as strnumber;
                (&mut *(self as *mut PortableTexEngine<'_>)).inserror()?;
            }
            7 => {
                if (*eqtb.offset(7892323 as i64 as isize)).u.CINT > 1 as i32
                    && self.state.curlist.modefield as i32 == 105 as i32
                {
                    (&mut *(self as *mut PortableTexEngine<'_>)).backinput()?;
                    self.state.curtok = self.state.partoken;
                    (&mut *(self as *mut PortableTexEngine<'_>)).backinput()?;
                    self.state.curinput.indexfield = 5 as quarterword;
                } else {
                    (&mut *(self as *mut PortableTexEngine<'_>)).endgraf()?;
                    (&mut *(self as *mut PortableTexEngine<'_>)).unsave()?;
                    (&mut *(self as *mut PortableTexEngine<'_>)).alignpeek()?;
                }
            }
            12 => {
                if (*eqtb.offset(7892323 as i64 as isize)).u.CINT > 0 as i32
                    && self.state.curlist.modefield as i32 == 105 as i32
                {
                    (&mut *(self as *mut PortableTexEngine<'_>)).backinput()?;
                    self.state.curtok = self.state.partoken;
                    (&mut *(self as *mut PortableTexEngine<'_>)).backinput()?;
                    self.state.curinput.indexfield = 5 as quarterword;
                } else {
                    (&mut *(self as *mut PortableTexEngine<'_>)).endgraf()?;
                    (&mut *(self as *mut PortableTexEngine<'_>)).unsave()?;
                    self.state.saveptr = (self.state.saveptr as i32 - 2 as i32)
                        as integer;
                    p = (&mut *(self as *mut PortableTexEngine<'_>))
                        .zvpackage(
                            (*mem.offset(self.state.curlist.headfield as isize)).hh.v.RH,
                            (*self
                                .state
                                .savestack
                                .offset((self.state.saveptr as i32 + 1 as i32) as isize))
                                .u
                                .CINT,
                            (*self
                                .state
                                .savestack
                                .offset((self.state.saveptr as i32 + 0 as i32) as isize))
                                .u
                                .CINT as smallnumber,
                            1073741823 as i64 as scaled,
                        )?;
                    (&mut *(self as *mut PortableTexEngine<'_>)).popnest();
                    (*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
                        as *mut PortableTexEngine<'_>))
                        .newnoad()?;
                    self.state.curlist.tailfield = (*mem
                        .offset(self.state.curlist.tailfield as isize))
                        .hh
                        .v
                        .RH;
                    (*mem.offset(self.state.curlist.tailfield as isize)).hh.u.B0 = 29
                        as i16;
                    (*mem
                        .offset(
                            (self.state.curlist.tailfield as i32 + 1 as i32) as isize,
                        ))
                        .hh
                        .v
                        .RH = 2 as i32 as halfword;
                    (*mem
                        .offset(
                            (self.state.curlist.tailfield as i32 + 1 as i32) as isize,
                        ))
                        .hh
                        .v
                        .LH = p;
                }
            }
            13 => {
                (&mut *(self as *mut PortableTexEngine<'_>)).buildchoices()?;
            }
            9 => {
                Self::src_scan_math_group_close(self as *mut PortableTexEngine<'_>);
                (&mut *(self as *mut PortableTexEngine<'_>)).unsave()?;
                self.state.saveptr -= 1;
                (*mem
                    .offset(
                        (*self
                            .state
                            .savestack
                            .offset((self.state.saveptr as i32 + 0 as i32) as isize))
                            .u
                            .CINT as isize,
                    ))
                    .hh
                    .v
                    .RH = 3 as i32 as halfword;
                p = (&mut *(self as *mut PortableTexEngine<'_>))
                    .zfinmlist(-(268435455 as i64) as halfword)?;
                (*mem
                    .offset(
                        (*self
                            .state
                            .savestack
                            .offset((self.state.saveptr as i32 + 0 as i32) as isize))
                            .u
                            .CINT as isize,
                    ))
                    .hh
                    .v
                    .LH = p;
                Self::src_construct_extend_to_loc(self as *mut PortableTexEngine<'_>);
                if p as i64 != -(268435455 as i64) {
                    if (*mem.offset(p as isize)).hh.v.RH as i64 == -(268435455 as i64) {
                        if (*mem.offset(p as isize)).hh.u.B0 as i32 == 16 as i32 {
                            if (*mem.offset((p as i32 + 3 as i32) as isize)).hh.v.RH
                                == 0 as i32
                            {
                                if (*mem.offset((p as i32 + 2 as i32) as isize)).hh.v.RH
                                    == 0 as i32
                                {
                                    (*mem
                                        .offset(
                                            (*self
                                                .state
                                                .savestack
                                                .offset((self.state.saveptr as i32 + 0 as i32) as isize))
                                                .u
                                                .CINT as isize,
                                        ))
                                        .hh = (*mem.offset((p as i32 + 1 as i32) as isize)).hh;
                                    Self::src_carry_collapse(
                                        self as *mut PortableTexEngine<'_>,
                                        p,
                                        (*self
                                            .state
                                            .savestack
                                            .offset((self.state.saveptr as i32 + 0 as i32) as isize))
                                            .u
                                            .CINT,
                                    );
                                    (&mut *(self as *mut PortableTexEngine<'_>))
                                        .zfreenode(p, 4 as i32);
                                }
                            }
                        } else if (*mem.offset(p as isize)).hh.u.B0 as i32 == 28 as i32 {
                            if (*self
                                .state
                                .savestack
                                .offset((self.state.saveptr as i32 + 0 as i32) as isize))
                                .u
                                .CINT == self.state.curlist.tailfield as i32 + 1 as i32
                            {
                                if (*mem.offset(self.state.curlist.tailfield as isize))
                                    .hh
                                    .u
                                    .B0 as i32 == 16 as i32
                                {
                                    q = self.state.curlist.headfield;
                                    while (*mem.offset(q as isize)).hh.v.RH
                                        != self.state.curlist.tailfield
                                    {
                                        q = (*mem.offset(q as isize)).hh.v.RH;
                                    }
                                    (*mem.offset(q as isize)).hh.v.RH = p;
                                    (&mut *(self as *mut PortableTexEngine<'_>))
                                        .zfreenode(self.state.curlist.tailfield, 4 as i32);
                                    self.state.curlist.tailfield = p;
                                }
                            }
                        }
                    }
                }
            }
            _ => {
                match (&mut *(self as *mut PortableTexEngine<'_>))
                    .zconfusion(66480 as i64 as strnumber)?
                {};
            }
        };
        Ok(())
    }
    pub(crate) unsafe fn headforvmode(&mut self) -> EngineFlow<()> {
        if (self.state.curlist.modefield as i32) < 0 as i32 {
            if self.state.curcmd as i32 != 36 as i32 {
                (&mut *(self as *mut PortableTexEngine<'_>)).offsave()?;
            } else {
                if self.state.filelineerrorstylep != 0 {
                    (&mut *(self as *mut PortableTexEngine<'_>)).printfileline();
                } else {
                    (&mut *(self as *mut PortableTexEngine<'_>))
                        .zprintnl(65544 as i64 as strnumber);
                }
                (&mut *(self as *mut PortableTexEngine<'_>))
                    .zprint(66034 as i64 as integer);
                (&mut *(self as *mut PortableTexEngine<'_>))
                    .zprintesc(65836 as i64 as strnumber);
                (&mut *(self as *mut PortableTexEngine<'_>))
                    .zprint(66516 as i64 as integer);
                self.state.helpptr = 2 as eightbits;
                self.state.helpline[1 as i32 as usize] = 66517 as i64 as strnumber;
                self.state.helpline[0 as i32 as usize] = 66518 as i64 as strnumber;
                (&mut *(self as *mut PortableTexEngine<'_>)).error()?;
            }
        } else {
            (&mut *(self as *mut PortableTexEngine<'_>)).backinput()?;
            self.state.curtok = self.state.partoken;
            (&mut *(self as *mut PortableTexEngine<'_>)).backinput()?;
            self.state.curinput.indexfield = 5 as quarterword;
        };
        Ok(())
    }
    pub(crate) unsafe fn hyphenate(&mut self) -> EngineFlow<()> {
        let mut current_block: u64;
        let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
        let eqtb = self.state.zeqtb.as_mut_ptr();
        let mut i: i16 = 0;
        let mut j: i16 = 0;
        let mut l_0: i16 = 0;
        let mut q: halfword = 0;
        let mut r: halfword = 0;
        let mut s: halfword = 0;
        let mut bchar_0: halfword = 0;
        let mut majortail: halfword = 0;
        let mut minortail: halfword = 0;
        let mut c_0: UnicodeScalar = 0;
        let mut cloc: i16 = 0;
        let mut rcount: integer = 0;
        let mut hyfnode: halfword = 0;
        let mut z: triepointer = 0;
        let mut v: integer = 0;
        let mut h: hyphpointer = 0;
        let mut k: strnumber = 0;
        let mut u: poolpointer = 0;
        let mut for_end: integer = 0;
        j = 0 as i16;
        for_end = self.state.hn as integer;
        if j as i32 <= for_end {
            loop {
                self.state.hyf[j as usize] = 0 as eightbits;
                let fresh145 = j;
                j = j + 1;
                if !((fresh145 as i32) < for_end) {
                    break;
                }
            }
        }
        h = self.state.hc[1 as i32 as usize] as hyphpointer;
        self.state.hn += 1;
        self.state.hc[self.state.hn as usize] = self.state.curlang as integer;
        let mut for_end_0: integer = 0;
        j = 2 as i16;
        for_end_0 = self.state.hn as integer;
        if j as i32 <= for_end_0 {
            loop {
                h = ((h as i32 + h as i32 + self.state.hc[j as usize]) % 607 as i32)
                    as hyphpointer;
                let fresh146 = j;
                j = j + 1;
                if !((fresh146 as i32) < for_end_0) {
                    break;
                }
            }
        }
        loop {
            k = *self.state.hyphword.offset(h as isize);
            if k == 0 as i32 {
                current_block = 16309950401822844224;
                break;
            }
            if (&mut *(self as *mut PortableTexEngine<'_>)).zlength(k)
                == self.state.hn as i32
            {
                j = 1 as i16;
                u = *self.state.strstart.offset((k as i64 - 65536 as i64) as isize);
                loop {
                    if *self.state.strpool.offset(u as isize) as i32
                        != self.state.hc[j as usize]
                    {
                        current_block = 5494826135382683477;
                        break;
                    }
                    j += 1;
                    u += 1;
                    if j as i32 > self.state.hn as i32 {
                        current_block = 7172762164747879670;
                        break;
                    }
                }
                match current_block {
                    5494826135382683477 => {}
                    _ => {
                        s = *self.state.hyphlist.offset(h as isize);
                        while s as i64 != -(268435455 as i64) {
                            self.state.hyf[(*mem.offset(s as isize)).hh.v.LH as usize] = 1
                                as eightbits;
                            s = (*mem.offset(s as isize)).hh.v.RH;
                        }
                        self.state.hn -= 1;
                        current_block = 13227940548865458082;
                        break;
                    }
                }
            }
            h = *self.state.hyphlink.offset(h as isize);
            if h as i32 == 0 as i32 {
                current_block = 16309950401822844224;
                break;
            }
            h = h.wrapping_sub(1);
        }
        match current_block {
            16309950401822844224 => {
                self.state.hn -= 1;
                if *self
                    .state
                    .trietrc
                    .offset((self.state.curlang as i32 + 1 as i32) as isize) as i32
                    != self.state.curlang as i32
                {
                    return Ok(());
                }
                self.state.hc[0 as i32 as usize] = 0 as i32 as integer;
                self.state.hc[(self.state.hn as i32 + 1 as i32) as usize] = 0 as i32
                    as integer;
                self.state.hc[(self.state.hn as i32 + 2 as i32) as usize] = self
                    .state
                    .maxhyphchar;
                let mut for_end_1: integer = 0;
                j = 0 as i16;
                for_end_1 = (self.state.hn as i32 - self.state.rhyf as i32 + 1 as i32)
                    as integer;
                if j as i32 <= for_end_1 {
                    loop {
                        z = (*self
                            .state
                            .trietrl
                            .offset((self.state.curlang as i32 + 1 as i32) as isize)
                            as integer + self.state.hc[j as usize]) as triepointer;
                        l_0 = j;
                        while self.state.hc[l_0 as usize]
                            == *self.state.trietrc.offset(z as isize) as i32
                        {
                            if *self.state.trietro.offset(z as isize) != mintrieop {
                                v = *self.state.trietro.offset(z as isize) as integer;
                                loop {
                                    v = v + self.state.opstart[self.state.curlang as usize];
                                    i = (l_0 as i32 - self.state.hyfdistance[v as usize] as i32)
                                        as i16;
                                    if self.state.hyfnum[v as usize] as i32
                                        > self.state.hyf[i as usize] as i32
                                    {
                                        self.state.hyf[i as usize] = self.state.hyfnum[v as usize]
                                            as eightbits;
                                    }
                                    v = self.state.hyfnext[v as usize] as integer;
                                    if v == mintrieop {
                                        break;
                                    }
                                }
                            }
                            l_0 += 1;
                            z = (*self.state.trietrl.offset(z as isize) as integer
                                + self.state.hc[l_0 as usize]) as triepointer;
                        }
                        let fresh147 = j;
                        j = j + 1;
                        if !((fresh147 as i32) < for_end_1) {
                            break;
                        }
                    }
                }
            }
            _ => {}
        }
        let mut for_end_2: integer = 0;
        j = 0 as i16;
        for_end_2 = (self.state.lhyf as i32 - 1 as i32) as integer;
        if j as i32 <= for_end_2 {
            loop {
                self.state.hyf[j as usize] = 0 as eightbits;
                let fresh148 = j;
                j = j + 1;
                if !((fresh148 as i32) < for_end_2) {
                    break;
                }
            }
        }
        let mut for_end_3: integer = 0;
        j = 0 as i16;
        for_end_3 = (self.state.rhyf as i32 - 1 as i32) as integer;
        if j as i32 <= for_end_3 {
            loop {
                self.state.hyf[(self.state.hn as i32 - j as i32) as usize] = 0
                    as eightbits;
                let fresh149 = j;
                j = j + 1;
                if !((fresh149 as i32) < for_end_3) {
                    break;
                }
            }
        }
        let mut for_end_4: integer = 0;
        j = self.state.lhyf as i16;
        for_end_4 = self.state.hn as integer - self.state.rhyf;
        if j as i32 <= for_end_4 {
            current_block = 18038362259723567392;
        } else {
            current_block = 12961834331865314435;
        }
        loop {
            match current_block {
                12961834331865314435 => return Ok(()),
                _ => {
                    if self.state.hyf[j as usize] as i32 & 1 as i32 != 0 {
                        break;
                    }
                    let fresh150 = j;
                    j = j + 1;
                    if (fresh150 as i32) < for_end_4 {
                        current_block = 18038362259723567392;
                    } else {
                        current_block = 12961834331865314435;
                    }
                }
            }
        }
        if self.state.ha as i64 != -(268435455 as i64)
            && !(self.state.ha >= self.state.himemmin)
            && (*mem.offset(self.state.ha as isize)).hh.u.B0 as i32 == 8 as i32
            && ((*mem.offset(self.state.ha as isize)).hh.u.B1 as i32 >= 40 as i32
                && (*mem.offset(self.state.ha as isize)).hh.u.B1 as i32 <= 41 as i32)
        {
            s = self.state.curp;
            while (*mem.offset(s as isize)).hh.v.RH != self.state.ha {
                s = (*mem.offset(s as isize)).hh.v.RH;
            }
            self.state.hyphenpassed = 0 as smallnumber;
            let mut for_end_5: integer = 0;
            j = self.state.lhyf as i16;
            for_end_5 = self.state.hn as integer - self.state.rhyf;
            if j as i32 <= for_end_5 {
                loop {
                    if self.state.hyf[j as usize] as i32 & 1 as i32 != 0 {
                        q = (&mut *(self as *mut PortableTexEngine<'_>))
                            .znewnativewordnode(
                                self.state.hf,
                                j as i32 - self.state.hyphenpassed as i32,
                            )?;
                        (*mem.offset(q as isize)).hh.u.B1 = (*mem
                            .offset(self.state.ha as isize))
                            .hh
                            .u
                            .B1;
                        let mut for_end_6: integer = 0;
                        i = 0 as i16;
                        for_end_6 = (j as i32 - self.state.hyphenpassed as i32
                            - 1 as i32) as integer;
                        if i as i32 <= for_end_6 {
                            loop {
                                *(mem.offset((q as i32 + native_node_size) as isize)
                                    as *mut memoryword as *mut u16)
                                    .offset(i as isize) = *(mem
                                    .offset((self.state.ha as i32 + 6 as i32) as isize)
                                    as *mut memoryword as *mut u16)
                                    .offset(
                                        (i as i32 + self.state.hyphenpassed as i32) as isize,
                                    );
                                let fresh151 = i;
                                i = i + 1;
                                if !((fresh151 as i32) < for_end_6) {
                                    break;
                                }
                            }
                        }
                        Self::measure_native_node(
                            self as *mut PortableTexEngine<'resources>,
                            mem.offset(q as isize) as *mut memoryword as *mut (),
                            ((*eqtb.offset(7892342 as i64 as isize)).u.CINT > 0 as i32)
                                as i32,
                        );
                        (*mem.offset(s as isize)).hh.v.RH = q;
                        s = q;
                        q = (&mut *(self as *mut PortableTexEngine<'_>)).newdisc()?;
                        (*mem.offset((q as i32 + 1 as i32) as isize)).hh.v.LH = (&mut *(self
                            as *mut PortableTexEngine<'_>))
                            .znewnativecharacter(self.state.hf, self.state.hyfchar)?;
                        (*mem.offset(s as isize)).hh.v.RH = q;
                        s = q;
                        self.state.hyphenpassed = j as smallnumber;
                    }
                    let fresh152 = j;
                    j = j + 1;
                    if !((fresh152 as i32) < for_end_5) {
                        break;
                    }
                }
            }
            self.state.hn = ((*mem.offset((self.state.ha as i32 + 4 as i32) as isize))
                .v
                .QQQQ
                .u
                .B2) as i32 as smallnumber;
            q = (&mut *(self as *mut PortableTexEngine<'_>))
                .znewnativewordnode(
                    self.state.hf,
                    self.state.hn as i32 - self.state.hyphenpassed as i32,
                )?;
            (*mem.offset(q as isize)).hh.u.B1 = (*mem.offset(self.state.ha as isize))
                .hh
                .u
                .B1;
            let mut for_end_7: integer = 0;
            i = 0 as i16;
            for_end_7 = (self.state.hn as i32 - self.state.hyphenpassed as i32
                - 1 as i32) as integer;
            if i as i32 <= for_end_7 {
                loop {
                    *(mem.offset((q as i32 + native_node_size) as isize)
                        as *mut memoryword as *mut u16)
                        .offset(i as isize) = *(mem
                        .offset((self.state.ha as i32 + 6 as i32) as isize)
                        as *mut memoryword as *mut u16)
                        .offset((i as i32 + self.state.hyphenpassed as i32) as isize);
                    let fresh153 = i;
                    i = i + 1;
                    if !((fresh153 as i32) < for_end_7) {
                        break;
                    }
                }
            }
            Self::measure_native_node(
                self as *mut PortableTexEngine<'resources>,
                mem.offset(q as isize) as *mut memoryword as *mut (),
                ((*eqtb.offset(7892342 as i64 as isize)).u.CINT > 0 as i32) as i32,
            );
            (*mem.offset(s as isize)).hh.v.RH = q;
            s = q;
            q = (*mem.offset(self.state.ha as isize)).hh.v.RH;
            (*mem.offset(s as isize)).hh.v.RH = q;
            (*mem.offset(self.state.ha as isize)).hh.v.RH = -(268435455 as i64)
                as halfword;
            (&mut *(self as *mut PortableTexEngine<'_>)).zflushnodelist(self.state.ha)?;
        } else {
            q = (*mem.offset(self.state.hb as isize)).hh.v.RH;
            (*mem.offset(self.state.hb as isize)).hh.v.RH = -(268435455 as i64)
                as halfword;
            r = (*mem.offset(self.state.ha as isize)).hh.v.RH;
            (*mem.offset(self.state.ha as isize)).hh.v.RH = -(268435455 as i64)
                as halfword;
            bchar_0 = self.state.hyfbchar;
            if self.state.ha >= self.state.himemmin {
                if (*mem.offset(self.state.ha as isize)).hh.u.B0 as i32 != self.state.hf
                {
                    current_block = 369919793395225485;
                } else {
                    self.state.initlist = self.state.ha;
                    self.state.initlig = false_0 as boolean;
                    self.state.hu[0 as i32 as usize] = (*mem
                        .offset(self.state.ha as isize))
                        .hh
                        .u
                        .B1 as integer;
                    current_block = 10256747982273457880;
                }
            } else if (*mem.offset(self.state.ha as isize)).hh.u.B0 as i32 == 6 as i32 {
                if (*mem.offset((self.state.ha as i32 + 1 as i32) as isize)).hh.u.B0
                    as i32 != self.state.hf
                {
                    current_block = 369919793395225485;
                } else {
                    self.state.initlist = (*mem
                        .offset((self.state.ha as i32 + 1 as i32) as isize))
                        .hh
                        .v
                        .RH;
                    self.state.initlig = true_0 as boolean;
                    self.state.initlft = ((*mem.offset(self.state.ha as isize)).hh.u.B1
                        as i32 > 1 as i32) as i32 as boolean;
                    self.state.hu[0 as i32 as usize] = (*mem
                        .offset((self.state.ha as i32 + 1 as i32) as isize))
                        .hh
                        .u
                        .B1 as integer;
                    if self.state.initlist as i64 == -(268435455 as i64) {
                        if self.state.initlft != 0 {
                            self.state.hu[0 as i32 as usize] = self.state.maxhyphchar;
                            self.state.initlig = false_0 as boolean;
                        }
                    }
                    (&mut *(self as *mut PortableTexEngine<'_>))
                        .zfreenode(self.state.ha, 2 as i32);
                    current_block = 10256747982273457880;
                }
            } else {
                if !(r >= self.state.himemmin) {
                    if (*mem.offset(r as isize)).hh.u.B0 as i32 == 6 as i32 {
                        if (*mem.offset(r as isize)).hh.u.B1 as i32 > 1 as i32 {
                            current_block = 369919793395225485;
                        } else {
                            current_block = 11702799181856929651;
                        }
                    } else {
                        current_block = 11702799181856929651;
                    }
                } else {
                    current_block = 11702799181856929651;
                }
                match current_block {
                    369919793395225485 => {}
                    _ => {
                        j = 1 as i16;
                        s = self.state.ha;
                        self.state.initlist = -(268435455 as i64) as halfword;
                        current_block = 2906951988409343122;
                    }
                }
            }
            match current_block {
                10256747982273457880 => {
                    s = self.state.curp;
                    while (*mem.offset(s as isize)).hh.v.RH != self.state.ha {
                        s = (*mem.offset(s as isize)).hh.v.RH;
                    }
                    j = 0 as i16;
                }
                369919793395225485 => {
                    s = self.state.ha;
                    j = 0 as i16;
                    self.state.hu[0 as i32 as usize] = self.state.maxhyphchar;
                    self.state.initlig = false_0 as boolean;
                    self.state.initlist = -(268435455 as i64) as halfword;
                }
                _ => {}
            }
            (&mut *(self as *mut PortableTexEngine<'_>)).zflushnodelist(r)?;
            loop {
                l_0 = j;
                j = ((&mut *(self as *mut PortableTexEngine<'_>))
                    .zreconstitute(
                        j as smallnumber,
                        self.state.hn as smallnumber,
                        bchar_0,
                        self.state.hyfchar,
                    )? as i32 + 1 as i32) as i16;
                if self.state.hyphenpassed as i32 == 0 as i32 {
                    (*mem.offset(s as isize)).hh.v.RH = (*mem
                        .offset((self.state.memtop as i32 - 4 as i32) as isize))
                        .hh
                        .v
                        .RH;
                    while (*mem.offset(s as isize)).hh.v.RH as i64 > -(268435455 as i64)
                    {
                        s = (*mem.offset(s as isize)).hh.v.RH;
                    }
                    if self.state.hyf[(j as i32 - 1 as i32) as usize] as i32 & 1 as i32
                        != 0
                    {
                        l_0 = j;
                        self.state.hyphenpassed = (j as i32 - 1 as i32) as smallnumber;
                        (*mem.offset((self.state.memtop as i32 - 4 as i32) as isize))
                            .hh
                            .v
                            .RH = -(268435455 as i64) as halfword;
                    }
                }
                if self.state.hyphenpassed as i32 > 0 as i32 {
                    loop {
                        r = (&mut *(self as *mut PortableTexEngine<'_>))
                            .zgetnode(2 as i32)?;
                        (*mem.offset(r as isize)).hh.v.RH = (*mem
                            .offset((self.state.memtop as i32 - 4 as i32) as isize))
                            .hh
                            .v
                            .RH;
                        (*mem.offset(r as isize)).hh.u.B0 = 7 as i16;
                        majortail = r;
                        rcount = 0 as i32 as integer;
                        while (*mem.offset(majortail as isize)).hh.v.RH as i64
                            > -(268435455 as i64)
                        {
                            majortail = (*mem.offset(majortail as isize)).hh.v.RH;
                            rcount += 1;
                        }
                        i = self.state.hyphenpassed as i16;
                        self.state.hyf[i as usize] = 0 as eightbits;
                        minortail = -(268435455 as i64) as halfword;
                        (*mem.offset((r as i32 + 1 as i32) as isize)).hh.v.LH = -(268435455
                            as i64) as halfword;
                        hyfnode = (&mut *(self as *mut PortableTexEngine<'_>))
                            .znewcharacter(
                                self.state.hf,
                                self.state.hyfchar as UTF16code,
                            )?;
                        if hyfnode as i64 != -(268435455 as i64) {
                            i += 1;
                            c_0 = self.state.hu[i as usize] as UnicodeScalar;
                            self.state.hu[i as usize] = self.state.hyfchar;
                            (*mem.offset(hyfnode as isize)).hh.v.RH = self.state.avail;
                            self.state.avail = hyfnode;
                            self.state.dynused -= 1;
                        }
                        while l_0 as i32 <= i as i32 {
                            l_0 = ((&mut *(self as *mut PortableTexEngine<'_>))
                                .zreconstitute(
                                    l_0 as smallnumber,
                                    i as smallnumber,
                                    *self.state.fontbchar.offset(self.state.hf as isize)
                                        as halfword,
                                    65536 as i64 as halfword,
                                )? as i32 + 1 as i32) as i16;
                            if (*mem
                                .offset((self.state.memtop as i32 - 4 as i32) as isize))
                                .hh
                                .v
                                .RH as i64 > -(268435455 as i64)
                            {
                                if minortail as i64 == -(268435455 as i64) {
                                    (*mem.offset((r as i32 + 1 as i32) as isize)).hh.v.LH = (*mem
                                        .offset((self.state.memtop as i32 - 4 as i32) as isize))
                                        .hh
                                        .v
                                        .RH;
                                } else {
                                    (*mem.offset(minortail as isize)).hh.v.RH = (*mem
                                        .offset((self.state.memtop as i32 - 4 as i32) as isize))
                                        .hh
                                        .v
                                        .RH;
                                }
                                minortail = (*mem
                                    .offset((self.state.memtop as i32 - 4 as i32) as isize))
                                    .hh
                                    .v
                                    .RH;
                                while (*mem.offset(minortail as isize)).hh.v.RH as i64
                                    > -(268435455 as i64)
                                {
                                    minortail = (*mem.offset(minortail as isize)).hh.v.RH;
                                }
                            }
                        }
                        if hyfnode as i64 != -(268435455 as i64) {
                            self.state.hu[i as usize] = c_0 as integer;
                            l_0 = i;
                            i -= 1;
                        }
                        minortail = -(268435455 as i64) as halfword;
                        (*mem.offset((r as i32 + 1 as i32) as isize)).hh.v.RH = -(268435455
                            as i64) as halfword;
                        cloc = 0 as i16;
                        if *self.state.bcharlabel.offset(self.state.hf as isize)
                            != 0 as i32
                        {
                            l_0 -= 1;
                            c_0 = self.state.hu[l_0 as usize] as UnicodeScalar;
                            cloc = l_0;
                            self.state.hu[l_0 as usize] = self.state.maxhyphchar;
                        }
                        while (l_0 as i32) < j as i32 {
                            loop {
                                l_0 = ((&mut *(self as *mut PortableTexEngine<'_>))
                                    .zreconstitute(
                                        l_0 as smallnumber,
                                        self.state.hn as smallnumber,
                                        bchar_0,
                                        65536 as i64 as halfword,
                                    )? as i32 + 1 as i32) as i16;
                                if cloc as i32 > 0 as i32 {
                                    self.state.hu[cloc as usize] = c_0 as integer;
                                    cloc = 0 as i16;
                                }
                                if (*mem
                                    .offset((self.state.memtop as i32 - 4 as i32) as isize))
                                    .hh
                                    .v
                                    .RH as i64 > -(268435455 as i64)
                                {
                                    if minortail as i64 == -(268435455 as i64) {
                                        (*mem.offset((r as i32 + 1 as i32) as isize)).hh.v.RH = (*mem
                                            .offset((self.state.memtop as i32 - 4 as i32) as isize))
                                            .hh
                                            .v
                                            .RH;
                                    } else {
                                        (*mem.offset(minortail as isize)).hh.v.RH = (*mem
                                            .offset((self.state.memtop as i32 - 4 as i32) as isize))
                                            .hh
                                            .v
                                            .RH;
                                    }
                                    minortail = (*mem
                                        .offset((self.state.memtop as i32 - 4 as i32) as isize))
                                        .hh
                                        .v
                                        .RH;
                                    while (*mem.offset(minortail as isize)).hh.v.RH as i64
                                        > -(268435455 as i64)
                                    {
                                        minortail = (*mem.offset(minortail as isize)).hh.v.RH;
                                    }
                                }
                                if l_0 as i32 >= j as i32 {
                                    break;
                                }
                            }
                            while l_0 as i32 > j as i32 {
                                j = ((&mut *(self as *mut PortableTexEngine<'_>))
                                    .zreconstitute(
                                        j as smallnumber,
                                        self.state.hn as smallnumber,
                                        bchar_0,
                                        65536 as i64 as halfword,
                                    )? as i32 + 1 as i32) as i16;
                                (*mem.offset(majortail as isize)).hh.v.RH = (*mem
                                    .offset((self.state.memtop as i32 - 4 as i32) as isize))
                                    .hh
                                    .v
                                    .RH;
                                while (*mem.offset(majortail as isize)).hh.v.RH as i64
                                    > -(268435455 as i64)
                                {
                                    majortail = (*mem.offset(majortail as isize)).hh.v.RH;
                                    rcount += 1;
                                }
                            }
                        }
                        if rcount > 127 as i32 {
                            (*mem.offset(s as isize)).hh.v.RH = (*mem.offset(r as isize))
                                .hh
                                .v
                                .RH;
                            (*mem.offset(r as isize)).hh.v.RH = -(268435455 as i64)
                                as halfword;
                            (&mut *(self as *mut PortableTexEngine<'_>))
                                .zflushnodelist(r)?;
                        } else {
                            (*mem.offset(s as isize)).hh.v.RH = r;
                            (*mem.offset(r as isize)).hh.u.B1 = rcount as i16;
                        }
                        s = majortail;
                        self.state.hyphenpassed = (j as i32 - 1 as i32) as smallnumber;
                        (*mem.offset((self.state.memtop as i32 - 4 as i32) as isize))
                            .hh
                            .v
                            .RH = -(268435455 as i64) as halfword;
                        if !(self.state.hyf[(j as i32 - 1 as i32) as usize] as i32
                            & 1 as i32 != 0)
                        {
                            break;
                        }
                    }
                }
                if j as i32 > self.state.hn as i32 {
                    break;
                }
            }
            (*mem.offset(s as isize)).hh.v.RH = q;
            (&mut *(self as *mut PortableTexEngine<'_>)).zflushlist(self.state.initlist);
        };
        Ok(())
    }
}