#![allow(dead_code, non_camel_case_types, non_snake_case, unused_assignments, unused_must_use, 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 => {
self.state.interaction as i32 == 3 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(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
{
self.state.interaction as i32 == 3 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)
{
self.state.interaction as i32 == 3 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(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;
self.state.interaction as i32 == 3 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(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 {
self.state.interaction as i32 == 3 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(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 {
if self.state.curcmd as i32 == 15 as i32 {
let mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let head = self.state.curlist.headfield;
let first = (*mem.offset(head as isize)).hh.v.RH;
(*mem.offset(head as isize)).hh.v.RH = -(268435455 as i64) as halfword;
self.state.curlist.tailfield = head;
if first != -(268435455 as i64) as halfword {
(&mut *(self as *mut PortableTexEngine<'_>)).zflushnodelist(first)?;
}
}
(&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(())
}
}