From def6d5bb71c412ffcb3c5c9390537621382fae66 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 12 Nov 2026 17:16:54 -0800 Subject: [PATCH 01/13] chore(quest): claim quest/m0/nightly-bump.md Quest-Claim: 2157d1a20ef95679 From 4d7f8f0f6f952f4e365757a1b9504adde95a9643 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 12 Nov 2026 17:55:21 -0800 Subject: [PATCH 02/13] chore: bump the rustc nightly to 2026-11-12 and port the drivers Co-Authored-By: Claude Opus 5.5 --- driver/src/bin/rust2-lint/mono.rs | 37 +++++++---- ffi/src/collect.rs | 100 ++++++++++++++---------------- flake.lock | 6 +- go/src/lower/body.rs | 4 +- go/src/lower/consts.rs | 2 +- go/src/lower/hand.rs | 6 +- go/src/lower/library.rs | 4 +- go/src/lower/split.rs | 2 +- go/src/lower/ty.rs | 4 +- ts/rust-toolchain.toml | 2 +- ts/src/lower/array_slice.rs | 2 +- ts/src/lower/bind.rs | 22 ++++--- ts/src/lower/body.rs | 10 +-- ts/src/lower/collections.rs | 14 +++-- ts/src/lower/consts.rs | 2 +- ts/src/lower/copy.rs | 32 +++++----- ts/src/lower/defined.rs | 14 ++--- ts/src/lower/drop.rs | 14 ++--- ts/src/lower/dynamic.rs | 20 +++--- ts/src/lower/fmt.rs | 10 +-- ts/src/lower/iter.rs | 18 +++--- ts/src/lower/lend.rs | 21 ++++--- ts/src/lower/library.rs | 36 ++++++----- ts/src/lower/mir/alloc.rs | 5 +- ts/src/lower/mir/call.rs | 16 ++--- ts/src/lower/mir/coroutine.rs | 6 +- ts/src/lower/mir/decided.rs | 2 +- ts/src/lower/mir/holders.rs | 38 ++++++------ ts/src/lower/mir/mod.rs | 8 +-- ts/src/lower/mir/origin.rs | 12 ++-- ts/src/lower/mir/place.rs | 42 ++++++------- ts/src/lower/mir/rvalue.rs | 16 ++--- ts/src/lower/mir/scalar.rs | 4 +- ts/src/lower/mod.rs | 40 ++++++------ ts/src/lower/names.rs | 12 ++-- ts/src/lower/pointer.rs | 22 +++---- ts/src/lower/smallvec.rs | 6 +- ts/src/lower/task.rs | 4 +- ts/src/lower/tokio.rs | 10 +-- ts/src/lower/unions.rs | 26 +++----- 40 files changed, 330 insertions(+), 321 deletions(-) diff --git a/driver/src/bin/rust2-lint/mono.rs b/driver/src/bin/rust2-lint/mono.rs index 14a68c1d7..2d2ecebcd 100644 --- a/driver/src/bin/rust2-lint/mono.rs +++ b/driver/src/bin/rust2-lint/mono.rs @@ -5,12 +5,13 @@ //! part of the copy of the function that defines it. A generic fails when that total //! exceeds its budget, unless every copy is thin enough to only forward. -use rustc_ast::LitKind; -use rustc_attr_ir::Attribute; +use rustc_ast::token::Delimiter; +use rustc_ast::{LitKind, MetaItemKind}; +use rustc_attr_ir::{AttrArgs, AttrItem, Attribute}; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_hir::def::DefKind; use rustc_middle::mono::{CollectionMode, MonoItem}; -use rustc_middle::ty::{GenericArgsRef, Instance, InstanceKind, TyCtxt}; +use rustc_middle::ty::{GenericArgs, Instance, InstanceKind, TyCtxt}; use rustc_span::def_id::DefId; use rustc_span::{Span, Symbol}; @@ -30,7 +31,7 @@ const ATTRIBUTE: [&str; 2] = ["rust2", "mono_budget"]; struct Cost<'tcx> { /// The MIR statements of each copy, its closures' included, by the generic's arguments: /// a closure's own arguments start with them. - copies: FxHashMap, u64>, + copies: FxHashMap, u64>, } impl Cost<'_> { @@ -147,9 +148,9 @@ fn callers<'tcx>( /// The budget `generic`'s own attribute sets, if it has one. fn limit(tcx: TyCtxt<'_>, generic: DefId) -> Option> { - let attr = tcx.get_attrs_by_path(generic, &ATTRIBUTE.map(Symbol::intern)).next()?; + let attr = tcx.tool_attrs(generic, &ATTRIBUTE.map(Symbol::intern)).next()?; Some(parse(attr).map_err(|err| { - tcx.dcx().span_err(attr.span(), err); + tcx.dcx().span_err(attr.span, err); })) } @@ -160,12 +161,16 @@ pub fn check_attributes(tcx: TyCtxt<'_>) { let [tool, name] = ATTRIBUTE.map(Symbol::intern); for owner in tcx.hir_crate_items(()).owners() { for (local_id, attrs) in tcx.hir_attr_map(owner).map.iter() { - for attr in attrs.iter().filter(|attr| attr.path().first() == Some(&tool)) { - let path = attr.path(); - if path.as_slice() != [tool, name] { + let tools = attrs.iter().filter_map(|attr| match attr { + Attribute::Tool(item) => Some(&**item), + _ => None, + }); + for attr in tools.filter(|attr| attr.path.segments.first() == Some(&tool)) { + let path = &attr.path.segments; + if **path != [tool, name] { let path: Vec<&str> = path.iter().map(Symbol::as_str).collect(); tcx.dcx() - .span_err(attr.span(), format!("unknown attribute `{}`", path.join("::"))); + .span_err(attr.span, format!("unknown attribute `{}`", path.join("::"))); continue; } let def = owner.def_id.to_def_id(); @@ -177,7 +182,7 @@ pub fn check_attributes(tcx: TyCtxt<'_>) { false => Err(format!("`{}` goes on a generic function", ATTRIBUTE.join("::"))), }; if let Err(err) = checked { - tcx.dcx().span_err(attr.span(), err); + tcx.dcx().span_err(attr.span, err); } } } @@ -185,10 +190,16 @@ pub fn check_attributes(tcx: TyCtxt<'_>) { } /// The limit a budget attribute sets. -fn parse(attr: &Attribute) -> Result { +fn parse(attr: &AttrItem) -> Result { let mut limit = None; let mut reason = false; - for item in attr.meta_item_list().unwrap_or_default() { + let list = match &attr.args { + AttrArgs::Delimited(args) if args.delim == Delimiter::Parenthesis => { + MetaItemKind::list_from_tokens(args.tokens.clone()) + } + _ => None, + }; + for item in list.unwrap_or_default() { let arg = item .meta_item() .and_then(|meta| Some((meta.name()?, &meta.name_value_literal()?.kind))); diff --git a/ffi/src/collect.rs b/ffi/src/collect.rs index e2a8b1b08..23df95a83 100644 --- a/ffi/src/collect.rs +++ b/ffi/src/collect.rs @@ -20,7 +20,8 @@ use rustc_infer::traits::util::elaborate; use rustc_infer::traits::{Obligation, ObligationCause}; use rustc_middle::ty::fast_reject::{TreatParams, simplify_type}; use rustc_middle::ty::{ - self, GenericArgKind, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor, TypingEnv, + self, CallerBoundsIterator as _, GenericArgKind, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, + TypeVisitor, TypingEnv, }; use rustc_span::{DUMMY_SP, Span, sym}; use rustc_trait_selection::infer::InferCtxtExt; @@ -134,7 +135,7 @@ enum Decl { #[derive(Clone, Copy, PartialEq, Eq, Hash)] struct Key<'tcx> { def_id: DefId, - args: Option>, + args: Option>, } /// A type the export declares, and how it names it. @@ -142,7 +143,7 @@ struct Key<'tcx> { struct Site<'tcx> { key: Key<'tcx>, /// Its generic arguments as exported, each lifetime `'static`. - args: ty::GenericArgsRef<'tcx>, + args: ty::GenericArgs<'tcx>, /// How many of its type and const arguments it is named by: each up to the last that is not its /// default, as Rust spells it. explicit: usize, @@ -155,7 +156,7 @@ struct Site<'tcx> { /// The arguments a function exports at: an instance, if a type parameter exports at /// several types. struct Instantiation<'tcx> { - args: ty::GenericArgsRef<'tcx>, + args: ty::GenericArgs<'tcx>, /// The type parameters that stay parameters, each taking a lent closure or a foreign /// implementation, which typing maps. kept: Vec>, @@ -549,13 +550,13 @@ impl<'tcx> Collector<'tcx> { } /// The key of `def_id` at `args`: an instance's, if it takes type parameters. - fn key(&self, def_id: DefId, args: ty::GenericArgsRef<'tcx>) -> Key<'tcx> { + fn key(&self, def_id: DefId, args: ty::GenericArgs<'tcx>) -> Key<'tcx> { let args = self.typed(def_id).then(|| self.tcx.erase_and_anonymize_regions(args)); Key { def_id, args } } /// How the type `def_id` is exported at `args`. - fn decl(&self, def_id: DefId, args: ty::GenericArgsRef<'tcx>) -> Option<&Decl> { + fn decl(&self, def_id: DefId, args: ty::GenericArgs<'tcx>) -> Option<&Decl> { self.decls.get(&self.key(def_id, args)) } @@ -592,7 +593,7 @@ impl<'tcx> Collector<'tcx> { /// How many of `def_id`'s type and const arguments `args` names it by, as Rust spells /// it: each up to the last that is not its default. - fn explicit(&self, def_id: DefId, args: ty::GenericArgsRef<'tcx>) -> usize { + fn explicit(&self, def_id: DefId, args: ty::GenericArgs<'tcx>) -> usize { let tcx = self.tcx; let params: Vec<&ty::GenericParamDef> = (tcx.generics_of(def_id).own_params.iter()) .filter(|p| !matches!(p.kind, ty::GenericParamDefKind::Lifetime)) @@ -614,7 +615,7 @@ impl<'tcx> Collector<'tcx> { } /// The first `explicit` type and const arguments of `args`, which name an instance. - fn shown_args(args: ty::GenericArgsRef<'tcx>, explicit: usize) -> Vec> { + fn shown_args(args: ty::GenericArgs<'tcx>, explicit: usize) -> Vec> { let named = args .iter() .filter(|arg| !matches!(arg.kind(), GenericArgKind::Lifetime(_))); @@ -659,8 +660,8 @@ impl<'tcx> Collector<'tcx> { Some((_, path)) => path.join("::"), None => tcx.def_path_str(adt.did()), }; - let explicit = self.explicit(adt.did(), args); - let args: Vec = (Self::shown_args(args, explicit).into_iter()) + let explicit = self.explicit(adt.did(), *args); + let args: Vec = (Self::shown_args(*args, explicit).into_iter()) .map(|arg| self.spell_arg(arg)) .collect(); match args.is_empty() { @@ -868,7 +869,7 @@ impl<'tcx> Collector<'tcx> { /// The types a function's signature names, bounds included, at each instantiation it /// is not excluded at. - fn instantiated(&mut self, def_id: DefId, shown: &Path, parent: Option>) -> Vec> { + fn instantiated(&mut self, def_id: DefId, shown: &Path, parent: Option>) -> Vec> { let tcx = self.tcx; let mut named = Vec::new(); for instance in self.instantiate(def_id, parent).unwrap_or_default() { @@ -908,7 +909,7 @@ impl<'tcx> Collector<'tcx> { /// Each type a function's signature names at `args`, normalized, with what a returned /// future resolves to. A type holding a foreign future names no instance: the future /// that holds it, as `Timeout` does, is polled, never a handle. - fn spelled(&self, def_id: DefId, args: ty::GenericArgsRef<'tcx>) -> Vec> { + fn spelled(&self, def_id: DefId, args: ty::GenericArgs<'tcx>) -> Vec> { let tcx = self.tcx; let env = TypingEnv::post_analysis(tcx, def_id); let normalize = |ty: Ty<'tcx>| { @@ -1683,7 +1684,7 @@ impl<'tcx> Collector<'tcx> { let ty::Adt(inner, inner_args) = ty.kind() else { continue; }; - let key = self.key(inner.did(), inner_args); + let key = self.key(inner.did(), *inner_args); if !matches!(self.decls.get(&key), Some(Decl::Record(_) | Decl::Enum(_))) { continue; } @@ -1691,7 +1692,7 @@ impl<'tcx> Collector<'tcx> { return true; } if seen.insert(key) { - stack.push((inner.did(), inner_args)); + stack.push((inner.did(), *inner_args)); } } } @@ -2128,7 +2129,7 @@ impl<'tcx> Collector<'tcx> { /// the arguments of its impl, the path reports show it by, and whether it is /// `doc(hidden)`. One whose own bounds fail at the instance is none of its methods, as /// is each of an impl whose bounds fail. - fn members(&mut self, site: &Site<'tcx>) -> Vec<(ty::AssocItem, ty::GenericArgsRef<'tcx>, Path, bool)> { + fn members(&mut self, site: &Site<'tcx>) -> Vec<(ty::AssocItem, ty::GenericArgs<'tcx>, Path, bool)> { let tcx = self.tcx; let self_ty = self.site_ty(site); let mut members = Vec::new(); @@ -2157,9 +2158,9 @@ impl<'tcx> Collector<'tcx> { /// The arguments an inherent impl applies to `self_ty` at, if it does: its type /// parameters as `self_ty` fixes them, its lifetimes as they are, and its bounds met. - fn impl_args(&self, imp: DefId, self_ty: Ty<'tcx>) -> Option> { + fn impl_args(&self, imp: DefId, self_ty: Ty<'tcx>) -> Option> { let tcx = self.tcx; - let mut args = ty::GenericArgs::identity_for_item(tcx, imp).to_vec(); + let mut args = ty::GenericArgs::identity_for_item(tcx, imp).as_slice().to_vec(); let pattern = tcx.type_of(imp).instantiate_identity().skip_norm_wip(); if !matches(tcx, pattern, self_ty, &mut args) { return None; @@ -2176,10 +2177,10 @@ impl<'tcx> Collector<'tcx> { /// Whether an impl item's bounds hold with the impl's parameters at `parent`. A bound on /// the item's own type parameters is the choice of a type for each. - fn applies(&self, item: DefId, parent: ty::GenericArgsRef<'tcx>) -> bool { + fn applies(&self, item: DefId, parent: ty::GenericArgs<'tcx>) -> bool { let tcx = self.tcx; - let mut args = ty::GenericArgs::identity_for_item(tcx, item).to_vec(); - args[..parent.len()].copy_from_slice(parent); + let mut args = ty::GenericArgs::identity_for_item(tcx, item).as_slice().to_vec(); + args[..parent.len()].copy_from_slice(parent.as_slice()); self.holds(item, tcx.mk_args(&args), &[]) } @@ -2257,7 +2258,7 @@ impl<'tcx> Collector<'tcx> { path: &Path, shown: &Path, self_ty: Option>, - parent: Option>, + parent: Option>, ) -> Vec<(Result>, Path, bool)> { let instances = match self.instantiate(def_id, parent) { Ok(instances) => instances, @@ -2292,8 +2293,8 @@ impl<'tcx> Collector<'tcx> { // it for. let mut impls = Vec::new(); for ¶m in &instance.kept { - let taken = (self.closure(def_id, param, args)) - .or_else(|| self.reader(def_id, param, args)) + let taken = (self.closure(def_id, param, args.as_slice())) + .or_else(|| self.reader(def_id, param, args.as_slice())) .unwrap_or_else(|| { let callback = self.taken(def_id, param).expect("a kept parameter takes a callback"); Ok(Type::Callback(callback, Dyn::Impl)) @@ -2370,7 +2371,7 @@ impl<'tcx> Collector<'tcx> { let lendable = match unbound.inputs().first().map(|ty| ty.kind()) { Some(&ty::Ref(region, inner, ty::Mutability::Not)) if has_self - && matches!(inner.kind(), ty::Adt(adt, args) if matches!(self.decl(adt.did(), args), Some(Decl::Object(_)))) => + && matches!(inner.kind(), ty::Adt(adt, args) if matches!(self.decl(adt.did(), *args), Some(Decl::Object(_)))) => { let regions: Vec<_> = (unbound.output().walk()).filter_map(|arg| arg.as_region()).collect(); !regions.is_empty() @@ -2385,7 +2386,7 @@ impl<'tcx> Collector<'tcx> { let written: Vec<_> = (unbound.inputs().iter()) .filter_map(|input| match input.kind() { ty::Ref(region, inner, ty::Mutability::Mut) - if !matches!(inner.kind(), ty::Adt(adt, args) if matches!(self.decl(adt.did(), args), Some(Decl::Object(_)))) => + if !matches!(inner.kind(), ty::Adt(adt, args) if matches!(self.decl(adt.did(), *args), Some(Decl::Object(_)))) => { Some(*region) } @@ -2556,7 +2557,7 @@ impl<'tcx> Collector<'tcx> { Some(ty::Upcast::upcast(ty::TraitRef::new(tcx, tr, [param]), tcx)) }); let kept = TypingEnv::new( - ty::ParamEnv::new(tcx, env.param_env.caller_bounds().chain(marked)), + ty::ParamEnv::new(tcx, env.param_env.caller_bounds().all_clauses(tcx).iter().chain(marked)), env.typing_mode(), ); if !self.is_send(output, kept) { @@ -2669,15 +2670,15 @@ impl<'tcx> Collector<'tcx> { fn instantiate( &self, def_id: DefId, - parent: Option>, + parent: Option>, ) -> Result>, Vec> { let tcx = self.tcx; let generics = tcx.generics_of(def_id); let identity = ty::GenericArgs::identity_for_item(tcx, def_id); - let mut args: Vec> = identity.to_vec(); + let mut args: Vec> = identity.as_slice().to_vec(); let count = generics.parent_count; if let Some(parent) = parent { - args[..count].copy_from_slice(parent); + args[..count].copy_from_slice(parent.as_slice()); } let base = args.clone(); let mut kept = Vec::new(); @@ -2776,7 +2777,7 @@ impl<'tcx> Collector<'tcx> { .collect(); let unmet = self.unmet(def_id, choices[0].0, &kept); let instances: Vec> = (choices.into_iter()) - .filter(|(args, _)| self.holds(def_id, args, &kept)) + .filter(|(args, _)| self.holds(def_id, *args, &kept)) .map(|(args, named)| Instantiation { args, kept: kept.clone(), @@ -2791,7 +2792,7 @@ impl<'tcx> Collector<'tcx> { /// Whether `def_id`'s bounds hold at `args`, with `kept` the parameters kept for what /// the call passes. - fn holds(&self, def_id: DefId, args: ty::GenericArgsRef<'tcx>, kept: &[Ty<'tcx>]) -> bool { + fn holds(&self, def_id: DefId, args: ty::GenericArgs<'tcx>, kept: &[Ty<'tcx>]) -> bool { self.unmet(def_id, args, kept).is_none() } @@ -2801,7 +2802,7 @@ impl<'tcx> Collector<'tcx> { /// bound naming a kept parameter must hold for each type passed for it, as the item's /// own environment proves: `B: From` holds for every `U: Callback` only through an /// impl for each. - fn unmet(&self, def_id: DefId, args: ty::GenericArgsRef<'tcx>, kept: &[Ty<'tcx>]) -> Option> { + fn unmet(&self, def_id: DefId, args: ty::GenericArgs<'tcx>, kept: &[Ty<'tcx>]) -> Option> { let tcx = self.tcx; let env = TypingEnv::post_analysis(tcx, def_id); let (infcx, param_env) = tcx.infer_ctxt().build_with_typing_env(env); @@ -2861,7 +2862,7 @@ impl<'tcx> Collector<'tcx> { let string = tcx .lang_items() .string() - .map(|string| Ty::new_adt(tcx, tcx.adt_def(string), ty::List::empty())); + .map(|string| Ty::new_adt(tcx, tcx.adt_def(string), ty::GenericArgs::empty())); let mut candidates = Vec::new(); let implied = (implied.iter()) .filter_map(|clause| clause.as_trait_clause()) @@ -2918,7 +2919,7 @@ impl<'tcx> Collector<'tcx> { } candidates.extend(string.map(|ty| (ty, None))); if let Some(bytes) = self.bytes { - candidates.push((Ty::new_adt(tcx, tcx.adt_def(bytes), ty::List::empty()), None)); + candidates.push((Ty::new_adt(tcx, tcx.adt_def(bytes), ty::GenericArgs::empty()), None)); } candidates.extend(self.vec_of(tcx.types.u8).map(|ty| (ty, None))); // `impl Into>` takes a `String` too, which maps where `Arc` does not. @@ -2966,7 +2967,7 @@ impl<'tcx> Collector<'tcx> { let tcx = self.tcx; (self.foreign.iter()) .find(|&&(ty, _)| tcx.crate_name(ty.krate).as_str() == "serde_json") - .map(|&(ty, _)| Ty::new_adt(tcx, tcx.adt_def(ty), ty::List::empty())) + .map(|&(ty, _)| Ty::new_adt(tcx, tcx.adt_def(ty), ty::GenericArgs::empty())) } /// The `Item` that `clauses` bind `param`'s `IntoIterator` to, if it names no type @@ -3147,7 +3148,7 @@ impl<'tcx> Collector<'tcx> { param: Ty<'tcx>, base: &[ty::GenericArg<'tcx>], candidate: Ty<'tcx>, - ) -> Option> { + ) -> Option> { let tcx = self.tcx; let ty::Param(p) = param.kind() else { unreachable!("a generic type argument is a parameter"); @@ -3212,7 +3213,7 @@ impl<'tcx> Collector<'tcx> { let named = (spelled(args).into_iter().filter_map(exported)) .filter(|(_, args)| !args.has_non_region_param()) .all(|(adt, args)| { - let key = self.key(adt, args); + let key = self.key(adt, *args); match self.inferring { true => self.instances.iter().any(|site| site.key == key), false => matches!( @@ -3262,7 +3263,7 @@ impl<'tcx> Collector<'tcx> { .filter_map(exported) .filter(|(_, args)| !args.has_non_region_param()) .all(|(adt, args)| { - let key = self.key(adt, args); + let key = self.key(adt, *args); match self.inferring { true => self.instances.iter().any(|site| site.key == key), false => matches!( @@ -3541,7 +3542,7 @@ impl<'tcx> Collector<'tcx> { let tcx = self.tcx; let vec = tcx.get_diagnostic_item(sym::Vec)?; let alloc = tcx.lang_items().global_alloc_ty()?; - let alloc = Ty::new_adt(tcx, tcx.adt_def(alloc), ty::List::empty()); + let alloc = Ty::new_adt(tcx, tcx.adt_def(alloc), ty::GenericArgs::empty()); Some(Ty::new_adt( tcx, tcx.adt_def(vec), @@ -3868,7 +3869,7 @@ impl<'tcx> Collector<'tcx> { for ty in ty.walk().filter_map(|arg| arg.as_type()) { match ty.kind() { ty::Ref(region, ..) => lent.push(*region), - ty::Adt(adt, args) if matches!(self.decl(adt.did(), args), Some(Decl::Object(_))) => { + ty::Adt(adt, args) if matches!(self.decl(adt.did(), *args), Some(Decl::Object(_))) => { held.extend(args.regions()) } // An `impl Future` holds what its bounds name, as an `async fn` its output. @@ -3943,7 +3944,7 @@ impl<'tcx> Collector<'tcx> { let tcx = self.tcx; ty.walk().filter_map(|arg| arg.as_type()).any(|ty| match ty.kind() { ty::Adt(adt, args) => { - let object = matches!(self.decl(adt.did(), args), Some(Decl::Object(_))) + let object = matches!(self.decl(adt.did(), *args), Some(Decl::Object(_))) || self.foreign.iter().any(|&(ty, _)| ty == adt.did()); object && !implements(tcx, ty, adt.did(), sym::Copy) } @@ -4022,7 +4023,7 @@ impl<'tcx> Collector<'tcx> { && tcx.adt_destructor(did).is_none() && adt .all_fields() - .all(|field| self.shares(field.ty(tcx, args).skip_norm_wip(), env, seen)) + .all(|field| self.shares(field.ty(tcx, *args).skip_norm_wip(), env, seen)) } } _ => false, @@ -4101,12 +4102,7 @@ impl<'tcx> Collector<'tcx> { /// A constant: a C constant if a `bool` or integer, or else a function returning it, /// which the caller adds. One of an instance's impl, at its `parent` arguments, is /// always a function, as its value may differ by instance. - fn constant_item( - &mut self, - def_id: DefId, - path: Path, - parent: Option>, - ) -> Option { + fn constant_item(&mut self, def_id: DefId, path: Path, parent: Option>) -> Option { let tcx = self.tcx; let span = tcx.def_span(def_id); let ty = match parent { @@ -4435,7 +4431,7 @@ impl<'tcx> Collector<'tcx> { } else if !self.exported(did.krate) { return Err(why("foreign type", strip_args(tcx, did))); } else { - let key = self.key(did, args); + let key = self.key(did, *args); // An instance is named as its key would spell it. let name = match key.args { Some(_) => self.spell(ty), @@ -4787,7 +4783,7 @@ fn docs(tcx: TyCtxt<'_>, def_id: DefId) -> String { let attrs = tcx.get_all_attrs(def_id); let lines: Vec = attrs .iter() - .filter_map(|attr| attr.doc_str()) + .filter_map(|attr| rustc_ast::attr::AttributeExt::doc_str_and_fragment_kind(attr).map(|(doc, ..)| doc)) .flat_map(|doc| { doc.as_str() .lines() @@ -4811,7 +4807,7 @@ fn must_outlive<'tcx>(implied: &[ty::Clause<'tcx>], param: Ty<'tcx>) -> bool { /// Whether a bound on another type names `param`, such as `T: From`. fn mentions<'tcx>(clause: ty::Clause<'tcx>, param: Ty<'tcx>) -> bool { let args: Vec> = match (clause.as_trait_clause(), clause.as_projection_clause()) { - (Some(pred), _) => pred.skip_binder().trait_ref.args.to_vec(), + (Some(pred), _) => pred.skip_binder().trait_ref.args.as_slice().to_vec(), (_, Some(pred)) => (pred.skip_binder().projection_term.args.iter()) .chain(pred.skip_binder().term.as_type().map(Into::into)) .collect(), @@ -4886,7 +4882,7 @@ fn matches<'tcx>(tcx: TyCtxt<'tcx>, pattern: Ty<'tcx>, ty: Ty<'tcx>, args: &mut } /// A type's own generic arguments as it is exported: its lifetimes `'static`. -fn statics<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> ty::GenericArgsRef<'tcx> { +fn statics<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> ty::GenericArgs<'tcx> { ty::GenericArgs::for_item(tcx, def_id, |param, _| match param.kind { ty::GenericParamDefKind::Lifetime => tcx.lifetimes.re_static.into(), _ => tcx.mk_param_from_def(param), diff --git a/flake.lock b/flake.lock index f6c8e9def..485b92162 100644 --- a/flake.lock +++ b/flake.lock @@ -134,11 +134,11 @@ ] }, "locked": { - "lastModified": 1793348683, - "narHash": "sha256-qv+P8z2xS5Xdws5Kigvr/WKJiaJSa6Ke8iH7ozmO53w=", + "lastModified": 1794518310, + "narHash": "sha256-NmwbbRaUf/AoY+NoJimXOdjlbkwl6+aDbe8nodaaZzY=", "owner": "oxalica", "repo": "rust-overlay", - "rev": "96a0986b0486341fbc163fa2fabc6d3b44cdcbf1", + "rev": "8bbfc858c7b85f5e6ed6d6cc201ffcee1bb08a9b", "type": "github" }, "original": { diff --git a/go/src/lower/body.rs b/go/src/lower/body.rs index ede99b563..3ae384ced 100644 --- a/go/src/lower/body.rs +++ b/go/src/lower/body.rs @@ -1017,7 +1017,7 @@ impl<'a, 'tcx> Fx<'a, 'tcx> { if active.is_some() { return self.err(span, "a union"); } - self.adt_lit(adt, *variant, args, &values, &go, span) + self.adt_lit(adt, *variant, *args, &values, &go, span) } _ => self.err(span, format!("the aggregate `{kind:?}`")), } @@ -1029,7 +1029,7 @@ impl<'a, 'tcx> Fx<'a, 'tcx> { &mut self, adt: ty::AdtDef<'tcx>, variant: rustc_abi::VariantIdx, - args: ty::GenericArgsRef<'tcx>, + args: ty::GenericArgs<'tcx>, values: &[String], go: &str, span: Span, diff --git a/go/src/lower/consts.rs b/go/src/lower/consts.rs index 0b10ffaec..3edabeba8 100644 --- a/go/src/lower/consts.rs +++ b/go/src/lower/consts.rs @@ -53,7 +53,7 @@ impl<'a, 'tcx> Fx<'a, 'tcx> { return match ty.kind() { ty::Adt(adt, args) => { let variant = d.variant.unwrap_or(rustc_abi::FIRST_VARIANT); - self.adt_lit(*adt, variant, args, &values, &go, span) + self.adt_lit(*adt, variant, *args, &values, &go, span) } _ => format!("{go}{{{}}}", values.join(", ")), }; diff --git a/go/src/lower/hand.rs b/go/src/lower/hand.rs index e326199dd..6e840db09 100644 --- a/go/src/lower/hand.rs +++ b/go/src/lower/hand.rs @@ -111,13 +111,13 @@ impl<'tcx> Translator<'tcx> { } /// The slice a `slice::Iter` with `args` walks, whose first is the slice's lifetime. - fn iter_slice(&self, args: ty::GenericArgsRef<'tcx>) -> Ty<'tcx> { + fn iter_slice(&self, args: ty::GenericArgs<'tcx>) -> Ty<'tcx> { let elem = args.types().next().expect("a slice iterator's element type"); Ty::new_slice(self.tcx, elem) } /// A field's type at `args`. - fn mono_field_ty(&self, field: &ty::FieldDef, args: ty::GenericArgsRef<'tcx>) -> Ty<'tcx> { + fn mono_field_ty(&self, field: &ty::FieldDef, args: ty::GenericArgs<'tcx>) -> Ty<'tcx> { let fty = field.ty(self.tcx, args).skip_norm_wip(); self.tcx .normalize_erasing_regions(TypingEnv::fully_monomorphized(), Unnormalized::new_wip(fty)) @@ -248,7 +248,7 @@ impl<'tcx> Translator<'tcx> { fn hand_adt( &mut self, adt: AdtDef<'tcx>, - args: ty::GenericArgsRef<'tcx>, + args: ty::GenericArgs<'tcx>, hand: Hand, body: &mut Vec, span: Span, diff --git a/go/src/lower/library.rs b/go/src/lower/library.rs index fd6cc0684..2c720595e 100644 --- a/go/src/lower/library.rs +++ b/go/src/lower/library.rs @@ -107,7 +107,7 @@ fn refused_in<'tcx>(tcx: TyCtxt<'tcx>, env: TypingEnv<'tcx>, ty: Ty<'tcx>, seen: return Some(format!("which runs `{}`'s `Drop` impl,", path(tcx, adt.did()))); } for field in adt.all_fields() { - let fty = field.ty(tcx, args).skip_norm_wip(); + let fty = field.ty(tcx, *args).skip_norm_wip(); let fty = tcx.normalize_erasing_regions(env, ty::Unnormalized::new_wip(fty)); if let Some(why) = refused_in(tcx, env, fty, seen) { return Some(why); @@ -608,7 +608,7 @@ fn intrinsic<'tcx>( let layout = tcx.layout_of(fx.t_env().as_query_input(ty)).ok()?; let n = match name.as_str() { "size_of" => layout.size.bytes(), - _ => layout.align.abi.bytes(), + _ => layout.align.bytes(), }; expr(format!("uint({n})")) } diff --git a/go/src/lower/split.rs b/go/src/lower/split.rs index 7483aa8e6..3d8bc103a 100644 --- a/go/src/lower/split.rs +++ b/go/src/lower/split.rs @@ -177,7 +177,7 @@ impl<'tcx> Translator<'tcx> { } /// A field's monomorphic type. - fn field_of(&self, field: &ty::FieldDef, args: ty::GenericArgsRef<'tcx>) -> Ty<'tcx> { + fn field_of(&self, field: &ty::FieldDef, args: ty::GenericArgs<'tcx>) -> Ty<'tcx> { let fty = field.ty(self.tcx, args).skip_norm_wip(); self.tcx .normalize_erasing_regions(self.env(), ty::Unnormalized::new_wip(fty)) diff --git a/go/src/lower/ty.rs b/go/src/lower/ty.rs index 8ad6c4f74..255d1521a 100644 --- a/go/src/lower/ty.rs +++ b/go/src/lower/ty.rs @@ -116,7 +116,7 @@ impl<'tcx> Translator<'tcx> { &mut self, mapped: Mapped, ty: Ty<'tcx>, - args: ty::GenericArgsRef<'tcx>, + args: ty::GenericArgs<'tcx>, span: Span, generic: bool, ) -> String { @@ -250,7 +250,7 @@ impl<'tcx> Translator<'tcx> { } /// A field's Go type in its ADT's declaration, over the ADT's type parameters. - fn field_ty(&mut self, field: DefId, identity: ty::GenericArgsRef<'tcx>, span: Span) -> String { + fn field_ty(&mut self, field: DefId, identity: ty::GenericArgs<'tcx>, span: Span) -> String { let tcx = self.tcx; let fty = tcx.type_of(field).instantiate(tcx, identity).skip_norm_wip(); let fty = diff --git a/ts/rust-toolchain.toml b/ts/rust-toolchain.toml index 23fab2486..1af7bb4cd 100644 --- a/ts/rust-toolchain.toml +++ b/ts/rust-toolchain.toml @@ -2,7 +2,7 @@ # The driver links rustc's internal crates, which only a nightly's rustc-dev ships, and # their API changes every release: pin one. Scoped to ts/, whose own workspace this is; # flake.nix reads this file for the dev shell's RUST2_TS_TOOLCHAIN. -channel = "nightly-2026-10-15" +channel = "nightly-2026-11-12" components = ["rustc-dev", "llvm-tools", "rust-src", "rustfmt", "clippy"] # Translation type-checks for wasm32, whose 32-bit usize is the one a JS number holds. targets = ["wasm32-unknown-unknown"] diff --git a/ts/src/lower/array_slice.rs b/ts/src/lower/array_slice.rs index f7af00439..abcbcdf24 100644 --- a/ts/src/lower/array_slice.rs +++ b/ts/src/lower/array_slice.rs @@ -20,7 +20,7 @@ pub fn of_arrays(ty: Ty<'_>) -> bool { /// Whether std's `def_id` of `args` is a method of a slice of arrays the runtime's own /// functions map, which take and lend the arrays where the slice holds them. -pub fn native<'tcx>(tcx: TyCtxt<'tcx>, def_id: rustc_hir::def_id::DefId, args: ty::GenericArgsRef<'tcx>) -> bool { +pub fn native<'tcx>(tcx: TyCtxt<'tcx>, def_id: rustc_hir::def_id::DefId, args: ty::GenericArgs<'tcx>) -> bool { let Some((owner, name)) = library::key(tcx, def_id) else { return false; }; diff --git a/ts/src/lower/bind.rs b/ts/src/lower/bind.rs index 5540e5ecc..f6790f72f 100644 --- a/ts/src/lower/bind.rs +++ b/ts/src/lower/bind.rs @@ -10,7 +10,7 @@ use std::path::{Component, Path, PathBuf}; use rustc_hir::def::{DefKind, Res}; use rustc_hir::def_id::{CRATE_DEF_ID, DefId}; use rustc_metadata::creader::CStore; -use rustc_middle::ty::{self, Instance, InstanceKind, TyCtxt, TypeVisitableExt}; +use rustc_middle::ty::{self, CallerBoundsIterator as _, Instance, InstanceKind, TyCtxt, TypeVisitableExt}; use rustc_span::Span; use super::{Translator, camel, names}; @@ -231,7 +231,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } /// The symbol of a bound type, from its binding's file. `span` is where `args` reach it. - pub fn bound_type(&mut self, adt: ty::AdtDef<'tcx>, args: ty::GenericArgsRef<'tcx>, span: Span) -> Option { + pub fn bound_type(&mut self, adt: ty::AdtDef<'tcx>, args: ty::GenericArgs<'tcx>, span: Span) -> Option { let def_id = adt.did(); let drop = self.bound_drops(def_id)?; // What it holds drops only where it does. @@ -361,13 +361,17 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { _ => None, }) .collect(); - tcx.param_env(def_id).caller_bounds().find_map(|clause| { - let pred = clause.as_trait_clause()?.skip_binder(); - match pred.self_ty().kind() { - ty::Param(p) if !held.contains(&p.index) && !tcx.is_sizedness_trait(pred.def_id()) => Some(p.name), - _ => None, - } - }) + tcx.param_env(def_id) + .caller_bounds() + .all_clauses(tcx) + .iter() + .find_map(|clause| { + let pred = clause.as_trait_clause()?.skip_binder(); + match pred.self_ty().kind() { + ty::Param(p) if !held.contains(&p.index) && !tcx.is_sizedness_trait(pred.def_id()) => Some(p.name), + _ => None, + } + }) } /// A symbol of a binding's file, named as the file exports it, which reaches the file. diff --git a/ts/src/lower/body.rs b/ts/src/lower/body.rs index 69bbadec4..2e3a067a5 100644 --- a/ts/src/lower/body.rs +++ b/ts/src/lower/body.rs @@ -2,7 +2,7 @@ //! through it, to the crate's own functions, constructors, and std's. use rustc_data_structures::fx::FxHashSet; -use rustc_middle::ty::{self, GenericArgsRef, Instance, Ty, TypeVisitableExt}; +use rustc_middle::ty::{self, GenericArgs, Instance, Ty, TypeVisitableExt}; use rustc_span::Span; use super::library; @@ -90,7 +90,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { pub fn call_def( &mut self, def_id: rustc_hir::def_id::DefId, - gargs: GenericArgsRef<'tcx>, + gargs: GenericArgs<'tcx>, args: Vec, span: Span, out: &mut Vec, @@ -191,7 +191,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { fn library_call( &mut self, def_id: rustc_hir::def_id::DefId, - gargs: GenericArgsRef<'tcx>, + gargs: GenericArgs<'tcx>, instance: Instance<'tcx>, args: Vec, span: Span, @@ -261,7 +261,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { fn ctor( &mut self, def_id: rustc_hir::def_id::DefId, - gargs: GenericArgsRef<'tcx>, + gargs: GenericArgs<'tcx>, args: Vec, span: Span, ) -> Expr { @@ -425,7 +425,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { /// A function item as a value, typed as one: a declared function's `()` result is `void`, /// which a value's type says is `undefined`. - pub fn fn_value(&mut self, def_id: rustc_hir::def_id::DefId, gargs: GenericArgsRef<'tcx>, span: Span) -> Expr { + pub fn fn_value(&mut self, def_id: rustc_hir::def_id::DefId, gargs: GenericArgs<'tcx>, span: Span) -> Expr { let tcx = self.t.tcx; let sig = self.t.sig(def_id, gargs); // A constructor makes its value, as a call of it does. diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index 3e4d61652..7e89b943d 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -9,7 +9,7 @@ //! stores is its own copy, as in Rust. use rustc_hir::def_id::DefId; -use rustc_middle::ty::{self, GenericArgsRef, Instance, Ty}; +use rustc_middle::ty::{self, CallerBoundsIterator as _, GenericArgs, Instance, Ty}; use rustc_span::Span; use super::Translator; @@ -416,7 +416,7 @@ fn lookup_ty<'tcx>(b: &Body<'_, '_, 'tcx>, std: Std, call: &Call<'tcx>, owner: & ) => { let tcx = b.t.tcx; let imp = tcx.inherent_impl_of_assoc(call.def_id)?; - call.args[tcx.generics_of(imp).count()..] + call.args.as_slice()[tcx.generics_of(imp).count()..] .iter() .find_map(|a| a.as_type()) } @@ -549,7 +549,7 @@ fn impl_self_ty<'tcx>(b: &Body<'_, '_, 'tcx>, call: &Call<'tcx>) -> Ty<'tcx> { let generics = tcx.generics_of(imp).count(); let ty = tcx .type_of(imp) - .instantiate(tcx, &call.args[..generics]) + .instantiate(tcx, &call.args.as_slice()[..generics]) .skip_norm_wip(); tcx.instantiate_bound_regions_with_erased(ty::Binder::dummy(ty)) } @@ -598,7 +598,7 @@ fn peel_by<'tcx>( b: &Body<'_, '_, 'tcx>, f: DefId, mut ty: Ty<'tcx>, - args: impl Fn(Ty<'tcx>) -> GenericArgsRef<'tcx>, + args: impl Fn(Ty<'tcx>) -> GenericArgs<'tcx>, ) -> Ty<'tcx> { while let Some(inner) = pointee(b, ty) && !own_impl(b, f, args(ty)) @@ -636,7 +636,7 @@ fn peel_hash<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>, hasher: Ty<'tcx>) -> Ty } /// Whether `f` with `args` resolves to an impl other than std's. -fn own_impl<'tcx>(b: &Body<'_, '_, 'tcx>, f: DefId, args: GenericArgsRef<'tcx>) -> bool { +fn own_impl<'tcx>(b: &Body<'_, '_, 'tcx>, f: DefId, args: GenericArgs<'tcx>) -> bool { let tcx = b.t.tcx; Instance::try_resolve(tcx, b.t.typing_env_pub(), f, args) .ok() @@ -1739,7 +1739,7 @@ fn own_ord<'tcx>( || !derived("PartialEq", "eq", &[ty.into(), ty.into()]) || adt .all_fields() - .any(|f| own_ord(b, f.ty(tcx, args).skip_norm_wip(), seen)) + .any(|f| own_ord(b, f.ty(tcx, *args).skip_norm_wip(), seen)) } // Which compare nothing they name. ty::RawPtr(..) | ty::FnPtr(..) => false, @@ -3014,6 +3014,8 @@ fn range_input<'tcx>(b: &Body<'_, '_, 'tcx>, call: &Call<'tcx>) -> (usize, Ty<'t let (input, target) = tcx .param_env(call.def_id) .caller_bounds() + .all_clauses(tcx) + .iter() .find_map(|clause| { let tr = clause.as_trait_clause()?.skip_binder().trait_ref; let input = sig.inputs().iter().position(|&ty| ty == tr.self_ty())?; diff --git a/ts/src/lower/consts.rs b/ts/src/lower/consts.rs index c846f4f31..f9b25cf82 100644 --- a/ts/src/lower/consts.rs +++ b/ts/src/lower/consts.rs @@ -211,7 +211,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { match info.repr { AdtRepr::Struct { ctor, fields } => { let values = (def.fields.iter().zip(values)) - .map(|(field, v)| self.t.field_value(v, adt.did(), field.did, args, span)) + .map(|(field, v)| self.t.field_value(v, adt.did(), field.did, *args, span)) .collect(); self.t.construct(info.sym, &ctor, &fields, values) } diff --git a/ts/src/lower/copy.rs b/ts/src/lower/copy.rs index a60b22a18..771d7c2aa 100644 --- a/ts/src/lower/copy.rs +++ b/ts/src/lower/copy.rs @@ -90,7 +90,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } Some(_) => return false, None if self.own(adt.did()) && adt.all_fields().next().is_some() => { - (true, adt.all_fields().map(|f| self.field_ty(f.did, args)).collect()) + (true, adt.all_fields().map(|f| self.field_ty(f.did, *args)).collect()) } None => return false, }, @@ -231,7 +231,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { Some(inline) => inline.fields.into_iter().find_map(|(_, t)| self.opaque(t)), None => Some(ty), }, - None => adt.all_fields().find_map(|f| self.opaque(self.field_ty(f.did, args))), + None => adt.all_fields().find_map(|f| self.opaque(self.field_ty(f.did, *args))), }, _ => None, } @@ -520,7 +520,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { Some(Std::RawWaker) => ret(super::task::raw_waker(v().member("data"), v().member("vtable"))), Some(Std::ControlFlow) => { let (residual, value) = (args.type_at(0), args.type_at(1)); - ret(match (Flow::of(tcx, args), residual.kind()) { + ret(match (Flow::of(tcx, *args), residual.kind()) { (Flow::Result, ty::Adt(_, residual)) => self.copy_result(value, residual.type_at(1), span), (Flow::Option, _) => self.copy_unless(self.none(value), value, span), _ => self.copy_result(value, residual, span), @@ -560,10 +560,10 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { let variant = adt.non_enum_variant(); let values = (variant.fields.iter().zip(&fields)) .map(|(field, &id)| { - let field_ty = self.field_ty(field.did, args); - let read = self.held_field(Translator::read_field(v(), id), field.did, args, span); + let field_ty = self.field_ty(field.did, *args); + let read = self.held_field(Translator::read_field(v(), id), field.did, *args, span); let copy = self.snapshot(read, part(field_ty), span); - self.field_value(copy, adt.did(), field.did, args, span) + self.field_value(copy, adt.did(), field.did, *args, span) }) .collect(); ret(self.construct(info.sym, &ctor, &fields, values)) @@ -576,8 +576,8 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { let mut props = vec![(Key::Name("tag".into()), Expr::Str(tag.clone()))]; for (i, field) in variant.fields.iter().enumerate() { let name = field_name(field.name.as_str(), i); - let field_ty = self.field_ty(field.did, args); - let read = self.held_field(v().member(name.clone()), field.did, args, span); + let field_ty = self.field_ty(field.did, *args); + let read = self.held_field(v().member(name.clone()), field.did, *args, span); props.push((Key::Name(name), self.snapshot(read, field_ty, span))); } body.push( @@ -595,7 +595,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } // A slot no field was written into yet holds nothing. AdtRepr::Slots(layout) => { - let (_, slots) = self.laid_out(*adt, args, span); + let (_, slots) = self.laid_out(*adt, *args, span); let ts_ty = self.ty(ty, span); let slots = slots .into_iter() @@ -641,7 +641,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } /// The type of field `did` of an ADT with `args`, normalized in the translator's environment. - pub fn field_ty(&self, did: DefId, args: ty::GenericArgsRef<'tcx>) -> Ty<'tcx> { + pub fn field_ty(&self, did: DefId, args: ty::GenericArgs<'tcx>) -> Ty<'tcx> { field_ty(self.tcx, self.typing_env(), did, args) } } @@ -652,7 +652,7 @@ pub fn field_ty<'tcx>( tcx: TyCtxt<'tcx>, env: ty::TypingEnv<'tcx>, did: DefId, - args: ty::GenericArgsRef<'tcx>, + args: ty::GenericArgs<'tcx>, ) -> Ty<'tcx> { instantiate(tcx, env, tcx.type_of(did).instantiate_identity().skip_norm_wip(), args) } @@ -662,7 +662,7 @@ pub fn instantiate<'tcx>( tcx: TyCtxt<'tcx>, env: ty::TypingEnv<'tcx>, ty: Ty<'tcx>, - args: ty::GenericArgsRef<'tcx>, + args: ty::GenericArgs<'tcx>, ) -> Ty<'tcx> { let ty = EarlyBinder::bind(tcx, ty); tcx.try_instantiate_and_normalize_erasing_regions(args, env, ty) @@ -703,7 +703,7 @@ pub struct Writes<'tcx> { read: FxHashSet, /// The arguments of each body's instances that translation reached, without type /// parameters. - reached: FxHashMap>>, + reached: FxHashMap>>, } /// Types, each without type parameters or over those of the body naming it. @@ -905,7 +905,7 @@ fn replaces<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, this: Ty<'tcx>) -> Option(tcx: TyCtxt<'tcx>, def_id: DefId, args: ty::GenericArgsRef<'tcx>) -> Option> { +fn cell_writes<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, args: ty::GenericArgs<'tcx>) -> Option> { let (owner, name) = super::library::key(tcx, def_id)?; let writes = match owner.as_str() { // Refused of an array. @@ -920,7 +920,7 @@ fn cell_writes<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, args: ty::GenericArgsRef< /// The type std's `def_id` writes whole through a raw pointer to one, by the runtime's /// write of a pointer's value: `ptr::write`, `replace`, or `swap`. -fn pointer_writes<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, args: ty::GenericArgsRef<'tcx>) -> Option> { +fn pointer_writes<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, args: ty::GenericArgs<'tcx>) -> Option> { let (owner, name) = super::library::key(tcx, def_id)?; let writes = owner == "ptr" && matches!( @@ -1414,7 +1414,7 @@ impl<'tcx> BodyWrites<'_, '_, '_, 'tcx> { /// Whether the function item `def_id` with `args` translates, whose body is /// read, rather than std's or a trait method only an instance resolves. - fn crate_fn(&self, def_id: DefId, args: ty::GenericArgsRef<'tcx>) -> bool { + fn crate_fn(&self, def_id: DefId, args: ty::GenericArgs<'tcx>) -> bool { let env = ty::TypingEnv::post_analysis(self.tcx, self.def_id); matches!( ty::Instance::try_resolve(self.tcx, env, def_id, args), diff --git a/ts/src/lower/defined.rs b/ts/src/lower/defined.rs index dad3123c4..3a76a35e4 100644 --- a/ts/src/lower/defined.rs +++ b/ts/src/lower/defined.rs @@ -10,7 +10,7 @@ //! once every definition typed with them is. use rustc_hir::def_id::DefId; -use rustc_middle::ty::{self, GenericArgsRef, Ty, TypeVisitableExt, TypingEnv}; +use rustc_middle::ty::{self, GenericArgs, Ty, TypeVisitableExt, TypingEnv}; use rustc_span::Span; use super::{Adt, Translator}; @@ -75,16 +75,16 @@ pub enum Decides { pub struct Check<'tcx> { pub adt: DefId, pub decided: Decided<'tcx>, - pub args: GenericArgsRef<'tcx>, + pub args: GenericArgs<'tcx>, } /// `args`, over a definition's parameters, at that definition's instance `at`. pub fn instantiate_args<'tcx>( tcx: ty::TyCtxt<'tcx>, env: TypingEnv<'tcx>, - args: GenericArgsRef<'tcx>, - at: GenericArgsRef<'tcx>, -) -> GenericArgsRef<'tcx> { + args: GenericArgs<'tcx>, + at: GenericArgs<'tcx>, +) -> GenericArgs<'tcx> { let bound = ty::EarlyBinder::bind(tcx, args); tcx.try_instantiate_and_normalize_erasing_regions(at, env, bound) .unwrap_or_else(|_| bound.instantiate(tcx, at).skip_norm_wip()) @@ -150,7 +150,7 @@ struct Member { struct Pending<'tcx> { adt: DefId, - args: GenericArgsRef<'tcx>, + args: GenericArgs<'tcx>, /// The definition typing it, and the field whose type did. at: Option<(DefId, TypingEnv<'tcx>)>, field: Option, @@ -330,7 +330,7 @@ impl<'tcx> Translator<'_, 'tcx> { /// The projection arguments of an instance of the crate's generic `adt` with `args`, a /// definition still being typed, as a [`Type::Later`] filled in once it is complete. - pub(super) fn later_projections(&mut self, adt: DefId, args: GenericArgsRef<'tcx>, span: Span) -> Option { + pub(super) fn later_projections(&mut self, adt: DefId, args: GenericArgs<'tcx>, span: Span) -> Option { let state = &mut self.defining_state; let low = state.records.get(&adt)?.open?; // Whatever types it is typed with it. diff --git a/ts/src/lower/drop.rs b/ts/src/lower/drop.rs index ee00e0a09..bd8f4b148 100644 --- a/ts/src/lower/drop.rs +++ b/ts/src/lower/drop.rs @@ -126,10 +126,10 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { { args.types().any(|t| self.drops(t)) } - false => self.fields_drop(*adt, args, true), + false => self.fields_drop(*adt, *args, true), }, Some(_) => false, - None if self.crates.translates(adt.did()) => adt.has_dtor(tcx) || self.fields_drop(*adt, args, true), + None if self.crates.translates(adt.did()) => adt.has_dtor(tcx) || self.fields_drop(*adt, *args, true), None => false, }, ty::Tuple(tys) => tys.iter().any(|t| self.drops(t)), @@ -170,7 +170,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { /// Whether any field of `adt` with `args` drops, counting one of a type parameter only /// if `params`. - pub fn fields_drop(&mut self, adt: AdtDef<'tcx>, args: ty::GenericArgsRef<'tcx>, params: bool) -> bool { + pub fn fields_drop(&mut self, adt: AdtDef<'tcx>, args: ty::GenericArgs<'tcx>, params: bool) -> bool { let tcx = self.tcx; let env = self.typing_env_pub(); adt.all_fields().any(|field| { @@ -218,7 +218,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { None | Some(Std::Peekable) if self.std_iter(ty) => self.closures_held(ty), Some(_) => false, None if self.shared_glue(*adt) => { - if !self.glue_all(ty, *adt, args, Asked::Disposable(glue.is_some()), |t, held| { + if !self.glue_all(ty, *adt, *args, Asked::Disposable(glue.is_some()), |t, held| { t.disposable(held, glue) }) { return false; @@ -254,7 +254,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { &mut self, ty: Ty<'tcx>, adt: AdtDef<'tcx>, - args: ty::GenericArgsRef<'tcx>, + args: ty::GenericArgs<'tcx>, asked: Asked, f: impl Fn(&mut Self, Ty<'tcx>) -> bool, ) -> bool { @@ -318,7 +318,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { /// What a generic struct's glue drops through, at an instance with `args`: each type /// argument, and what each projection from them its fields name is there. - fn glue_held(&mut self, adt: AdtDef<'tcx>, args: ty::GenericArgsRef<'tcx>) -> Vec> { + fn glue_held(&mut self, adt: AdtDef<'tcx>, args: ty::GenericArgs<'tcx>) -> Vec> { let mut held: Vec> = args.types().collect(); if self.crates.translates(adt.did()) { let env = self.typing_env_pub(); @@ -506,7 +506,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { Some(Std::Context) => false, Some(_) => true, // Its glue, if an instance that drops gave it one, drops its type parameters' fields. - None if adt.is_struct() => self.glue_all(ty, *adt, args, Asked::Inert, |t, held| t.inert(held)), + None if adt.is_struct() => self.glue_all(ty, *adt, *args, Asked::Inert, |t, held| t.inert(held)), None => true, }, _ => true, diff --git a/ts/src/lower/dynamic.rs b/ts/src/lower/dynamic.rs index da2352f28..8e28cdb53 100644 --- a/ts/src/lower/dynamic.rs +++ b/ts/src/lower/dynamic.rs @@ -20,7 +20,7 @@ use std::collections::hash_map::Entry; use rustc_hir::def_id::DefId; use rustc_middle::ty::{ - self, GenericArgsRef, Instance, Interner as _, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable, + self, GenericArgs, Instance, Interner as _, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt, TypingEnv, Upcast as _, }; use rustc_span::Span; @@ -62,7 +62,7 @@ enum Slot { struct Method<'tcx> { def_id: DefId, /// The arguments of the trait it is of, over the object's trait's own parameters. - tr: GenericArgsRef<'tcx>, + tr: GenericArgs<'tcx>, name: String, /// Its type over the object type's parameters, once the object holds it: from the start for the trait of a crate that /// translates whole, which a TS caller may call or implement, and else, for std's or a @@ -738,7 +738,7 @@ pub fn unsized_object<'tcx>(tcx: TyCtxt<'tcx>, mut ty: Ty<'tcx>) -> bool { && adt.is_struct() && let Some(last) = adt.non_enum_variant().tail_opt() { - ty = last.ty(tcx, args).skip_norm_wip(); + ty = last.ty(tcx, *args).skip_norm_wip(); } ty.is_trait() } @@ -770,9 +770,9 @@ fn principal(ty: Ty<'_>) -> Option { /// The arguments of a trait object's method `def_id` of a trait with the arguments `tr`: /// those, then its own early-bound lifetimes, erased, which are all a dispatchable method /// takes. -fn method_args<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, tr: GenericArgsRef<'tcx>) -> GenericArgsRef<'tcx> { +fn method_args<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, tr: GenericArgs<'tcx>) -> GenericArgs<'tcx> { ty::GenericArgs::for_item(tcx, def_id, |param, _| match tr.get(param.index as usize) { - Some(&arg) => arg, + Some(arg) => arg, None => tcx.lifetimes.re_erased.into(), }) } @@ -783,10 +783,10 @@ fn method_args<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, tr: GenericArgsRef<'tcx>) fn instance_args<'tcx>( tcx: TyCtxt<'tcx>, def_id: DefId, - tr: GenericArgsRef<'tcx>, + tr: GenericArgs<'tcx>, object: Ty<'tcx>, self_ty: Ty<'tcx>, -) -> GenericArgsRef<'tcx> { +) -> GenericArgs<'tcx> { let ty::Dynamic(preds, ..) = object.kind() else { unreachable!("a trait object"); }; @@ -1105,11 +1105,11 @@ impl<'tcx> Body<'_, '_, 'tcx> { return None; }; let held = ( - last.ty(tcx, from_args).skip_norm_wip(), - last.ty(tcx, to_args).skip_norm_wip(), + last.ty(tcx, *from_args).skip_norm_wip(), + last.ty(tcx, *to_args).skip_norm_wip(), ); let at = v.clone().field(id); - let read = self.t.held_field(at.clone(), last.did, from_args, span); + let read = self.t.held_field(at.clone(), last.did, *from_args, span); let value = self.fresh("value"); let set = Expr::Lambda( vec![Param { diff --git a/ts/src/lower/fmt.rs b/ts/src/lower/fmt.rs index c0c72cd99..fdfdacd3d 100644 --- a/ts/src/lower/fmt.rs +++ b/ts/src/lower/fmt.rs @@ -463,13 +463,13 @@ pub fn std_impl<'tcx>( } ty::Adt(adt, args) if tr == Trait::Debug - && let Some(e) = iter_debug(b, adt.did(), args, &value, &f, span) => + && let Some(e) = iter_debug(b, adt.did(), *args, &value, &f, span) => { e } ty::Adt(adt, args) if tr == Trait::Debug - && let Some(e) = adaptor_debug(b, adt.did(), args, &value, &f, span) => + && let Some(e) = adaptor_debug(b, adt.did(), *args, &value, &f, span) => { e } @@ -527,7 +527,7 @@ pub fn std_impl<'tcx>( (Std::ControlFlow, Trait::Debug) => { let go = b.fmt_fn(tr, args.type_at(1), span); let stop = b.fmt_fn(tr, args.type_at(0), span); - match library::Flow::of(tcx, args) { + match library::Flow::of(tcx, *args) { library::Flow::Other => rs("controlFlow", vec![value, f, go, stop]), library::Flow::Result => rs("controlFlow", vec![value, f, go, stop, Expr::lit("true")]), library::Flow::Option => { @@ -699,7 +699,7 @@ pub fn std_impl<'tcx>( fn iter_debug<'tcx>( b: &mut Body<'_, '_, 'tcx>, did: DefId, - args: ty::GenericArgsRef<'tcx>, + args: ty::GenericArgs<'tcx>, value: &Expr, f: &Expr, span: Span, @@ -938,7 +938,7 @@ fn iter_debug<'tcx>( fn adaptor_debug<'tcx>( b: &mut Body<'_, '_, 'tcx>, did: DefId, - args: ty::GenericArgsRef<'tcx>, + args: ty::GenericArgs<'tcx>, value: &Expr, f: &Expr, span: Span, diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 91b432828..14fef056d 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -284,7 +284,7 @@ fn erases(tcx: TyCtxt<'_>, def_id: DefId, name: &str) -> Option<(Span, String)> /// Whether a call of `def_id` for `args` runs the crate's code over `B` or `F`, or code /// that can tell them apart: anything but `F`'s calls and std's iterators', which take /// any `B` and `F`. - fn tells(&mut self, def_id: DefId, args: ty::GenericArgsRef<'tcx>) -> bool { + fn tells(&mut self, def_id: DefId, args: ty::GenericArgs<'tcx>) -> bool { let tcx = self.tcx; let any = tcx.trait_of_assoc(def_id).is_some_and(|tr| { tcx.is_fn_trait(tr) @@ -333,7 +333,7 @@ fn erases(tcx: TyCtxt<'_>, def_id: DefId, name: &str) -> Option<(Span, String)> fn visit_const_operand(&mut self, c: &ConstOperand<'tcx>, loc: Location) { let args = match c.const_ { mir::Const::Unevaluated(uv, _) => uv.args, - _ => ty::List::empty(), + _ => ty::GenericArgs::empty(), }; let params = std::mem::take(&mut self.params); if self.over(c.const_.ty().into(), ¶ms, false) || args.iter().any(|a| self.over(a, ¶ms, false)) { @@ -1169,7 +1169,9 @@ pub fn call<'tcx>( { let imp = tcx.inherent_impl_of_assoc(call.def_id)?; let generics = tcx.generics_of(imp).count(); - tcx.type_of(imp).instantiate(tcx, &gargs[..generics]).skip_norm_wip() + tcx.type_of(imp) + .instantiate(tcx, &gargs.as_slice()[..generics]) + .skip_norm_wip() } _ => return None, }; @@ -1644,7 +1646,7 @@ fn undefined(e: &Expr) -> bool { /// only a census's instance, which never runs, has. pub(super) fn layout<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Result<(u64, u64), Expr> { match b.t.tcx.layout_of(b.t.typing_env_pub().as_query_input(ty)) { - Ok(layout) => Ok((layout.size.bytes(), layout.align.abi.bytes())), + Ok(layout) => Ok((layout.size.bytes(), layout.align.bytes())), Err(_) if ty.has_param() => Err(Expr::undefined()), Err(_) => Err(b.err(span, format!("reserving for `{ty}`, whose layout is unknown"))), } @@ -1713,7 +1715,7 @@ fn std_iter_path(tcx: ty::TyCtxt<'_>, ty: Ty<'_>) -> Option> { /// The function or `Iterator` method named for `ty`, one of std's iterators of zero-sized /// fields, as `from_fn` makes a `FromFn` and `map` a `Map`, and its generic arguments: what /// MIR reads as a constant, rather than from that call, makes it of its fields in order. -pub(super) fn maker<'tcx>(t: &Translator<'_, 'tcx>, ty: Ty<'tcx>) -> Option<(DefId, ty::GenericArgsRef<'tcx>)> { +pub(super) fn maker<'tcx>(t: &Translator<'_, 'tcx>, ty: Ty<'tcx>) -> Option<(DefId, ty::GenericArgs<'tcx>)> { let tcx = t.tcx; let ty::Adt(adt, args) = ty.kind() else { return None; @@ -1765,7 +1767,7 @@ pub(super) fn maker<'tcx>(t: &Translator<'_, 'tcx>, ty: Ty<'tcx>) -> Option<(Def }); let sig = tcx.fn_sig(make).instantiate(tcx, gargs).skip_norm_wip(); let sig = tcx.instantiate_bound_regions_with_erased(sig); - let fields = adt.non_enum_variant().fields.iter().map(|f| t.field_ty(f.did, args)); + let fields = adt.non_enum_variant().fields.iter().map(|f| t.field_ty(f.did, *args)); (sig.output() == ty && sig.inputs().iter().copied().eq(fields)).then_some((make, gargs)) } @@ -2311,7 +2313,7 @@ fn try_flow<'tcx>(b: &Body<'_, '_, 'tcx>, r: Ty<'tcx>) -> Option<(bool, Option Some((true, b.t.none_arg(args.type_at(0)))), - Std::ControlFlow if library::Flow::of(b.t.tcx, args) == library::Flow::Option => { + Std::ControlFlow if library::Flow::of(b.t.tcx, *args) == library::Flow::Option => { Some((true, b.t.none_arg(args.type_at(1)))) } Std::Result | Std::ControlFlow => Some((false, None)), @@ -2461,7 +2463,7 @@ fn in_place<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> O // As std's `in_place_collectible`, where `None`, an overflow, is 0. (!from.is_zst() && !to.is_zst() - && from.align.abi == to.align.abi + && from.align == to.align && merge > 0 && expand > 0 && u128::from(from.size.bytes()) * merge >= u128::from(to.size.bytes()) * expand) diff --git a/ts/src/lower/lend.rs b/ts/src/lower/lend.rs index 2687dbade..035520201 100644 --- a/ts/src/lower/lend.rs +++ b/ts/src/lower/lend.rs @@ -9,7 +9,7 @@ //! is a slice on both sides: a `&T` where `T = [T; N]`, not a `T` where `T = &[T; N]`. use rustc_hir::def_id::DefId; -use rustc_middle::ty::{self, EarlyBinder, GenericArgsRef, Instance, Ty, TypingEnv}; +use rustc_middle::ty::{self, CallerBoundsIterator as _, EarlyBinder, GenericArgs, Instance, Ty, TypingEnv}; use rustc_span::Span; use super::Translator; @@ -54,7 +54,7 @@ pub struct Closure<'tcx> { } /// What a call of std's `def_id` lends. -pub fn plan<'tcx>(t: &Translator<'_, 'tcx>, def_id: DefId, args: GenericArgsRef<'tcx>) -> Plan<'tcx> { +pub fn plan<'tcx>(t: &Translator<'_, 'tcx>, def_id: DefId, args: GenericArgs<'tcx>) -> Plan<'tcx> { let tcx = t.tcx; if t.translated(def_id, args) || !args.types().any(owns_array) || super::array_slice::native(tcx, def_id, args) { return Plan::Untouched; @@ -160,13 +160,15 @@ pub fn plan<'tcx>(t: &Translator<'_, 'tcx>, def_id: DefId, args: GenericArgsRef< /// Whether `def_id` is a method of a collection whose runtime reads the bytes it is given /// in either form. -fn collection<'tcx>(t: &Translator<'_, 'tcx>, def_id: DefId, args: GenericArgsRef<'tcx>) -> bool { +fn collection<'tcx>(t: &Translator<'_, 'tcx>, def_id: DefId, args: GenericArgs<'tcx>) -> bool { let tcx = t.tcx; // An inherent method's type, or a trait method's `Self`. let coll = match tcx.inherent_impl_of_assoc(def_id) { Some(imp) => { let generics = tcx.generics_of(imp).count(); - tcx.type_of(imp).instantiate(tcx, &args[..generics]).skip_norm_wip() + tcx.type_of(imp) + .instantiate(tcx, &args.as_slice()[..generics]) + .skip_norm_wip() } None => match args.types().next() { Some(ty) => ty.peel_refs(), @@ -201,13 +203,13 @@ fn owns_array(ty: Ty<'_>) -> bool { /// `next` makes it. pub struct Sig<'tcx> { def_id: DefId, - args: GenericArgsRef<'tcx>, + args: GenericArgs<'tcx>, generic: ty::FnSig<'tcx>, sig: ty::FnSig<'tcx>, } impl<'tcx> Sig<'tcx> { - pub fn of(t: &Translator<'_, 'tcx>, def_id: DefId, args: GenericArgsRef<'tcx>) -> Self { + pub fn of(t: &Translator<'_, 'tcx>, def_id: DefId, args: GenericArgs<'tcx>) -> Self { let tcx = t.tcx; let generic = tcx.fn_sig(def_id).instantiate_identity().skip_norm_wip(); let generic = normalize( @@ -236,14 +238,15 @@ impl<'tcx> Sig<'tcx> { if !matches!(f.kind(), ty::Param(_)) { return None; } - let bounds = tcx.param_env(self.def_id).caller_bounds(); - let trait_pred = (bounds.clone().filter_map(|c| c.as_trait_clause())) + let env = tcx.param_env(self.def_id); + let bounds = || env.caller_bounds().all_clauses(tcx).iter(); + let trait_pred = (bounds().filter_map(|c| c.as_trait_clause())) .map(|p| tcx.instantiate_bound_regions_with_erased(p)) .find(|p| p.self_ty() == f && tcx.is_fn_trait(p.def_id()))?; let ty::Tuple(params) = trait_pred.trait_ref.args.type_at(1).kind() else { return None; }; - let output = (bounds.filter_map(|c| c.as_projection_clause())) + let output = (bounds().filter_map(|c| c.as_projection_clause())) .map(|p| tcx.instantiate_bound_regions_with_erased(p)) .find(|p| p.self_ty() == f && tcx.is_lang_item(p.def_id(), rustc_attr_ir::LangItem::FnOnceOutput)) .and_then(|p| p.term.as_type()); diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index a36ece662..fc98393e7 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -7,7 +7,7 @@ use rustc_hir::def::DefKind; use rustc_hir::def_id::DefId; -use rustc_middle::ty::{self, GenericArgsRef, Instance, Ty, TyCtxt, TypingEnv}; +use rustc_middle::ty::{self, CallerBoundsIterator as _, GenericArgs, Instance, Ty, TyCtxt, TypingEnv}; use rustc_span::Span; use super::body::Body; @@ -446,7 +446,7 @@ pub enum Flow { impl Flow { /// The representation of a `ControlFlow` with `args`, its break's type first. - pub fn of<'tcx>(tcx: TyCtxt<'tcx>, args: GenericArgsRef<'tcx>) -> Self { + pub fn of<'tcx>(tcx: TyCtxt<'tcx>, args: GenericArgs<'tcx>) -> Self { let ty::Adt(adt, residual) = args.type_at(0).kind() else { return Self::Other; }; @@ -460,7 +460,7 @@ impl Flow { } /// The test that `value`, a `ControlFlow` with `args`, continues, or breaks. - pub fn test<'tcx>(t: &Translator<'_, 'tcx>, args: GenericArgsRef<'tcx>, value: Expr, continues: bool) -> Expr { + pub fn test<'tcx>(t: &Translator<'_, 'tcx>, args: GenericArgs<'tcx>, value: Expr, continues: bool) -> Expr { match (Self::of(t.tcx, args), continues) { (Self::Result | Self::Other, true) => value.member("ok"), (Self::Result | Self::Other, false) => value.member("ok").not(), @@ -574,7 +574,7 @@ pub fn wrapped<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option> { return None; } let field = adt.non_enum_variant().fields.iter().next()?; - Some(field.ty(tcx, args).skip_norm_wip()) + Some(field.ty(tcx, *args).skip_norm_wip()) } }, _ => None, @@ -705,9 +705,9 @@ pub fn is_std(tcx: TyCtxt<'_>, did: DefId) -> bool { pub fn referent<'tcx>( tcx: TyCtxt<'tcx>, def_id: DefId, - gargs: GenericArgsRef<'tcx>, + gargs: GenericArgs<'tcx>, instance: Instance<'tcx>, -) -> Option> { +) -> Option> { let tr = tcx.trait_of_assoc(def_id)?; // A method the impl leaves to its trait's default, as `Ord::max` is, is not forwarded. let imp = tcx.impl_of_assoc(instance.def_id())?; @@ -721,7 +721,7 @@ pub fn referent<'tcx>( _ if hasher => 1, _ => return None, }; - let mut args = gargs.to_vec(); + let mut args = gargs.as_slice().to_vec(); for arg in &mut args[..operands] { let ty = arg.as_type()?; *arg = match ty.kind() { @@ -835,7 +835,7 @@ fn clone_only_copies<'tcx>(t: &super::Translator<'_, 'tcx>, env: TypingEnv<'tcx> derived && adt .all_fields() - .all(|field| clone_only_copies(t, env, super::copy::field_ty(tcx, env, field.did, args))) + .all(|field| clone_only_copies(t, env, super::copy::field_ty(tcx, env, field.did, *args))) } _ => false, } @@ -905,9 +905,9 @@ pub fn from_mir<'tcx>(t: &Translator<'_, 'tcx>, env: TypingEnv<'tcx>, instance: pub fn callee_args<'tcx>( t: &Translator<'_, 'tcx>, def_id: DefId, - args: GenericArgsRef<'tcx>, + args: GenericArgs<'tcx>, callee: impl Fn(DefId) -> bool, -) -> Option> { +) -> Option> { let tcx = t.tcx; let env = t.typing_env_pub(); let instance = Instance::try_resolve(tcx, env, def_id, args).ok()??; @@ -1042,7 +1042,7 @@ pub struct Call<'tcx> { /// The function as written, before resolving a trait method to its impl. pub def_id: DefId, /// Its generic arguments: the impl's or trait's, then the function's. - pub args: GenericArgsRef<'tcx>, + pub args: GenericArgs<'tcx>, pub span: Span, } @@ -1232,7 +1232,7 @@ pub(super) fn sentinel_option<'tcx>(t: &Translator<'_, 'tcx>, call: &Call<'tcx>) let tcx = t.tcx; let sig = tcx.fn_sig(call.def_id).instantiate_identity().skip_norm_wip(); let sig = tcx.instantiate_bound_regions_with_erased(sig); - let bounds = tcx.param_env(call.def_id).caller_bounds(); + let bounds = tcx.param_env(call.def_id).caller_bounds().all_clauses(tcx).iter(); let bound_args = bounds.flat_map(|clause| { let trait_args = clause.as_trait_clause().map(|c| c.skip_binder().trait_ref.args); let projection = clause.as_projection_clause().map(|c| c.skip_binder()); @@ -1368,7 +1368,7 @@ fn called_closures<'tcx>( if lent { continue; } - let index = call.args[..param.index as usize] + let index = call.args.as_slice()[..param.index as usize] .iter() .filter(|a| a.as_type().is_some()) .count(); @@ -1403,6 +1403,8 @@ fn called_closures<'tcx>( fn called_by<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, input: Ty<'tcx>) -> Option { tcx.param_env(def_id) .caller_bounds() + .all_clauses(tcx) + .iter() .filter_map(|p| p.as_trait_clause()) .filter(|t| t.self_ty().skip_binder() == input) .filter_map(|t| match std_path(tcx, t.def_id()).as_slice() { @@ -3109,7 +3111,7 @@ fn mapping<'tcx>( }; let str = class(b, Ty::new_static_str(tcx))?; let string = tcx.lang_items().string()?; - let string = class(b, Ty::new_adt(tcx, tcx.adt_def(string), ty::List::empty()))?; + let string = class(b, Ty::new_adt(tcx, tcx.adt_def(string), ty::GenericArgs::empty()))?; Expr::rs("hookPayload", vec![args.pop()?, str, string]) } ("PanicHookInfo", "payload_as_str") => args.pop()?.member("text"), @@ -3151,7 +3153,7 @@ fn mapping<'tcx>( ("mem", "align_of") => { let env = b.t.typing_env_pub(); let layout = tcx.layout_of(env.as_query_input(targ(gargs, 0))).ok()?; - Expr::lit(layout.align.abi.bytes().to_string()) + Expr::lit(layout.align.bytes().to_string()) } // rustc's answers for the instance, which a JS value that drops nothing, such as a // `String`'s, leaves as they are. @@ -3175,7 +3177,7 @@ fn mapping<'tcx>( let layout = tcx.layout_of(env.as_query_input(elem)).ok()?; let size = layout.size.bytes(); match (name.as_str(), len) { - ("align_of_val", _) => Expr::lit(layout.align.abi.bytes().to_string()), + ("align_of_val", _) => Expr::lit(layout.align.bytes().to_string()), (_, None) => Expr::lit(size.to_string()), (_, Some(len)) if size == 1 => len, (_, Some(len)) => len.binary("*", Expr::lit(size.to_string())), @@ -3410,7 +3412,7 @@ pub fn be_word(int: Int, values: Vec) -> Expr { } /// The `n`th type among a call's generic arguments, skipping lifetimes. -pub fn targ<'tcx>(gargs: GenericArgsRef<'tcx>, n: usize) -> Ty<'tcx> { +pub fn targ<'tcx>(gargs: GenericArgs<'tcx>, n: usize) -> Ty<'tcx> { gargs.types().nth(n).expect("a type argument") } diff --git a/ts/src/lower/mir/alloc.rs b/ts/src/lower/mir/alloc.rs index 6b9988f3b..6a6aef1c3 100644 --- a/ts/src/lower/mir/alloc.rs +++ b/ts/src/lower/mir/alloc.rs @@ -114,7 +114,8 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { if !library::is_std(tcx, def_id) || !matches!(owner.as_str(), "ptr" | "NonNull") || name != "cast" { return None; } - let mut types = gargs.skip_binder().types(); + let gargs = gargs.skip_binder(); + let mut types = gargs.types(); Some((&args.first()?.node, types.next()?, types.next()?)) }; assigns.chain(call()) @@ -128,7 +129,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { pub(super) fn alloc_cast_call( &mut self, def_id: rustc_hir::def_id::DefId, - gargs: ty::GenericArgsRef<'tcx>, + gargs: ty::GenericArgs<'tcx>, args: &[Spanned>], span: Span, out: &mut Vec, diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index c73a2f8bb..95df24054 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -5,7 +5,7 @@ use rustc_abi::{FieldIdx, VariantIdx}; use rustc_middle::mir::{Operand, Place, ProjectionElem}; -use rustc_middle::ty::{self, GenericArgsRef, Instance, Ty, TyCtxt}; +use rustc_middle::ty::{self, GenericArgs, Instance, Ty, TyCtxt}; use rustc_span::{Span, Spanned}; use super::{Fx, Slot}; @@ -257,7 +257,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { fn call_def( &mut self, def_id: rustc_hir::def_id::DefId, - gargs: GenericArgsRef<'tcx>, + gargs: GenericArgs<'tcx>, args: &[Spanned>], result: Ty<'tcx>, span: Span, @@ -430,7 +430,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { fn std_places( &mut self, def_id: rustc_hir::def_id::DefId, - gargs: GenericArgsRef<'tcx>, + gargs: GenericArgs<'tcx>, result: Ty<'tcx>, span: Span, ) -> Option { @@ -564,7 +564,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { fn intercept( &mut self, def_id: rustc_hir::def_id::DefId, - gargs: GenericArgsRef<'tcx>, + gargs: GenericArgs<'tcx>, args: &[Spanned>], dest: Place<'tcx>, span: Span, @@ -1785,7 +1785,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { fn fmt_write( &mut self, def_id: rustc_hir::def_id::DefId, - gargs: GenericArgsRef<'tcx>, + gargs: GenericArgs<'tcx>, args: &[Spanned>], dest: Place<'tcx>, span: Span, @@ -2159,7 +2159,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { fn index( &mut self, name: &str, - gargs: GenericArgsRef<'tcx>, + gargs: GenericArgs<'tcx>, args: &[Spanned>], dest: Place<'tcx>, span: Span, @@ -2418,7 +2418,7 @@ fn int_named(name: &str) -> Option { /// How a `ControlFlow` type is represented. fn flow<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Flow { match ty.kind() { - ty::Adt(_, args) => Flow::of(tcx, args), + ty::Adt(_, args) => Flow::of(tcx, *args), _ => unreachable!("checked by the caller"), } } @@ -2442,7 +2442,7 @@ pub fn control_flow_test<'tcx>( let ty::Adt(_, args) = ty.kind() else { unreachable!("checked by the caller") }; - Flow::test(fx.b.t, args, scrut.clone(), continues) + Flow::test(fx.b.t, *args, scrut.clone(), continues) } /// A field of a `ControlFlow`: `Continue`'s value, or `Break`'s, which for `?` is the diff --git a/ts/src/lower/mir/coroutine.rs b/ts/src/lower/mir/coroutine.rs index 37a08816f..ee219d551 100644 --- a/ts/src/lower/mir/coroutine.rs +++ b/ts/src/lower/mir/coroutine.rs @@ -9,7 +9,7 @@ use rustc_hir as hir; use rustc_hir::def_id::DefId; use rustc_index::IndexVec; use rustc_middle::mir::{self, CoroutineSavedLocal, Operand}; -use rustc_middle::ty::{self, EarlyBinder, GenericArgsRef, Instance}; +use rustc_middle::ty::{self, EarlyBinder, GenericArgs, Instance}; use rustc_span::Span; use super::{Env, Fx}; @@ -38,7 +38,7 @@ impl Info<'_> { } /// The class of the coroutine `def_id` with `args`, made the first time. -pub fn info<'tcx>(t: &mut Translator<'_, 'tcx>, def_id: DefId, args: GenericArgsRef<'tcx>, span: Span) -> Info<'tcx> { +pub fn info<'tcx>(t: &mut Translator<'_, 'tcx>, def_id: DefId, args: GenericArgs<'tcx>, span: Span) -> Info<'tcx> { let instance = Instance::new_raw(def_id, args); if let Some(info) = t.coroutines.get(&instance) { return info.clone(); @@ -434,7 +434,7 @@ pub fn of_async_fn<'tcx>(t: &mut Translator<'_, 'tcx>, instance: Instance<'tcx>, pub fn construct<'tcx>( fx: &mut Fx<'_, '_, '_, 'tcx>, def_id: DefId, - args: GenericArgsRef<'tcx>, + args: GenericArgs<'tcx>, ops: &IndexVec>, span: Span, out: &mut Vec, diff --git a/ts/src/lower/mir/decided.rs b/ts/src/lower/mir/decided.rs index 69a4a7c5e..2e47ef6a5 100644 --- a/ts/src/lower/mir/decided.rs +++ b/ts/src/lower/mir/decided.rs @@ -1065,7 +1065,7 @@ fn lends<'tcx>(tcx: TyCtxt<'tcx>, crates: &Crates<'tcx>, ty: Ty<'tcx>) -> bool { ty::Adt(adt, args) if crates.translates(adt.did()) && seen.insert(t) => { stack.extend( adt.all_fields() - .map(|field| (field.ty(tcx, args).skip_norm_wip(), depth + 1)), + .map(|field| (field.ty(tcx, *args).skip_norm_wip(), depth + 1)), ); } _ => {} diff --git a/ts/src/lower/mir/holders.rs b/ts/src/lower/mir/holders.rs index f59ed10f8..cfec77e0c 100644 --- a/ts/src/lower/mir/holders.rs +++ b/ts/src/lower/mir/holders.rs @@ -21,7 +21,7 @@ use rustc_middle::mir::{ StatementKind, TerminatorKind, }; use rustc_middle::traits::ImplSource; -use rustc_middle::ty::{self, GenericArgsRef, Instance, Interner as _, Ty, TypeVisitableExt, TypingEnv}; +use rustc_middle::ty::{self, GenericArgs, Instance, Interner as _, Ty, TypeVisitableExt, TypingEnv}; use rustc_mir_dataflow::impls::MaybeLiveLocals; use rustc_mir_dataflow::{Analysis, ResultsCursor}; use rustc_span::Spanned; @@ -84,7 +84,7 @@ pub(in crate::lower) struct Memo<'tcx> { /// or a thread-local; or `None` if anywhere else. returned: FxHashMap>>>, /// Whether std's function or impl, given these arguments, is [`Trace::inert`]. - inert: FxHashMap<(DefId, GenericArgsRef<'tcx>), bool>, + inert: FxHashMap<(DefId, GenericArgs<'tcx>), bool>, } /// The locals that may hold a pointer, and where one may escape them. @@ -443,7 +443,7 @@ impl<'x, 'a, 'tcx> Trace<'x, 'a, 'tcx> { /// The crate's function a call of `def_id` with `args` runs, if its body translates and /// takes its arguments as it declares them, which a closure's doesn't. - fn read_fn(&self, def_id: DefId, args: ty::GenericArgsRef<'tcx>) -> Option { + fn read_fn(&self, def_id: DefId, args: ty::GenericArgs<'tcx>) -> Option { let tcx = self.t.tcx; let instance = Instance::try_resolve(tcx, self.env, def_id, args).ok()??; let ty::InstanceKind::Item(did) = instance.def else { @@ -514,7 +514,7 @@ impl<'x, 'a, 'tcx> Trace<'x, 'a, 'tcx> { fn leaves( &self, def_id: DefId, - gargs: ty::GenericArgsRef<'tcx>, + gargs: ty::GenericArgs<'tcx>, args: &[Spanned>], given: &[Ty<'tcx>], ) -> bool { @@ -526,7 +526,7 @@ impl<'x, 'a, 'tcx> Trace<'x, 'a, 'tcx> { } /// Whether a call of `def_id` with `args` runs std's code, calling none of the crate's. - fn runs_std(&self, def_id: DefId, gargs: ty::GenericArgsRef<'tcx>, args: &[Spanned>]) -> bool { + fn runs_std(&self, def_id: DefId, gargs: ty::GenericArgs<'tcx>, args: &[Spanned>]) -> bool { if self.translated(def_id, gargs) { return false; } @@ -549,7 +549,7 @@ impl<'x, 'a, 'tcx> Trace<'x, 'a, 'tcx> { /// calls nothing, as `Sized` or `Send`, or is met by std's own impl, inert in turn. Code /// generic over a type calls its methods only through its bounds, so an iterator over /// slots of the crate's type, bound by none, runs none of it. - fn inert(&self, did: DefId, args: GenericArgsRef<'tcx>) -> bool { + fn inert(&self, did: DefId, args: GenericArgs<'tcx>) -> bool { let tcx = self.t.tcx; let key = (did, args); if let Some(&inert) = self.memo.borrow().inert.get(&key) { @@ -594,7 +594,7 @@ impl<'x, 'a, 'tcx> Trace<'x, 'a, 'tcx> { /// and whose drop runs none of the crate's code. It runs the crate's code only as its /// element's `Clone`, which it gives the value it moves into the vector last, never the /// memory it returns, and which returns no pointer std's code could keep. - fn repeats(&self, def_id: DefId, args: ty::GenericArgsRef<'tcx>) -> bool { + fn repeats(&self, def_id: DefId, args: ty::GenericArgs<'tcx>) -> bool { let tcx = self.t.tcx; crate::lower::library::is_std(tcx, def_id) && matches!(crate::lower::library::key(tcx, def_id), Some((owner, name)) if owner == "vec" && name == "from_elem") @@ -623,7 +623,7 @@ impl<'x, 'a, 'tcx> Trace<'x, 'a, 'tcx> { } /// Whether a call of `def_id` with `args` runs a function whose body translates. - fn translated(&self, def_id: DefId, args: ty::GenericArgsRef<'tcx>) -> bool { + fn translated(&self, def_id: DefId, args: ty::GenericArgs<'tcx>) -> bool { match Instance::try_resolve(self.t.tcx, self.env, def_id, args) { Ok(Some(instance)) => self.t.lowers(self.env, instance) || self.t.dispatches(instance), _ => false, @@ -716,7 +716,7 @@ impl<'x, 'a, 'tcx> Trace<'x, 'a, 'tcx> { } ty::Adt(adt, args) if crate::lower::library::is_std(tcx, adt.did()) => stack.extend(args.types()), ty::Adt(adt, args) => { - stack.extend(adt.all_fields().map(|field| field_ty(tcx, self.env, field.did, args))) + stack.extend(adt.all_fields().map(|field| field_ty(tcx, self.env, field.did, *args))) } _ => return true, } @@ -751,7 +751,7 @@ impl<'x, 'a, 'tcx> Trace<'x, 'a, 'tcx> { ty::Adt(adt, _) if raw_carrier(tcx, adt.did()) => return true, ty::Adt(adt, args) if crate::lower::library::is_std(tcx, adt.did()) => stack.extend(args.types()), ty::Adt(adt, args) => { - stack.extend(adt.all_fields().map(|field| field_ty(tcx, self.env, field.did, args))) + stack.extend(adt.all_fields().map(|field| field_ty(tcx, self.env, field.did, *args))) } _ => return true, } @@ -793,7 +793,7 @@ impl<'x, 'a, 'tcx> Trace<'x, 'a, 'tcx> { } ty::Adt(adt, args) => stack.extend( adt.all_fields() - .map(|field| field_ty(self.t.tcx, self.env, field.did, args)), + .map(|field| field_ty(self.t.tcx, self.env, field.did, *args)), ), ty::Param(_) if !params => {} _ => return true, @@ -971,7 +971,7 @@ impl<'x, 'a, 'tcx> Trace<'x, 'a, 'tcx> { ty::Tuple(tys) => tys.to_vec(), ty::Adt(adt, args) => adt .all_fields() - .map(|field| field_ty(self.t.tcx, self.env, field.did, args)) + .map(|field| field_ty(self.t.tcx, self.env, field.did, *args)) .collect(), _ => return None, }) @@ -1023,14 +1023,14 @@ impl<'x, 'a, 'tcx> Trace<'x, 'a, 'tcx> { .fields .iter_enumerated() .filter(|&(i, _)| i != field) - .map(|(_, f)| field_ty(tcx, self.env, f.did, args)), + .map(|(_, f)| field_ty(tcx, self.env, f.did, *args)), ); } (ProjectionElem::Downcast(_, at), ty::Adt(adt, args)) => beside.extend( adt.variants() .iter_enumerated() .filter(|&(i, _)| i != at) - .flat_map(|(_, v)| v.fields.iter().map(|f| field_ty(tcx, self.env, f.did, args))), + .flat_map(|(_, v)| v.fields.iter().map(|f| field_ty(tcx, self.env, f.did, *args))), ), ( ProjectionElem::Index(_) | ProjectionElem::ConstantIndex { .. } | ProjectionElem::Subslice { .. }, @@ -1051,7 +1051,7 @@ impl<'x, 'a, 'tcx> Trace<'x, 'a, 'tcx> { /// The body a call of std's `def_id` with `args`, given `count` arguments, runs, over its /// own generics; `None` if it takes another count, as a closure's call does. - fn generic(&self, def_id: DefId, args: GenericArgsRef<'tcx>, count: usize) -> Option> { + fn generic(&self, def_id: DefId, args: GenericArgs<'tcx>, count: usize) -> Option> { let tcx = self.t.tcx; let instance = Instance::try_resolve(tcx, self.env, def_id, args).ok()??; let ty::InstanceKind::Item(did) = instance.def else { @@ -1099,7 +1099,7 @@ impl<'x, 'a, 'tcx> Trace<'x, 'a, 'tcx> { fn returned_mask( &self, def_id: DefId, - args: GenericArgsRef<'tcx>, + args: GenericArgs<'tcx>, count: usize, given: &[(usize, Mask<'tcx>)], ) -> Mask<'tcx> { @@ -1136,7 +1136,7 @@ impl<'x, 'a, 'tcx> Trace<'x, 'a, 'tcx> { fn reached_masks( &self, def_id: DefId, - args: GenericArgsRef<'tcx>, + args: GenericArgs<'tcx>, count: usize, mask: Mask<'tcx>, into: Option, @@ -1460,7 +1460,7 @@ impl<'x, 'a, 'tcx> Trace<'x, 'a, 'tcx> { clippy::type_complexity, reason = "a call's function, its generic arguments, and its arguments" )] - fn lent_to(&self, lent: Local) -> Option, &'x [Spanned>])>> { + fn lent_to(&self, lent: Local) -> Option, &'x [Spanned>])>> { let (mir, tcx) = (self.mir, self.t.tcx); let ty = mir.local_decls[lent].ty; let borrowed = ty.builtin_deref(true)?; @@ -1641,7 +1641,7 @@ impl<'tcx> Held<'tcx> { /// A call of std's code over type parameters, as the body it runs declares it. struct Generic<'tcx> { /// The arguments for the body's generics. - args: GenericArgsRef<'tcx>, + args: GenericArgs<'tcx>, /// Its parameters' types, over its generics. inputs: &'tcx [Ty<'tcx>], /// Its result's type, over its generics. diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index 6a6c57b12..c7f63b624 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -97,7 +97,7 @@ pub fn function<'a, 'tcx>(t: &mut Translator<'a, 'tcx>, instance: Instance<'tcx> pub fn fn_value<'tcx>( b: &mut Body<'_, '_, 'tcx>, def_id: rustc_hir::def_id::DefId, - args: ty::GenericArgsRef<'tcx>, + args: ty::GenericArgs<'tcx>, span: Span, ) -> Expr { let tcx = b.t.tcx; @@ -3553,7 +3553,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { ty::Tuple(tys) => stack.extend(tys.iter()), ty::Array(elem, _) | ty::Slice(elem) => stack.push(*elem), ty::Adt(adt, args) if self.b.t.own(adt.did()) => { - stack.extend(adt.all_fields().map(|field| self.b.t.field_ty(field.did, args))) + stack.extend(adt.all_fields().map(|field| self.b.t.field_ty(field.did, *args))) } ty::Adt(_, args) => stack.extend(args.types()), ty::Closure(..) | ty::CoroutineClosure(..) => { @@ -3592,7 +3592,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { ) => { adt.all_fields() - .any(|field| self.holds_behind(self.b.t.field_ty(field.did, args), part)) + .any(|field| self.holds_behind(self.b.t.field_ty(field.did, *args), part)) } _ => self.b.t.holds(self.b.t.typing_env_pub(), ty, part), } @@ -3674,7 +3674,7 @@ impl<'tcx> Translator<'_, 'tcx> { } stack.extend( adt.all_fields() - .map(|field| (field_ty(self.tcx, env, field.did, args), depth + 1)), + .map(|field| (field_ty(self.tcx, env, field.did, *args), depth + 1)), ); } } diff --git a/ts/src/lower/mir/origin.rs b/ts/src/lower/mir/origin.rs index 78a7cd46b..c1937444e 100644 --- a/ts/src/lower/mir/origin.rs +++ b/ts/src/lower/mir/origin.rs @@ -13,7 +13,7 @@ use rustc_middle::mir::visit::{MutatingUseContext, PlaceContext, Visitor}; use rustc_middle::mir::{ self, BasicBlock, Local, Location, Operand, ProjectionElem, Rvalue, StatementKind, TerminatorKind, }; -use rustc_middle::ty::{self, GenericArgsRef}; +use rustc_middle::ty::{self, GenericArgs}; use rustc_span::Spanned; use super::{Fx, Slot}; @@ -75,7 +75,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { pub(super) fn stray( &self, def_id: rustc_hir::def_id::DefId, - gargs: GenericArgsRef<'tcx>, + gargs: GenericArgs<'tcx>, args: &[Spanned>], ) -> Option { if !library::is_std(self.tcx, def_id) { @@ -667,7 +667,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { let ok_call = match &data.terminator().kind { TerminatorKind::Call { func, args, .. } => { let rest = args.iter().skip(1).any(|a| read(&a.node)); - let own = |def_id, gargs: GenericArgsRef<'tcx>| { + let own = |def_id, gargs: GenericArgs<'tcx>| { library::inherent_std(self.tcx, def_id) == Some(Std::Bytes) || (self.tcx.trait_of_assoc(def_id).is_some() && gargs @@ -884,11 +884,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { pub(super) fn def_call( &self, local: Local, - ) -> Option<( - rustc_hir::def_id::DefId, - GenericArgsRef<'tcx>, - &[Spanned>], - )> { + ) -> Option<(rustc_hir::def_id::DefId, GenericArgs<'tcx>, &[Spanned>])> { let bb = self.def_block(local)?; let TerminatorKind::Call { func, args, .. } = &self.mir.basic_blocks[bb].terminator().kind else { return None; diff --git a/ts/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index 2af3521fb..429935b94 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -209,7 +209,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { && adt.is_union() => { let rest = &place.projection[read + 1..]; - let (parts, n, part_ty) = self.union_part(*adt, args, field.as_usize(), field_ty, rest, span); + let (parts, n, part_ty) = self.union_part(*adt, *args, field.as_usize(), field_ty, rest, span); consumed = n; e = self.b.t.of_slots(e, part_ty, &parts, span); } @@ -383,7 +383,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { pub(super) fn union_part( &mut self, adt: ty::AdtDef<'tcx>, - args: ty::GenericArgsRef<'tcx>, + args: ty::GenericArgs<'tcx>, field: usize, field_ty: Ty<'tcx>, rest: &[ProjectionElem>], @@ -419,7 +419,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { continue; } let rest = &place.projection[i + 1..]; - let (parts, n, _) = self.union_part(*adt, args, field.as_usize(), field_ty, rest, span); + let (parts, n, _) = self.union_part(*adt, *args, field.as_usize(), field_ty, rest, span); let whole = crate::lower::unions::whole(&parts); return (n == rest.len() && !whole).then(|| (base.to_place(tcx), parts)); } @@ -592,7 +592,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { match Std::of(tcx, adt.did()) { Some(Std::Option | Std::Poll) => { let payload = adt.variant(variant).fields.iter().next()?; - Some(self.b.t.ty(payload.ty(tcx, args).skip_norm_wip(), span)) + Some(self.b.t.ty(payload.ty(tcx, *args).skip_norm_wip(), span)) } Some(Std::Result) => { let payload = self.b.t.ty(args.type_at(variant.index()), span); @@ -601,7 +601,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // What `control_flow_field` reads of each variant. Some(Std::ControlFlow) => { let (breaks, continues) = (args.type_at(0), args.type_at(1)); - Some(match (Flow::of(tcx, args), variant.index()) { + Some(match (Flow::of(tcx, *args), variant.index()) { (Flow::Option, 0) => self.b.t.ty(continues, span), (Flow::Option, _) => match self.b.t.erases_to(continues).undefined { true => crate::ts::Type::Rs("None", vec![]), @@ -616,7 +616,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let def = adt.variant(variant); let mut fields = vec![("tag".to_string(), crate::ts::Type::StrLit(def.name.to_string()))]; for (i, field) in def.fields.iter().enumerate() { - let ty = self.b.t.ty(field.ty(tcx, args).skip_norm_wip(), span); + let ty = self.b.t.ty(field.ty(tcx, *args).skip_norm_wip(), span); fields.push((crate::lower::field_name(field.name.as_str(), i), ty)); } Some(crate::ts::Type::Object(fields)) @@ -639,7 +639,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { match ty.kind() { ty::Tuple(_) => base.index(Expr::lit(field.index().to_string())), ty::Coroutine(def_id, args) => { - let info = super::coroutine::info(self.b.t, *def_id, args, span); + let info = super::coroutine::info(self.b.t, *def_id, *args, span); match variant { None => base.field(info.upvars[field.index()]), Some(variant) => { @@ -665,7 +665,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Some(Std::Bound | Std::TryLockError) => { let ty::Adt(_, args) = ty.kind() else { unreachable!() }; let variant = adt.variant(variant.unwrap_or(rustc_abi::FIRST_VARIANT)); - let held = variant.fields[field].ty(tcx, args).skip_norm_wip(); + let held = variant.fields[field].ty(tcx, *args).skip_norm_wip(); let fields = vec![ ("tag".to_string(), crate::ts::Type::StrLit(variant.name.to_string())), ("_0".to_string(), self.b.t.ty(held, span)), @@ -726,7 +726,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { match def.name.as_str() { name if crate::lower::bindgen::js_field(tcx, adt.did()) == Some(name) => base, _ if def - .ty(tcx, args) + .ty(tcx, *args) .skip_norm_wip() .ty_adt_def() .is_some_and(|f| f.is_phantom_data()) => @@ -760,7 +760,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } }; let ty::Adt(_, args) = ty.kind() else { unreachable!() }; - self.b.t.held_field(read, def.did, args, span) + self.b.t.held_field(read, def.did, *args, span) } _ => self.err(span, format!("a field of `{ty}`")), }, @@ -1030,7 +1030,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { ) { break; } - value = narrowed(self.adt(adt.did(), *variant, args, vec![value], ty, span)); + value = narrowed(self.adt(adt.did(), *variant, *args, vec![value], ty, span)); (at, rebuilt) = (base, true); } match rebuilt { @@ -1339,7 +1339,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.err(span, format!("setting the discriminant of `{ty}`")); return None; }; - let info = super::coroutine::info(self.b.t, *def_id, args, span); + let info = super::coroutine::info(self.b.t, *def_id, *args, span); let mut out = Vec::new(); let target = self.place_expr(place, span, &mut out); Some(StmtKind::Expr(target.field(info.state).assign(Expr::lit(variant.as_u32().to_string()))).at(None)) @@ -1352,7 +1352,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let tcx = self.tcx; match ty.kind() { ty::Coroutine(def_id, args) => { - let info = super::coroutine::info(self.b.t, *def_id, args, span); + let info = super::coroutine::info(self.b.t, *def_id, *args, span); scrut .clone() .field(info.state) @@ -1750,11 +1750,11 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { { let values = (adt.non_enum_variant().fields.iter()) .map(|f| { - let t = self.b.t.field_ty(f.did, args); + let t = self.b.t.field_ty(f.did, *args); self.zero(t, span) }) .collect(); - self.adt(adt.did(), rustc_abi::FIRST_VARIANT, args, values, ty, span) + self.adt(adt.did(), rustc_abi::FIRST_VARIANT, *args, values, ty, span) } _ => { let env = self.b.t.typing_env_pub(); @@ -1767,7 +1767,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } let memory = Allocation::from_bytes( vec![0; layout.size.bytes_usize()], - layout.align.abi, + layout.align, rustc_ast::Mutability::Not, (), ); @@ -1791,11 +1791,11 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }; let values = (adt.variant(variant).fields.iter()) .map(|f| { - let t = self.b.t.field_ty(f.did, args); + let t = self.b.t.field_ty(f.did, *args); self.zero(t, span) }) .collect(); - self.adt(adt.did(), variant, args, values, ty, span) + self.adt(adt.did(), variant, *args, values, ty, span) } } } @@ -1834,7 +1834,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { ty::Adt(adt, args) => self.adt( adt.did(), d.variant.unwrap_or(rustc_abi::FIRST_VARIANT), - args, + *args, values, ty, span, @@ -2501,7 +2501,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { pub(super) fn made_out_of_step( &self, def_id: rustc_hir::def_id::DefId, - gargs: ty::GenericArgsRef<'tcx>, + gargs: ty::GenericArgs<'tcx>, pointee: Place<'tcx>, ) -> Option { let tcx = self.tcx; @@ -2514,7 +2514,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { && let ty::Adt(adt, args) = pointee.ty(&self.mir.local_decls, tcx).ty.kind() => { let unsafe_cell = adt.non_enum_variant().fields[FieldIdx::ZERO] - .ty(tcx, args) + .ty(tcx, *args) .skip_norm_wip(); tcx.mk_place_field( tcx.mk_place_field(pointee, FieldIdx::ZERO, unsafe_cell), diff --git a/ts/src/lower/mir/rvalue.rs b/ts/src/lower/mir/rvalue.rs index 242c26f2e..b91e7616b 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -699,7 +699,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { fn discriminant(&mut self, scrut: Expr, ty: Ty<'tcx>, next: bool, span: Span, out: &mut Vec) -> Expr { match ty.kind() { ty::Coroutine(def_id, args) => { - let info = super::coroutine::info(self.b.t, *def_id, args, span); + let info = super::coroutine::info(self.b.t, *def_id, *args, span); scrut.field(info.state) } ty::Adt(adt, _) if adt.is_enum() => { @@ -772,13 +772,13 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { ) -> Option { match kind { AggregateKind::Closure(def_id, args) => { - return Some(self.closure(Ty::new_closure(self.tcx, *def_id, args), ops, span, out)); + return Some(self.closure(Ty::new_closure(self.tcx, *def_id, *args), ops, span, out)); } AggregateKind::CoroutineClosure(def_id, args) => { - return Some(self.closure(Ty::new_coroutine_closure(self.tcx, *def_id, args), ops, span, out)); + return Some(self.closure(Ty::new_coroutine_closure(self.tcx, *def_id, *args), ops, span, out)); } AggregateKind::Coroutine(def_id, args) => { - return Some(super::coroutine::construct(self, *def_id, args, ops, span, out)); + return Some(super::coroutine::construct(self, *def_id, *args, ops, span, out)); } AggregateKind::RawPtr(..) => return Some(self.err(span, "a raw pointer made from parts")), _ => {} @@ -824,7 +824,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let parts = self .b .t - .union_field(self.tcx.adt_def(*def_id), args, active.as_usize(), span); + .union_field(self.tcx.adt_def(*def_id), *args, active.as_usize(), span); let field_ty = ops[FieldIdx::ZERO].ty(&self.mir.local_decls, self.tcx); let value = values.pop().expect("a union's field"); let value = match parts.len() { @@ -839,7 +839,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { return Some(same); } let values = self.held_slices(ty, values, span, out); - self.adt(*def_id, *variant, args, values, ty, span) + self.adt(*def_id, *variant, *args, values, ty, span) } _ => unreachable!(), }) @@ -922,7 +922,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { &mut self, def_id: rustc_hir::def_id::DefId, variant: VariantIdx, - args: ty::GenericArgsRef<'tcx>, + args: ty::GenericArgs<'tcx>, mut values: Vec, ty: Ty<'tcx>, span: Span, @@ -1179,7 +1179,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { coroutine_closure_def_id: def_id, receiver_by_ref: false, }), - args, + args: *args, }; let mir = shim.instantiate_mir_and_normalize_erasing_regions( tcx, diff --git a/ts/src/lower/mir/scalar.rs b/ts/src/lower/mir/scalar.rs index 1f7a9b427..c544abd3c 100644 --- a/ts/src/lower/mir/scalar.rs +++ b/ts/src/lower/mir/scalar.rs @@ -504,7 +504,7 @@ impl<'tcx> crate::lower::Translator<'_, 'tcx> { .variant(VariantIdx::from_usize(v)) .fields .iter() - .map(|f| f.ty(tcx, args).skip_norm_wip()) + .map(|f| f.ty(tcx, *args).skip_norm_wip()) .collect(); if tys.iter().any(|t| uninhabited(*t)) { return Some(None); @@ -1631,7 +1631,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { values.push(fx.build(field, None, &parts[at..at + field.size()], span)); at += field.size(); } - fx.adt(adt.did(), VariantIdx::from_usize(v), args, values, *ty, span) + fx.adt(adt.did(), VariantIdx::from_usize(v), *args, values, *ty, span) }; match known { Some(v) => make(self, v), diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index 2948ebaee..f7280482a 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -39,7 +39,7 @@ use std::collections::VecDeque; use rustc_hir::def::DefKind; use rustc_hir::def_id::{CrateNum, DefId, LocalDefId}; use rustc_middle::ty::{ - self, AdtDef, EarlyBinder, GenericArgsRef, Instance, InstanceKind, Ty, TyCtxt, TypeVisitableExt, TypingEnv, + self, AdtDef, EarlyBinder, GenericArgs, Instance, InstanceKind, Ty, TyCtxt, TypeVisitableExt, TypingEnv, }; use rustc_span::Span; @@ -275,7 +275,7 @@ pub struct Translator<'a, 'tcx> { object_classes: rustc_data_structures::fx::FxHashMap<(Ty<'tcx>, dynamic::Held), dynamic::Class>, /// The trait method, with its arguments, each of those classes' methods calls, by class /// and name. - class_methods: rustc_data_structures::fx::FxHashMap<(SymId, String), (DefId, GenericArgsRef<'tcx>)>, + class_methods: rustc_data_structures::fx::FxHashMap<(SymId, String), (DefId, GenericArgs<'tcx>)>, /// The class of each coroutine instance. pub coroutines: rustc_data_structures::fx::FxHashMap, mir::coroutine::Info<'tcx>>, /// Whether [`Self::ty`] is typing a variable: see [`Self::held_ty`]. @@ -1030,14 +1030,14 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { }) } - pub fn subst>>(&self, args: GenericArgsRef<'tcx>, value: T) -> T { + pub fn subst>>(&self, args: GenericArgs<'tcx>, value: T) -> T { self.tcx .instantiate_and_normalize_erasing_regions(args, self.typing_env(), EarlyBinder::bind(self.tcx, value)) } /// `def_id`'s signature for `args`, with what its projections name, as `Deref::deref`'s /// `&Self::Target`, where they resolve: a census's call over type parameters may leave one. - pub fn sig(&self, def_id: DefId, args: GenericArgsRef<'tcx>) -> ty::FnSig<'tcx> { + pub fn sig(&self, def_id: DefId, args: GenericArgs<'tcx>) -> ty::FnSig<'tcx> { let sig = self.tcx.fn_sig(def_id).instantiate(self.tcx, args).skip_norm_wip(); let sig = self.tcx.instantiate_bound_regions_with_erased(sig); self.tcx @@ -1059,7 +1059,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { /// Whether a call of `def_id` with `args` runs a function whose body translates, the /// crate's own or std's from its MIR, rather than a mapping. - pub fn translated(&self, def_id: DefId, args: GenericArgsRef<'tcx>) -> bool { + pub fn translated(&self, def_id: DefId, args: GenericArgs<'tcx>) -> bool { match Instance::try_resolve(self.tcx, self.typing_env(), def_id, args) { Ok(Some(instance)) => self.lowers(self.typing_env(), instance) || self.dispatches(instance), _ => false, @@ -1083,7 +1083,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { /// Whether a call of `def_id` with `args` runs std's mapping, which takes a `&mut` /// parameter as what it points at, rather than a body that translates or a binding's export. - pub fn mapped(&self, def_id: DefId, args: GenericArgsRef<'tcx>) -> bool { + pub fn mapped(&self, def_id: DefId, args: GenericArgs<'tcx>) -> bool { match Instance::try_resolve(self.tcx, self.typing_env(), def_id, args) { Ok(Some(instance)) => { !self.lowers(self.typing_env(), instance) @@ -1096,7 +1096,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } /// Whether a call of `def_id` with `args` calls a binding's export. - pub fn binds(&self, def_id: DefId, args: GenericArgsRef<'tcx>) -> bool { + pub fn binds(&self, def_id: DefId, args: GenericArgs<'tcx>) -> bool { match Instance::try_resolve(self.tcx, self.typing_env(), def_id, args) { Ok(Some(instance)) => self.bound_module(instance).is_some(), _ => false, @@ -1627,7 +1627,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { .collect(); Type::Func(params, Box::new(self.future_ty(sig.return_ty, span))) } - ty::Adt(adt, args) => self.adt_ty(*adt, args, span), + ty::Adt(adt, args) => self.adt_ty(*adt, *args, span), ty::Pat(base, _) => self.ty(*base, span), ty::Coroutine(_, args) => self.future_ty(args.as_coroutine().return_ty(), span), ty::Dynamic(..) if let Some(output) = self.dyn_future(ty) => self.future_ty(output, span), @@ -1707,7 +1707,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { ) }) } - library::Std::ControlFlow if library::Flow::of(self.tcx, args) == library::Flow::Option => { + library::Std::ControlFlow if library::Flow::of(self.tcx, *args) == library::Flow::Option => { let erased = self.erases_to(args.type_at(1)); (erased.undefined && erased.none) .then(|| format!("`{ty}` is not supported: its break and its continue would both be `rs.None`")) @@ -1731,7 +1731,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } } - fn adt_ty(&mut self, adt: AdtDef<'tcx>, args: GenericArgsRef<'tcx>, span: Span) -> Type { + fn adt_ty(&mut self, adt: AdtDef<'tcx>, args: GenericArgs<'tcx>, span: Span) -> Type { let tcx = self.tcx; if let Some(vec) = smallvec::as_vec(tcx, Ty::new_adt(tcx, adt, args)) { return self.ty(vec, span); @@ -2030,7 +2030,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { /// The TypeScript type arguments of an instance of the crate's generic `adt` with `args`, /// by the name of the parameter each is: one per type parameter, then one per projection /// typing its fields named, which is what the projection normalizes to at `args`. - fn instance_params(&mut self, adt: DefId, args: GenericArgsRef<'tcx>, span: Span) -> Vec<(String, Type)> { + fn instance_params(&mut self, adt: DefId, args: GenericArgs<'tcx>, span: Span) -> Vec<(String, Type)> { let mut params = self.own_args(adt, args, span); let instance = Ty::new_adt(self.tcx, self.tcx.adt_def(adt), args); if !self.enter_instance(instance, span) { @@ -2043,7 +2043,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } /// The TypeScript type of each type argument of an instance of `adt`, by its parameter. - fn own_args(&mut self, adt: DefId, args: GenericArgsRef<'tcx>, span: Span) -> Vec<(String, Type)> { + fn own_args(&mut self, adt: DefId, args: GenericArgs<'tcx>, span: Span) -> Vec<(String, Type)> { (self.tcx.generics_of(adt).own_params.iter()) .filter(|param| matches!(param.kind, ty::GenericParamDefKind::Type { .. })) .map(|param| { @@ -2057,7 +2057,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { /// What each projection typing the crate's generic `adt`'s fields named normalizes to at /// `args`, by its parameter. - fn projection_args(&mut self, adt: DefId, args: GenericArgsRef<'tcx>, span: Span) -> Vec<(String, Type)> { + fn projection_args(&mut self, adt: DefId, args: GenericArgs<'tcx>, span: Span) -> Vec<(String, Type)> { let (projections, names): (Vec>, Vec) = self.defined(adt).projections.iter().cloned().unzip(); let env = self.defining.map_or(self.typing_env(), |(_, env)| env); let tcx = self.tcx; @@ -2107,7 +2107,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { value: ts::Expr, adt: DefId, field: DefId, - args: GenericArgsRef<'tcx>, + args: GenericArgs<'tcx>, span: Span, ) -> ts::Expr { let defined = match self.instanced_fields.get(&field) { @@ -2124,7 +2124,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { /// `read`, of `field` of an instance with `args`, cast to what the instance holds there /// where the definition types a form in it that only an instance decides. - pub fn held_field(&mut self, read: ts::Expr, field: DefId, args: GenericArgsRef<'tcx>, span: Span) -> ts::Expr { + pub fn held_field(&mut self, read: ts::Expr, field: DefId, args: GenericArgs<'tcx>, span: Span) -> ts::Expr { if !self.instanced_fields.contains_key(&field) { return read; } @@ -2136,7 +2136,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { /// if it can't: a part its definition, or that of an instance it holds, types that this /// instance represents otherwise (see [`defined::Decides`]), or that can't tell its values /// apart at all. - fn generic_erasure(&mut self, adt: AdtDef<'tcx>, args: GenericArgsRef<'tcx>, span: Span) -> Option { + fn generic_erasure(&mut self, adt: AdtDef<'tcx>, args: GenericArgs<'tcx>, span: Span) -> Option { let tcx = self.tcx; let env = self.defining.map_or(self.typing_env(), |(_, env)| env); // Each its definition typed, which leaves out what types nothing, such as a `PhantomData`. @@ -2152,7 +2152,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { fn decided_conflict( &mut self, adt: AdtDef<'tcx>, - args: GenericArgsRef<'tcx>, + args: GenericArgs<'tcx>, decided: &defined::Decided<'tcx>, span: Span, ) -> Option { @@ -2185,7 +2185,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { let (ty::Adt(_, at), ty::Adt(_, typed)) = (held.kind(), part.kind()) else { return None; }; - return (library::Flow::of(tcx, at) != library::Flow::of(tcx, typed)).then(|| { + return (library::Flow::of(tcx, *at) != library::Flow::of(tcx, *typed)).then(|| { format!( "`{ty}` is not supported: its field `{field}` is `{part}`, typed as a result that breaks with `{inner}`, which `{held}` is not, as it breaks with what `?` makes" ) @@ -2372,7 +2372,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { undefined: true, ..Erased::default() }, - Some(library::Std::ControlFlow) if library::Flow::of(self.tcx, args) == library::Flow::Option => { + Some(library::Std::ControlFlow) if library::Flow::of(self.tcx, *args) == library::Flow::Option => { self.erases_to(args.type_at(1)).option() } _ => Erased::default(), @@ -2440,7 +2440,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { .tcx .get_all_attrs(def_id) .iter() - .filter_map(|attr| attr.doc_str()) + .filter_map(|attr| rustc_ast::attr::AttributeExt::doc_str_and_fragment_kind(attr).map(|(doc, ..)| doc)) .map(|doc| doc.to_string()) .collect(); let doc = lines.join("\n"); diff --git a/ts/src/lower/names.rs b/ts/src/lower/names.rs index bcc9a4325..95ce69e04 100644 --- a/ts/src/lower/names.rs +++ b/ts/src/lower/names.rs @@ -45,14 +45,14 @@ impl<'tcx> Translator<'_, 'tcx> { // The references after the arguments, which no spelling of a type ends in, so // `&mut Take`'s differ from `Take<&mut T>`'s. ty::Adt(_, adt_args) if owned => { - parts.extend(args(tcx, adt_args)); + parts.extend(args(tcx, adt_args.as_slice())); parts.extend(refs); } _ => parts.push(ty(tcx, self_ty)), } } let own = tcx.generics_of(def_id).parent_count; - parts.extend(args(tcx, &instance.args[own..])); + parts.extend(args(tcx, &instance.args.as_slice()[own..])); parts.join("_") } @@ -214,7 +214,9 @@ pub fn ty<'tcx>(tcx: TyCtxt<'tcx>, t: Ty<'tcx>) -> String { let parts: Vec = match t.kind() { // Its arguments, but not defaults such as a `Vec`'s allocator. ty::Adt(adt, adt_args) => { - let adt_args = tcx.generics_of(adt.did()).own_args_no_defaults(tcx, adt_args); + let adt_args = tcx + .generics_of(adt.did()) + .own_args_no_defaults(tcx, adt_args.as_slice()); defined(tcx, adt.did(), adt_args) } ty::Ref(_, inner, mutability) => vec![reference(*mutability).into(), ty(tcx, *inner)], @@ -254,7 +256,7 @@ pub fn ty<'tcx>(tcx: TyCtxt<'tcx>, t: Ty<'tcx>) -> String { ty::Closure(def_id, closure) => defined(tcx, *def_id, closure.as_closure().parent_args()), ty::Coroutine(def_id, coroutine) => defined(tcx, *def_id, coroutine.as_coroutine().parent_args()), ty::CoroutineClosure(def_id, closure) => defined(tcx, *def_id, closure.as_coroutine_closure().parent_args()), - ty::FnDef(def_id, fn_args) => defined(tcx, *def_id, fn_args.skip_binder()), + ty::FnDef(def_id, fn_args) => defined(tcx, *def_id, fn_args.skip_binder().as_tcx_slice()), _ => vec![t.to_string().replace(|c: char| !c.is_alphanumeric(), "")], }; parts.join("_") @@ -311,7 +313,7 @@ fn reference(mutability: ty::Mutability) -> &'static str { pub fn trait_name<'tcx>(tcx: TyCtxt<'tcx>, trait_ref: ty::TraitRef<'tcx>) -> String { let trait_args = tcx .generics_of(trait_ref.def_id) - .own_args_no_defaults(tcx, trait_ref.args); + .own_args_no_defaults(tcx, trait_ref.args.as_slice()); std::iter::once(path(tcx, trait_ref.def_id)) .chain(args(tcx, trait_args)) .collect::>() diff --git a/ts/src/lower/pointer.rs b/ts/src/lower/pointer.rs index ef0b53e96..26291e5c3 100644 --- a/ts/src/lower/pointer.rs +++ b/ts/src/lower/pointer.rs @@ -198,7 +198,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } ty::Tuple(tys) => Some((tys.to_vec(), false)), ty::Adt(adt, args) if adt.is_struct() && Std::of(self.tcx, adt.did()).is_none() && self.own(adt.did()) => { - Some((adt.all_fields().map(|f| self.field_ty(f.did, args)).collect(), false)) + Some((adt.all_fields().map(|f| self.field_ty(f.did, *args)).collect(), false)) } _ => None, } @@ -272,7 +272,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { ty::Adt(adt, args) => match Std::of(self.tcx, adt.did()) { Some(Std::MaybeUninit | Std::ManuallyDrop) => self.empty(args.type_at(0)), Some(_) => false, - None => adt.is_struct() && adt.all_fields().all(|f| self.empty(self.field_ty(f.did, args))), + None => adt.is_struct() && adt.all_fields().all(|f| self.empty(self.field_ty(f.did, *args))), }, _ => false, } @@ -336,12 +336,12 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { let plain = self.plain(info.sym); let values = (adt.non_enum_variant().fields.iter()) .map(|f| { - let t = self.field_ty(f.did, args); + let t = self.field_ty(f.did, *args); let value = match plain { true => self.shell(t, span), false => self.uninit(t, span), }; - self.field_value(value, adt.did(), f.did, args, span) + self.field_value(value, adt.did(), f.did, *args, span) }) .collect(); self.construct(info.sym, &ctor, &fields, values) @@ -362,7 +362,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { pub fn from_reference<'tcx>( tcx: ty::TyCtxt<'tcx>, def_id: rustc_hir::def_id::DefId, - args: ty::GenericArgsRef<'tcx>, + args: ty::GenericArgs<'tcx>, ) -> bool { let Some((owner, name)) = super::library::key(tcx, def_id) else { return false; @@ -492,7 +492,7 @@ pub fn lends(tcx: ty::TyCtxt<'_>, def_id: rustc_hir::def_id::DefId) -> bool { /// Whether std's `def_id` with `args` is one that only makes a pointer or points one /// elsewhere, reads through it, or drops what it points at, as this module maps them, or /// an atomic's, which holds a pointer as a value, so it gives no part another object. -pub fn keeps<'tcx>(tcx: ty::TyCtxt<'tcx>, def_id: rustc_hir::def_id::DefId, args: ty::GenericArgsRef<'tcx>) -> bool { +pub fn keeps<'tcx>(tcx: ty::TyCtxt<'tcx>, def_id: rustc_hir::def_id::DefId, args: ty::GenericArgs<'tcx>) -> bool { let keeps = matches!( super::library::key(tcx, def_id), Some((owner, name)) if matches!( @@ -527,11 +527,7 @@ pub fn keeps<'tcx>(tcx: ty::TyCtxt<'tcx>, def_id: rustc_hir::def_id::DefId, args /// own iterator's that its `next` reads through, an `IoSlice`'s and a `&mut` to a slice of /// them, which `advance` and `advance_slices` move, and a well-known crate's, such as a /// `Bytes` that `Buf::advance` moves past its front. -fn takes_place<'tcx>( - t: &Translator<'_, 'tcx>, - def_id: rustc_hir::def_id::DefId, - args: ty::GenericArgsRef<'tcx>, -) -> bool { +fn takes_place<'tcx>(t: &Translator<'_, 'tcx>, def_id: rustc_hir::def_id::DefId, args: ty::GenericArgs<'tcx>) -> bool { matches!( super::library::key(t.tcx, def_id), Some((owner, name)) if matches!(owner.as_str(), "MaybeUninit" | "ManuallyDrop" | "IoSlice") @@ -553,7 +549,7 @@ fn takes_place<'tcx>( pub fn pointees<'tcx>( t: &Translator<'_, 'tcx>, def_id: rustc_hir::def_id::DefId, - args: ty::GenericArgsRef<'tcx>, + args: ty::GenericArgs<'tcx>, ) -> Vec { let takes_place = takes_place(t, def_id, args); let sig = t.tcx.fn_sig(def_id).instantiate_identity().skip_norm_wip(); @@ -1293,7 +1289,7 @@ pub fn cast<'tcx>(b: &mut Body<'_, '_, 'tcx>, p: Expr, from: Ty<'tcx>, to: Ty<'t let (tcx, env) = (b.t.tcx, b.t.typing_env_pub()); let key = |t: Ty<'tcx>| Expr::Str(tcx.erase_and_anonymize_regions(t).to_string()); let align = |t: Ty<'tcx>| { - let align = tcx.layout_of(env.as_query_input(t)).map_or(1, |l| l.align.abi.bytes()); + let align = tcx.layout_of(env.as_query_input(t)).map_or(1, |l| l.align.bytes()); Expr::lit(align.to_string()) }; if b.t.identity_pointee(into) { diff --git a/ts/src/lower/smallvec.rs b/ts/src/lower/smallvec.rs index d4cf0d359..5a63b7ae6 100644 --- a/ts/src/lower/smallvec.rs +++ b/ts/src/lower/smallvec.rs @@ -56,7 +56,7 @@ pub fn as_vec<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option> { let global = Ty::new_adt( tcx, tcx.adt_def(tcx.lang_items().get(LangItem::GlobalAlloc)?), - ty::List::empty(), + ty::GenericArgs::empty(), ); let (did, args): (DefId, Vec>) = match tcx.item_name(adt.did()).as_str() { "SmallVec" => (vec, vec![(*elem).into(), global.into()]), @@ -265,7 +265,7 @@ fn inherent<'tcx>( .iter() .find(|v| v.name.as_str() == "CapacityOverflow")? .ctor_def_id()?; - let overflow = b.call_def(overflow, eargs, Vec::new(), span, out); + let overflow = b.call_def(overflow, *eargs, Vec::new(), span, out); Some(Expr::Cond( Box::new(ok), Box::new(Expr::Rs("OK".into())), @@ -409,7 +409,7 @@ fn vec_call<'tcx>( let global = Ty::new_adt( tcx, tcx.adt_def(tcx.lang_items().get(LangItem::GlobalAlloc)?), - ty::List::empty(), + ty::GenericArgs::empty(), ); // `Vec`'s or `Vec`'s parameters, then the method's own, which follow // `SmallVec`'s one. diff --git a/ts/src/lower/task.rs b/ts/src/lower/task.rs index 56560f22b..ce8518f8c 100644 --- a/ts/src/lower/task.rs +++ b/ts/src/lower/task.rs @@ -510,7 +510,7 @@ fn atomic<'tcx>( let generics = tcx.generics_of(imp).count(); let atomic = tcx .type_of(imp) - .instantiate(tcx, &call.args[..generics]) + .instantiate(tcx, &call.args.as_slice()[..generics]) .skip_norm_wip(); let pointee = match atomic.kind() { ty::Adt(_, atomic_args) => match atomic_args.type_at(0).kind() { @@ -691,7 +691,7 @@ fn once<'tcx>( let generics = tcx.generics_of(imp).count(); let cell = tcx .type_of(imp) - .instantiate(tcx, &call.args[..generics]) + .instantiate(tcx, &call.args.as_slice()[..generics]) .skip_norm_wip(); let inner = call.args.type_at(0); let none = b.t.none_arg(inner); diff --git a/ts/src/lower/tokio.rs b/ts/src/lower/tokio.rs index 57c8a082a..4e886abdc 100644 --- a/ts/src/lower/tokio.rs +++ b/ts/src/lower/tokio.rs @@ -401,7 +401,7 @@ pub fn trait_call<'tcx>( let ty::Adt(_, handle_args) = self_ty.peel_refs().kind() else { return Err(args); }; - let value = held(handle_args); + let value = held(*handle_args); let span = call.span; let mut args = args.into_iter(); let mut arg = || args.next().expect("an argument"); @@ -458,7 +458,7 @@ pub fn debug<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, f: Exp return None; }; let handle = Handle::of(tcx, adt.did())?; - let shown = |b: &mut Body<'_, '_, 'tcx>| b.fmt_fn(super::fmt::Trait::Debug, held(args), span); + let shown = |b: &mut Body<'_, '_, 'tcx>| b.fmt_fn(super::fmt::Trait::Debug, held(*args), span); Some(match handle { Handle::WatchSender => Expr::rs("watchSenderDebug", vec![value, f, shown(b)]), Handle::WatchReceiver => Expr::rs("watchReceiverDebug", vec![value, f, shown(b)]), @@ -498,7 +498,7 @@ pub fn lends(tcx: TyCtxt<'_>, did: DefId) -> bool { /// The type of the values a handle's channel holds, its one type parameter, after the /// lifetime of a `watch::Ref`. -pub fn held<'tcx>(args: ty::GenericArgsRef<'tcx>) -> Ty<'tcx> { +pub fn held<'tcx>(args: ty::GenericArgs<'tcx>) -> Ty<'tcx> { args.types().next().expect("a channel's value type") } @@ -511,7 +511,7 @@ fn err_of(ty: Ty<'_>) -> Ty<'_> { } /// The constructor of `ty`'s variant named `variant`, or of its struct. -fn ctor<'tcx>(ty: Ty<'tcx>, variant: Option<&str>) -> (DefId, ty::GenericArgsRef<'tcx>) { +fn ctor<'tcx>(ty: Ty<'tcx>, variant: Option<&str>) -> (DefId, ty::GenericArgs<'tcx>) { let ty::Adt(adt, args) = ty.kind() else { unreachable!("tokio's errors are structs and enums") }; @@ -523,7 +523,7 @@ fn ctor<'tcx>(ty: Ty<'tcx>, variant: Option<&str>) -> (DefId, ty::GenericArgsRef .expect("tokio's error variant"), None => adt.non_enum_variant(), }; - (variant.ctor_def_id().expect("a tuple or unit constructor"), args) + (variant.ctor_def_id().expect("a tuple or unit constructor"), *args) } /// A value of `ty`'s variant `variant`, or of its struct, of `fields`. diff --git a/ts/src/lower/unions.rs b/ts/src/lower/unions.rs index 1f6bac053..d13b2a2bb 100644 --- a/ts/src/lower/unions.rs +++ b/ts/src/lower/unions.rs @@ -12,7 +12,7 @@ use rustc_abi::FieldIdx; use rustc_middle::ty::layout::LayoutError; -use rustc_middle::ty::{self, AdtDef, GenericArgsRef, Ty, TypeVisitableExt, TypingEnv}; +use rustc_middle::ty::{self, AdtDef, GenericArgs, Ty, TypeVisitableExt, TypingEnv}; use rustc_span::Span; use super::library::Std; @@ -63,7 +63,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { &self, env: TypingEnv<'tcx>, adt: AdtDef<'tcx>, - args: GenericArgsRef<'tcx>, + args: GenericArgs<'tcx>, typed: bool, ) -> Result, String> { self.overlay_of(env, adt, args, typed, &[]) @@ -93,7 +93,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { &self, env: TypingEnv<'tcx>, adt: AdtDef<'tcx>, - args: GenericArgsRef<'tcx>, + args: GenericArgs<'tcx>, typed: bool, open: &[bool], ) -> Result, String> { @@ -165,7 +165,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { adt.non_enum_variant() .fields .iter() - .map(|f| self.field_ty(f.did, args)) + .map(|f| self.field_ty(f.did, *args)) .collect(), ), _ => None, @@ -229,7 +229,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { /// The slots of union `adt` with `args`, laid out the first time: none, refused, if its /// fields overlap in values JS keeps apart. - pub fn laid_out(&mut self, adt: AdtDef<'tcx>, args: GenericArgsRef<'tcx>, span: Span) -> Overlay<'tcx> { + pub fn laid_out(&mut self, adt: AdtDef<'tcx>, args: GenericArgs<'tcx>, span: Span) -> Overlay<'tcx> { let AdtRepr::Slots(layout) = self.adt(adt, span).repr else { unreachable!("a union") }; @@ -284,8 +284,8 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { unreachable!("a union's part is in a struct") }; let field = &adt.non_enum_variant().fields[FieldIdx::from_usize(first)]; - let part_ty = self.field_ty(field.did, args); - let read = self.held_field(Translator::read_field(value, fields[first]), field.did, args, span); + let part_ty = self.field_ty(field.did, *args); + let read = self.held_field(Translator::read_field(value, fields[first]), field.did, *args, span); self.part_of(read, part_ty, rest, span) } _ => unreachable!("a union's part is in a tuple or a struct"), @@ -325,14 +325,14 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { .non_enum_variant() .fields .iter() - .map(|f| self.field_ty(f.did, args)) + .map(|f| self.field_ty(f.did, *args)) .collect(); let defs = &adt.non_enum_variant().fields; let values = (tys.into_iter().zip(defs.iter()).enumerate()) .map(|(i, (t, field))| { let part = within(i); let value = self.of_slots(base.clone(), t, &part, span); - self.field_value(value, adt.did(), field.did, args, span) + self.field_value(value, adt.did(), field.did, *args, span) }) .collect(); self.construct(info.sym, &ctor, &fields, values) @@ -343,13 +343,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } /// The parts of field `field` of union `adt` with `args`. - pub fn union_field( - &mut self, - adt: AdtDef<'tcx>, - args: GenericArgsRef<'tcx>, - field: usize, - span: Span, - ) -> Vec { + pub fn union_field(&mut self, adt: AdtDef<'tcx>, args: GenericArgs<'tcx>, field: usize, span: Span) -> Vec { self.laid_out(adt, args, span).0.swap_remove(field) } } From 18b5a774bd4d94020a512ce26280dda9c49ad32a Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 12 Nov 2026 18:08:22 -0800 Subject: [PATCH 03/13] test(ffi): the reject fixture on 1.102's std, where Pattern is unsafe and Allocator stable Co-Authored-By: Claude Opus 5.5 --- ffi/fixtures/reject/src/lib.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ffi/fixtures/reject/src/lib.rs b/ffi/fixtures/reject/src/lib.rs index 71dee9e46..4648e30ae 100644 --- a/ffi/fixtures/reject/src/lib.rs +++ b/ffi/fixtures/reject/src/lib.rs @@ -1,5 +1,5 @@ //! Items rust2-ffi cannot export: each is a compile error at its span. -#![feature(allocator_api, pattern)] +#![feature(pattern)] use std::collections::HashMap; /// A tuple of references taken: C lends nothing inside a value. @@ -738,7 +738,7 @@ pub fn lent() -> impl Iterator { /// A pattern of the crate's own, whose searcher a split runs as it is read. struct Slash; -impl std::str::pattern::Pattern for Slash { +unsafe impl std::str::pattern::Pattern for Slash { type Searcher<'a> = std::str::pattern::CharSearcher<'a>; fn into_searcher(self, haystack: &str) -> std::str::pattern::CharSearcher<'_> { From 566d3ea5f5ada4d7e180dabf171e91e890436747 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 12 Nov 2026 19:43:42 -0800 Subject: [PATCH 04/13] fix(ts,go): port derived Debug, vec![x; n], the default panic messages, and IoSlice::advance to 1.102's std Co-Authored-By: Claude Opus 5.5 --- go/runtime/rt_fmt.go | 30 +++++++++++++------- go/src/lower/library.rs | 19 ++++--------- ts/runtime/rs.ts | 40 ++++++++++++++++++--------- ts/runtime/rs/task.ts | 4 +-- ts/src/lower/caller.rs | 14 +++++++--- ts/src/lower/library.rs | 55 +++++++++++++++---------------------- ts/src/lower/mir/holders.rs | 2 +- 7 files changed, 88 insertions(+), 76 deletions(-) diff --git a/go/runtime/rt_fmt.go b/go/runtime/rt_fmt.go index 853a0beec..ddb65a3d5 100644 --- a/go/runtime/rt_fmt.go +++ b/go/runtime/rt_fmt.go @@ -5,6 +5,7 @@ package rt import ( "strconv" + "strings" "unicode/utf8" ) @@ -516,20 +517,29 @@ func (b *DebugBuilder) finishNonExhaustive() fmtResult { return f.writeStr([]uint8(" { .. }")) } -func (f *Formatter) debugTupleFields(name []uint8, values ...fmtDyn) fmtResult { - b := f.debugTuple(name) - for _, v := range values { - b.field(nil, v) +// debugFields is derived Debug's `debug_struct_fields_finish`: names holds the type's +// name, then each field's, separated by spaces, and a name alone is a tuple struct's. +func (f *Formatter) debugFields(names []uint8, values []fmtDyn) fmtResult { + words := strings.Split(string(names), " ") + if len(words) == 1 { + b := f.debugTuple(names) + for _, v := range values { + b.field(nil, v) + } + return b.finish() + } + b := f.debugStruct([]uint8(words[0])) + for i, v := range values { + b.field([]uint8(words[i+1]), v) } return b.finish() } -func (f *Formatter) debugStructFields(name []uint8, names [][]uint8, values []fmtDyn) fmtResult { - b := f.debugStruct(name) - for i := range names { - b.field(names[i], values[i]) - } - return b.finish() +// debugEnum is derived Debug's `debug_c_like_enum_write_str`: the variant's name is the +// word of the space-separated names that starts at start. +func (f *Formatter) debugEnum(names []uint8, start uint) fmtResult { + name, _, _ := strings.Cut(string(names[start:]), " ") + return f.writeStr([]uint8(name)) } // then runs each step while the last succeeded, as `?` does. diff --git a/go/src/lower/library.rs b/go/src/lower/library.rs index 2c720595e..6d47c75e4 100644 --- a/go/src/lower/library.rs +++ b/go/src/lower/library.rs @@ -393,22 +393,15 @@ pub fn call_with<'tcx>( | "::finish" | "::finish" => expr(format!("{}.finish()", a[0])), "::finish_non_exhaustive" => expr(format!("{}.finishNonExhaustive()", a[0])), - k if k.starts_with("::debug_tuple_field") && k.ends_with("_finish") => { - expr(format!("{}.debugTupleFields({}, {})", a[0], a[1], a[2..].join(", "))) - } + // Derived `Debug`, whose names are the type's then its fields', space-separated. "::debug_struct_fields_finish" => { - expr(format!("{}.debugStructFields({}, {}, {})", a[0], a[1], a[2], a[3])) + expr(format!("{}.debugFields({}, {})", a[0], a[1], a[2])) } k if k.starts_with("::debug_struct_field") && k.ends_with("_finish") => { - let names: Vec<&str> = a[2..].iter().step_by(2).map(String::as_str).collect(); - let values: Vec<&str> = a[3..].iter().step_by(2).map(String::as_str).collect(); - expr(format!( - "{}.debugStructFields({}, [][]uint8{{{}}}, []fmtDyn{{{}}})", - a[0], - a[1], - names.join(", "), - values.join(", ") - )) + expr(format!("{}.debugFields({}, []fmtDyn{{{}}})", a[0], a[1], a[2..].join(", "))) + } + "::debug_c_like_enum_write_str" => { + expr(format!("{}.debugEnum({}, {})", a[0], a[1], a[2])) } "::fmt" => expr(format!("{}.pad({})", a[1], a[0])), "::fmt" | "::fmt" => expr(format!( diff --git a/ts/runtime/rs.ts b/ts/runtime/rs.ts index 2b34f1018..82493ac8a 100644 --- a/ts/runtime/rs.ts +++ b/ts/runtime/rs.ts @@ -16,7 +16,7 @@ import { drop as dispose, dropAll, partPlace, type Pending } from "./rs/task.ts" import { allocError, CAPACITY_OVERFLOW, type TryReserveError } from "./rs/alloc.ts"; import { AtIndex } from "./rs/collections.ts"; import { escapeDebug } from "./rs/char.ts"; -import { byteSliceUtf8Chunks, String as RsString, strFromUtf8Unchecked, stringClone, stringCloneFrom, stringFrom, stringLen, stringNew, stringOf, stringPush, stringPushStr, stringWithCapacity } from "./rs/str.ts"; +import { byteSliceUtf8Chunks, String as RsString, strFromUtf8Unchecked, strGet, stringClone, stringCloneFrom, stringFrom, stringLen, stringNew, stringOf, stringPush, stringPushStr, stringWithCapacity } from "./rs/str.ts"; export * from "./rs/alloc.ts"; export * from "./rs/any.ts"; export * from "./rs/ascii.ts"; @@ -2191,7 +2191,8 @@ export function byteSliceRange(s: ByteSlice, start: number, end: number = s.leng /** `IoSlice::advance` of the one at `p`: its bytes past the first `n`, which panics past its end. */ export function ioSliceAdvance(p: Place, n: number, at?: Location): void { - p.v = byteSliceRange(p.v, n, undefined, at); + if (n > p.v.length) panic("mid > len", at); + p.v = new ByteSlice(p.v.data, p.v.start + n, p.v.length - n); } /** @@ -3636,29 +3637,42 @@ export function fmtDebugList(f: Formatter): DebugList { return { fmt: f, result: f.out.writeStr("["), hasFields: false }; } -/** `debug_struct_fields_finish`, which derived `Debug` calls past five fields. */ +/** A struct's `Debug` of its name, each field's, and their values, as the runtime's impls write it. */ export function fmtDebugStructFields(f: Formatter, name: string, names: readonly string[], values: readonly Fmt[]): FmtResult { - if (names.length !== values.length) { - assertFailed( - "==", - (f) => usizeDisplay(names.length, f), - (f) => usizeDisplay(values.length, f), - undefined, - "debug_struct_fields", - ); - } const builder = fmtDebugStruct(f, name); names.forEach((field, i) => debugStructField(builder, field, values[i])); return debugStructFinish(builder); } -/** `debug_tuple_fields_finish`, which derived `Debug` calls past five fields. */ +/** A tuple struct's `Debug` of its name and its fields' values. */ export function fmtDebugTupleFields(f: Formatter, name: string, values: readonly Fmt[]): FmtResult { const builder = fmtDebugTuple(f, name); for (const value of values) debugTupleField(builder, value); return debugTupleFinish(builder); } +/** + * `Formatter::debug_struct_fields_finish`, which derived `Debug` calls with the type's name, + * then each field's, separated by spaces: a name alone is a tuple struct's. + */ +export function fmtDebugFields(f: Formatter, names: string, values: readonly Fmt[]): FmtResult { + const [name, ...fields] = names.split(" "); + if (fields.length === 0) return fmtDebugTupleFields(f, name, values); + const builder = fmtDebugStruct(f, name); + values.forEach((value, i) => { + if (i >= fields.length) panic("called `Option::unwrap()` on a `None` value", "debug_struct_fields"); + debugStructField(builder, fields[i], value); + }); + return debugStructFinish(builder); +} + +/** `Formatter::debug_c_like_enum_write_str`: the word of `names` from byte `start`. */ +export function fmtDebugEnum(f: Formatter, names: string, start: usize): FmtResult { + const rest = strGet(names, start); + if (rest === undefined) panic("called `Option::unwrap()` on a `None` value", "debug_enum"); + return f.out.writeStr(rest.split(" ", 1)[0]); +} + /** `fmt::DebugStruct`. */ export interface DebugStruct { readonly fmt: Formatter; diff --git a/ts/runtime/rs/task.ts b/ts/runtime/rs/task.ts index 2f7f4e73b..c0faa97ff 100644 --- a/ts/runtime/rs/task.ts +++ b/ts/runtime/rs/task.ts @@ -1712,12 +1712,12 @@ export class Ready implements Future { } poll(_cx: Context): Poll { - return this.#take("`Ready` polled after completion", "ready_poll"); + return this.#take("`Ready` should not be polled after completion", "ready_poll"); } /** `into_inner`, which consumes it. */ intoInner(): T { - return this.#take("Called `into_inner()` on `Ready` after completion", "ready_into_inner"); + return this.#take("`into_inner()` should not be called on `Ready` after completion", "ready_into_inner"); } #take(message: string, at: string): T { diff --git a/ts/src/lower/caller.rs b/ts/src/lower/caller.rs index 5f82daee9..5aa4d2d04 100644 --- a/ts/src/lower/caller.rs +++ b/ts/src/lower/caller.rs @@ -184,8 +184,14 @@ const SITES: &[(&str, &str, &str, &str)] = &[ ( "debug_struct_fields", "core/src/fmt/mod.rs", - "pub fn debug_struct_fields_finish", - "assert_eq!(", + "let name = names.next()", + "unwrap()", + ), + ( + "debug_enum", + "core/src/fmt/mod.rs", + "pub fn debug_c_like_enum_write_str", + "unwrap()", ), ( "exact_len", @@ -445,8 +451,8 @@ const CALLEES: &[(&str, &str, &str, &str)] = &[ ( "io::io_slice::advance", "core/src/io/io_slice/repr_generic.rs", - "pub(crate) fn advance(&mut self, n: usize)", - "[n..]", + "pub(crate) const fn advance(&mut self, n: usize)", + "split_at(", ), ( "io::io_slice::advance_slices", diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index fc98393e7..d5beb823b 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -1091,7 +1091,7 @@ fn discards(owner: &str, name: &str) -> Option<&'static [usize]> { // over, and `fill` its value if there is no slot for it. ("slice", "fill" | "fill_with" | "clone_from_slice") => &[0], // `vec![x; 0]` drops `x`. - ("vec", "from_elem") => &[0], + ("vec", "from_elem_global") => &[0], // `get_or_init::` drops its function uncalled if the cell is set. ("OnceCell" | "OnceLock", "get_or_init" | "get_or_try_init") => &[1], // A guard's map calls its function, filtered or not. @@ -2555,7 +2555,7 @@ fn mapping<'tcx>( ("Box", "assume_init") => args.pop()?, // `vec![x; n]`: `n - 1` clones of `x`, then `x` itself, which the caller gives as its // own, as it does whatever std keeps, or `x` dropped where `n` is 0. - ("vec", "from_elem") => { + ("vec", "from_elem_global") => { let elem = targ(gargs, 0); let mut values = args; match byte(elem) { @@ -3052,6 +3052,16 @@ fn mapping<'tcx>( } } ("panicking", "panic") => Expr::rs("panic", [args, hook_at(b)].concat()), + // `panic!()`, `unreachable!()`, `unimplemented!()`, and `todo!()` without a message. + ("panicking", "panic_default_msg" | "unreachable_default_msg" | "unimplemented_default_msg" | "todo_default_msg") => { + let message = match name.as_str() { + "panic_default_msg" => "explicit panic", + "unreachable_default_msg" => "internal error: entered unreachable code", + "unimplemented_default_msg" => "not implemented", + _ => "not yet implemented", + }; + Expr::rs("panic", [vec![Expr::Str(message.into())], hook_at(b)].concat()) + } // The harness writes a payload of text, and `Box` for any other. A hook reads // the payload itself: a `String`, a `&str`, or the `dyn Any` object of any other. ("panic", "panic_any") | ("panicking", "begin_panic") => { @@ -3316,39 +3326,18 @@ fn mapping<'tcx>( }; Expr::rs_of(of, &super::camel(&name)).call(args) } - // Derived `Debug`: `debug_struct_field2_finish(f, name, "a", &a, "b", &b)`. - // Of slices of names and values. - ("Formatter", "debug_struct_fields_finish" | "debug_tuple_fields_finish") => { - let mut values = args.into_iter(); - let (f, type_name) = (values.next()?, values.next()?); - let finish = match name.as_str() { - "debug_struct_fields_finish" => "fmtDebugStructFields", - _ => "fmtDebugTupleFields", - }; - Expr::rs( - finish, - [f, type_name].into_iter().chain(values.map(slice_items)).collect(), - ) + // Derived `Debug`, whose names are the type's then its fields', space-separated: + // `debug_struct_field2_finish(f, "Point x y", &x, &y)`, past five fields of a slice. + ("Formatter", "debug_struct_fields_finish") => { + let [f, names, values] = <[Expr; 3]>::try_from(args).ok()?; + Expr::rs("fmtDebugFields", vec![f, names, slice_items(values)]) } - ("Formatter", n) if n.starts_with("debug_struct_field") || n.starts_with("debug_tuple_field") => { - let mut values = args.into_iter(); - let (f, type_name) = (values.next()?, values.next()?); - let structure = n.starts_with("debug_struct"); - let (of, start) = match structure { - true => ("debugStruct", "fmtDebugStruct"), - false => ("debugTuple", "fmtDebugTuple"), - }; - let mut builder = Expr::rs(start, vec![f, type_name]); - let values: Vec = values.collect(); - let fields = match structure { - true => values.chunks(2).map(<[Expr]>::to_vec).collect::>(), - false => values.into_iter().map(|v| vec![v]).collect(), - }; - for field in fields { - builder = Expr::rs_of(of, "field").call([vec![builder], field].concat()); - } - Expr::rs_of(of, "finish").call(vec![builder]) + ("Formatter", n) if n.starts_with("debug_struct_field") => { + let mut args = args.into_iter(); + let (f, names) = (args.next()?, args.next()?); + Expr::rs("fmtDebugFields", vec![f, names, Expr::Array(args.collect())]) } + ("Formatter", "debug_c_like_enum_write_str") => Expr::rs("fmtDebugEnum", args), _ => return super::iter::call(b, call, &owner, &name, args), }; if let Some(ty) = dropping { diff --git a/ts/src/lower/mir/holders.rs b/ts/src/lower/mir/holders.rs index cfec77e0c..5fa1ad1b9 100644 --- a/ts/src/lower/mir/holders.rs +++ b/ts/src/lower/mir/holders.rs @@ -597,7 +597,7 @@ impl<'x, 'a, 'tcx> Trace<'x, 'a, 'tcx> { fn repeats(&self, def_id: DefId, args: ty::GenericArgs<'tcx>) -> bool { let tcx = self.t.tcx; crate::lower::library::is_std(tcx, def_id) - && matches!(crate::lower::library::key(tcx, def_id), Some((owner, name)) if owner == "vec" && name == "from_elem") + && matches!(crate::lower::library::key(tcx, def_id), Some((owner, name)) if owner == "vec" && name == "from_elem_global") && !self.shows_pointer(args.type_at(0)) && !self.drops_own_code(args.type_at(0)) } From b702e0b590513b9a250f93bee9481c477546431c Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 12 Nov 2026 21:15:10 -0800 Subject: [PATCH 05/13] fix(ts): follow 1.102's std in String's char collects, str::escape_default, Fuse::advance_back_by, and EscapeDebug's Debug Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/bindgen/expected/imports.Kind.ts | 15 +- ts/fixtures/codec/expected/bench.Point.ts | 7 +- ts/fixtures/codec/expected/bench.ts | 4 +- .../expected/coding/decode.DecodeError.ts | 19 +- .../expected/coding/encode.EncodeError.ts | 19 +- ts/fixtures/codec/expected/harness.ts | 7 +- .../codec/expected/lib.SessionError.ts | 4 +- ts/fixtures/lang/arrays/expected/arrays.ts | 21 +- ts/fixtures/lang/ascii/expected/ascii.ts | 152 +- .../lang/borrows/expected/borrows.Shown.ts | 7 +- ts/fixtures/lang/borrows/expected/borrows.ts | 8 +- .../lang/capacity/expected/capacity.ts | 173 +- ts/fixtures/lang/capacity/src/capacity.rs | 21 +- ts/fixtures/lang/chars/expected/chars.ts | 61 +- ts/fixtures/lang/clones/expected/clones.ts | 1366 ++--- .../lang/collections/expected/collections.ts | 88 +- ts/fixtures/lang/counts/expected/counts.ts | 20 +- ts/fixtures/lang/cows/expected/cows.Named.ts | 7 +- ts/fixtures/lang/cows/expected/cows.Run.ts | 5 +- ts/fixtures/lang/cows/expected/cows.ts | 10 +- .../lang/defaults/expected/defaults.Made.ts | 7 +- .../durations/expected/durations.Window.ts | 7 +- ts/fixtures/lang/dyns/expected/dyns.Square.ts | 5 +- ts/fixtures/lang/dyns/expected/dyns.Tri.ts | 4 +- ts/fixtures/lang/dyns/expected/ids.ts | 34 +- ts/fixtures/lang/edits/expected/edits.ts | 72 +- .../lang/elements/expected/elements.ts | 10 +- ts/fixtures/lang/ends/expected/ends.ts | 532 +- .../lang/errors/expected/errors.Failure.ts | 12 +- .../lang/errors/expected/errors.Leaf.ts | 5 +- .../errors/expected/errors.Transported.ts | 4 +- .../lang/fields/expected/fields.Couple.ts | 8 +- .../lang/fields/expected/fields.Exposed.ts | 7 +- .../lang/fields/expected/fields.Glued.ts | 4 +- .../lang/fields/expected/fields.Scanner.ts | 7 +- .../lang/floats/expected/floats.Reading.ts | 9 +- ts/fixtures/lang/floats/expected/floats.ts | 276 +- .../lang/hashes/expected/hashes.Switch.ts | 20 +- .../lang/hashes/expected/hashes.Tallied.ts | 7 +- ts/fixtures/lang/hashes/expected/hashes.ts | 116 +- ts/fixtures/lang/heap/expected/heap.Fault.ts | 5 +- ts/fixtures/lang/heap/expected/heap.ts | 3 +- .../lang/inlines/expected/inlines.Block.ts | 6 +- .../lang/inlines/expected/inlines.Full.ts | 4 +- .../lang/inlines/expected/inlines.Mod.ts | 8 +- .../lang/inlines/expected/inlines.Small.ts | 18 +- ts/fixtures/lang/ints/expected/ints.ts | 4732 ++++++++------- ts/fixtures/lang/iters/expected/iters.ts | 5347 ++++++++--------- ts/fixtures/lang/joins/expected/joins.ts | 17 +- ts/fixtures/lang/keys/expected/keys.ts | 10 +- ts/fixtures/lang/lengths/expected/lengths.ts | 536 +- .../lang/lists/expected/lists.Tally.ts | 5 +- ts/fixtures/lang/lists/expected/lists.ts | 3 +- ts/fixtures/lang/methods/expected/methods.ts | 408 +- ts/fixtures/lang/nested/expected/nested.ts | 14 +- .../lang/operators/expected/operators.ts | 72 +- ts/fixtures/lang/orders/expected/orders.ts | 26 +- .../lang/panics/expected/located.Held$read.ts | 7 +- ts/fixtures/lang/panics/expected/located.ts | 20 +- .../lang/panics/expected/panics.Point.ts | 7 +- .../lang/panics/hook/expected/hooked.Shown.ts | 2 +- .../lang/panics/hook/expected/hooked.ts | 478 +- .../panics/hook/expected/located.Held$read.ts | 7 +- .../lang/panics/hook/expected/located.ts | 20 +- .../lang/panics/hook/expected/panics.Point.ts | 7 +- .../panics/hook/expected/std/thread/local.ts | 4 +- .../lang/pointers/expected/pointers.List.ts | 21 +- .../pointers/expected/pointers.Waiters.ts | 18 +- .../lang/pointers/expected/pointers.ts | 49 +- .../lang/refs/expected/refs.Listing.ts | 9 +- ts/fixtures/lang/refs/expected/refs.ts | 26 +- ts/fixtures/lang/results/expected/results.ts | 149 +- .../saturates/expected/saturates.Gauge.ts | 48 +- .../lang/saturates/expected/saturates.ts | 72 +- .../lang/shapes/expected/fmt.Countdown.ts | 4 +- ts/fixtures/lang/shapes/expected/fmt.Fault.ts | 15 +- ts/fixtures/lang/shapes/expected/fmt.Kind.ts | 11 +- .../lang/shapes/expected/fmt.Nested.ts | 5 +- ts/fixtures/lang/shapes/expected/fmt.Pair.ts | 5 +- .../lang/shapes/expected/fmt.Shared.ts | 9 +- ts/fixtures/lang/shapes/expected/fmt.Six.ts | 2 +- ts/fixtures/lang/shapes/expected/fmt.Wide.ts | 4 +- ts/fixtures/lang/shapes/expected/fmt.ts | 30 +- .../lang/shapes/expected/generics.Either.ts | 27 +- .../lang/shapes/expected/generics.Fixed.ts | 20 +- .../lang/shapes/expected/generics.Run.ts | 18 +- .../lang/shapes/expected/generics.Runs.ts | 10 +- .../lang/shapes/expected/generics.Tagged.ts | 9 +- .../lang/shapes/expected/generics.Wrap.ts | 63 +- ts/fixtures/lang/shapes/expected/generics.ts | 12 +- .../lang/shapes/expected/shapes.Moved.ts | 5 +- .../lang/shapes/expected/shapes.Point.ts | 7 +- .../lang/shapes/expected/shapes.Shape.ts | 14 +- ts/fixtures/lang/shapes/expected/shapes.ts | 90 +- .../lang/singles/expected/singles.Reading.ts | 7 +- ts/fixtures/lang/singles/expected/singles.ts | 272 +- ts/fixtures/lang/slices/expected/slices.ts | 56 +- .../lang/statics/expected/statics.Dropped.ts | 4 +- ts/fixtures/lang/statics/expected/statics.ts | 12 +- ts/fixtures/lang/strs/expected/strs.ts | 328 +- .../lang/wrappers/expected/wrappers.ts | 14 +- ts/fixtures/lang/wraps/expected/wraps.Tick.ts | 48 +- ts/fixtures/lang/wraps/expected/wraps.ts | 72 +- .../lang/zeros/expected/zeros.Names.ts | 2 +- ts/fixtures/lang/zeros/expected/zeros.Rest.ts | 5 +- .../lang/zeros/expected/zeros.Tagged.ts | 22 +- ts/fixtures/lang/zeros/expected/zeros.ts | 81 +- ts/fixtures/model/expected/harness.ts | 42 +- ts/fixtures/stock/expected/buf.ts | 9 +- ts/fixtures/stock/expected/maps.ts | 161 +- .../expected/smallvec.CollectionAllocErr.ts | 5 +- ts/fixtures/task/expected/drops.ts | 138 +- ts/fixtures/task/expected/drops/called.ts | 10 +- ts/fixtures/task/expected/drops/folds.ts | 38 +- ts/fixtures/task/expected/drops/iters.ts | 10 +- ts/fixtures/task/expected/model.Listing.ts | 7 +- ts/fixtures/task/expected/model.ts | 3 +- ts/fixtures/tokio/expected/log.Item.ts | 4 +- ts/fixtures/tokio/expected/mpsc.ts | 12 +- .../tokio/sync/oneshot/error.RecvError.ts | 4 +- .../tokio/sync/watch/error.RecvError.ts | 4 +- ts/runtime/rs/char.ts | 37 +- ts/runtime/rs/iter.ts | 14 + ts/runtime/rs/str.ts | 10 +- ts/src/lower/iter.rs | 16 + ts/src/lower/library.rs | 3 + 126 files changed, 8303 insertions(+), 8825 deletions(-) diff --git a/ts/fixtures/bindgen/expected/imports.Kind.ts b/ts/fixtures/bindgen/expected/imports.Kind.ts index a1ff849ab..a9b9c75b0 100644 --- a/ts/fixtures/bindgen/expected/imports.Kind.ts +++ b/ts/fixtures/bindgen/expected/imports.Kind.ts @@ -6,19 +6,20 @@ import * as rs from "./rs.ts"; export type Kind = "Number" | "String" | "Object" | "Undefined" | "__Invalid"; export function fmt$fmt_Debug(self: Kind, f: rs.Formatter): rs.Result { - let _3!: string; + let _4!: rs.usize; + const _3: string = "Number String Object Undefined __Invalid"; if (self === "Number") { - _3 = "Number"; + _4 = 0; } else if (self === "String") { - _3 = "String"; + _4 = 7; } else if (self === "Object") { - _3 = "Object"; + _4 = 14; } else if (self === "Undefined") { - _3 = "Undefined"; + _4 = 21; } else { - _3 = "__Invalid"; + _4 = 31; } - return rs.fmtWriteStr(f, _3); + return rs.fmtDebugEnum(f, _3, _4); } //# sourceMappingURL=imports.Kind.ts.map diff --git a/ts/fixtures/codec/expected/bench.Point.ts b/ts/fixtures/codec/expected/bench.Point.ts index c249c1c00..9310fca35 100644 --- a/ts/fixtures/codec/expected/bench.Point.ts +++ b/ts/fixtures/codec/expected/bench.Point.ts @@ -3,12 +3,7 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug(self: Point, f: rs.Formatter): rs.Result { - const _3: string = "Point"; - const _4: string = "x"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.i64Debug(self.x, f); - const _7: string = "y"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.i64Debug(self.y, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Point x y", [(f: rs.Formatter) => rs.i64Debug(self.x, f), (f: rs.Formatter) => rs.i64Debug(self.y, f)]); } /** A pair `format` writes with its derived `Debug`. */ diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index c541f15df..0a0a9c265 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -298,10 +298,10 @@ export function ordered(data: rs.ByteSlice, out: rs.ByteVec): void { let _15!: rs.u32; let _28!: rs.u32; let _66!: rs.u32; + const count2: rs.u32 = rs.u64Low(rs.u64Min(takeU64(data)[0], 65536)); const _10: (a0: rs.u32) => rs.u32 = (i4: rs.u32): rs.u32 => { return rs.u32Rem(rs.u32Mul(i4, 40503), 1 << 16); }; - const count2: rs.u32 = rs.u64Low(rs.u64Min(takeU64(data)[0], 65536)); const map: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; let iterStart: rs.u32 = 0; const iterEnd: rs.u32 = count2; @@ -344,10 +344,10 @@ export function hashed(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo let sum!: rs.u64; let _30!: rs.u32; let _51!: rs.u32; + const count2: rs.u32 = rs.u64Low(rs.u64Min(takeU64(data)[0], 65536)); const _11: (a0: rs.u32) => rs.u32 = (i4: rs.u32): rs.u32 => { return rs.u32Rem(rs.u32Mul(i4, 40503), 1 << 16); }; - const count2: rs.u32 = rs.u64Low(rs.u64Min(takeU64(data)[0], 65536)); const map: rs.HashMap = rs.hashNew() as rs.HashMap; let iterStart: rs.u32 = 0; const iterEnd: rs.u32 = count2; diff --git a/ts/fixtures/codec/expected/coding/decode.DecodeError.ts b/ts/fixtures/codec/expected/coding/decode.DecodeError.ts index bb6f6fb0a..be042a70d 100644 --- a/ts/fixtures/codec/expected/coding/decode.DecodeError.ts +++ b/ts/fixtures/codec/expected/coding/decode.DecodeError.ts @@ -79,14 +79,10 @@ export function fmt$fmt_Debug(self: DecodeError, f: rs.Formatter): rs.Result rs.fmtFromUtf8ErrorDebug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _7), _8)); + return rs.fmtDebugFields(f, "InvalidString", [(f: rs.Formatter) => rs.fmtFromUtf8ErrorDebug(self._0, f)]); } if (self.tag === "InvalidMessage") { - const _11: string = "InvalidMessage"; - const _12: rs.Fmt = (f: rs.Formatter) => rs.u64Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _11), _12)); + return rs.fmtDebugFields(f, "InvalidMessage", [(f: rs.Formatter) => rs.u64Debug(self._0, f)]); } if (self.tag === "InvalidSubscribeLocation") { return rs.fmtWriteStr(f, "InvalidSubscribeLocation"); @@ -104,12 +100,7 @@ export function fmt$fmt_Debug(self: DecodeError, f: rs.Formatter): rs.Result rs.usizeDebug(self.size, f); - const _24: string = "max"; - const _25: rs.Fmt = (f: rs.Formatter) => rs.usizeDebug(self.max, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _21), _22, _23), _24, _25)); + return rs.fmtDebugFields(f, "MessageTooLarge size max", [(f: rs.Formatter) => rs.usizeDebug(self.size, f), (f: rs.Formatter) => rs.usizeDebug(self.max, f)]); } if (self.tag === "ExpectedData") { return rs.fmtWriteStr(f, "ExpectedData"); @@ -130,9 +121,7 @@ export function fmt$fmt_Debug(self: DecodeError, f: rs.Formatter): rs.Result SessionError.fmt$fmt_Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _34), _35)); + return rs.fmtDebugFields(f, "Session", [(f: rs.Formatter) => SessionError.fmt$fmt_Debug(self._0, f)]); } if (self.tag === "MalformedAuthToken") { return rs.fmtWriteStr(f, "MalformedAuthToken"); diff --git a/ts/fixtures/codec/expected/coding/encode.EncodeError.ts b/ts/fixtures/codec/expected/coding/encode.EncodeError.ts index 91bd019db..bfe879544 100644 --- a/ts/fixtures/codec/expected/coding/encode.EncodeError.ts +++ b/ts/fixtures/codec/expected/coding/encode.EncodeError.ts @@ -26,23 +26,24 @@ export function fmt$fmt_Display(self: EncodeError, __formatter: rs.Formatter): r } export function fmt$fmt_Debug(self: EncodeError, f: rs.Formatter): rs.Result { - let _3!: string; + let _4!: rs.usize; + const _3: string = "BoundsExceeded TooLarge Short InvalidState TooMany Version Unsupported"; if (self === "BoundsExceeded") { - _3 = "BoundsExceeded"; + _4 = 0; } else if (self === "TooLarge") { - _3 = "TooLarge"; + _4 = 15; } else if (self === "Short") { - _3 = "Short"; + _4 = 24; } else if (self === "InvalidState") { - _3 = "InvalidState"; + _4 = 30; } else if (self === "TooMany") { - _3 = "TooMany"; + _4 = 43; } else if (self === "Version") { - _3 = "Version"; + _4 = 51; } else { - _3 = "Unsupported"; + _4 = 59; } - return rs.fmtWriteStr(f, _3); + return rs.fmtDebugEnum(f, _3, _4); } /** An error that occurs during encoding. */ diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index 783750699..52b0a53b0 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -584,10 +584,9 @@ export function errors(dataData: Uint8Array, dataStart: number, dataLen: number, err = DecodeError.from$convert_From_coding_varint_BoundsExceeded({}); } else { if (_10 === 6) { - const arg = {}; - const _26: rs.String = rs.fmtToString((f: rs.Formatter) => BoundsExceeded.fmt$fmt_Display(arg, f)); - const arg2 = {}; - const args7 = [(f: rs.Formatter) => BoundsExceeded.fmt$fmt_Debug(arg2, f)]; + const _24: BoundsExceeded.BoundsExceeded = {}; + const _26: rs.String = rs.fmtToString((f: rs.Formatter) => BoundsExceeded.fmt$fmt_Display(_24, f)); + const args7 = [(f: rs.Formatter) => BoundsExceeded.fmt$fmt_Debug(_24, f)]; putText(out, _26, rs.fmtFormat([args7[0], " ", rs.fmtSpec({ alternate: true }, args7[0])])); break b0; } diff --git a/ts/fixtures/codec/expected/lib.SessionError.ts b/ts/fixtures/codec/expected/lib.SessionError.ts index a0935678a..0620270e8 100644 --- a/ts/fixtures/codec/expected/lib.SessionError.ts +++ b/ts/fixtures/codec/expected/lib.SessionError.ts @@ -15,9 +15,7 @@ export function fmt$fmt_Debug(self: SessionError, f: rs.Formatter): rs.Result rs.u16Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _6), _7)); + return rs.fmtDebugFields(f, "App", [(f: rs.Formatter) => rs.u16Debug(self._0, f)]); } /** moq-net's session error, trimmed to a few variants: the codec only carries it. */ diff --git a/ts/fixtures/lang/arrays/expected/arrays.ts b/ts/fixtures/lang/arrays/expected/arrays.ts index ada3dbec1..71b86e853 100644 --- a/ts/fixtures/lang/arrays/expected/arrays.ts +++ b/ts/fixtures/lang/arrays/expected/arrays.ts @@ -273,6 +273,7 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { const pairs: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { return copy$array_u32(item2); }); + const _12: Uint8Array = Uint8Array.of(); for (const op of rs.byteSliceView(data)) { const i: rs.usize = op as rs.usize; const _21: rs.u8 = rs.u8Rem(op, 6); @@ -330,7 +331,7 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { _78[0].data[_78[0].start + _83] = (_80 << 20) >>> 0; rs.sliceCopyFromSlice(_78[1], rs.sliceFrom([_78[0].data[_78[0].start + 1], op as rs.u32])); } else if (_21 === 4) { - rs.slicePlaces(rs.byteSliceFrom(Uint8Array.of())); + rs.slicePlaces(rs.byteSliceFrom(_12)); const iter3: rs.Iter> = rs.iterSlice([]); while (true) { const _99: rs.Place | rs.Done = iter3.next(); @@ -358,7 +359,7 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { } else { const read: rs.u8[] = rs.arrayFrom(rs.byteSliceView(rs.byteSliceFrom(bytes))); const wides: rs.u16[] = rs.arrayFrom(wide); - const _134: rs.Slice = rs.sliceFrom(rs.arrayFrom(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of())))); + const _134: rs.Slice = rs.sliceFrom(rs.arrayFrom(rs.byteSliceView(rs.byteSliceFrom(_12)))); const _137: rs.Slice = rs.sliceFrom(read); [_134, _137, rs.sliceFrom(wides)] as [rs.Slice, rs.Slice, rs.Slice]; const _140: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_137), f, rs.u8Debug); @@ -401,6 +402,8 @@ export function asSlices(data: rs.ByteSlice, out: rs.ByteVec): void { const pairs: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { return copy$array_u32(item2); }); + const _12: rs.u16[] = []; + const _13: Uint8Array = Uint8Array.of(); for (const op of rs.byteSliceView(data)) { const i: rs.usize = op as rs.usize; const _22: rs.u8 = rs.u8Rem(op, 8); @@ -446,9 +449,9 @@ export function asSlices(data: rs.ByteSlice, out: rs.ByteVec): void { rs.sliceCopyFromSlice(rs.arraySliceAt(all, _93), rs.sliceFrom([op as rs.u32, ((op as rs.u32) << 20) >>> 0])); rs.arraySliceSwap(all, 0, 1, undefined); } else if (_22 === 5) { - rs.sliceReverse(rs.sliceFrom([])); - rs.byteSliceFill(rs.byteSliceFrom(Uint8Array.of()), op); - rs.byteVecPush(out, rs.u8Add(rs.sliceFrom([]).length & 0xff, rs.byteSliceFrom(Uint8Array.of()).length & 0xff)); + rs.sliceReverse(rs.sliceFrom(_12)); + rs.byteSliceFill(rs.byteSliceFrom(_13), op); + rs.byteVecPush(out, rs.u8Add(rs.sliceFrom(_12).length & 0xff, rs.byteSliceFrom(_13).length & 0xff)); } else if (_22 === 6) { written(rs.byteSliceFrom(bytes), rs.sliceFrom(wide), op); } else { @@ -463,8 +466,8 @@ export function asSlices(data: rs.ByteSlice, out: rs.ByteVec): void { const _149: rs.Slice = rs.sliceFrom(words); const _152: rs.ArraySlice = rs.arraySliceFrom(grid, rs.byteSliceFrom); const _155: rs.ArraySlice> = rs.arraySliceFrom(pairs, rs.sliceFrom); - const _158: rs.Slice = rs.sliceFrom([]); - const _161: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of()); + const _158: rs.Slice = rs.sliceFrom(_12); + const _161: rs.ByteSlice = rs.byteSliceFrom(_13); const args3 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_143), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_146), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_149), f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.fmtList(rs.arraySliceItems(_152), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(rs.arraySliceItems(_155), f, (value: rs.u32[], f: rs.Formatter) => rs.fmtList(value, f, rs.u32Debug)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_158), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_161), f, rs.u8Debug)]; rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4], " ", args3[5], " ", args3[6]]).v)); } @@ -2079,8 +2082,8 @@ export function converted(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi if (shared.ok) { rs.byteVecExtendFromSlice(out, shared.value); } else { - const arg = new rs.TryFromSliceError(); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.fmtTryFromSliceErrorDisplay(arg, f)).v)); + const _37: rs.TryFromSliceError = new rs.TryFromSliceError(); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.fmtTryFromSliceErrorDisplay(_37, f)).v)); } rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u32 => { diff --git a/ts/fixtures/lang/ascii/expected/ascii.ts b/ts/fixtures/lang/ascii/expected/ascii.ts index 75d0df110..9832b0f0a 100644 --- a/ts/fixtures/lang/ascii/expected/ascii.ts +++ b/ts/fixtures/lang/ascii/expected/ascii.ts @@ -73,91 +73,87 @@ export function steps$ascii_EscapeDefault(e: rs.Iter, data: rs.ByteSlice, export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let _67!: rs.usize; const all: rs.ByteVec = rs.iterToByteVec(new rs.RangeInclusive(0, 255, rs.u8Step), undefined, true); - b0: { - const _6: rs.u8 = rs.u8Rem(kind, 4); - if (_6 === 0) { - const iter: rs.RangeInclusive = new rs.RangeInclusive(0, 255, rs.u8Step); - while (true) { - const _11: rs.u8 | rs.Done = iter.next(); - if (_11 === rs.DONE) { - break b0; - } - const b: rs.u8 = _11; - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(byteTests(b)))); - rs.byteVecPush(out, rs.toAsciiUppercase(b)); - rs.byteVecPush(out, rs.toAsciiLowercase(b)); - const other: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), b ^ 32); - rs.byteVecPush(out, rs.eqIgnoreAsciiCase(b, other) ? 1 : 0); - rs.byteVecPush(out, rs.eqIgnoreAsciiCase(b, b ^ 32) ? 1 : 0); + const _6: rs.u8 = rs.u8Rem(kind, 4); + if (_6 === 0) { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, 255, rs.u8Step); + while (true) { + const _11: rs.u8 | rs.Done = iter.next(); + if (_11 === rs.DONE) { + break; } + const b: rs.u8 = _11; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(byteTests(b)))); + rs.byteVecPush(out, rs.toAsciiUppercase(b)); + rs.byteVecPush(out, rs.toAsciiLowercase(b)); + const other: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), b ^ 32); + rs.byteVecPush(out, rs.eqIgnoreAsciiCase(b, other) ? 1 : 0); + rs.byteVecPush(out, rs.eqIgnoreAsciiCase(b, b ^ 32) ? 1 : 0); } - if (_6 === 1) { - const iter2: rs.RangeInclusive = new rs.RangeInclusive(0, 255, rs.u8Step); - while (true) { - const _44: rs.u8 | rs.Done = iter2.next(); - if (_44 === rs.DONE) { - break; - } - const b2: rs.u8 = _44; - let local: rs.u8 = b2; - local = rs.toAsciiUppercase(local); - rs.byteVecPush(out, local); - const pair: [rs.u8, rs.u8] = [b2, b2]; - pair[1] = rs.toAsciiLowercase(pair[1]); - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(pair[0], pair[1]))); + } else if (_6 === 1) { + const iter2: rs.RangeInclusive = new rs.RangeInclusive(0, 255, rs.u8Step); + while (true) { + const _44: rs.u8 | rs.Done = iter2.next(); + if (_44 === rs.DONE) { + break; } - const _64: rs.usize = all.length; - let iterStart: rs.usize = 0; - const iterEnd: rs.usize = _64; - while ((_67 = iterStart++) < iterEnd) { - const i: rs.usize = _67; - if (!(rs.usizeRem(i, 2) === 0)) { - const at2 = rs.idx(all, i); - upperByte(rs.place(() => all.data[at2], (value) => all.data[at2] = value)); - } else { - const at = rs.idx(all, i); - all.data[at] = rs.toAsciiLowercase(all.data[at]); - } + const b2: rs.u8 = _44; + let local: rs.u8 = b2; + local = rs.toAsciiUppercase(local); + rs.byteVecPush(out, local); + const pair: [rs.u8, rs.u8] = [b2, b2]; + pair[1] = rs.toAsciiLowercase(pair[1]); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(pair[0], pair[1]))); + } + const _64: rs.usize = all.length; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _64; + while ((_67 = iterStart++) < iterEnd) { + const i: rs.usize = _67; + if (!(rs.usizeRem(i, 2) === 0)) { + const at2 = rs.idx(all, i); + upperByte(rs.place(() => all.data[at2], (value) => all.data[at2] = value)); + } else { + const at = rs.idx(all, i); + all.data[at] = rs.toAsciiLowercase(all.data[at]); } - const iter4: rs.Iter> = rs.iterSkip(rs.iterSliceMut(rs.byteVecSlice(all)), option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0) as rs.usize); - while (true) { - const _90: rs.Place | rs.Done = iter4.next(); - if (_90 === rs.DONE) { - break; - } - _90.v = rs.toAsciiUppercase(_90.v); + } + const iter4: rs.Iter> = rs.iterSkip(rs.iterSliceMut(rs.byteVecSlice(all)), option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0) as rs.usize); + while (true) { + const _90: rs.Place | rs.Done = iter4.next(); + if (_90 === rs.DONE) { + break; } - rs.byteVecExtendFromSlice(out, rs.byteVecSlice(all)); - } else { - if (_6 === 2) { - const iter5: rs.RangeInclusive = new rs.RangeInclusive(0, 255, rs.u8Step); - while (true) { - const _101: rs.u8 | rs.Done = iter5.next(); - if (_101 === rs.DONE) { - break b0; - } - const b3: rs.u8 = _101; - const e: rs.Iter = rs.escapeAscii(b3); - const shown: rs.String = rs.stringNew(); - const _113: rs.Iter = rs.escapeAscii(b3); - const _115: rs.usize = rs.iterCount(e.clone()); - const args3 = [(f: rs.Formatter) => rs.fmtEscapeAscii(e, f), (f: rs.Formatter) => rs.fmtEscapeAscii(_113, f), (f: rs.Formatter) => rs.usizeDisplay(_115, f)]; - rs.resultUnwrap(rs.fmtWriteString(shown, [args3[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args3[1]), "|", args3[2]]), rs.fmtErrorDebug); - put(out, shown.v); - rs.iterExtendBytes(out, e.clone(), "next"); - rs.iterExtendBytes(out, rs.iterRev(e.clone()), "next"); - rs.byteVecPush(out, rs.optionUnwrap(rs.iterLast(e.clone()))); - rs.byteVecPush(out, rs.fmtToString((f: rs.Formatter) => rs.fmtEscapeAscii(e, f)).len & 0xff); - } + _90.v = rs.toAsciiUppercase(_90.v); + } + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(all)); + } else if (_6 === 2) { + const iter5: rs.RangeInclusive = new rs.RangeInclusive(0, 255, rs.u8Step); + while (true) { + const _101: rs.u8 | rs.Done = iter5.next(); + if (_101 === rs.DONE) { + break; } - const iter6: rs.RangeInclusive = new rs.RangeInclusive(0, 255, rs.u8Step); - while (true) { - const _149: rs.u8 | rs.Done = iter6.next(); - if (_149 === rs.DONE) { - break b0; - } - steps$ascii_EscapeDefault(rs.escapeAscii(_149), data, out); + const b3: rs.u8 = _101; + const e: rs.Iter = rs.escapeAscii(b3); + const shown: rs.String = rs.stringNew(); + const _113: rs.Iter = rs.escapeAscii(b3); + const _115: rs.usize = rs.iterCount(e.clone()); + const args3 = [(f: rs.Formatter) => rs.fmtEscapeAscii(e, f), (f: rs.Formatter) => rs.fmtEscapeAscii(_113, f), (f: rs.Formatter) => rs.usizeDisplay(_115, f)]; + rs.resultUnwrap(rs.fmtWriteString(shown, [args3[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args3[1]), "|", args3[2]]), rs.fmtErrorDebug); + put(out, shown.v); + rs.iterExtendBytes(out, e.clone(), "next"); + rs.iterExtendBytes(out, rs.iterRev(e.clone()), "next"); + rs.byteVecPush(out, rs.optionUnwrap(rs.iterLast(e.clone()))); + rs.byteVecPush(out, rs.fmtToString((f: rs.Formatter) => rs.fmtEscapeAscii(e, f)).len & 0xff); + } + } else { + const iter6: rs.RangeInclusive = new rs.RangeInclusive(0, 255, rs.u8Step); + while (true) { + const _149: rs.u8 | rs.Done = iter6.next(); + if (_149 === rs.DONE) { + break; } + steps$ascii_EscapeDefault(rs.escapeAscii(_149), data, out); } } } diff --git a/ts/fixtures/lang/borrows/expected/borrows.Shown.ts b/ts/fixtures/lang/borrows/expected/borrows.Shown.ts index c9271277d..4149979f0 100644 --- a/ts/fixtures/lang/borrows/expected/borrows.Shown.ts +++ b/ts/fixtures/lang/borrows/expected/borrows.Shown.ts @@ -3,12 +3,7 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug(self: Shown, f: rs.Formatter): rs.Result { - const _3: string = "Shown"; - const _4: string = "cell"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.cellDebug(() => self.cell.v, f, rs.u8Debug); - const _7: string = "refcell"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.refCellDebug(self.refcell, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug)); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Shown cell refcell", [(f: rs.Formatter) => rs.cellDebug(() => self.cell.v, f, rs.u8Debug), (f: rs.Formatter) => rs.refCellDebug(self.refcell, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]); } /** What a derived `Debug` writes each cell of as its field. */ diff --git a/ts/fixtures/lang/borrows/expected/borrows.ts b/ts/fixtures/lang/borrows/expected/borrows.ts index 18e6b73f0..5412b9a6e 100644 --- a/ts/fixtures/lang/borrows/expected/borrows.ts +++ b/ts/fixtures/lang/borrows/expected/borrows.ts @@ -176,8 +176,8 @@ export function guards(data: rs.ByteSlice, out: rs.ByteVec): void { if (_116.ok) { rs.byteVecPush(out, 254); } else { - const part3 = new rs.BorrowMutError(); - const args5 = [(f: rs.Formatter) => rs.borrowMutErrorDisplay(part3, f), (f: rs.Formatter) => rs.borrowMutErrorDebug(part3, f)]; + const _119: rs.BorrowMutError = new rs.BorrowMutError(); + const args5 = [(f: rs.Formatter) => rs.borrowMutErrorDisplay(_119, f), (f: rs.Formatter) => rs.borrowMutErrorDebug(_119, f)]; rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); } if (_116.ok) { @@ -190,8 +190,8 @@ export function guards(data: rs.ByteSlice, out: rs.ByteVec): void { if (_141.ok) { rs.byteVecPush(out, 254); } else { - const part4 = new rs.BorrowError(); - const args6 = [(f: rs.Formatter) => rs.borrowErrorDisplay(part4, f), (f: rs.Formatter) => rs.borrowErrorDebug(part4, f)]; + const _144: rs.BorrowError = new rs.BorrowError(); + const args6 = [(f: rs.Formatter) => rs.borrowErrorDisplay(_144, f), (f: rs.Formatter) => rs.borrowErrorDebug(_144, f)]; rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v)); } if (_141.ok) { diff --git a/ts/fixtures/lang/capacity/expected/capacity.ts b/ts/fixtures/lang/capacity/expected/capacity.ts index 622120dcd..410e05db8 100644 --- a/ts/fixtures/lang/capacity/expected/capacity.ts +++ b/ts/fixtures/lang/capacity/expected/capacity.ts @@ -222,11 +222,11 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d rs.vecAppend(v, other, 1280); sized(out, other.items.length, rs.vecCapacity(other, 1280)); } else if (_39 === 30 || _39 === 31) { - b8: { + b9: { if ((arg >> 5) === 6) { if (size > 0) { newLen = rs.usizeAdd(rs.usizeAdd(rs.usizeDiv(2147483647, size), 1), (arg & 7) as rs.usize); - break b8; + break b9; } } newLen = rs.u8Rem(arg, 24) as rs.usize; @@ -463,11 +463,11 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, rs.vecAppend(v, other, 16); sized(out, other.items.length, rs.vecCapacity(other, 16)); } else if (_39 === 30 || _39 === 31) { - b8: { + b9: { if ((arg >> 5) === 6) { if (size > 0) { newLen = rs.usizeAdd(rs.usizeAdd(rs.usizeDiv(2147483647, size), 1), (arg & 7) as rs.usize); - break b8; + break b9; } } newLen = rs.u8Rem(arg, 24) as rs.usize; @@ -704,11 +704,11 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n rs.vecAppend(v, other, 2); sized(out, other.items.length, rs.vecCapacity(other, 2)); } else if (_39 === 30 || _39 === 31) { - b8: { + b9: { if ((arg >> 5) === 6) { if (size > 0) { newLen = rs.usizeAdd(rs.usizeAdd(rs.usizeDiv(2147483647, size), 1), (arg & 7) as rs.usize); - break b8; + break b9; } } newLen = rs.u8Rem(arg, 24) as rs.usize; @@ -943,11 +943,11 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu rs.byteVecAppend(v, other); sized(out, other.length, other.data.length); } else if (_39 === 30 || _39 === 31) { - b8: { + b9: { if ((arg >> 5) === 6) { if (size > 0) { newLen = rs.usizeAdd(rs.usizeAdd(rs.usizeDiv(2147483647, size), 1), (arg & 7) as rs.usize); - break b8; + break b9; } } newLen = rs.u8Rem(arg, 24) as rs.usize; @@ -1190,11 +1190,11 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: rs.vecAppend(v, other, 0); sized(out, other.items.length, rs.vecCapacity(other, 0)); } else if (_39 === 30 || _39 === 31) { - b8: { + b9: { if ((arg >> 5) === 6) { if (size > 0) { newLen = rs.usizeAdd(rs.usizeAdd(rs.usizeDiv(2147483647, size), 1), (arg & 7) as rs.usize); - break b8; + break b9; } } newLen = rs.u8Rem(arg, 24) as rs.usize; @@ -1326,13 +1326,6 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo export function cloneFromSteps$array160_u64(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u64[], out: rs.ByteVec): void { let result!: rs.Result, rs.Vec>; let _204!: rs.Result, rs.Vec>; - const _17: (a0: rs.Slice>, a1: rs.ByteVec) => undefined = (vs: rs.Slice>, out2: rs.ByteVec): undefined => { - put(out2, vs.length); - for (const _8 of rs.sliceItems(vs)) { - put(out2, _8.items.length); - put(out2, rs.vecCapacity(_8, 1280)); - } - }; const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), rs.u8WrappingMul(i & 0xff, 53) ^ (data.length & 0xff)); }; @@ -1345,9 +1338,9 @@ export function cloneFromSteps$array160_u64(data: rs.ByteSlice, make: (a0: rs.u8 } else { v = new rs.Vec(); } - const _132: rs.u8 = rs.u8Rem(b >> 1, 6); + const _13: rs.u8 = rs.u8Rem(b >> 1, 6); let iterStart: rs.u8 = 0; - const iterEnd: rs.u8 = _132; + const iterEnd: rs.u8 = _13; while (true) { if (!((_192 = iterStart++) < iterEnd)) { return v; @@ -1374,6 +1367,13 @@ export function cloneFromSteps$array160_u64(data: rs.ByteSlice, make: (a0: rs.u8 return source(rs.usizeAdd(from2, j3)); }), undefined, 12, true); }; + const _17: (a0: rs.Slice>, a1: rs.ByteVec) => undefined = (vs: rs.Slice>, out2: rs.ByteVec): undefined => { + put(out2, vs.length); + for (const _86 of rs.sliceItems(vs)) { + put(out2, _86.items.length); + put(out2, rs.vecCapacity(_86, 1280)); + } + }; const array: rs.Vec[] = [held(0), held(1)]; rs.sliceCloneFromSlice(rs.sliceFrom(array), rs.sliceFrom([source(2), source(3)]), (a0: rs.Vec): rs.Vec => { return rs.vecFrom(a0.items.map(copy$array_u64)); @@ -1524,13 +1524,6 @@ export function cloneFromSteps$array160_u64(data: rs.ByteSlice, make: (a0: rs.u8 export function cloneFromSteps$tuple2_u64_u8(data: rs.ByteSlice, make: (a0: rs.u8) => [rs.u64, rs.u8], out: rs.ByteVec): void { let result!: rs.Result, rs.Vec<[rs.u64, rs.u8]>>; let _204!: rs.Result, rs.Vec<[rs.u64, rs.u8]>>; - const _17: (a0: rs.Slice>, a1: rs.ByteVec) => undefined = (vs: rs.Slice>, out2: rs.ByteVec): undefined => { - put(out2, vs.length); - for (const _8 of rs.sliceItems(vs)) { - put(out2, _8.items.length); - put(out2, rs.vecCapacity(_8, 16)); - } - }; const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), rs.u8WrappingMul(i & 0xff, 53) ^ (data.length & 0xff)); }; @@ -1543,9 +1536,9 @@ export function cloneFromSteps$tuple2_u64_u8(data: rs.ByteSlice, make: (a0: rs.u } else { v = new rs.Vec(); } - const _132: rs.u8 = rs.u8Rem(b >> 1, 6); + const _13: rs.u8 = rs.u8Rem(b >> 1, 6); let iterStart: rs.u8 = 0; - const iterEnd: rs.u8 = _132; + const iterEnd: rs.u8 = _13; while (true) { if (!((_192 = iterStart++) < iterEnd)) { return v; @@ -1572,6 +1565,13 @@ export function cloneFromSteps$tuple2_u64_u8(data: rs.ByteSlice, make: (a0: rs.u return source(rs.usizeAdd(from2, j3)); }), undefined, 12, true); }; + const _17: (a0: rs.Slice>, a1: rs.ByteVec) => undefined = (vs: rs.Slice>, out2: rs.ByteVec): undefined => { + put(out2, vs.length); + for (const _86 of rs.sliceItems(vs)) { + put(out2, _86.items.length); + put(out2, rs.vecCapacity(_86, 16)); + } + }; const array: rs.Vec<[rs.u64, rs.u8]>[] = [held(0), held(1)]; rs.sliceCloneFromSlice(rs.sliceFrom(array), rs.sliceFrom([source(2), source(3)]), (a0: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { return rs.vecFrom(a0.items.map(copy$tuple2_u64_u8)); @@ -1722,13 +1722,6 @@ export function cloneFromSteps$tuple2_u64_u8(data: rs.ByteSlice, make: (a0: rs.u export function cloneFromSteps$u16(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u16, out: rs.ByteVec): void { let result!: rs.Result, rs.Vec>; let _204!: rs.Result, rs.Vec>; - const _17: (a0: rs.Slice>, a1: rs.ByteVec) => undefined = (vs: rs.Slice>, out2: rs.ByteVec): undefined => { - put(out2, vs.length); - for (const _8 of rs.sliceItems(vs)) { - put(out2, _8.items.length); - put(out2, rs.vecCapacity(_8, 2)); - } - }; const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), rs.u8WrappingMul(i & 0xff, 53) ^ (data.length & 0xff)); }; @@ -1741,9 +1734,9 @@ export function cloneFromSteps$u16(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u } else { v = new rs.Vec(); } - const _132: rs.u8 = rs.u8Rem(b >> 1, 6); + const _13: rs.u8 = rs.u8Rem(b >> 1, 6); let iterStart: rs.u8 = 0; - const iterEnd: rs.u8 = _132; + const iterEnd: rs.u8 = _13; while (true) { if (!((_192 = iterStart++) < iterEnd)) { return v; @@ -1770,6 +1763,13 @@ export function cloneFromSteps$u16(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u return source(rs.usizeAdd(from2, j3)); }), undefined, 12, true); }; + const _17: (a0: rs.Slice>, a1: rs.ByteVec) => undefined = (vs: rs.Slice>, out2: rs.ByteVec): undefined => { + put(out2, vs.length); + for (const _86 of rs.sliceItems(vs)) { + put(out2, _86.items.length); + put(out2, rs.vecCapacity(_86, 2)); + } + }; const array: rs.Vec[] = [held(0), held(1)]; rs.sliceCloneFromSlice(rs.sliceFrom(array), rs.sliceFrom([source(2), source(3)]), (a0: rs.Vec): rs.Vec => { return rs.vecFrom(a0.items.slice()); @@ -1920,13 +1920,6 @@ export function cloneFromSteps$u16(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u export function cloneFromSteps$u8(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let result!: rs.Result; let _204!: rs.Result; - const _17: (a0: rs.Slice, a1: rs.ByteVec) => undefined = (vs: rs.Slice, out2: rs.ByteVec): undefined => { - put(out2, vs.length); - for (const _8 of rs.sliceItems(vs)) { - put(out2, _8.length); - put(out2, _8.data.length); - } - }; const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), rs.u8WrappingMul(i & 0xff, 53) ^ (data.length & 0xff)); }; @@ -1939,9 +1932,9 @@ export function cloneFromSteps$u8(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u8 } else { v = new rs.ByteVec(); } - const _132: rs.u8 = rs.u8Rem(b >> 1, 6); + const _13: rs.u8 = rs.u8Rem(b >> 1, 6); let iterStart: rs.u8 = 0; - const iterEnd: rs.u8 = _132; + const iterEnd: rs.u8 = _13; while (true) { if (!((_192 = iterStart++) < iterEnd)) { return v; @@ -1965,6 +1958,13 @@ export function cloneFromSteps$u8(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u8 return source(rs.usizeAdd(from2, j3)); }), undefined, 12, true); }; + const _17: (a0: rs.Slice, a1: rs.ByteVec) => undefined = (vs: rs.Slice, out2: rs.ByteVec): undefined => { + put(out2, vs.length); + for (const _86 of rs.sliceItems(vs)) { + put(out2, _86.length); + put(out2, _86.data.length); + } + }; const array: rs.ByteVec[] = [held(0), held(1)]; rs.sliceCloneFromSlice(rs.sliceFrom(array), rs.sliceFrom([source(2), source(3)]), (a0: rs.ByteVec): rs.ByteVec => { return rs.byteVecFrom(rs.byteVecView(a0)); @@ -2115,13 +2115,6 @@ export function cloneFromSteps$u8(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u8 export function cloneFromSteps$unit(data: rs.ByteSlice, make: (a0: rs.u8) => undefined, out: rs.ByteVec): void { let result!: rs.Result, rs.Vec>; let _204!: rs.Result, rs.Vec>; - const _17: (a0: rs.Slice>, a1: rs.ByteVec) => undefined = (vs: rs.Slice>, out2: rs.ByteVec): undefined => { - put(out2, vs.length); - for (const _8 of rs.sliceItems(vs)) { - put(out2, _8.items.length); - put(out2, rs.vecCapacity(_8, 0)); - } - }; const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), rs.u8WrappingMul(i & 0xff, 53) ^ (data.length & 0xff)); }; @@ -2134,9 +2127,9 @@ export function cloneFromSteps$unit(data: rs.ByteSlice, make: (a0: rs.u8) => und } else { v = new rs.Vec(); } - const _132: rs.u8 = rs.u8Rem(b >> 1, 6); + const _13: rs.u8 = rs.u8Rem(b >> 1, 6); let iterStart: rs.u8 = 0; - const iterEnd: rs.u8 = _132; + const iterEnd: rs.u8 = _13; while (true) { if (!((_192 = iterStart++) < iterEnd)) { return v; @@ -2163,6 +2156,13 @@ export function cloneFromSteps$unit(data: rs.ByteSlice, make: (a0: rs.u8) => und return source(rs.usizeAdd(from2, j3)); }), undefined, 12, true); }; + const _17: (a0: rs.Slice>, a1: rs.ByteVec) => undefined = (vs: rs.Slice>, out2: rs.ByteVec): undefined => { + put(out2, vs.length); + for (const _86 of rs.sliceItems(vs)) { + put(out2, _86.items.length); + put(out2, rs.vecCapacity(_86, 0)); + } + }; const array: rs.Vec[] = [held(0), held(1)]; rs.sliceCloneFromSlice(rs.sliceFrom(array), rs.sliceFrom([source(2), source(3)]), (a0: rs.Vec): rs.Vec => { return rs.vecFrom(a0.items.slice()); @@ -3551,6 +3551,17 @@ export function collects(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void export function maps(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let _8!: [rs.HashMap, rs.HashSet]; let _199!: rs.usize; + const made: rs.usize = option_mapOr$1d4bp7c(rs.byteSliceFirst(data), 0, (_2: rs.u8): rs.usize => { + return rs.u8Rem(_2, 24) as rs.usize; + }); + if ((kind & 1) === 1) { + _8 = [rs.hashWithCapacity(made, 58720256) as rs.HashMap, rs.hashWithCapacity(made, 469762048) as rs.HashSet] as [rs.HashMap, rs.HashSet]; + } else { + _8 = [rs.hashNew() as rs.HashMap, rs.hashNew() as rs.HashSet] as [rs.HashMap, rs.HashSet]; + } + let m: rs.HashMap = _8[0]; + let s: rs.HashSet = _8[1]; + const floor: rs.usize = rs.usizeMul(made, (kind & 1) as rs.usize); const _18: (a0: rs.ByteVec, a1: rs.usize[], a2: rs.usize[], a3: rs.usize[]) => undefined = (out2: rs.ByteVec, lens2: rs.usize[], caps: rs.usize[], floors2: rs.usize[]): undefined => { let _92!: rs.usize; let iterStart: rs.usize = 0; @@ -3575,23 +3586,12 @@ export function maps(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out2, _19 >= rs.max(_223, floors2[i2]) ? 1 : 0); } }; - const made: rs.usize = option_mapOr$1d4bp7c(rs.byteSliceFirst(data), 0, (_2: rs.u8): rs.usize => { - return rs.u8Rem(_2, 24) as rs.usize; - }); - if ((kind & 1) === 1) { - _8 = [rs.hashWithCapacity(made, 58720256) as rs.HashMap, rs.hashWithCapacity(made, 469762048) as rs.HashSet] as [rs.HashMap, rs.HashSet]; - } else { - _8 = [rs.hashNew() as rs.HashMap, rs.hashNew() as rs.HashSet] as [rs.HashMap, rs.HashSet]; - } - let m: rs.HashMap = _8[0]; - let s: rs.HashSet = _8[1]; - const floor: rs.usize = rs.usizeMul(made, (kind & 1) as rs.usize); - const _22: rs.usize[] = [rs.hashLen(m), rs.hashLen(s)]; - const _27: rs.usize[] = [rs.hashCapacity(m), rs.hashCapacity(s)]; - const part = Array.from({ length: 2 }, (): rs.usize => { + const part = [rs.hashLen(m), rs.hashLen(s)]; + const part2 = [rs.hashCapacity(m), rs.hashCapacity(s)]; + const part3 = Array.from({ length: 2 }, (): rs.usize => { return floor; }); - _18(out, _22, _27, part); + _18(out, part, part2, part3); const iter: rs.Iter = rs.byteSliceChunks(option_unwrapOrDefault$0avqj0t(rs.byteSliceGetRange(data, 1)), 2); while (true) { const _39: rs.ByteSlice | rs.Done = iter.next(); @@ -3685,10 +3685,10 @@ export function maps(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } } } - const part2 = [rs.hashLen(m), rs.hashLen(s)]; - const part3 = [rs.hashCapacity(m), rs.hashCapacity(s)]; - const part4 = copy$array_usize(floors); - _18(out, part2, part3, part4); + const part4 = [rs.hashLen(m), rs.hashLen(s)]; + const part5 = [rs.hashCapacity(m), rs.hashCapacity(s)]; + const part6 = copy$array_usize(floors); + _18(out, part4, part5, part6); } if ((kind & 128) !== 0) { put(out, rs.hashLen(rs.hashWithCapacity(rs.usizeShr(4294967295, kind & 3), 117440512, rs.hashing(rs.hash64, rs.u64Eq)) as rs.HashSet)); @@ -3717,6 +3717,7 @@ export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): voi let _318!: rs.String; let _350!: rs.String; let _421!: rs.String; + let _525!: rs.String; const _4: (a0: rs.u8) => string = (arg2: rs.u8): string => { const _42: rs.usize = rs.usizeRem(arg2 as rs.usize, rs.sliceFrom(["", "ab", "démo", "アリス📷, and more text past sixteen bytes"]).length); if (!(_42 < 4)) { @@ -3752,7 +3753,7 @@ export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): voi rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _56); } const c: rs.char = [97, 233, 20013, 128512][_56]; - const _64: rs.u8 = rs.u8Rem(op, 49); + const _64: rs.u8 = rs.u8Rem(op, 53); if (_64 === 0) { rs.stringPush(s, c); } else if (_64 === 1) { @@ -3904,8 +3905,7 @@ export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): voi sized(out, bytes3.length, bytes3.data.length); s = rs.resultUnwrap(rs.stringFromUtf8(bytes3), rs.fmtFromUtf8ErrorDebug); } else if (_64 === 39) { - const _404: rs.Iter = rs.iterRev(rs.strChars(s.v)); - s = rs.stringExtendChars(rs.stringNew(), _404); + s = rs.stringFromChars(rs.iterRev(rs.strChars(s.v))); } else if (_64 === 40) { s = rs.stringFromStrings(rs.vecIntoIter(rs.vecFrom([s, rs.stringFrom(_4(arg))]))); } else if (_64 === 41) { @@ -3941,6 +3941,25 @@ export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): voi const _493: rs.Place = new of$String(s).borrowMut$BorrowMut() as rs.Place; _493.v = rs.strToAsciiUppercase(_493.v); put(out, rs.stringLen(new of$String(s).borrow$Borrow() as string)); + } else if (_64 === 49) { + s = rs.stringFromEscapeDefault(rs.strEscapeDefault(s.v)); + } else if (_64 === 50) { + s = rs.stringFromEscapeDefault(rs.strEscapeDefault(s.v)); + } else if (_64 === 51) { + const grown: rs.String = rs.stringWithCapacity(rs.u8Rem(arg, 8) as rs.usize); + const _514: rs.Iter = rs.strEscapeDefault(s.v); + rs.stringExtendEscapeDefault(grown, _514); + s = grown; + } else if (_64 === 52) { + const escape: rs.Iter = rs.strEscapeDefault(s.v); + escape.next(); + escape.next(); + if ((arg & 1) === 0) { + _525 = rs.stringFromEscapeDefault(escape); + } else { + _525 = rs.stringFromEscapeDefault(escape); + } + s = _525; } sized(out, s.len, s.cap); } diff --git a/ts/fixtures/lang/capacity/src/capacity.rs b/ts/fixtures/lang/capacity/src/capacity.rs index 40d73541c..45ed9cb4e 100644 --- a/ts/fixtures/lang/capacity/src/capacity.rs +++ b/ts/fixtures/lang/capacity/src/capacity.rs @@ -678,7 +678,7 @@ pub fn strings(first: u8, steps: &[u8], out: &mut Vec) { for step in steps.chunks(2) { let (op, arg) = (step[0], step.get(1).copied().unwrap_or(0)); let c = CHARS[usize::from(arg) % CHARS.len()]; - match op % 49 { + match op % 53 { 0 => s.push(c), 1 => s.push_str(text(arg)), 2 => s.reserve(amount(arg, s.len(), 1)), @@ -810,6 +810,25 @@ pub fn strings(first: u8, steps: &[u8], out: &mut Vec) { let shared: &dyn Borrow = &s; put(out, shared.borrow().len()); } + // `str::escape_default` by std's own `ToString`, `FromIterator`, and `Extend`, which + // reserve by its parts, and each `\u{..}` by ten bytes. + 49 => s = s.escape_default().to_string(), + 50 => s = s.escape_default().collect(), + 51 => { + let mut grown = String::with_capacity(usize::from(arg % 8)); + grown.extend(s.escape_default()); + s = grown; + } + // With an escape begun, which its front part holds. + 52 => { + let mut escape = s.escape_default(); + escape.next(); + escape.next(); + s = match arg & 1 { + 0 => escape.to_string(), + _ => escape.collect(), + }; + } _ => {} } sized(out, s.len(), s.capacity()); diff --git a/ts/fixtures/lang/chars/expected/chars.ts b/ts/fixtures/lang/chars/expected/chars.ts index 451ad57ce..17dc97020 100644 --- a/ts/fixtures/lang/chars/expected/chars.ts +++ b/ts/fixtures/lang/chars/expected/chars.ts @@ -213,8 +213,7 @@ export function walk$char_EscapeDebug(out: rs.ByteVec, it: rs.Iter): vo const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); const args11 = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]]).v); - const _79: rs.Iter = it; - const rest: rs.String = rs.stringExtendChars(rs.stringNew(), _79); + const rest: rs.String = rs.stringFromChars(it); const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest.v), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; put(out, rs.fmtFormat([args12[0], "|", args12[1]]).v); } @@ -239,8 +238,7 @@ export function walk$char_EscapeDefault(out: rs.ByteVec, it: rs.Iter): const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); const args11 = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]]).v); - const _79: rs.Iter = it; - const rest: rs.String = rs.stringExtendChars(rs.stringNew(), _79); + const rest: rs.String = rs.stringFromChars(it); const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest.v), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; put(out, rs.fmtFormat([args12[0], "|", args12[1]]).v); } @@ -265,8 +263,7 @@ export function walk$char_EscapeUnicode(out: rs.ByteVec, it: rs.Iter): const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); const args11 = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]]).v); - const _79: rs.Iter = it; - const rest: rs.String = rs.stringExtendChars(rs.stringNew(), _79); + const rest: rs.String = rs.stringFromChars(it); const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest.v), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; put(out, rs.fmtFormat([args12[0], "|", args12[1]]).v); } @@ -291,8 +288,7 @@ export function walk$char_ToLowercase(out: rs.ByteVec, it: rs.Iter): vo const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); const args11 = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]]).v); - const _79: rs.Iter = it; - const rest: rs.String = rs.stringExtendChars(rs.stringNew(), _79); + const rest: rs.String = rs.stringFromChars(it); const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest.v), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; put(out, rs.fmtFormat([args12[0], "|", args12[1]]).v); } @@ -317,8 +313,7 @@ export function walk$char_ToUppercase(out: rs.ByteVec, it: rs.Iter): vo const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); const args11 = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]]).v); - const _79: rs.Iter = it; - const rest: rs.String = rs.stringExtendChars(rs.stringNew(), _79); + const rest: rs.String = rs.stringFromChars(it); const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest.v), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; put(out, rs.fmtFormat([args12[0], "|", args12[1]]).v); } @@ -340,8 +335,7 @@ export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _15: rs.u8 = rs.u8Rem(kind, 5); if (_15 === 0) { walk$char_ToLowercase(out, rs.charToLowercase(c)); - const _23: rs.Iter = rs.iterRev(rs.charToLowercase(c)); - put(out, rs.stringExtendChars(rs.stringNew(), _23).v); + put(out, rs.stringFromChars(rs.iterRev(rs.charToLowercase(c))).v); } else if (_15 === 1) { walk$char_ToUppercase(out, rs.charToUppercase(c)); const up: rs.Iter = rs.charToUppercase(c); @@ -463,14 +457,12 @@ export function decodes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void break; } } - const _94: rs.Iter = rs.iterMap(rs.charDecodeUtf16(rs.iterSlice([55357, 56832])), (r2: rs.Result): rs.char => { + const s: rs.String = rs.stringFromChars(rs.iterMap(rs.charDecodeUtf16(rs.iterSlice([55357, 56832])), (r2: rs.Result): rs.char => { return result_unwrapOr$1yj84xe(r2, 65533); - }); - const s: rs.String = rs.stringExtendChars(rs.stringNew(), _94); - const _97: rs.Iter = rs.iterMap(rs.charDecodeUtf16(rs.vecIntoIter(units)), (r3: rs.Result): rs.char => { + })); + const lossy: rs.String = rs.stringFromChars(rs.iterMap(rs.charDecodeUtf16(rs.vecIntoIter(units)), (r3: rs.Result): rs.char => { return result_unwrapOr$1yj84xe(r3, 63); - }); - const lossy: rs.String = rs.stringExtendChars(rs.stringNew(), _97); + })); const args6 = [(f: rs.Formatter) => rs.fmtPad(f, s.v), (f: rs.Formatter) => rs.fmtPad(f, lossy.v)]; put(out, rs.fmtFormat([args6[0], "|", args6[1]]).v); } @@ -491,8 +483,8 @@ export function converts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void if (_11 === rs.DONE) { break; } - const part3 = rs.charFromDigit(_11, radix); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part3, f, rs.fmtCharDebug)]).v); + const part = rs.charFromDigit(_11, radix); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part, f, rs.fmtCharDebug)]).v); } } else if (_6 === 1) { const iter2: rs.Iter = rs.iterSlice([48, 57, 97, 122, 65, 90, 47, 58, 64, 91, 96, 123, 1635, 65345]); @@ -508,11 +500,10 @@ export function converts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const r: rs.Result = rs.charTryFrom(n2); put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(r, f, rs.fmtCharDebug, rs.fmtCharTryFromErrorDebug)]).v); if (!r.ok) { - const part = new rs.CharTryFromError(); - const args12 = [(f: rs.Formatter) => rs.fmtCharTryFromErrorDisplay(part, f), (f: rs.Formatter) => rs.fmtCharTryFromErrorDebug(part, f)]; + const _59: rs.CharTryFromError = new rs.CharTryFromError(); + const args12 = [(f: rs.Formatter) => rs.fmtCharTryFromErrorDisplay(_59, f), (f: rs.Formatter) => rs.fmtCharTryFromErrorDebug(_59, f)]; put(out, rs.fmtFormat([args12[0], "|", rs.fmtSpec({ align: ">", width: 45 }, args12[0]), "|", args12[1], "|", rs.fmtSpec({ alternate: true }, args12[1])]).v); - const _78: rs.CharTryFromError = new rs.CharTryFromError(); - rs.byteVecPush(out, convert_eq$1efmo6b(new rs.CharTryFromError(), _78) ? 1 : 0); + rs.byteVecPush(out, convert_eq$1efmo6b(_59, _59) ? 1 : 0); } const _80: rs.char | undefined = rs.charFromU32(n2); if (_80 !== undefined) { @@ -528,11 +519,10 @@ export function converts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return a0 as rs.u16; }); if (!result_and$02o4suw(w, _109).ok) { - const part2 = new rs.TryFromCharError(); - const args14 = [(f: rs.Formatter) => rs.fmtTryFromCharErrorDisplay(part2, f), (f: rs.Formatter) => rs.fmtTryFromCharErrorDebug(part2, f)]; + const _111: rs.TryFromCharError = new rs.TryFromCharError(); + const args14 = [(f: rs.Formatter) => rs.fmtTryFromCharErrorDisplay(_111, f), (f: rs.Formatter) => rs.fmtTryFromCharErrorDebug(_111, f)]; put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ align: "<", width: 35 }, args14[0]), "|", args14[1], "|", rs.fmtSpec({ alternate: true }, args14[1])]).v); - const _130: rs.TryFromCharError = new rs.TryFromCharError(); - rs.byteVecPush(out, char_eq$1g188ap(new rs.TryFromCharError(), _130) ? 1 : 0); + rs.byteVecPush(out, char_eq$1g188ap(_111, _111) ? 1 : 0); } } } @@ -572,21 +562,18 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const units: rs.usize = rs.iterSum(rs.iterMap(rs.strChars(s2), (a08: rs.char): rs.usize => { return rs.charLenUtf16(a08); }), rs.usizeAdd, 0); - const _61: rs.Iter = rs.iterFlatMap(rs.strChars(s2), (a09: rs.char): rs.Iter => { + const upper: rs.String = rs.stringFromChars(rs.iterFlatMap(rs.strChars(s2), (a09: rs.char): rs.Iter => { return rs.charToUppercase(a09); - }, undefined, true); - const upper: rs.String = rs.stringExtendChars(rs.stringNew(), _61); - const _64: rs.Iter = rs.iterFlatMap(rs.strChars(s2), (a010: rs.char): rs.Iter => { + }, undefined, true)); + const lower: rs.String = rs.stringFromChars(rs.iterFlatMap(rs.strChars(s2), (a010: rs.char): rs.Iter => { return rs.charToLowercase(a010); - }, undefined, true); - const lower: rs.String = rs.stringExtendChars(rs.stringNew(), _64); + }, undefined, true)); const args12 = [(f: rs.Formatter) => rs.usizeDisplay(lens, f), (f: rs.Formatter) => rs.usizeDisplay(units, f), (f: rs.Formatter) => rs.fmtPad(f, upper.v), (f: rs.Formatter) => rs.fmtPad(f, lower.v)]; put(out, rs.fmtFormat([args12[0], "|", args12[1], "|", args12[2], "|", args12[3]]).v); } else { - const _85: rs.Iter = rs.iterFlatMap(rs.strChars(s2), (a0: rs.char): rs.Iter => { + const escaped: rs.String = rs.stringFromChars(rs.iterFlatMap(rs.strChars(s2), (a0: rs.char): rs.Iter => { return rs.charEscapeDefault(a0); - }, undefined, true); - const escaped: rs.String = rs.stringExtendChars(rs.stringNew(), _85); + }, undefined, true)); const debug: rs.String = rs.stringFromStrings(rs.iterMap(rs.iterMap(rs.strChars(s2), (a02: rs.char): rs.Iter => { return rs.charEscapeDebug(a02); }), (e: rs.Iter): rs.String => { diff --git a/ts/fixtures/lang/clones/expected/clones.ts b/ts/fixtures/lang/clones/expected/clones.ts index c14365ce2..d72527307 100644 --- a/ts/fixtures/lang/clones/expected/clones.ts +++ b/ts/fixtures/lang/clones/expected/clones.ts @@ -29,12 +29,6 @@ export function flush(log: rs.RefCell, out: rs.ByteVec): void { export function turns$array_IntoIter_u8_4_clones_iters_closure20_clones_iters_closure21(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -54,6 +48,12 @@ export function turns$array_IntoIter_u8_4_clones_iters_closure20_clones_iters_cl } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -67,11 +67,11 @@ export function turns$array_IntoIter_u8_4_clones_iters_closure20_clones_iters_cl } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -109,12 +109,6 @@ export function turns$array_IntoIter_u8_4_clones_iters_closure20_clones_iters_cl export function turns$collections_binary_heap_IntoIter_u8_clones_iters_closure142_clones_iters_closure143(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -134,6 +128,12 @@ export function turns$collections_binary_heap_IntoIter_u8_clones_iters_closure14 } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -147,11 +147,11 @@ export function turns$collections_binary_heap_IntoIter_u8_clones_iters_closure14 } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -189,12 +189,6 @@ export function turns$collections_binary_heap_IntoIter_u8_clones_iters_closure14 export function turns$collections_binary_heap_Iter_u8_clones_iters_closure141_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -214,6 +208,12 @@ export function turns$collections_binary_heap_Iter_u8_clones_iters_closure141_cl } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -227,11 +227,11 @@ export function turns$collections_binary_heap_Iter_u8_clones_iters_closure141_cl } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -269,12 +269,6 @@ export function turns$collections_binary_heap_Iter_u8_clones_iters_closure141_cl export function turns$collections_btree_map_Iter_u8_u8_clones_iters_closure122_clones_iters_closure123(it: rs.Iter<[rs.u8, rs.u8]>, back: (a0: rs.Iter<[rs.u8, rs.u8]>) => [rs.u8, rs.u8] | undefined, plan: Plan.Plan, put: (a0: [rs.u8, rs.u8]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: [rs.u8, rs.u8] | undefined; - const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -294,6 +288,12 @@ export function turns$collections_btree_map_Iter_u8_u8_clones_iters_closure122_c } } const other: rs.Iter<[rs.u8, rs.u8]> = it.clone(); + const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -307,11 +307,11 @@ export function turns$collections_btree_map_Iter_u8_u8_clones_iters_closure122_c } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -349,12 +349,6 @@ export function turns$collections_btree_map_Iter_u8_u8_clones_iters_closure122_c export function turns$collections_btree_map_Keys_u8_u8_clones_iters_closure124_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -374,6 +368,12 @@ export function turns$collections_btree_map_Keys_u8_u8_clones_iters_closure124_c } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -387,11 +387,11 @@ export function turns$collections_btree_map_Keys_u8_u8_clones_iters_closure124_c } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -429,12 +429,6 @@ export function turns$collections_btree_map_Keys_u8_u8_clones_iters_closure124_c export function turns$collections_btree_map_Range_u8_u8_clones_iters_closure126_clones_iters_closure127(it: rs.Iter<[rs.u8, rs.u8]>, back: (a0: rs.Iter<[rs.u8, rs.u8]>) => [rs.u8, rs.u8] | undefined, plan: Plan.Plan, put: (a0: [rs.u8, rs.u8]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: [rs.u8, rs.u8] | undefined; - const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -454,6 +448,12 @@ export function turns$collections_btree_map_Range_u8_u8_clones_iters_closure126_ } } const other: rs.Iter<[rs.u8, rs.u8]> = it.clone(); + const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -467,11 +467,11 @@ export function turns$collections_btree_map_Range_u8_u8_clones_iters_closure126_ } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -509,12 +509,6 @@ export function turns$collections_btree_map_Range_u8_u8_clones_iters_closure126_ export function turns$collections_btree_map_Range_u8_u8_clones_iters_closure128_clones_iters_closure129(it: rs.Iter<[rs.u8, rs.u8]>, back: (a0: rs.Iter<[rs.u8, rs.u8]>) => [rs.u8, rs.u8] | undefined, plan: Plan.Plan, put: (a0: [rs.u8, rs.u8]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: [rs.u8, rs.u8] | undefined; - const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -534,6 +528,12 @@ export function turns$collections_btree_map_Range_u8_u8_clones_iters_closure128_ } } const other: rs.Iter<[rs.u8, rs.u8]> = it.clone(); + const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -547,11 +547,11 @@ export function turns$collections_btree_map_Range_u8_u8_clones_iters_closure128_ } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -589,12 +589,6 @@ export function turns$collections_btree_map_Range_u8_u8_clones_iters_closure128_ export function turns$collections_btree_map_Values_u8_u8_clones_iters_closure125_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -614,6 +608,12 @@ export function turns$collections_btree_map_Values_u8_u8_clones_iters_closure125 } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -627,11 +627,11 @@ export function turns$collections_btree_map_Values_u8_u8_clones_iters_closure125 } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -669,12 +669,6 @@ export function turns$collections_btree_map_Values_u8_u8_clones_iters_closure125 export function turns$collections_btree_set_Difference_u8_clones_iters_closure135_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -694,6 +688,12 @@ export function turns$collections_btree_set_Difference_u8_clones_iters_closure13 } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -707,11 +707,11 @@ export function turns$collections_btree_set_Difference_u8_clones_iters_closure13 } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -749,12 +749,6 @@ export function turns$collections_btree_set_Difference_u8_clones_iters_closure13 export function turns$collections_btree_set_Difference_u8_clones_iters_closure136_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -774,6 +768,12 @@ export function turns$collections_btree_set_Difference_u8_clones_iters_closure13 } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -787,11 +787,11 @@ export function turns$collections_btree_set_Difference_u8_clones_iters_closure13 } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -829,12 +829,6 @@ export function turns$collections_btree_set_Difference_u8_clones_iters_closure13 export function turns$collections_btree_set_Intersection_u8_clones_iters_closure133_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -854,6 +848,12 @@ export function turns$collections_btree_set_Intersection_u8_clones_iters_closure } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -867,11 +867,11 @@ export function turns$collections_btree_set_Intersection_u8_clones_iters_closure } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -909,12 +909,6 @@ export function turns$collections_btree_set_Intersection_u8_clones_iters_closure export function turns$collections_btree_set_Intersection_u8_clones_iters_closure134_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -934,6 +928,12 @@ export function turns$collections_btree_set_Intersection_u8_clones_iters_closure } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -947,11 +947,11 @@ export function turns$collections_btree_set_Intersection_u8_clones_iters_closure } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -989,12 +989,6 @@ export function turns$collections_btree_set_Intersection_u8_clones_iters_closure export function turns$collections_btree_set_Iter_u8_clones_iters_closure130_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -1014,6 +1008,12 @@ export function turns$collections_btree_set_Iter_u8_clones_iters_closure130_clon } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -1027,11 +1027,11 @@ export function turns$collections_btree_set_Iter_u8_clones_iters_closure130_clon } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -1069,12 +1069,6 @@ export function turns$collections_btree_set_Iter_u8_clones_iters_closure130_clon export function turns$collections_btree_set_Range_u8_clones_iters_closure131_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -1094,6 +1088,12 @@ export function turns$collections_btree_set_Range_u8_clones_iters_closure131_clo } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -1107,11 +1107,11 @@ export function turns$collections_btree_set_Range_u8_clones_iters_closure131_clo } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -1149,12 +1149,6 @@ export function turns$collections_btree_set_Range_u8_clones_iters_closure131_clo export function turns$collections_btree_set_SymmetricDifference_u8_clones_iters_closure137_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -1174,6 +1168,12 @@ export function turns$collections_btree_set_SymmetricDifference_u8_clones_iters_ } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -1187,11 +1187,11 @@ export function turns$collections_btree_set_SymmetricDifference_u8_clones_iters_ } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -1229,12 +1229,6 @@ export function turns$collections_btree_set_SymmetricDifference_u8_clones_iters_ export function turns$collections_btree_set_Union_u8_clones_iters_closure132_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -1254,6 +1248,12 @@ export function turns$collections_btree_set_Union_u8_clones_iters_closure132_clo } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -1267,11 +1267,11 @@ export function turns$collections_btree_set_Union_u8_clones_iters_closure132_clo } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -1309,12 +1309,6 @@ export function turns$collections_btree_set_Union_u8_clones_iters_closure132_clo export function turns$collections_vec_deque_IntoIter_clones_Logged_clones_owned_closure5_clones_owned_closure6(it: rs.Iter, back: (a0: rs.Iter) => Logged.Logged | undefined, plan: Plan.Plan, put: (a0: Logged.Logged) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: Logged.Logged | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -1334,6 +1328,12 @@ export function turns$collections_vec_deque_IntoIter_clones_Logged_clones_owned_ } } const other: rs.Iter = it.clone({ v: Logged.clone$Clone }); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -1347,11 +1347,11 @@ export function turns$collections_vec_deque_IntoIter_clones_Logged_clones_owned_ } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -1391,12 +1391,6 @@ export function turns$collections_vec_deque_IntoIter_clones_Logged_clones_owned_ export function turns$collections_vec_deque_IntoIter_u8_clones_iters_closure139_clones_iters_closure140(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -1416,6 +1410,12 @@ export function turns$collections_vec_deque_IntoIter_u8_clones_iters_closure139_ } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -1429,11 +1429,11 @@ export function turns$collections_vec_deque_IntoIter_u8_clones_iters_closure139_ } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -1471,12 +1471,6 @@ export function turns$collections_vec_deque_IntoIter_u8_clones_iters_closure139_ export function turns$collections_vec_deque_Iter_u8_clones_iters_closure138_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -1496,6 +1490,12 @@ export function turns$collections_vec_deque_Iter_u8_clones_iters_closure138_clon } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -1509,11 +1509,11 @@ export function turns$collections_vec_deque_Iter_u8_clones_iters_closure138_clon } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -1551,12 +1551,6 @@ export function turns$collections_vec_deque_Iter_u8_clones_iters_closure138_clon export function turns$iter_Chain_iter_Once_clones_Logged_option_IntoIter_clones_Logged_clones_owned_closure10_clones_owned_closure11(it: rs.Iter, back: (a0: rs.Iter) => Logged.Logged | undefined, plan: Plan.Plan, put: (a0: Logged.Logged) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: Logged.Logged | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -1576,6 +1570,12 @@ export function turns$iter_Chain_iter_Once_clones_Logged_option_IntoIter_clones_ } } const other: rs.Iter = it.clone({ i: { v: Logged.clone$Clone }, o: { v: Logged.clone$Clone } }); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -1589,11 +1589,11 @@ export function turns$iter_Chain_iter_Once_clones_Logged_option_IntoIter_clones_ } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -1633,12 +1633,6 @@ export function turns$iter_Chain_iter_Once_clones_Logged_option_IntoIter_clones_ export function turns$iter_Chain_slice_Iter_u8_iter_Skip_iter_Rev_slice_Iter_u8_clones_iters_closure85_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -1658,6 +1652,12 @@ export function turns$iter_Chain_slice_Iter_u8_iter_Skip_iter_Rev_slice_Iter_u8_ } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -1671,11 +1671,11 @@ export function turns$iter_Chain_slice_Iter_u8_iter_Skip_iter_Rev_slice_Iter_u8_ } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -1713,12 +1713,6 @@ export function turns$iter_Chain_slice_Iter_u8_iter_Skip_iter_Rev_slice_Iter_u8_ export function turns$iter_Cloned_slice_Iter_u8_clones_iters_closure82_clones_iters_closure83(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -1738,6 +1732,12 @@ export function turns$iter_Cloned_slice_Iter_u8_clones_iters_closure82_clones_it } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -1751,11 +1751,11 @@ export function turns$iter_Cloned_slice_Iter_u8_clones_iters_closure82_clones_it } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -1793,12 +1793,6 @@ export function turns$iter_Cloned_slice_Iter_u8_clones_iters_closure82_clones_it export function turns$iter_Copied_slice_Iter_u8_clones_iters_closure80_clones_iters_closure81(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -1818,6 +1812,12 @@ export function turns$iter_Copied_slice_Iter_u8_clones_iters_closure80_clones_it } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -1831,11 +1831,11 @@ export function turns$iter_Copied_slice_Iter_u8_clones_iters_closure80_clones_it } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -1873,12 +1873,6 @@ export function turns$iter_Copied_slice_Iter_u8_clones_iters_closure80_clones_it export function turns$iter_Empty_u8_clones_iters_closure51_clones_iters_closure52(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -1898,6 +1892,12 @@ export function turns$iter_Empty_u8_clones_iters_closure51_clones_iters_closure5 } } const other: rs.Iter = rs.iterEmpty() as rs.Iter; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -1911,11 +1911,11 @@ export function turns$iter_Empty_u8_clones_iters_closure51_clones_iters_closure5 } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -1953,12 +1953,6 @@ export function turns$iter_Empty_u8_clones_iters_closure51_clones_iters_closure5 export function turns$iter_Enumerate_slice_Iter_u8_clones_iters_closure74_clones_iters_closure75(it: rs.Iter<[rs.usize, rs.u8]>, back: (a0: rs.Iter<[rs.usize, rs.u8]>) => [rs.usize, rs.u8] | undefined, plan: Plan.Plan, put: (a0: [rs.usize, rs.u8]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: [rs.usize, rs.u8] | undefined; - const _44: (a0: rs.Iter<[rs.usize, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.usize, rs.u8]>): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -1978,6 +1972,12 @@ export function turns$iter_Enumerate_slice_Iter_u8_clones_iters_closure74_clones } } const other: rs.Iter<[rs.usize, rs.u8]> = it.clone(); + const _44: (a0: rs.Iter<[rs.usize, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.usize, rs.u8]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -1991,11 +1991,11 @@ export function turns$iter_Enumerate_slice_Iter_u8_clones_iters_closure74_clones } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -2033,12 +2033,6 @@ export function turns$iter_Enumerate_slice_Iter_u8_clones_iters_closure74_clones export function turns$iter_FilterMap_slice_Iter_u8_clones_iters_closure71_clones_iters_closure72_clones_iters_closure73(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -2058,6 +2052,12 @@ export function turns$iter_FilterMap_slice_Iter_u8_clones_iters_closure71_clones } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -2071,11 +2071,11 @@ export function turns$iter_FilterMap_slice_Iter_u8_clones_iters_closure71_clones } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -2113,12 +2113,6 @@ export function turns$iter_FilterMap_slice_Iter_u8_clones_iters_closure71_clones export function turns$iter_Filter_iter_Map_slice_Iter_u8_clones_closures_closure1_clones_closures_closure2_clones_closures_closure3_clones_closures_closure4(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -2138,6 +2132,12 @@ export function turns$iter_Filter_iter_Map_slice_Iter_u8_clones_closures_closure } } const other: rs.Iter = it.clone({ i: { f: rs.closureClone }, f: rs.closureClone }); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -2151,11 +2151,11 @@ export function turns$iter_Filter_iter_Map_slice_Iter_u8_clones_closures_closure } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -2195,12 +2195,6 @@ export function turns$iter_Filter_iter_Map_slice_Iter_u8_clones_closures_closure export function turns$iter_Filter_slice_Iter_u8_clones_iters_closure147_clones_iters_closure148_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -2220,6 +2214,12 @@ export function turns$iter_Filter_slice_Iter_u8_clones_iters_closure147_clones_i } } const other: rs.Iter = it.clone({ f: rs.closureClone }); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -2233,11 +2233,11 @@ export function turns$iter_Filter_slice_Iter_u8_clones_iters_closure147_clones_i } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -2275,12 +2275,6 @@ export function turns$iter_Filter_slice_Iter_u8_clones_iters_closure147_clones_i export function turns$iter_Filter_slice_Iter_u8_clones_iters_closure69_clones_iters_closure70_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -2300,6 +2294,12 @@ export function turns$iter_Filter_slice_Iter_u8_clones_iters_closure69_clones_it } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -2313,11 +2313,11 @@ export function turns$iter_Filter_slice_Iter_u8_clones_iters_closure69_clones_it } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -2355,12 +2355,6 @@ export function turns$iter_Filter_slice_Iter_u8_clones_iters_closure69_clones_it export function turns$iter_FlatMap_slice_Chunks_u8_iter_Map_slice_Iter_u8_clones_iters_closure153_closure0_clones_iters_closure153_clones_iters_closure154_clones_iters_closure155(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -2380,6 +2374,12 @@ export function turns$iter_FlatMap_slice_Chunks_u8_iter_Map_slice_Iter_u8_clones } } const other: rs.Iter = it.clone({ i: { f: rs.closureClone } }); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -2393,11 +2393,11 @@ export function turns$iter_FlatMap_slice_Chunks_u8_iter_Map_slice_Iter_u8_clones } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -2435,12 +2435,6 @@ export function turns$iter_FlatMap_slice_Chunks_u8_iter_Map_slice_Iter_u8_clones export function turns$iter_FlatMap_slice_Chunks_u8_slice_Iter_u8_clones_iters_closure87_clones_iters_closure88_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -2460,6 +2454,12 @@ export function turns$iter_FlatMap_slice_Chunks_u8_slice_Iter_u8_clones_iters_cl } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -2473,11 +2473,11 @@ export function turns$iter_FlatMap_slice_Chunks_u8_slice_Iter_u8_clones_iters_cl } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -2515,12 +2515,6 @@ export function turns$iter_FlatMap_slice_Chunks_u8_slice_Iter_u8_clones_iters_cl export function turns$iter_Flatten_iter_Map_slice_Chunks_u8_clones_iters_closure89_clones_iters_closure90_clones_iters_closure91(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -2540,6 +2534,12 @@ export function turns$iter_Flatten_iter_Map_slice_Chunks_u8_clones_iters_closure } } const other: rs.Iter = it.clone({ o: { v: rs.itself } }); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -2553,11 +2553,11 @@ export function turns$iter_Flatten_iter_Map_slice_Chunks_u8_clones_iters_closure } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -2595,12 +2595,6 @@ export function turns$iter_Flatten_iter_Map_slice_Chunks_u8_clones_iters_closure export function turns$iter_Flatten_slice_Chunks_u8_clones_iters_closure92_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -2620,6 +2614,12 @@ export function turns$iter_Flatten_slice_Chunks_u8_clones_iters_closure92_clones } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -2633,11 +2633,11 @@ export function turns$iter_Flatten_slice_Chunks_u8_clones_iters_closure92_clones } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -2675,12 +2675,6 @@ export function turns$iter_Flatten_slice_Chunks_u8_clones_iters_closure92_clones export function turns$iter_Flatten_vec_IntoIter_Vec_clones_Logged_clones_owned_closure13_clones_owned_closure14(it: rs.Iter, back: (a0: rs.Iter) => Logged.Logged | undefined, plan: Plan.Plan, put: (a0: Logged.Logged) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: Logged.Logged | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -2702,6 +2696,12 @@ export function turns$iter_Flatten_vec_IntoIter_Vec_clones_Logged_clones_owned_c const other: rs.Iter = it.clone({ i: { v: (a0: rs.Vec): rs.Vec => { return rs.vecFrom(a0.items.map(Logged.clone$Clone)); } }, o: { v: Logged.clone$Clone } }); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -2715,11 +2715,11 @@ export function turns$iter_Flatten_vec_IntoIter_Vec_clones_Logged_clones_owned_c } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -2759,12 +2759,6 @@ export function turns$iter_Flatten_vec_IntoIter_Vec_clones_Logged_clones_owned_c export function turns$iter_FromFn_clones_iters_closure105_clones_iters_closure106_clones_iters_closure107(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -2784,6 +2778,12 @@ export function turns$iter_FromFn_clones_iters_closure105_clones_iters_closure10 } } const other: rs.Iter = it.clone({ v: rs.closureClone }); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -2797,11 +2797,11 @@ export function turns$iter_FromFn_clones_iters_closure105_clones_iters_closure10 } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -2839,12 +2839,6 @@ export function turns$iter_FromFn_clones_iters_closure105_clones_iters_closure10 export function turns$iter_Fuse_slice_Iter_u8_clones_iters_closure84_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -2864,6 +2858,12 @@ export function turns$iter_Fuse_slice_Iter_u8_clones_iters_closure84_clones_iter } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -2877,11 +2877,11 @@ export function turns$iter_Fuse_slice_Iter_u8_clones_iters_closure84_clones_iter } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -2919,12 +2919,6 @@ export function turns$iter_Fuse_slice_Iter_u8_clones_iters_closure84_clones_iter export function turns$iter_MapWhile_slice_Iter_u8_clones_iters_closure97_clones_iters_closure98_clones_iters_closure99(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -2944,6 +2938,12 @@ export function turns$iter_MapWhile_slice_Iter_u8_clones_iters_closure97_clones_ } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -2957,11 +2957,11 @@ export function turns$iter_MapWhile_slice_Iter_u8_clones_iters_closure97_clones_ } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -2999,12 +2999,6 @@ export function turns$iter_MapWhile_slice_Iter_u8_clones_iters_closure97_clones_ export function turns$iter_Map_clones_Countdown_clones_iters_closure100_clones_iters_closure101_clones_iters_closure102(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -3024,6 +3018,12 @@ export function turns$iter_Map_clones_Countdown_clones_iters_closure100_clones_i } } const other: rs.Iter = it.clone({ i: { v: Countdown.clone$Clone } }); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -3037,11 +3037,11 @@ export function turns$iter_Map_clones_Countdown_clones_iters_closure100_clones_i } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -3079,12 +3079,6 @@ export function turns$iter_Map_clones_Countdown_clones_iters_closure100_clones_i export function turns$iter_Map_iter_Inspect_slice_Iter_u8_clones_iters_closure149_clones_iters_closure150_clones_iters_closure151_clones_iters_closure152(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -3104,6 +3098,12 @@ export function turns$iter_Map_iter_Inspect_slice_Iter_u8_clones_iters_closure14 } } const other: rs.Iter = it.clone({ i: { f: rs.closureClone } }); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -3117,11 +3117,11 @@ export function turns$iter_Map_iter_Inspect_slice_Iter_u8_clones_iters_closure14 } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -3159,12 +3159,6 @@ export function turns$iter_Map_iter_Inspect_slice_Iter_u8_clones_iters_closure14 export function turns$iter_Map_slice_Iter_u8_clones_iters_closure144_clones_iters_closure145_clones_iters_closure146(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -3184,6 +3178,12 @@ export function turns$iter_Map_slice_Iter_u8_clones_iters_closure144_clones_iter } } const other: rs.Iter = it.clone({ f: rs.closureClone }); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -3197,11 +3197,11 @@ export function turns$iter_Map_slice_Iter_u8_clones_iters_closure144_clones_iter } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -3239,12 +3239,6 @@ export function turns$iter_Map_slice_Iter_u8_clones_iters_closure144_clones_iter export function turns$iter_Map_slice_Iter_u8_clones_iters_closure66_clones_iters_closure67_clones_iters_closure68(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -3264,6 +3258,12 @@ export function turns$iter_Map_slice_Iter_u8_clones_iters_closure66_clones_iters } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -3277,11 +3277,11 @@ export function turns$iter_Map_slice_Iter_u8_clones_iters_closure66_clones_iters } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -3319,12 +3319,6 @@ export function turns$iter_Map_slice_Iter_u8_clones_iters_closure66_clones_iters export function turns$iter_Once_u8_clones_iters_closure49_clones_iters_closure50(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -3344,6 +3338,12 @@ export function turns$iter_Once_u8_clones_iters_closure49_clones_iters_closure50 } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -3357,11 +3357,11 @@ export function turns$iter_Once_u8_clones_iters_closure49_clones_iters_closure50 } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -3399,12 +3399,6 @@ export function turns$iter_Once_u8_clones_iters_closure49_clones_iters_closure50 export function turns$iter_Peekable_iter_Copied_slice_Iter_u8_clones_iters_closure120_clones_iters_closure121(it: rs.Peekable, back: (a0: rs.Peekable) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Peekable) => Uint8Array = (it2: rs.Peekable): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -3424,6 +3418,12 @@ export function turns$iter_Peekable_iter_Copied_slice_Iter_u8_clones_iters_closu } } const other: rs.Peekable = it.clone(); + const _44: (a0: rs.Peekable) => Uint8Array = (it2: rs.Peekable): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -3437,11 +3437,11 @@ export function turns$iter_Peekable_iter_Copied_slice_Iter_u8_clones_iters_closu } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -3479,12 +3479,6 @@ export function turns$iter_Peekable_iter_Copied_slice_Iter_u8_clones_iters_closu export function turns$iter_Peekable_slice_Iter_u8_clones_iters_closure119_clones_iters_closure0(it: rs.Peekable, back: (a0: rs.Peekable) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Peekable) => Uint8Array = (it2: rs.Peekable): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -3504,6 +3498,12 @@ export function turns$iter_Peekable_slice_Iter_u8_clones_iters_closure119_clones } } const other: rs.Peekable = it.clone(); + const _44: (a0: rs.Peekable) => Uint8Array = (it2: rs.Peekable): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -3517,11 +3517,11 @@ export function turns$iter_Peekable_slice_Iter_u8_clones_iters_closure119_clones } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -3559,12 +3559,6 @@ export function turns$iter_Peekable_slice_Iter_u8_clones_iters_closure119_clones export function turns$iter_Peekable_slice_Iter_u8_clones_iters_closure86_clones_iters_closure0(it: rs.Peekable, back: (a0: rs.Peekable) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Peekable) => Uint8Array = (it2: rs.Peekable): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -3584,6 +3578,12 @@ export function turns$iter_Peekable_slice_Iter_u8_clones_iters_closure86_clones_ } } const other: rs.Peekable = it.clone(); + const _44: (a0: rs.Peekable) => Uint8Array = (it2: rs.Peekable): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -3597,11 +3597,11 @@ export function turns$iter_Peekable_slice_Iter_u8_clones_iters_closure86_clones_ } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -3639,12 +3639,6 @@ export function turns$iter_Peekable_slice_Iter_u8_clones_iters_closure86_clones_ export function turns$iter_Peekable_vec_IntoIter_clones_Logged_clones_owned_closure8_clones_owned_closure9(it: rs.Peekable, back: (a0: rs.Peekable) => Logged.Logged | undefined, plan: Plan.Plan, put: (a0: Logged.Logged) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: Logged.Logged | undefined; - const _44: (a0: rs.Peekable) => Uint8Array = (it2: rs.Peekable): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -3664,6 +3658,12 @@ export function turns$iter_Peekable_vec_IntoIter_clones_Logged_clones_owned_clos } } const other: rs.Peekable = it.clone({ i: { v: Logged.clone$Clone }, v: Logged.clone$Clone }); + const _44: (a0: rs.Peekable) => Uint8Array = (it2: rs.Peekable): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -3677,11 +3677,11 @@ export function turns$iter_Peekable_vec_IntoIter_clones_Logged_clones_owned_clos } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -3721,12 +3721,6 @@ export function turns$iter_Peekable_vec_IntoIter_clones_Logged_clones_owned_clos export function turns$iter_Rev_slice_Iter_u8_clones_iters_closure76_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -3746,6 +3740,12 @@ export function turns$iter_Rev_slice_Iter_u8_clones_iters_closure76_clones_iters } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -3759,11 +3759,11 @@ export function turns$iter_Rev_slice_Iter_u8_clones_iters_closure76_clones_iters } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -3801,12 +3801,6 @@ export function turns$iter_Rev_slice_Iter_u8_clones_iters_closure76_clones_iters export function turns$iter_SkipWhile_slice_Iter_u8_clones_iters_closure93_clones_iters_closure94_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -3826,6 +3820,12 @@ export function turns$iter_SkipWhile_slice_Iter_u8_clones_iters_closure93_clones } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -3839,11 +3839,11 @@ export function turns$iter_SkipWhile_slice_Iter_u8_clones_iters_closure93_clones } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -3881,12 +3881,6 @@ export function turns$iter_SkipWhile_slice_Iter_u8_clones_iters_closure93_clones export function turns$iter_Skip_slice_Iter_u8_clones_iters_closure77_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -3906,6 +3900,12 @@ export function turns$iter_Skip_slice_Iter_u8_clones_iters_closure77_clones_iter } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -3919,11 +3919,11 @@ export function turns$iter_Skip_slice_Iter_u8_clones_iters_closure77_clones_iter } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -3961,12 +3961,6 @@ export function turns$iter_Skip_slice_Iter_u8_clones_iters_closure77_clones_iter export function turns$iter_StepBy_slice_Iter_u8_clones_iters_closure79_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -3986,6 +3980,12 @@ export function turns$iter_StepBy_slice_Iter_u8_clones_iters_closure79_clones_it } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -3999,11 +3999,11 @@ export function turns$iter_StepBy_slice_Iter_u8_clones_iters_closure79_clones_it } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -4041,12 +4041,6 @@ export function turns$iter_StepBy_slice_Iter_u8_clones_iters_closure79_clones_it export function turns$iter_Successors_clones_Logged_clones_owned_closure15_clones_owned_closure16_clones_owned_closure17(it: rs.Iter, back: (a0: rs.Iter) => Logged.Logged | undefined, plan: Plan.Plan, put: (a0: Logged.Logged) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: Logged.Logged | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -4066,6 +4060,12 @@ export function turns$iter_Successors_clones_Logged_clones_owned_closure15_clone } } const other: rs.Iter = it.clone({ v: Logged.clone$Clone }); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -4079,11 +4079,11 @@ export function turns$iter_Successors_clones_Logged_clones_owned_closure15_clone } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -4123,12 +4123,6 @@ export function turns$iter_Successors_clones_Logged_clones_owned_closure15_clone export function turns$iter_Successors_u8_clones_iters_closure108_clones_iters_closure109_clones_iters_closure110(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -4148,6 +4142,12 @@ export function turns$iter_Successors_u8_clones_iters_closure108_clones_iters_cl } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -4161,11 +4161,11 @@ export function turns$iter_Successors_u8_clones_iters_closure108_clones_iters_cl } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -4203,12 +4203,6 @@ export function turns$iter_Successors_u8_clones_iters_closure108_clones_iters_cl export function turns$iter_TakeWhile_slice_Iter_u8_clones_iters_closure95_clones_iters_closure96_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -4228,6 +4222,12 @@ export function turns$iter_TakeWhile_slice_Iter_u8_clones_iters_closure95_clones } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -4241,11 +4241,11 @@ export function turns$iter_TakeWhile_slice_Iter_u8_clones_iters_closure95_clones } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -4283,12 +4283,6 @@ export function turns$iter_TakeWhile_slice_Iter_u8_clones_iters_closure95_clones export function turns$iter_Take_slice_Iter_u8_clones_iters_closure78_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -4308,6 +4302,12 @@ export function turns$iter_Take_slice_Iter_u8_clones_iters_closure78_clones_iter } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -4321,11 +4321,11 @@ export function turns$iter_Take_slice_Iter_u8_clones_iters_closure78_clones_iter } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -4363,12 +4363,6 @@ export function turns$iter_Take_slice_Iter_u8_clones_iters_closure78_clones_iter export function turns$iter_Zip_clones_Countdown_slice_Iter_u8_clones_iters_closure103_clones_iters_closure104(it: rs.Iter<[rs.u8, rs.u8]>, back: (a0: rs.Iter<[rs.u8, rs.u8]>) => [rs.u8, rs.u8] | undefined, plan: Plan.Plan, put: (a0: [rs.u8, rs.u8]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: [rs.u8, rs.u8] | undefined; - const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -4388,6 +4382,12 @@ export function turns$iter_Zip_clones_Countdown_slice_Iter_u8_clones_iters_closu } } const other: rs.Iter<[rs.u8, rs.u8]> = it.clone({ i: { v: Countdown.clone$Clone } }); + const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -4401,11 +4401,11 @@ export function turns$iter_Zip_clones_Countdown_slice_Iter_u8_clones_iters_closu } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -4443,12 +4443,6 @@ export function turns$iter_Zip_clones_Countdown_slice_Iter_u8_clones_iters_closu export function turns$iter_Zip_iter_Filter_slice_Iter_u8_clones_iters_closure4_iter_Filter_slice_Iter_u8_clones_iters_closure5_clones_iters_closure113_clones_iters_closure114(it: rs.Iter<[rs.u8, rs.u8]>, back: (a0: rs.Iter<[rs.u8, rs.u8]>) => [rs.u8, rs.u8] | undefined, plan: Plan.Plan, put: (a0: [rs.u8, rs.u8]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: [rs.u8, rs.u8] | undefined; - const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -4468,6 +4462,12 @@ export function turns$iter_Zip_iter_Filter_slice_Iter_u8_clones_iters_closure4_i } } const other: rs.Iter<[rs.u8, rs.u8]> = it.clone(); + const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -4481,11 +4481,11 @@ export function turns$iter_Zip_iter_Filter_slice_Iter_u8_clones_iters_closure4_i } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -4523,12 +4523,6 @@ export function turns$iter_Zip_iter_Filter_slice_Iter_u8_clones_iters_closure4_i export function turns$iter_Zip_slice_Iter_u8_ops_RangeInclusive_u8_clones_iters_closure117_clones_iters_closure118(it: rs.Iter<[rs.u8, rs.u8]>, back: (a0: rs.Iter<[rs.u8, rs.u8]>) => [rs.u8, rs.u8] | undefined, plan: Plan.Plan, put: (a0: [rs.u8, rs.u8]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: [rs.u8, rs.u8] | undefined; - const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -4548,6 +4542,12 @@ export function turns$iter_Zip_slice_Iter_u8_ops_RangeInclusive_u8_clones_iters_ } } const other: rs.Iter<[rs.u8, rs.u8]> = it.clone(); + const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -4561,11 +4561,11 @@ export function turns$iter_Zip_slice_Iter_u8_ops_RangeInclusive_u8_clones_iters_ } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -4603,12 +4603,6 @@ export function turns$iter_Zip_slice_Iter_u8_ops_RangeInclusive_u8_clones_iters_ export function turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure111_clones_iters_closure112(it: rs.Iter<[rs.u8, rs.u8]>, back: (a0: rs.Iter<[rs.u8, rs.u8]>) => [rs.u8, rs.u8] | undefined, plan: Plan.Plan, put: (a0: [rs.u8, rs.u8]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: [rs.u8, rs.u8] | undefined; - const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -4628,6 +4622,12 @@ export function turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure1 } } const other: rs.Iter<[rs.u8, rs.u8]> = it.clone(); + const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -4641,11 +4641,11 @@ export function turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure1 } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -4683,12 +4683,6 @@ export function turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure1 export function turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure115_clones_iters_closure116(it: rs.Iter<[rs.u8, rs.u8]>, back: (a0: rs.Iter<[rs.u8, rs.u8]>) => [rs.u8, rs.u8] | undefined, plan: Plan.Plan, put: (a0: [rs.u8, rs.u8]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: [rs.u8, rs.u8] | undefined; - const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -4708,6 +4702,12 @@ export function turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure1 } } const other: rs.Iter<[rs.u8, rs.u8]> = it.clone(); + const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -4721,11 +4721,11 @@ export function turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure1 } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -4763,12 +4763,6 @@ export function turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure1 export function turns$ops_RangeFrom_char_clones_iters_closure44_clones_iters_closure45(it: rs.RangeFrom, back: (a0: rs.RangeFrom) => rs.char | undefined, plan: Plan.Plan, put: (a0: rs.char) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.char | undefined; - const _44: (a0: rs.RangeFrom) => Uint8Array = (it2: rs.RangeFrom): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -4788,6 +4782,12 @@ export function turns$ops_RangeFrom_char_clones_iters_closure44_clones_iters_clo } } const other: rs.RangeFrom = it.clone(); + const _44: (a0: rs.RangeFrom) => Uint8Array = (it2: rs.RangeFrom): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -4801,11 +4801,11 @@ export function turns$ops_RangeFrom_char_clones_iters_closure44_clones_iters_clo } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -4843,12 +4843,6 @@ export function turns$ops_RangeFrom_char_clones_iters_closure44_clones_iters_clo export function turns$ops_RangeFrom_u64_clones_iters_closure42_clones_iters_closure43(it: rs.RangeFrom, back: (a0: rs.RangeFrom) => rs.u64 | undefined, plan: Plan.Plan, put: (a0: rs.u64) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u64 | undefined; - const _44: (a0: rs.RangeFrom) => Uint8Array = (it2: rs.RangeFrom): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -4868,6 +4862,12 @@ export function turns$ops_RangeFrom_u64_clones_iters_closure42_clones_iters_clos } } const other: rs.RangeFrom = it.clone(); + const _44: (a0: rs.RangeFrom) => Uint8Array = (it2: rs.RangeFrom): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -4881,11 +4881,11 @@ export function turns$ops_RangeFrom_u64_clones_iters_closure42_clones_iters_clos } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -4923,12 +4923,6 @@ export function turns$ops_RangeFrom_u64_clones_iters_closure42_clones_iters_clos export function turns$ops_RangeFrom_u8_clones_iters_closure40_clones_iters_closure41(it: rs.RangeFrom, back: (a0: rs.RangeFrom) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.RangeFrom) => Uint8Array = (it2: rs.RangeFrom): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -4948,6 +4942,12 @@ export function turns$ops_RangeFrom_u8_clones_iters_closure40_clones_iters_closu } } const other: rs.RangeFrom = it.clone(); + const _44: (a0: rs.RangeFrom) => Uint8Array = (it2: rs.RangeFrom): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -4961,11 +4961,11 @@ export function turns$ops_RangeFrom_u8_clones_iters_closure40_clones_iters_closu } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -5003,12 +5003,6 @@ export function turns$ops_RangeFrom_u8_clones_iters_closure40_clones_iters_closu export function turns$ops_RangeInclusive_u8_clones_iters_closure36_clones_iters_closure37(it: rs.RangeInclusive, back: (a0: rs.RangeInclusive) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.RangeInclusive) => Uint8Array = (it2: rs.RangeInclusive): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -5028,6 +5022,12 @@ export function turns$ops_RangeInclusive_u8_clones_iters_closure36_clones_iters_ } } const other: rs.RangeInclusive = it.clone(); + const _44: (a0: rs.RangeInclusive) => Uint8Array = (it2: rs.RangeInclusive): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -5041,11 +5041,11 @@ export function turns$ops_RangeInclusive_u8_clones_iters_closure36_clones_iters_ } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -5083,12 +5083,6 @@ export function turns$ops_RangeInclusive_u8_clones_iters_closure36_clones_iters_ export function turns$ops_Range_u64_clones_iters_closure38_clones_iters_closure39(it: rs.Range, back: (a0: rs.Range) => rs.u64 | undefined, plan: Plan.Plan, put: (a0: rs.u64) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u64 | undefined; - const _44: (a0: rs.Range) => Uint8Array = (it2: rs.Range): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -5108,6 +5102,12 @@ export function turns$ops_Range_u64_clones_iters_closure38_clones_iters_closure3 } } const other: rs.Range = it.clone(); + const _44: (a0: rs.Range) => Uint8Array = (it2: rs.Range): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -5121,11 +5121,11 @@ export function turns$ops_Range_u64_clones_iters_closure38_clones_iters_closure3 } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -5164,12 +5164,6 @@ export function turns$ops_Range_u8_clones_iters_closure34_clones_iters_closure35 let _15!: rs.u8; let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Range) => Uint8Array = (it2: rs.Range): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -5192,6 +5186,12 @@ export function turns$ops_Range_u8_clones_iters_closure34_clones_iters_closure35 } } const other: rs.Range = it.clone(); + const _44: (a0: rs.Range) => Uint8Array = (it2: rs.Range): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -5205,11 +5205,11 @@ export function turns$ops_Range_u8_clones_iters_closure34_clones_iters_closure35 } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -5247,12 +5247,6 @@ export function turns$ops_Range_u8_clones_iters_closure34_clones_iters_closure35 export function turns$option_IntoIter_ref_u8_clones_iters_closure46_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -5272,6 +5266,12 @@ export function turns$option_IntoIter_ref_u8_clones_iters_closure46_clones_iters } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -5285,11 +5285,11 @@ export function turns$option_IntoIter_ref_u8_clones_iters_closure46_clones_iters } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -5327,12 +5327,6 @@ export function turns$option_IntoIter_ref_u8_clones_iters_closure46_clones_iters export function turns$option_IntoIter_u8_clones_iters_closure47_clones_iters_closure48(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -5352,6 +5346,12 @@ export function turns$option_IntoIter_u8_clones_iters_closure47_clones_iters_clo } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -5365,11 +5365,11 @@ export function turns$option_IntoIter_u8_clones_iters_closure47_clones_iters_clo } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -5407,12 +5407,6 @@ export function turns$option_IntoIter_u8_clones_iters_closure47_clones_iters_clo export function turns$slice_ChunksExact_u8_clones_iters_closure26_clones_iters_closure27(it: rs.Iter, back: (a0: rs.Iter) => rs.ByteSlice | undefined, plan: Plan.Plan, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.ByteSlice | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -5432,6 +5426,12 @@ export function turns$slice_ChunksExact_u8_clones_iters_closure26_clones_iters_c } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -5445,11 +5445,11 @@ export function turns$slice_ChunksExact_u8_clones_iters_closure26_clones_iters_c } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -5487,12 +5487,6 @@ export function turns$slice_ChunksExact_u8_clones_iters_closure26_clones_iters_c export function turns$slice_Chunks_u8_clones_iters_closure24_clones_iters_closure25(it: rs.Iter, back: (a0: rs.Iter) => rs.ByteSlice | undefined, plan: Plan.Plan, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.ByteSlice | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -5512,6 +5506,12 @@ export function turns$slice_Chunks_u8_clones_iters_closure24_clones_iters_closur } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -5525,11 +5525,11 @@ export function turns$slice_Chunks_u8_clones_iters_closure24_clones_iters_closur } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -5567,12 +5567,6 @@ export function turns$slice_Chunks_u8_clones_iters_closure24_clones_iters_closur export function turns$slice_Iter_array2_u8_clones_iters_closure32_clones_iters_closure33(it: rs.Iter, back: (a0: rs.Iter) => rs.ByteSlice | undefined, plan: Plan.Plan, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.ByteSlice | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -5592,6 +5586,12 @@ export function turns$slice_Iter_array2_u8_clones_iters_closure32_clones_iters_c } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -5605,11 +5605,11 @@ export function turns$slice_Iter_array2_u8_clones_iters_closure32_clones_iters_c } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -5647,12 +5647,6 @@ export function turns$slice_Iter_array2_u8_clones_iters_closure32_clones_iters_c export function turns$slice_Iter_u8_clones_iters_closure17_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -5672,6 +5666,12 @@ export function turns$slice_Iter_u8_clones_iters_closure17_clones_iters_closure0 } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -5685,11 +5685,11 @@ export function turns$slice_Iter_u8_clones_iters_closure17_clones_iters_closure0 } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -5727,12 +5727,6 @@ export function turns$slice_Iter_u8_clones_iters_closure17_clones_iters_closure0 export function turns$slice_RChunksExact_u8_clones_iters_closure30_clones_iters_closure31(it: rs.Iter, back: (a0: rs.Iter) => rs.ByteSlice | undefined, plan: Plan.Plan, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.ByteSlice | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -5752,6 +5746,12 @@ export function turns$slice_RChunksExact_u8_clones_iters_closure30_clones_iters_ } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -5765,11 +5765,11 @@ export function turns$slice_RChunksExact_u8_clones_iters_closure30_clones_iters_ } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -5807,12 +5807,6 @@ export function turns$slice_RChunksExact_u8_clones_iters_closure30_clones_iters_ export function turns$slice_RChunks_u8_clones_iters_closure28_clones_iters_closure29(it: rs.Iter, back: (a0: rs.Iter) => rs.ByteSlice | undefined, plan: Plan.Plan, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.ByteSlice | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -5832,6 +5826,12 @@ export function turns$slice_RChunks_u8_clones_iters_closure28_clones_iters_closu } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -5845,11 +5845,11 @@ export function turns$slice_RChunks_u8_clones_iters_closure28_clones_iters_closu } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -5887,12 +5887,6 @@ export function turns$slice_RChunks_u8_clones_iters_closure28_clones_iters_closu export function turns$slice_Windows_u8_clones_iters_closure22_clones_iters_closure23(it: rs.Iter, back: (a0: rs.Iter) => rs.ByteSlice | undefined, plan: Plan.Plan, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: rs.ByteSlice | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -5912,6 +5906,12 @@ export function turns$slice_Windows_u8_clones_iters_closure22_clones_iters_closu } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -5925,11 +5925,11 @@ export function turns$slice_Windows_u8_clones_iters_closure22_clones_iters_closu } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -5967,12 +5967,6 @@ export function turns$slice_Windows_u8_clones_iters_closure22_clones_iters_closu export function turns$str_Bytes_clones_iters_closure55_clones_iters_closure56(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -5992,6 +5986,12 @@ export function turns$str_Bytes_clones_iters_closure55_clones_iters_closure56(it } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -6005,11 +6005,11 @@ export function turns$str_Bytes_clones_iters_closure55_clones_iters_closure56(it } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -6047,12 +6047,6 @@ export function turns$str_Bytes_clones_iters_closure55_clones_iters_closure56(it export function turns$str_Chars_clones_iters_closure53_clones_iters_closure54(it: rs.Iter, back: (a0: rs.Iter) => rs.char | undefined, plan: Plan.Plan, put: (a0: rs.char) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.char | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -6072,6 +6066,12 @@ export function turns$str_Chars_clones_iters_closure53_clones_iters_closure54(it } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -6085,11 +6085,11 @@ export function turns$str_Chars_clones_iters_closure53_clones_iters_closure54(it } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -6127,12 +6127,6 @@ export function turns$str_Chars_clones_iters_closure53_clones_iters_closure54(it export function turns$str_MatchIndices_array2_char_clones_iters_closure64_clones_iters_closure65(it: rs.Iter<[rs.usize, string]>, back: (a0: rs.Iter<[rs.usize, string]>) => [rs.usize, string] | undefined, plan: Plan.Plan, put: (a0: [rs.usize, string]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: [rs.usize, string] | undefined; - const _44: (a0: rs.Iter<[rs.usize, string]>) => Uint8Array = (it2: rs.Iter<[rs.usize, string]>): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -6152,6 +6146,12 @@ export function turns$str_MatchIndices_array2_char_clones_iters_closure64_clones } } const other: rs.Iter<[rs.usize, string]> = it.clone(); + const _44: (a0: rs.Iter<[rs.usize, string]>) => Uint8Array = (it2: rs.Iter<[rs.usize, string]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -6165,11 +6165,11 @@ export function turns$str_MatchIndices_array2_char_clones_iters_closure64_clones } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -6207,12 +6207,6 @@ export function turns$str_MatchIndices_array2_char_clones_iters_closure64_clones export function turns$str_Split_char_clones_iters_closure57_clones_iters_closure58(it: rs.Iter, back: (a0: rs.Iter) => string | undefined, plan: Plan.Plan, put: (a0: string) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: string | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -6232,6 +6226,12 @@ export function turns$str_Split_char_clones_iters_closure57_clones_iters_closure } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -6245,11 +6245,11 @@ export function turns$str_Split_char_clones_iters_closure57_clones_iters_closure } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -6287,12 +6287,6 @@ export function turns$str_Split_char_clones_iters_closure57_clones_iters_closure export function turns$str_Split_clones_iters_closure61_clones_iters_closure62_clones_iters_closure63(it: rs.Iter, back: (a0: rs.Iter) => string | undefined, plan: Plan.Plan, put: (a0: string) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: string | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -6312,6 +6306,12 @@ export function turns$str_Split_clones_iters_closure61_clones_iters_closure62_cl } } const other: rs.Iter = it.clone({ f: rs.closureClone }); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -6325,11 +6325,11 @@ export function turns$str_Split_clones_iters_closure61_clones_iters_closure62_cl } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -6367,12 +6367,6 @@ export function turns$str_Split_clones_iters_closure61_clones_iters_closure62_cl export function turns$str_Split_ref_str_clones_iters_closure59_clones_iters_closure60(it: rs.Iter, back: (a0: rs.Iter) => string | undefined, plan: Plan.Plan, put: (a0: string) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: string | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -6392,6 +6386,12 @@ export function turns$str_Split_ref_str_clones_iters_closure59_clones_iters_clos } } const other: rs.Iter = it.clone(); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -6405,11 +6405,11 @@ export function turns$str_Split_ref_str_clones_iters_closure59_clones_iters_clos } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -6447,12 +6447,6 @@ export function turns$str_Split_ref_str_clones_iters_closure59_clones_iters_clos export function turns$vec_IntoIter_clones_Logged_clones_owned_closure2_clones_owned_closure3(it: rs.Iter, back: (a0: rs.Iter) => Logged.Logged | undefined, plan: Plan.Plan, put: (a0: Logged.Logged) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: Logged.Logged | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -6472,6 +6466,12 @@ export function turns$vec_IntoIter_clones_Logged_clones_owned_closure2_clones_ow } } const other: rs.Iter = it.clone({ v: Logged.clone$Clone }); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -6485,11 +6485,11 @@ export function turns$vec_IntoIter_clones_Logged_clones_owned_closure2_clones_ow } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -6529,12 +6529,6 @@ export function turns$vec_IntoIter_clones_Logged_clones_owned_closure2_clones_ow export function turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closure19(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: rs.u8 | undefined; - const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { - const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { - return n & 0xff; - })); - }; const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _8; @@ -6554,6 +6548,12 @@ export function turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closur } } const other: rs.Iter = it.clone({ v: rs.itself }); + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { + return n & 0xff; + })); + }; rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -6567,11 +6567,11 @@ export function turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closur } } const step: rs.u8 = Plan.next(plan); - b7: { + b8: { if ((step & 1) === 0) { if (!ended) { first = true; - break b7; + break b8; } } first = otherEnded; @@ -7637,9 +7637,6 @@ export function cloned$array2_clones_Logged(x: rs.Slice): Logged. */ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let a!: Logged.Logged[]; - const _13: (a0: rs.Slice, a1: rs.ByteVec) => undefined = (a3: rs.Slice, out2: rs.ByteVec): undefined => { - rs.iterExtendBytes(out2, rs.iterMap(rs.iterSlice(rs.sliceItems(a3)), Logged.id), undefined, true); - }; const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { return new Logged.Logged(id, rs.arcClone(log)); @@ -7650,6 +7647,9 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const three: () => Logged.Logged[] = (): Logged.Logged[] => { return [logged(at(0)), logged(at(1)), logged(at(2))]; }; + const _13: (a0: rs.Slice, a1: rs.ByteVec) => undefined = (a3: rs.Slice, out2: rs.ByteVec): undefined => { + rs.iterExtendBytes(out2, rs.iterMap(rs.iterSlice(rs.sliceItems(a3)), Logged.id), undefined, true); + }; const _14: rs.u8 = rs.u8Rem(kind, 8); if (_14 === 0) { a = three(); @@ -7662,7 +7662,8 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const c: Logged.Logged[] = b.map(Logged.clone$Clone); rs.dropAll(b); flush(log.value, out); - [].map(Logged.clone$Clone); + const _38: Logged.Logged[] = []; + _38.map(Logged.clone$Clone); const part33 = rs.sliceFrom(c); _13(part33, out); drop$tuple3_array0_clones_Logged_array0_clones_Logged_array3_clones_Logged([[], [], c] as [Logged.Logged[], Logged.Logged[], Logged.Logged[]]); @@ -7818,9 +7819,6 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let a!: Logged.Logged[] | undefined; let _156!: rs.usize; - const _14: (a0: rs.Slice, a1: rs.ByteVec) => undefined = (a7: rs.Slice, out2: rs.ByteVec): undefined => { - rs.iterExtendBytes(out2, rs.iterMap(rs.iterSlice(rs.sliceItems(a7)), Logged.id), undefined, true); - }; const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { return new Logged.Logged(id, rs.arcClone(log)); @@ -7836,6 +7834,9 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo return logged(at(rs.usizeAdd(from, i4))); }), undefined, 8, true); }; + const _14: (a0: rs.Slice, a1: rs.ByteVec) => undefined = (a7: rs.Slice, out2: rs.ByteVec): undefined => { + rs.iterExtendBytes(out2, rs.iterMap(rs.iterSlice(rs.sliceItems(a7)), Logged.id), undefined, true); + }; const _15: rs.u8 = rs.u8Rem(kind, 8); if (_15 === 0) { const pick: (a0: rs.usize) => Logged.Logged[] | undefined = (i13: rs.usize): Logged.Logged[] | undefined => { @@ -7977,7 +7978,8 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo flush(log.value, out); const part33 = rs.sliceFrom(rows.items[rs.idx(rows.items, 0)]); _14(part33, out); - const _375: rs.ArraySlice> = rs.arraySliceFrom([], rs.sliceFrom); + const _373: Logged.Logged[][] = []; + const _375: rs.ArraySlice> = rs.arraySliceFrom(_373, rs.sliceFrom); const part34 = at(10); const _378: Logged.Logged = logged(part34); const part35 = at(11); @@ -8105,9 +8107,6 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo */ export function repeats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let slot!: Slot.Slot; - const _11: (a0: rs.Slice, a1: rs.ByteVec) => undefined = (a: rs.Slice, out2: rs.ByteVec): undefined => { - rs.iterExtendBytes(out2, rs.iterMap(rs.iterSlice(rs.sliceItems(a)), Logged.id), undefined, true); - }; const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { return new Logged.Logged(id, rs.arcClone(log)); @@ -8118,6 +8117,9 @@ export function repeats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const n: (a0: rs.usize) => rs.usize = (i2: rs.usize): rs.usize => { return rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceGet(data, i2), i2 & 0xff), 5) as rs.usize; }; + const _11: (a0: rs.Slice, a1: rs.ByteVec) => undefined = (a: rs.Slice, out2: rs.ByteVec): undefined => { + rs.iterExtendBytes(out2, rs.iterMap(rs.iterSlice(rs.sliceItems(a)), Logged.id), undefined, true); + }; const _12: rs.u8 = rs.u8Rem(kind, 8); if (_12 === 0) { const part19 = at(0); @@ -8270,21 +8272,6 @@ export function repeated$clones_Logged(x: Logged.Logged, n: rs.usize): rs.Vec rs.u8 = (x2: Logged.Logged | undefined): rs.u8 => { - return option_mapOr$1ughiwf(x2, 238, (x3: Logged.Logged): rs.u8 => { - const _02: rs.u8 = Logged.id(x3); - x3[Symbol.dispose](); - return _02; - }); - }; - const _12: (a0: [rs.usize, rs.usize | undefined]) => Uint8Array = (hint: [rs.usize, rs.usize | undefined]): Uint8Array => { - return Uint8Array.of(rs.min(hint[0], 253) & 0xff, option_mapOr$188iunt(hint[1], 254, (n2: rs.usize): rs.u8 => { - return n2 & 0xff; - })); - }; - const _501: (a0: Logged.Logged) => rs.u8 = (x4: Logged.Logged): rs.u8 => { - return Logged.id(x4); - }; const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { return new Logged.Logged(id, rs.arcClone(log)); @@ -8295,6 +8282,18 @@ export function sources(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const n: (a0: rs.usize) => rs.usize = (i3: rs.usize): rs.usize => { return rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceGet(data, i3), i3 & 0xff), 5) as rs.usize; }; + const _11: (a0: Logged.Logged | undefined) => rs.u8 = (x2: Logged.Logged | undefined): rs.u8 => { + return option_mapOr$1ughiwf(x2, 238, (x3: Logged.Logged): rs.u8 => { + const _05: rs.u8 = Logged.id(x3); + x3[Symbol.dispose](); + return _05; + }); + }; + const _12: (a0: [rs.usize, rs.usize | undefined]) => Uint8Array = (hint: [rs.usize, rs.usize | undefined]): Uint8Array => { + return Uint8Array.of(rs.min(hint[0], 253) & 0xff, option_mapOr$188iunt(hint[1], 254, (n2: rs.usize): rs.u8 => { + return n2 & 0xff; + })); + }; const _13: rs.u8 = rs.u8Rem(kind, 6); if (_13 === 0) { const part27 = at(0); @@ -8505,6 +8504,9 @@ export function sources(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.drop(it9); rs.drop(it7); } else { + const _501: (a0: Logged.Logged) => rs.u8 = (x4: Logged.Logged): rs.u8 => { + return Logged.id(x4); + }; const part = at(0); rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(rs.iterRepeat(logged(part), Logged.clone$Clone, rs.drop), n(1), rs.drop), (x5: Logged.Logged): rs.u8 => { const _09: rs.u8 = Logged.id(x5) ^ 1; diff --git a/ts/fixtures/lang/collections/expected/collections.ts b/ts/fixtures/lang/collections/expected/collections.ts index 65efd5ce8..c2f9aec82 100644 --- a/ts/fixtures/lang/collections/expected/collections.ts +++ b/ts/fixtures/lang/collections/expected/collections.ts @@ -71,11 +71,6 @@ export function hashMaps(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void let _299!: rs.usize; let _377!: rs.u8; let _429!: rs.u8; - const _443: (a0: Nibble.Nibble) => rs.u64 = (n: Nibble.Nibble): rs.u64 => { - const h2: rs.Hasher = rs.hasher(); - Nibble.hash$Hash_hash_DefaultHasher(n, h2); - return rs.hashFinish(h2); - }; const _4: rs.u8 = rs.u8Rem(kind, 4); if (_4 === 0) { const map: rs.HashMap = rs.hashNew() as rs.HashMap; @@ -336,6 +331,11 @@ export function hashMaps(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return t16.n & 0xff; })); } + const _443: (a0: Nibble.Nibble) => rs.u64 = (n: Nibble.Nibble): rs.u64 => { + const h2: rs.Hasher = rs.hasher(); + Nibble.hash$Hash_hash_DefaultHasher(n, h2); + return rs.hashFinish(h2); + }; const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); rs.byteVecPush(out, rs.u64Eq(_443({ _0: first }), _443({ _0: first ^ 240 })) ? 1 : 0); const _461: [rs.Hasher, Tally.Tally] = [rs.hasher(), { n: first as rs.u16 }]; @@ -472,16 +472,6 @@ export function claim(map: rs.HashMap, k: rs.u8, n: rs.u16): /** `HashSet` and `BTreeSet`, each with the same script. */ export function sets(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _159: (a0: Nibble.Nibble | undefined) => rs.u8 = (n2: Nibble.Nibble | undefined): rs.u8 => { - return option_mapOr$0f7cus0(n2, 238, (n3: Nibble.Nibble): rs.u8 => { - return n3._0; - }); - }; - const _160: (a0: Nibble.Nibble | undefined) => rs.u8 = (n4: Nibble.Nibble | undefined): rs.u8 => { - return option_mapOr$0f7cus0(n4, 238, (n5: Nibble.Nibble): rs.u8 => { - return n5._0; - }); - }; const _4: rs.u8 = rs.u8Rem(kind, 3); if (_4 === 0) { const hashed: rs.HashSet = rs.hashNew() as rs.HashSet; @@ -551,6 +541,16 @@ export function sets(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.btreeAdd(nibbles, { _0: b2 }) ? 1 : 0); rs.byteVecPush(out, rs.hashAdd(seen, { _0: b2 }) ? 1 : 0); } + const _159: (a0: Nibble.Nibble | undefined) => rs.u8 = (n2: Nibble.Nibble | undefined): rs.u8 => { + return option_mapOr$0f7cus0(n2, 238, (n3: Nibble.Nibble): rs.u8 => { + return n3._0; + }); + }; + const _160: (a0: Nibble.Nibble | undefined) => rs.u8 = (n4: Nibble.Nibble | undefined): rs.u8 => { + return option_mapOr$0f7cus0(n4, 238, (n5: Nibble.Nibble): rs.u8 => { + return n5._0; + }); + }; const iter6: rs.Iter = rs.iterRev(rs.iterSlice(rs.byteSliceView(data))); while (true) { const _166: rs.u8 | rs.Done = iter6.next(); @@ -3988,18 +3988,13 @@ export function each$collections_Quirky_cell_RefCell_collections_Quirky_collecti * `kind` picks. */ export function ownNes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _34: (a0: rs.Slice, a1: rs.usize) => rs.u16 = (v: rs.Slice, i: rs.usize): rs.u16 => { - return option_mapOr$0pgapuk(rs.sliceGet(v, i), 0, (p: Picky.Picky): rs.u16 => { - return p._0; - }); - }; const log: rs.Cell = new rs.Cell(0); const _7: [rs.usize, rs.usize] = [(kind & 7) as rs.usize, ((kind >> 3) & 7) as rs.usize]; const byNe: rs.usize = _7[0]; const byEq: rs.usize = _7[1]; - const step: (a0: rs.usize) => rs.u16 = (i2: rs.usize): rs.u16 => { - if (!(i2 === byEq)) { - if (!(i2 === byNe)) { + const step: (a0: rs.usize) => rs.u16 = (i: rs.usize): rs.u16 => { + if (!(i === byEq)) { + if (!(i === byNe)) { return 12; } return 4; @@ -4015,6 +4010,11 @@ export function ownNes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if ((kind & 64) !== 0) { rs.vecPop(b); } + const _34: (a0: rs.Slice, a1: rs.usize) => rs.u16 = (v: rs.Slice, i3: rs.usize): rs.u16 => { + return option_mapOr$0pgapuk(rs.sliceGet(v, i3), 0, (p: Picky.Picky): rs.u16 => { + return p._0; + }); + }; const one: (a0: rs.Slice, a1: rs.usize) => Picky.Picky = (v2: rs.Slice, i4: rs.usize): Picky.Picky => { return { _0: _34(v2, i4), _1: log }; }; @@ -4679,12 +4679,6 @@ export function cellEqs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void * both by value and through references. */ export function unlikeCompares(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _9: (a0: rs.Ordering | undefined, a1: rs.Cell, a2: rs.ByteVec) => undefined = (o: rs.Ordering | undefined, log2: rs.Cell, out2: rs.ByteVec): undefined => { - rs.byteVecPush(out2, option_mapOr$14runhi(o, 9, (o2: rs.Ordering): rs.u8 => { - return o2 & 0xff; - })); - rs.iterExtendBytes(out2, rs.iterSlice(rs.u16ToBeBytes(rs.cellReplace(log2, 0)).reverse()), undefined, true); - }; const log: rs.Cell = new rs.Cell(0); const lefts: () => rs.Vec = (): rs.Vec => { return rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): Left.Left => { @@ -4694,6 +4688,12 @@ export function unlikeCompares(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec) const rights_: () => rs.Vec = (): rs.Vec => { return rights(kind, data); }; + const _9: (a0: rs.Ordering | undefined, a1: rs.Cell, a2: rs.ByteVec) => undefined = (o: rs.Ordering | undefined, log2: rs.Cell, out2: rs.ByteVec): undefined => { + rs.byteVecPush(out2, option_mapOr$14runhi(o, 9, (o2: rs.Ordering): rs.u8 => { + return o2 & 0xff; + })); + rs.iterExtendBytes(out2, rs.iterSlice(rs.u16ToBeBytes(rs.cellReplace(log2, 0)).reverse()), undefined, true); + }; const _12: [rs.Vec, rs.Vec] = [lefts(), rights_()]; const mine: rs.Vec = _12[0]; const theirs: rs.Vec = _12[1]; @@ -5982,11 +5982,6 @@ export function btreeSearches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): let range!: rs.Iter<[Probe.Probe, rs.u16]>; let _159!: [Probe.Probe, rs.u16] | undefined; let _452!: [Probe.Probe, Probe.Probe]; - const _28: (a0: rs.u16 | undefined) => rs.u16 = (v: rs.u16 | undefined): rs.u16 => { - return option_mapOr$1wei0sy(v, 65535, (v2: rs.u16): rs.u16 => { - return v2; - }); - }; const log: rs.Cell = new rs.Cell(0); const at: (a0: rs.usize) => rs.u8 = (i3: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i3), 0); @@ -6003,6 +5998,11 @@ export function btreeSearches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): const probe: (a0: rs.u8) => Probe.Probe = (b7: rs.u8): Probe.Probe => { return { _0: rs.u16Add(rs.u16Mul(b7 as rs.u16, 4), b7 >> 6 as rs.u16), _1: log }; }; + const _28: (a0: rs.u16 | undefined) => rs.u16 = (v: rs.u16 | undefined): rs.u16 => { + return option_mapOr$1wei0sy(v, 65535, (v2: rs.u16): rs.u16 => { + return v2; + }); + }; b0: { const _29: rs.u8 = rs.u8Rem(kind, 4); if (_29 === 0) { @@ -6274,14 +6274,6 @@ export function btreeSearches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): export function btreeBorrows(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let _29!: rs.usize; let _199!: [rs.u8, rs.u8]; - const _22: (a0: rs.u8) => rs.u16 = (b2: rs.u8): rs.u16 => { - return rs.u16Mul(b2 as rs.u16, 4) ^ 256; - }; - const _23: (a0: rs.u16 | undefined) => rs.u16 = (v: rs.u16 | undefined): rs.u16 => { - return option_mapOr$1wei0sy(v, 65535, (v2: rs.u16): rs.u16 => { - return v2; - }); - }; const log: rs.Cell = new rs.Cell(0); const at: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i2), 0); @@ -6302,8 +6294,16 @@ export function btreeBorrows(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): } return { start: { _0: start, _1: log }, end: { _0: end, _1: log }, id: end ^ 256 }; }; - const probe: (a0: rs.u8) => Probe.Probe = (b3: rs.u8): Probe.Probe => { - return { _0: rs.u16Add(rs.u16Mul(b3 as rs.u16, 4), b3 >> 6 as rs.u16), _1: log }; + const probe: (a0: rs.u8) => Probe.Probe = (b2: rs.u8): Probe.Probe => { + return { _0: rs.u16Add(rs.u16Mul(b2 as rs.u16, 4), b2 >> 6 as rs.u16), _1: log }; + }; + const _22: (a0: rs.u8) => rs.u16 = (b3: rs.u8): rs.u16 => { + return rs.u16Mul(b3 as rs.u16, 4) ^ 256; + }; + const _23: (a0: rs.u16 | undefined) => rs.u16 = (v: rs.u16 | undefined): rs.u16 => { + return option_mapOr$1wei0sy(v, 65535, (v2: rs.u16): rs.u16 => { + return v2; + }); }; const map: rs.BTreeMap = rs.btreeNew(Lent.cmp$cmp_Ord) as rs.BTreeMap; const set: rs.BTreeSet = rs.btreeNew(Lent.cmp$cmp_Ord) as rs.BTreeSet; diff --git a/ts/fixtures/lang/counts/expected/counts.ts b/ts/fixtures/lang/counts/expected/counts.ts index 868473217..4c1e8e982 100644 --- a/ts/fixtures/lang/counts/expected/counts.ts +++ b/ts/fixtures/lang/counts/expected/counts.ts @@ -150,7 +150,7 @@ export function arcs(data: rs.ByteSlice, out: rs.ByteVec): void { const log: rs.Arc> = new rs.Arc(new rs.Mutex(new rs.ByteVec())); const strong: rs.Vec> = new rs.Vec(); const weak: rs.Vec> = new rs.Vec(); - l1: for (const op of rs.byteSliceView(data)) { + for (const op of rs.byteSliceView(data)) { const pick: rs.usize = op >> 4 as rs.usize; const _19: rs.u8 = rs.u8Rem(op, 12); if (_19 === 0) { @@ -268,13 +268,7 @@ export function arcs(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, _171.strong & 0xff); rs.byteVecPush(out, _171.weak & 0xff); } - const iterS3: rs.Weak[] = weak.items; - let iterI3: number = 0; - while (true) { - const _184: rs.Weak | rs.Done = iterI3 < iterS3.length ? iterS3[iterI3++] : rs.DONE; - if (_184 === rs.DONE) { - continue l1; - } + for (const _184 of weak.items) { rs.byteVecPush(out, _184.arc.strong & 0xff); rs.byteVecPush(out, rs.weakWeakCount(_184) & 0xff); } @@ -1036,7 +1030,7 @@ export function rcs(data: rs.ByteSlice, out: rs.ByteVec): void { const log: rs.Arc> = new rs.Arc(new rs.Mutex(new rs.ByteVec())); const strong: rs.Vec> = new rs.Vec(); const weak: rs.Vec> = new rs.Vec(); - l1: for (const op of rs.byteSliceView(data)) { + for (const op of rs.byteSliceView(data)) { const pick: rs.usize = op >> 4 as rs.usize; const _19: rs.u8 = rs.u8Rem(op, 12); if (_19 === 0) { @@ -1154,13 +1148,7 @@ export function rcs(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, _171.strong & 0xff); rs.byteVecPush(out, _171.weak & 0xff); } - const iterS3: rs.Weak[] = weak.items; - let iterI3: number = 0; - while (true) { - const _184: rs.Weak | rs.Done = iterI3 < iterS3.length ? iterS3[iterI3++] : rs.DONE; - if (_184 === rs.DONE) { - continue l1; - } + for (const _184 of weak.items) { rs.byteVecPush(out, _184.arc.strong & 0xff); rs.byteVecPush(out, rs.weakWeakCount(_184) & 0xff); } diff --git a/ts/fixtures/lang/cows/expected/cows.Named.ts b/ts/fixtures/lang/cows/expected/cows.Named.ts index 30cf096c6..16f2f1466 100644 --- a/ts/fixtures/lang/cows/expected/cows.Named.ts +++ b/ts/fixtures/lang/cows/expected/cows.Named.ts @@ -7,12 +7,7 @@ export function clone$Clone(self: Named): Named { } export function fmt$fmt_Debug(self: Named, f: rs.Formatter): rs.Result { - const _3: string = "Named"; - const _4: string = "name"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtStr(rs.strCowStr(self.name), f); - const _7: string = "id"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.id, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Named name id", [(f: rs.Formatter) => rs.fmtStr(rs.strCowStr(self.name), f), (f: rs.Formatter) => rs.u8Debug(self.id, f)]); } export function default$Default(): Named { diff --git a/ts/fixtures/lang/cows/expected/cows.Run.ts b/ts/fixtures/lang/cows/expected/cows.Run.ts index ed7e3a7ac..3c06f6bef 100644 --- a/ts/fixtures/lang/cows/expected/cows.Run.ts +++ b/ts/fixtures/lang/cows/expected/cows.Run.ts @@ -7,10 +7,7 @@ export function clone$Clone(self: Run): Run { } export function fmt$fmt_Debug(self: Run, f: rs.Formatter): rs.Result { - const _3: string = "Run"; - const _4: string = "words"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(rs.cowSlice(self.words)), f, rs.u16Debug); - return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5)); + return rs.fmtDebugFields(f, "Run words", [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(rs.cowSlice(self.words)), f, rs.u16Debug)]); } export function default$Default(): Run { diff --git a/ts/fixtures/lang/cows/expected/cows.ts b/ts/fixtures/lang/cows/expected/cows.ts index f5d944321..aa20e1619 100644 --- a/ts/fixtures/lang/cows/expected/cows.ts +++ b/ts/fixtures/lang/cows/expected/cows.ts @@ -826,11 +826,6 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo let c3!: rs.ByteCow; let c4!: rs.Cow; let _157!: rs.Cow; - const _32: (a0: rs.Slice) => rs.ByteVec = (items: rs.Slice): rs.ByteVec => { - return rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.sliceItems(items)), (t: Tally.Tally): rs.u8 => { - return t._0; - }), undefined, true); - }; const _6: [boolean, boolean] = [(kind & 1) !== 0, (kind & 2) !== 0]; const intoOwned: boolean = _6[0]; const fromOwned: boolean = _6[1]; @@ -849,6 +844,11 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo const second: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(right)), (_27: rs.u8): Tally.Tally => { return new Tally.Tally(_27, log); }), undefined, 8, true); + const _32: (a0: rs.Slice) => rs.ByteVec = (items: rs.Slice): rs.ByteVec => { + return rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.sliceItems(items)), (t: Tally.Tally): rs.u8 => { + return t._0; + }), undefined, true); + }; if (!intoOwned) { c = new rs.Borrowed(rs.sliceFrom(first.items)); } else { diff --git a/ts/fixtures/lang/defaults/expected/defaults.Made.ts b/ts/fixtures/lang/defaults/expected/defaults.Made.ts index 5997e68ec..de37c8120 100644 --- a/ts/fixtures/lang/defaults/expected/defaults.Made.ts +++ b/ts/fixtures/lang/defaults/expected/defaults.Made.ts @@ -3,12 +3,7 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug(self: Made, f: rs.Formatter): rs.Result { - const _3: string = "Made"; - const _4: string = "n"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.u64Debug(self.n, f); - const _7: string = "tag"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtStr(self.tag.v, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Made n tag", [(f: rs.Formatter) => rs.u64Debug(self.n, f), (f: rs.Formatter) => rs.fmtStr(self.tag.v, f)]); } /** A type of the crate's own, whose `Default` impl is no zero value. */ diff --git a/ts/fixtures/lang/durations/expected/durations.Window.ts b/ts/fixtures/lang/durations/expected/durations.Window.ts index 270f075fb..e3579246a 100644 --- a/ts/fixtures/lang/durations/expected/durations.Window.ts +++ b/ts/fixtures/lang/durations/expected/durations.Window.ts @@ -3,12 +3,7 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug(self: Window, f: rs.Formatter): rs.Result { - const _3: string = "Window"; - const _4: string = "start"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.durationDebug(self.start, f); - const _7: string = "len"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(self.len, f, rs.durationDebug); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Window start len", [(f: rs.Formatter) => rs.durationDebug(self.start, f), (f: rs.Formatter) => rs.fmtOption(self.len, f, rs.durationDebug)]); } export function default$Default(): Window { diff --git a/ts/fixtures/lang/dyns/expected/dyns.Square.ts b/ts/fixtures/lang/dyns/expected/dyns.Square.ts index 2915dffea..5fc8d02d7 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Square.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Square.ts @@ -24,10 +24,7 @@ export function tally$dyns_Shape(self: Square, sum: rs.Place): void { } export function fmt$fmt_Debug(self: Square, f: rs.Formatter): rs.Result { - const _3: string = "Square"; - const _4: string = "side"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.u16Debug(self.side, f); - return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5)); + return rs.fmtDebugFields(f, "Square side", [(f: rs.Formatter) => rs.u16Debug(self.side, f)]); } export interface Square { diff --git a/ts/fixtures/lang/dyns/expected/dyns.Tri.ts b/ts/fixtures/lang/dyns/expected/dyns.Tri.ts index 0ddb30274..2c623afe0 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Tri.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Tri.ts @@ -18,9 +18,7 @@ export function fmt$fmt_Debug(self: Tri, f: rs.Formatter): rs.Result rs.u8Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _6), _7)); + return rs.fmtDebugFields(f, "Tall", [(f: rs.Formatter) => rs.u8Debug(self._0, f)]); } /** An enum, which JS copies, so `&mut self` reaches it through a place. */ diff --git a/ts/fixtures/lang/dyns/expected/ids.ts b/ts/fixtures/lang/dyns/expected/ids.ts index 5a0e3cee5..bceb33424 100644 --- a/ts/fixtures/lang/dyns/expected/ids.ts +++ b/ts/fixtures/lang/dyns/expected/ids.ts @@ -100,11 +100,6 @@ export function ids(dataData: Uint8Array, dataStart: number, dataLen: number, ou let _215!: Any.Any; let _439!: boolean; let _534!: rs.TypeId; - const _628: (a0: WithId.WithId, a1: WithId.WithId) => rs.Ordering = (k: WithId.WithId, l: WithId.WithId): rs.Ordering => { - const _63: rs.Vec = words(k.id); - const _9: rs.Vec = words(l.id); - return rs.orderingThen(rs.cmpSlice(rs.cmp)(_63, _9), rs.cmp(k.n, l.n)); - }; if (dataLen >= 2) { const _10: [rs.u8, rs.u8] = [dataData[dataStart], dataData[dataStart + 1]]; const a: rs.u8 = _10[0]; @@ -227,26 +222,26 @@ export function ids(dataData: Uint8Array, dataStart: number, dataLen: number, ou const _312: boolean = rs.iterAll(pairs(), (_213: [rs.usize, rs.TypeId, rs.usize, rs.TypeId]): boolean => { const x5: rs.TypeId = _213[1]; const y4: rs.TypeId = _213[3]; - const _613: rs.Ordering = rs.typeIdCmp(x5, y4); - const _1211: rs.Vec = words(x5); + const _66: rs.Ordering = rs.typeIdCmp(x5, y4); + const _1210: rs.Vec = words(x5); const _145: rs.Vec = words(y4); - return _613 === rs.cmpSlice(rs.cmp)(_1211, _145); + return _66 === rs.cmpSlice(rs.cmp)(_1210, _145); }); const _317: boolean = rs.iterAll(pairs(), (_224: [rs.usize, rs.TypeId, rs.usize, rs.TypeId]): boolean => { const x6: rs.TypeId = _224[1]; const y5: rs.TypeId = _224[3]; - const _614: rs.Ordering | undefined = rs.typeIdCmp(x6, y5); - const _136: rs.Vec = words(x6); + const _613: rs.Ordering | undefined = rs.typeIdCmp(x6, y5); + const _134: rs.Vec = words(x6); const _154: rs.Vec = words(y5); - return _614 === rs.cmpSlice(rs.cmp)(_136, _154) as rs.Ordering | undefined; + return _613 === rs.cmpSlice(rs.cmp)(_134, _154) as rs.Ordering | undefined; }); const _322: boolean = rs.iterAll(pairs(), (_225: [rs.usize, rs.TypeId, rs.usize, rs.TypeId]): boolean => { const x7: rs.TypeId = _225[1]; const y6: rs.TypeId = _225[3]; - const _616: boolean = rs.typeIdCmp(x7, y6) === -1; + const _614: boolean = rs.typeIdCmp(x7, y6) === -1; const _1112: rs.Vec = words(x7); - const _138: rs.Vec = words(y6); - if (!(_616 === (rs.cmpSlice(rs.cmp)(_1112, _138) === -1))) { + const _137: rs.Vec = words(y6); + if (!(_614 === (rs.cmpSlice(rs.cmp)(_1112, _137) === -1))) { return false; } const order2 = rs.typeIdCmp(x7, y6); @@ -336,10 +331,10 @@ export function ids(dataData: Uint8Array, dataStart: number, dataLen: number, ou rs.sliceSort(rs.sliceFrom(sorted.items), rs.cmpLt(rs.typeIdCmp), 16, true); const ordered: boolean = rs.iterAll(rs.sliceWindows(rs.sliceFrom(sorted.items), 2), (w4: rs.Slice): boolean => { rs.idx(w4, 0); - const _422: rs.Vec = words(w4.data[w4.start]); + const _421: rs.Vec = words(w4.data[w4.start]); rs.idx(w4, 1); - const _109: rs.Vec = words(w4.data[w4.start + 1]); - return rs.cmpSlice(rs.cmp)(_422, _109) === -1; + const _108: rs.Vec = words(w4.data[w4.start + 1]); + return rs.cmpSlice(rs.cmp)(_421, _108) === -1; }); const _556: rs.Iter = rs.iterChain(rs.iterSlice(ids), rs.iterSlice(found)); const set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.typeIdCmp) as rs.BTreeSet, _556, true, undefined, undefined, 16, true); @@ -357,6 +352,11 @@ export function ids(dataData: Uint8Array, dataStart: number, dataLen: number, ou } const keys: WithId.WithId[] = [{ id: x2, n: a }, { id: y, n: b }, { id: x2, n: b }]; const _636: rs.Slice = rs.sliceFrom(keys); + const _628: (a0: WithId.WithId, a1: WithId.WithId) => rs.Ordering = (k: WithId.WithId, l: WithId.WithId): rs.Ordering => { + const _616: rs.Vec = words(k.id); + const _95: rs.Vec = words(l.id); + return rs.orderingThen(rs.cmpSlice(rs.cmp)(_616, _95), rs.cmp(k.n, l.n)); + }; const part11 = rs.iterToVec(rs.iterMap(rs.iterFlatMap(rs.iterSlice(keys), (k2: WithId.WithId): rs.Iter<[WithId.WithId, WithId.WithId]> => { return rs.iterMap(rs.iterSlice(rs.sliceItems(_636)), (l2: WithId.WithId): [WithId.WithId, WithId.WithId] => { return [k2, l2] as [WithId.WithId, WithId.WithId]; diff --git a/ts/fixtures/lang/edits/expected/edits.ts b/ts/fixtures/lang/edits/expected/edits.ts index 1b7ec3dbd..9f1231f3f 100644 --- a/ts/fixtures/lang/edits/expected/edits.ts +++ b/ts/fixtures/lang/edits/expected/edits.ts @@ -34,17 +34,6 @@ export function putU16s(out: rs.ByteVec, v: rs.Slice): void { } export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _104: (a0: rs.u16) => Named.Named = (w: rs.u16): Named.Named => { - return { id: w, name: text(rs.byteSliceFrom(Uint8Array.of(rs.u8Div(w & 0xff, 16)))) }; - }; - const _604: (a0: rs.u16) => Named.Named = (w2: rs.u16): Named.Named => { - return { id: w2, name: text(rs.byteSliceFrom(Uint8Array.of(w2 & 0xff))) }; - }; - const _605: (a0: rs.Slice) => rs.Vec = (v8: rs.Slice): rs.Vec => { - return rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(v8)), (n: Named.Named): rs.u16 => { - return n.id; - }), undefined, 2, true); - }; const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { return rs.u16Mul(_2 as rs.u16, 3); }), undefined, 2, true); @@ -123,6 +112,9 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }), undefined, 2, true); rs.vecDedupBy(v3, rs.same); putU16s(out, rs.sliceFrom(v3.items)); + const _104: (a0: rs.u16) => Named.Named = (w8: rs.u16): Named.Named => { + return { id: w8, name: text(rs.byteSliceFrom(Uint8Array.of(rs.u8Div(w8 & 0xff, 16)))) }; + }; const keyed: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_225: rs.u16): Named.Named => { return _104(_225); }), undefined, 16, true); @@ -183,9 +175,9 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { putU16s(out, rs.sliceFrom([_222[0], _222[1]])); } const options: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_221: rs.u16): rs.u16 | undefined => { - const w8: rs.u16 = _221; - if (!(rs.u16Rem(w8, 2) === 0)) { - return w8; + const w7: rs.u16 = _221; + if (!(rs.u16Rem(w7, 2) === 0)) { + return w7; } return undefined; }), undefined, 4, true); @@ -223,8 +215,8 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.sliceReverse(rs.sliceFrom(v6.items)); putU16s(out, rs.sliceFrom(v6.items)); const named: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_216: rs.u16): Named.Named => { - const w6: rs.u16 = _216; - return { id: w6, name: text(rs.byteSliceFrom(Uint8Array.of(w6 & 0xff))) }; + const w5: rs.u16 = _216; + return { id: w5, name: text(rs.byteSliceFrom(Uint8Array.of(w5 & 0xff))) }; }), undefined, 16, true); const probe: Named.Named = { id: rs.u16Mul(at(1) as rs.u16, 3), name: text(rs.byteSliceFrom(Uint8Array.of(rs.u8WrappingMul(at(1), 3)))) }; rs.byteVecPush(out, rs.sliceContains(rs.sliceFrom(named.items), probe, Named.eq$cmp_PartialEq) ? 1 : 0); @@ -241,8 +233,8 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { putU16s(out, rs.sliceFrom(moved.items)); } else if (_8 === 4) { const named2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_28: rs.u16): Named.Named => { - const w4: rs.u16 = _28; - return { id: w4, name: text(rs.byteSliceFrom(Uint8Array.of(w4 & 0xff))) }; + const w3: rs.u16 = _28; + return { id: w3, name: text(rs.byteSliceFrom(Uint8Array.of(w3 & 0xff))) }; }), undefined, 16, true); const cloned: rs.Vec = rs.vecFrom(named2.items.map(Named.clone$Clone)); rs.byteVecPush(out, rs.eqSlice(Named.eq$cmp_PartialEq)(cloned, named2) ? 1 : 0); @@ -319,6 +311,14 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.ordMin(p, q, rs.cmpLt(Lean.partialCmp$cmp_PartialOrd))._0); rs.byteVecPush(out, rs.ordClamp(p, q, r, rs.cmpLe(Lean.partialCmp$cmp_PartialOrd), rs.cmpLt(Lean.partialCmp$cmp_PartialOrd), rs.cmpGt(Lean.partialCmp$cmp_PartialOrd))._0); } else if (_8 === 6) { + const _604: (a0: rs.u16) => Named.Named = (w: rs.u16): Named.Named => { + return { id: w, name: text(rs.byteSliceFrom(Uint8Array.of(w & 0xff))) }; + }; + const _605: (a0: rs.Slice) => rs.Vec = (v8: rs.Slice): rs.Vec => { + return rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(v8)), (n: Named.Named): rs.u16 => { + return n.id; + }), undefined, 2, true); + }; const v7: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_23: rs.u16): Named.Named => { return _604(_23); }), undefined, 16, true); @@ -970,14 +970,6 @@ export function wrap$u8(q: rs.VecDeque, n: rs.u8): void { * panics with std's message past the end. */ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _11: (a0: rs.Slice) => rs.ByteVec = (v7: rs.Slice): rs.ByteVec => { - return rs.iterToByteVec(rs.iterFlatMap(rs.iterSlice(rs.sliceItems(v7)), (t: Tracked.Tracked): Uint8Array => { - return Uint8Array.of(t.id, t.copies); - }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); - }; - const _196: (a0: rs.u16) => Named.Named = (w: rs.u16): Named.Named => { - return { id: w, name: text(rs.byteSliceFrom(Uint8Array.of(w & 0xff))) }; - }; const at: (a0: rs.usize) => rs.u8 = (i6: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i6), 0); }; @@ -986,9 +978,14 @@ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return new Tracked.Tracked(id, 0, log); }; const mark: (a0: rs.u8) => undefined = (m: rs.u8): undefined => { - const _52: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_52.value, m); - rs.refMutRelease(_52); + const _5: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_5.value, m); + rs.refMutRelease(_5); + }; + const _11: (a0: rs.Slice) => rs.ByteVec = (v7: rs.Slice): rs.ByteVec => { + return rs.iterToByteVec(rs.iterFlatMap(rs.iterSlice(rs.sliceItems(v7)), (t: Tracked.Tracked): Uint8Array => { + return Uint8Array.of(t.id, t.copies); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); }; const _12: rs.u8 = rs.u8Rem(kind, 6); if (_12 === 0) { @@ -1054,6 +1051,9 @@ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_190)), undefined, true); } } else if (_12 === 1) { + const _196: (a0: rs.u16) => Named.Named = (w2: rs.u16): Named.Named => { + return { id: w2, name: text(rs.byteSliceFrom(Uint8Array.of(w2 & 0xff))) }; + }; const v3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_225: rs.u8): Named.Named => { return _196(_225 as rs.u16); }), undefined, 16, true); @@ -1283,8 +1283,8 @@ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_698)), undefined, true); } const named: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.dequeIter(q3), (_212: rs.u16): Named.Named => { - const w2: rs.u16 = _212; - return { id: w2, name: text(rs.byteSliceFrom(Uint8Array.of(w2 & 0xff))) }; + const w: rs.u16 = _212; + return { id: w, name: text(rs.byteSliceFrom(Uint8Array.of(w & 0xff))) }; }), undefined, 16, true), 16) as rs.VecDeque; const _712: rs.Range = new rs.Range(rs.min(lo, hi), hi); const iter12: rs.Iter = rs.dequeRange(named, _712); @@ -1527,11 +1527,6 @@ export function spliced$iter_Map_ops_Range_u8_edits_extracts_closure15(v: rs.Vec */ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let i4!: rs.usize; - const _11: (a0: rs.Slice) => rs.ByteVec = (v3: rs.Slice): rs.ByteVec => { - return rs.iterToByteVec(rs.iterFlatMap(rs.iterSlice(rs.sliceItems(v3)), (t2: Tracked.Tracked): Uint8Array => { - return Uint8Array.of(t2.id, t2.copies); - }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); - }; const at: (a0: rs.usize) => rs.u8 = (i5: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i5), 0); }; @@ -1544,6 +1539,11 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.byteVecPush(_5.value, m); rs.refMutRelease(_5); }; + const _11: (a0: rs.Slice) => rs.ByteVec = (v3: rs.Slice): rs.ByteVec => { + return rs.iterToByteVec(rs.iterFlatMap(rs.iterSlice(rs.sliceItems(v3)), (t2: Tracked.Tracked): Uint8Array => { + return Uint8Array.of(t2.id, t2.copies); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + }; const _12: rs.u8 = rs.u8Rem(kind, 5); if (_12 === 0) { const v: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 8), (_222: rs.u8): Tracked.Tracked => { diff --git a/ts/fixtures/lang/elements/expected/elements.ts b/ts/fixtures/lang/elements/expected/elements.ts index ede779512..63715ee34 100644 --- a/ts/fixtures/lang/elements/expected/elements.ts +++ b/ts/fixtures/lang/elements/expected/elements.ts @@ -436,9 +436,6 @@ export function rawSlices(data: rs.ByteSlice, out: rs.ByteVec): void { export function emptyParts(data: rs.ByteSlice, out: rs.ByteVec): void { const lone = new Uint8Array(1); const held = new Uint8Array(1); - const _130: (a0: rs.Place) => rs.u8 = (p2: rs.Place): rs.u8 => { - return rs.ptrWrappingAdd(p2, -1, 1, 1) === rs.NULL ? 1 : 0; - }; const k: rs.usize = rs.usizeAdd(rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), 4) as rs.usize, 1); const wide: rs.Place = rs.DANGLING; const off: rs.Place = rs.ptrWrappingAdd(rs.NULL, k, 2, 2); @@ -449,8 +446,8 @@ export function emptyParts(data: rs.ByteSlice, out: rs.ByteVec): void { break; } const back: rs.usize = _23[1]; - const null_: (a0: rs.Place) => rs.u8 = (p3: rs.Place): rs.u8 => { - return rs.ptrWrappingAdd(p3, -back, 2, 2) === rs.NULL ? 1 : 0; + const null_: (a0: rs.Place) => rs.u8 = (p2: rs.Place): rs.u8 => { + return rs.ptrWrappingAdd(p2, -back, 2, 2) === rs.NULL ? 1 : 0; }; const _32: [rs.Slice, rs.Slice] = rs.sliceSplitAt(_23[0], 0); const part = rs.sliceAsPtr(_32[0]); @@ -494,6 +491,9 @@ export function emptyParts(data: rs.ByteSlice, out: rs.ByteVec): void { } const byte: rs.Place = rs.DANGLING; const s: rs.ByteSlice = rs.ptrByteSlice(byte, 0, false); + const _130: (a0: rs.Place) => rs.u8 = (p3: rs.Place): rs.u8 => { + return rs.ptrWrappingAdd(p3, -1, 1, 1) === rs.NULL ? 1 : 0; + }; const part17 = rs.byteSliceAsPtr(s); rs.byteVecPush(out, _130(part17)); const _139: [rs.ByteSlice, rs.ByteSlice] = rs.byteSliceSplitAt(s, 0); diff --git a/ts/fixtures/lang/ends/expected/ends.ts b/ts/fixtures/lang/ends/expected/ends.ts index a910e3006..3360faf21 100644 --- a/ts/fixtures/lang/ends/expected/ends.ts +++ b/ts/fixtures/lang/ends/expected/ends.ts @@ -2746,82 +2746,79 @@ export function found$mut_ends_Overrides(it: Overrides.Overrides, pick: rs.u8, k * `pick`. */ export function collected$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick: rs.u8, k: rs.usize, log: rs.RefCell, out: rs.ByteVec): void { - const _8: (a0: rs.Ordering | undefined) => rs.u8 = (o: rs.Ordering | undefined): rs.u8 => { - return option_mapOr$14runhi(o, 255, (o2: rs.Ordering): rs.u8 => { - return o2 & 0xff; - }); - }; + const other: rs.Range = new rs.Range(0, k & 0xff); const _9: (a0: rs.BTreeMap) => rs.Iter = (map: rs.BTreeMap): rs.Iter => { return rs.iterFlatMap(rs.btreeIter(map), (_2: [rs.u8, rs.u8]): Uint8Array => { return Uint8Array.of(_2[0], _2[1]); }, (value: Uint8Array) => rs.iterSlice(value), true, 2); }; - b0: { - const other: rs.Range = new rs.Range(0, k & 0xff); - if (pick === 0) { - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next")))), undefined, true); - } else if (pick === 1) { - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next")))), undefined, true); - } else if (pick === 2) { - const _17: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"))); - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_17.value)), undefined, true); - _17[Symbol.dispose](); - } else if (pick === 3) { - const _22: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"))); - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_22.value)), undefined, true); - _22[Symbol.dispose](); - } else if (pick === 4) { - const _25: Overrides.Overrides = it; - rs.iterExtendBytes(out, rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterBox(rs.iterFrom(_25, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), true, undefined, "next", 1)), undefined, true); - } else if (pick === 5) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(rs.heapFrom(rs.iterToVec(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next", 1), rs.le, rs.ge, rs.lt))), undefined, true); - } else if (pick === 6) { - const _33: Pairs.Pairs = new Pairs.Pairs(it, log); - const part4 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.vecIntoIter(Pairs.collect$iter_Iterator_boxed_Box_ends_Overrides_Vec_tuple2_u8_u8(_33)), true, undefined, undefined, undefined, 2, true); - rs.iterExtendBytes(out, _9(part4), "fold", true); - } else if (pick === 7) { - const _40: Pairs.Pairs = new Pairs.Pairs(it, log); - const part3 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterFrom(_40, Pairs.next$iter_Iterator_boxed_Box_ends_Overrides), true, undefined, undefined, "next", 2); - rs.iterExtendBytes(out, _9(part3), "fold", true); - } else if (pick === 8) { - const _46: Pairs.Pairs = new Pairs.Pairs(it, log); - const part2 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterBox(rs.iterFrom(_46, Pairs.next$iter_Iterator_boxed_Box_ends_Overrides)), true, undefined, undefined, "next", 2); - rs.iterExtendBytes(out, _9(part2), "fold", true); - } else if (pick === 9) { - rs.byteVecPush(out, rs.iterEq(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.same, undefined, true) ? 1 : 0); - } else if (pick === 10) { - rs.byteVecPush(out, !rs.iterEq(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.same, undefined, true) ? 1 : 0); - } else if (pick === 11) { - if (!(rs.usizeRem(k, 2) === 0)) { - rs.byteVecPush(out, rs.iterCmp(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.cmp, true) === 1 ? 1 : 0); - } else { - rs.byteVecPush(out, rs.iterCmp(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.cmp, true) === -1 ? 1 : 0); - } - } else if (pick === 12) { - if (!(rs.usizeRem(k, 2) === 0)) { - const order2 = rs.iterCmp(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.cmp, true); - rs.byteVecPush(out, order2 !== undefined && order2 >= 0 ? 1 : 0); - } else { - const order = rs.iterCmp(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.cmp, true); - rs.byteVecPush(out, order !== undefined && order <= 0 ? 1 : 0); - } - } else if (pick === 13) { - rs.byteVecPush(out, _8(rs.iterCmp(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.cmp, true))); + const _8: (a0: rs.Ordering | undefined) => rs.u8 = (o: rs.Ordering | undefined): rs.u8 => { + return option_mapOr$14runhi(o, 255, (o2: rs.Ordering): rs.u8 => { + return o2 & 0xff; + }); + }; + if (pick === 0) { + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next")))), undefined, true); + } else if (pick === 1) { + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next")))), undefined, true); + } else if (pick === 2) { + const _17: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"))); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_17.value)), undefined, true); + _17[Symbol.dispose](); + } else if (pick === 3) { + const _22: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"))); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_22.value)), undefined, true); + _22[Symbol.dispose](); + } else if (pick === 4) { + const _25: Overrides.Overrides = it; + rs.iterExtendBytes(out, rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterBox(rs.iterFrom(_25, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), true, undefined, "next", 1)), undefined, true); + } else if (pick === 5) { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(rs.heapFrom(rs.iterToVec(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next", 1), rs.le, rs.ge, rs.lt))), undefined, true); + } else if (pick === 6) { + const _33: Pairs.Pairs = new Pairs.Pairs(it, log); + const part4 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.vecIntoIter(Pairs.collect$iter_Iterator_boxed_Box_ends_Overrides_Vec_tuple2_u8_u8(_33)), true, undefined, undefined, undefined, 2, true); + rs.iterExtendBytes(out, _9(part4), "fold", true); + } else if (pick === 7) { + const _40: Pairs.Pairs = new Pairs.Pairs(it, log); + const part3 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterFrom(_40, Pairs.next$iter_Iterator_boxed_Box_ends_Overrides), true, undefined, undefined, "next", 2); + rs.iterExtendBytes(out, _9(part3), "fold", true); + } else if (pick === 8) { + const _46: Pairs.Pairs = new Pairs.Pairs(it, log); + const part2 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterBox(rs.iterFrom(_46, Pairs.next$iter_Iterator_boxed_Box_ends_Overrides)), true, undefined, undefined, "next", 2); + rs.iterExtendBytes(out, _9(part2), "fold", true); + } else if (pick === 9) { + rs.byteVecPush(out, rs.iterEq(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.same, undefined, true) ? 1 : 0); + } else if (pick === 10) { + rs.byteVecPush(out, !rs.iterEq(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.same, undefined, true) ? 1 : 0); + } else if (pick === 11) { + if (!(rs.usizeRem(k, 2) === 0)) { + rs.byteVecPush(out, rs.iterCmp(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.cmp, true) === 1 ? 1 : 0); } else { - if (pick === 14) { - rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterBorrow(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }))), k)) & 0xff); - const iter: rs.Place = rs.place(() => it, (value3) => it = value3); - while (true) { - const _88: rs.u8 | rs.Done = Overrides.next$iter_Iterator(iter.v); - if (_88 === rs.DONE) { - break b0; - } - rs.byteVecPush(out, _88); - } + rs.byteVecPush(out, rs.iterCmp(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.cmp, true) === -1 ? 1 : 0); + } + } else if (pick === 12) { + if (!(rs.usizeRem(k, 2) === 0)) { + const order2 = rs.iterCmp(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.cmp, true); + rs.byteVecPush(out, order2 !== undefined && order2 >= 0 ? 1 : 0); + } else { + const order = rs.iterCmp(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.cmp, true); + rs.byteVecPush(out, order !== undefined && order <= 0 ? 1 : 0); + } + } else if (pick === 13) { + rs.byteVecPush(out, _8(rs.iterCmp(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.cmp, true))); + } else if (pick === 14) { + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterBorrow(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }))), k)) & 0xff); + const iter: rs.Place = rs.place(() => it, (value3) => it = value3); + while (true) { + const _88: rs.u8 | rs.Done = Overrides.next$iter_Iterator(iter.v); + if (_88 === rs.DONE) { + break; } - put(out, rs.iterToOption(Overrides.next$iter_Iterator(it))); - putVec(out, rs.iterToByteVec(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next")); + rs.byteVecPush(out, _88); } + } else { + put(out, rs.iterToOption(Overrides.next$iter_Iterator(it))); + putVec(out, rs.iterToByteVec(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next")); } } @@ -2832,82 +2829,79 @@ export function collected$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick * `pick`. */ export function collected$ends_Overrides(it: Overrides.Overrides, pick: rs.u8, k: rs.usize, log: rs.RefCell, out: rs.ByteVec): void { - const _8: (a0: rs.Ordering | undefined) => rs.u8 = (o: rs.Ordering | undefined): rs.u8 => { - return option_mapOr$14runhi(o, 255, (o2: rs.Ordering): rs.u8 => { - return o2 & 0xff; - }); - }; + const other: rs.Range = new rs.Range(0, k & 0xff); const _9: (a0: rs.BTreeMap) => rs.Iter = (map: rs.BTreeMap): rs.Iter => { return rs.iterFlatMap(rs.btreeIter(map), (_2: [rs.u8, rs.u8]): Uint8Array => { return Uint8Array.of(_2[0], _2[1]); }, (value: Uint8Array) => rs.iterSlice(value), true, 2); }; - b0: { - const other: rs.Range = new rs.Range(0, k & 0xff); - if (pick === 0) { - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(Overrides.collect$iter_Iterator_boxed_Box_slice_u8(it))), undefined, true); - } else if (pick === 1) { - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(it)), "next", true, 1)))), undefined, true); - } else if (pick === 2) { - const _17: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(it)), "next", true, 1))); - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_17.value)), undefined, true); - _17[Symbol.dispose](); - } else if (pick === 3) { - const _22: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(it)), "next", true, 1))); - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_22.value)), undefined, true); - _22[Symbol.dispose](); - } else if (pick === 4) { - const _25: Overrides.Overrides = it; - rs.iterExtendBytes(out, rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(_25)), true, undefined, undefined, 1, true)), undefined, true); - } else if (pick === 5) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(rs.heapFrom(rs.iterToVec(rs.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(it)), "next", 1, true, 1), rs.le, rs.ge, rs.lt))), undefined, true); - } else if (pick === 6) { - const _33: Pairs.Pairs = new Pairs.Pairs(it, log); - const part4 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.vecIntoIter(Pairs.collect$iter_Iterator_ends_Overrides_Vec_tuple2_u8_u8(_33)), true, undefined, undefined, undefined, 2, true); - rs.iterExtendBytes(out, _9(part4), "fold", true); - } else if (pick === 7) { - const _40: Pairs.Pairs = new Pairs.Pairs(it, log); - const part3 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterFrom(_40, Pairs.next$iter_Iterator_ends_Overrides), true, undefined, undefined, "next", 2); - rs.iterExtendBytes(out, _9(part3), "fold", true); - } else if (pick === 8) { - const _46: Pairs.Pairs = new Pairs.Pairs(it, log); - const part2 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterBox(rs.iterFrom(_46, Pairs.next$iter_Iterator_ends_Overrides)), true, undefined, undefined, "next", 2); - rs.iterExtendBytes(out, _9(part2), "fold", true); - } else if (pick === 9) { - rs.byteVecPush(out, Overrides.eq$iter_Iterator_ops_Range_u8(it, other) ? 1 : 0); - } else if (pick === 10) { - rs.byteVecPush(out, !Overrides.eq$iter_Iterator_ops_Range_u8(it, other) ? 1 : 0); - } else if (pick === 11) { - if (!(rs.usizeRem(k, 2) === 0)) { - rs.byteVecPush(out, Overrides.partialCmp$iter_Iterator_ops_Range_u8(it, other) === 1 ? 1 : 0); - } else { - rs.byteVecPush(out, Overrides.partialCmp$iter_Iterator_ops_Range_u8(it, other) === -1 ? 1 : 0); - } - } else if (pick === 12) { - if (!(rs.usizeRem(k, 2) === 0)) { - const order2 = Overrides.partialCmp$iter_Iterator_ops_Range_u8(it, other); - rs.byteVecPush(out, order2 !== undefined && order2 >= 0 ? 1 : 0); - } else { - const order = Overrides.partialCmp$iter_Iterator_ops_Range_u8(it, other); - rs.byteVecPush(out, order !== undefined && order <= 0 ? 1 : 0); - } - } else if (pick === 13) { - rs.byteVecPush(out, _8(Overrides.partialCmp$iter_Iterator_ops_Range_u8(it, other))); + const _8: (a0: rs.Ordering | undefined) => rs.u8 = (o: rs.Ordering | undefined): rs.u8 => { + return option_mapOr$14runhi(o, 255, (o2: rs.Ordering): rs.u8 => { + return o2 & 0xff; + }); + }; + if (pick === 0) { + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(Overrides.collect$iter_Iterator_boxed_Box_slice_u8(it))), undefined, true); + } else if (pick === 1) { + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(it)), "next", true, 1)))), undefined, true); + } else if (pick === 2) { + const _17: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(it)), "next", true, 1))); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_17.value)), undefined, true); + _17[Symbol.dispose](); + } else if (pick === 3) { + const _22: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(it)), "next", true, 1))); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_22.value)), undefined, true); + _22[Symbol.dispose](); + } else if (pick === 4) { + const _25: Overrides.Overrides = it; + rs.iterExtendBytes(out, rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(_25)), true, undefined, undefined, 1, true)), undefined, true); + } else if (pick === 5) { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(rs.heapFrom(rs.iterToVec(rs.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(it)), "next", 1, true, 1), rs.le, rs.ge, rs.lt))), undefined, true); + } else if (pick === 6) { + const _33: Pairs.Pairs = new Pairs.Pairs(it, log); + const part4 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.vecIntoIter(Pairs.collect$iter_Iterator_ends_Overrides_Vec_tuple2_u8_u8(_33)), true, undefined, undefined, undefined, 2, true); + rs.iterExtendBytes(out, _9(part4), "fold", true); + } else if (pick === 7) { + const _40: Pairs.Pairs = new Pairs.Pairs(it, log); + const part3 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterFrom(_40, Pairs.next$iter_Iterator_ends_Overrides), true, undefined, undefined, "next", 2); + rs.iterExtendBytes(out, _9(part3), "fold", true); + } else if (pick === 8) { + const _46: Pairs.Pairs = new Pairs.Pairs(it, log); + const part2 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterBox(rs.iterFrom(_46, Pairs.next$iter_Iterator_ends_Overrides)), true, undefined, undefined, "next", 2); + rs.iterExtendBytes(out, _9(part2), "fold", true); + } else if (pick === 9) { + rs.byteVecPush(out, Overrides.eq$iter_Iterator_ops_Range_u8(it, other) ? 1 : 0); + } else if (pick === 10) { + rs.byteVecPush(out, !Overrides.eq$iter_Iterator_ops_Range_u8(it, other) ? 1 : 0); + } else if (pick === 11) { + if (!(rs.usizeRem(k, 2) === 0)) { + rs.byteVecPush(out, Overrides.partialCmp$iter_Iterator_ops_Range_u8(it, other) === 1 ? 1 : 0); } else { - if (pick === 14) { - rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterFrom(Overrides.byRef$iter_Iterator(it), Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), k)) & 0xff); - const iter: Overrides.Overrides = Overrides.byRef$iter_Iterator(it); - while (true) { - const _88: rs.u8 | rs.Done = Overrides.next$iter_Iterator(iter); - if (_88 === rs.DONE) { - break b0; - } - rs.byteVecPush(out, _88); - } + rs.byteVecPush(out, Overrides.partialCmp$iter_Iterator_ops_Range_u8(it, other) === -1 ? 1 : 0); + } + } else if (pick === 12) { + if (!(rs.usizeRem(k, 2) === 0)) { + const order2 = Overrides.partialCmp$iter_Iterator_ops_Range_u8(it, other); + rs.byteVecPush(out, order2 !== undefined && order2 >= 0 ? 1 : 0); + } else { + const order = Overrides.partialCmp$iter_Iterator_ops_Range_u8(it, other); + rs.byteVecPush(out, order !== undefined && order <= 0 ? 1 : 0); + } + } else if (pick === 13) { + rs.byteVecPush(out, _8(Overrides.partialCmp$iter_Iterator_ops_Range_u8(it, other))); + } else if (pick === 14) { + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterFrom(Overrides.byRef$iter_Iterator(it), Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), k)) & 0xff); + const iter: Overrides.Overrides = Overrides.byRef$iter_Iterator(it); + while (true) { + const _88: rs.u8 | rs.Done = Overrides.next$iter_Iterator(iter); + if (_88 === rs.DONE) { + break; } - put(out, rs.iterToOption(Overrides.next$iter_Iterator(Overrides.byRef$iter_Iterator(it)))); - putVec(out, Overrides.collect$iter_Iterator_Vec_u8(it)); + rs.byteVecPush(out, _88); } + } else { + put(out, rs.iterToOption(Overrides.next$iter_Iterator(Overrides.byRef$iter_Iterator(it)))); + putVec(out, Overrides.collect$iter_Iterator_Vec_u8(it)); } } @@ -2918,82 +2912,79 @@ export function collected$ends_Overrides(it: Overrides.Overrides, pick: rs.u8, k * `pick`. */ export function collected$ends_Run(it: Run.Run, pick: rs.u8, k: rs.usize, log: rs.RefCell, out: rs.ByteVec): void { - const _8: (a0: rs.Ordering | undefined) => rs.u8 = (o: rs.Ordering | undefined): rs.u8 => { - return option_mapOr$14runhi(o, 255, (o2: rs.Ordering): rs.u8 => { - return o2 & 0xff; - }); - }; + const other: rs.Range = new rs.Range(0, k & 0xff); const _9: (a0: rs.BTreeMap) => rs.Iter = (map: rs.BTreeMap): rs.Iter => { return rs.iterFlatMap(rs.btreeIter(map), (_2: [rs.u8, rs.u8]): Uint8Array => { return Uint8Array.of(_2[0], _2[1]); }, (value: Uint8Array) => rs.iterSlice(value), true, 2); }; - b0: { - const other: rs.Range = new rs.Range(0, k & 0xff); - if (pick === 0) { - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next")))), undefined, true); - } else if (pick === 1) { - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next")))), undefined, true); - } else if (pick === 2) { - const _17: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"))); - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_17.value)), undefined, true); - _17[Symbol.dispose](); - } else if (pick === 3) { - const _22: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"))); - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_22.value)), undefined, true); - _22[Symbol.dispose](); - } else if (pick === 4) { - const _25: Run.Run = it; - rs.iterExtendBytes(out, rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterFrom(_25, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), true, undefined, "next", 1)), undefined, true); - } else if (pick === 5) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(rs.heapFrom(rs.iterToVec(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next", 1), rs.le, rs.ge, rs.lt))), undefined, true); - } else if (pick === 6) { - const _33: Pairs.Pairs = new Pairs.Pairs(it, log); - const part4 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.vecIntoIter(Pairs.collect$iter_Iterator_ends_Run_Vec_tuple2_u8_u8(_33)), true, undefined, undefined, undefined, 2, true); - rs.iterExtendBytes(out, _9(part4), undefined, true); - } else if (pick === 7) { - const _40: Pairs.Pairs = new Pairs.Pairs(it, log); - const part3 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterFrom(_40, Pairs.next$iter_Iterator_ends_Run), true, undefined, undefined, "next", 2); - rs.iterExtendBytes(out, _9(part3), undefined, true); - } else if (pick === 8) { - const _46: Pairs.Pairs = new Pairs.Pairs(it, log); - const part2 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterBox(rs.iterFrom(_46, Pairs.next$iter_Iterator_ends_Run)), true, undefined, undefined, "next", 2); - rs.iterExtendBytes(out, _9(part2), undefined, true); - } else if (pick === 9) { - rs.byteVecPush(out, rs.iterEq(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.same) ? 1 : 0); - } else if (pick === 10) { - rs.byteVecPush(out, !rs.iterEq(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.same) ? 1 : 0); - } else if (pick === 11) { - if (!(rs.usizeRem(k, 2) === 0)) { - rs.byteVecPush(out, rs.iterCmp(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.cmp) === 1 ? 1 : 0); - } else { - rs.byteVecPush(out, rs.iterCmp(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.cmp) === -1 ? 1 : 0); - } - } else if (pick === 12) { - if (!(rs.usizeRem(k, 2) === 0)) { - const order2 = rs.iterCmp(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.cmp); - rs.byteVecPush(out, order2 !== undefined && order2 >= 0 ? 1 : 0); - } else { - const order = rs.iterCmp(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.cmp); - rs.byteVecPush(out, order !== undefined && order <= 0 ? 1 : 0); - } - } else if (pick === 13) { - rs.byteVecPush(out, _8(rs.iterCmp(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.cmp))); + const _8: (a0: rs.Ordering | undefined) => rs.u8 = (o: rs.Ordering | undefined): rs.u8 => { + return option_mapOr$14runhi(o, 255, (o2: rs.Ordering): rs.u8 => { + return o2 & 0xff; + }); + }; + if (pick === 0) { + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next")))), undefined, true); + } else if (pick === 1) { + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next")))), undefined, true); + } else if (pick === 2) { + const _17: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"))); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_17.value)), undefined, true); + _17[Symbol.dispose](); + } else if (pick === 3) { + const _22: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"))); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_22.value)), undefined, true); + _22[Symbol.dispose](); + } else if (pick === 4) { + const _25: Run.Run = it; + rs.iterExtendBytes(out, rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterFrom(_25, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), true, undefined, "next", 1)), undefined, true); + } else if (pick === 5) { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(rs.heapFrom(rs.iterToVec(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next", 1), rs.le, rs.ge, rs.lt))), undefined, true); + } else if (pick === 6) { + const _33: Pairs.Pairs = new Pairs.Pairs(it, log); + const part4 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.vecIntoIter(Pairs.collect$iter_Iterator_ends_Run_Vec_tuple2_u8_u8(_33)), true, undefined, undefined, undefined, 2, true); + rs.iterExtendBytes(out, _9(part4), undefined, true); + } else if (pick === 7) { + const _40: Pairs.Pairs = new Pairs.Pairs(it, log); + const part3 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterFrom(_40, Pairs.next$iter_Iterator_ends_Run), true, undefined, undefined, "next", 2); + rs.iterExtendBytes(out, _9(part3), undefined, true); + } else if (pick === 8) { + const _46: Pairs.Pairs = new Pairs.Pairs(it, log); + const part2 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterBox(rs.iterFrom(_46, Pairs.next$iter_Iterator_ends_Run)), true, undefined, undefined, "next", 2); + rs.iterExtendBytes(out, _9(part2), undefined, true); + } else if (pick === 9) { + rs.byteVecPush(out, rs.iterEq(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.same) ? 1 : 0); + } else if (pick === 10) { + rs.byteVecPush(out, !rs.iterEq(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.same) ? 1 : 0); + } else if (pick === 11) { + if (!(rs.usizeRem(k, 2) === 0)) { + rs.byteVecPush(out, rs.iterCmp(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.cmp) === 1 ? 1 : 0); } else { - if (pick === 14) { - rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), k)) & 0xff); - const iter: Run.Run = it; - while (true) { - const _88: rs.u8 | rs.Done = Run.next$iter_Iterator(iter); - if (_88 === rs.DONE) { - break b0; - } - rs.byteVecPush(out, _88); - } + rs.byteVecPush(out, rs.iterCmp(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.cmp) === -1 ? 1 : 0); + } + } else if (pick === 12) { + if (!(rs.usizeRem(k, 2) === 0)) { + const order2 = rs.iterCmp(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.cmp); + rs.byteVecPush(out, order2 !== undefined && order2 >= 0 ? 1 : 0); + } else { + const order = rs.iterCmp(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.cmp); + rs.byteVecPush(out, order !== undefined && order <= 0 ? 1 : 0); + } + } else if (pick === 13) { + rs.byteVecPush(out, _8(rs.iterCmp(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.cmp))); + } else if (pick === 14) { + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), k)) & 0xff); + const iter: Run.Run = it; + while (true) { + const _88: rs.u8 | rs.Done = Run.next$iter_Iterator(iter); + if (_88 === rs.DONE) { + break; } - put(out, rs.iterToOption(Run.next$iter_Iterator(it))); - putVec(out, rs.iterToByteVec(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next")); + rs.byteVecPush(out, _88); } + } else { + put(out, rs.iterToOption(Run.next$iter_Iterator(it))); + putVec(out, rs.iterToByteVec(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next")); } } @@ -3004,82 +2995,79 @@ export function collected$ends_Run(it: Run.Run, pick: rs.u8, k: rs.usize, log: r * `pick`. */ export function collected$mut_ends_Overrides(it: Overrides.Overrides, pick: rs.u8, k: rs.usize, log: rs.RefCell, out: rs.ByteVec): void { - const _8: (a0: rs.Ordering | undefined) => rs.u8 = (o: rs.Ordering | undefined): rs.u8 => { - return option_mapOr$14runhi(o, 255, (o2: rs.Ordering): rs.u8 => { - return o2 & 0xff; - }); - }; + const other: rs.Range = new rs.Range(0, k & 0xff); const _9: (a0: rs.BTreeMap) => rs.Iter = (map: rs.BTreeMap): rs.Iter => { return rs.iterFlatMap(rs.btreeIter(map), (_2: [rs.u8, rs.u8]): Uint8Array => { return Uint8Array.of(_2[0], _2[1]); }, (value: Uint8Array) => rs.iterSlice(value), true, 2); }; - b0: { - const other: rs.Range = new rs.Range(0, k & 0xff); - if (pick === 0) { - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next")))), undefined, true); - } else if (pick === 1) { - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next")))), undefined, true); - } else if (pick === 2) { - const _17: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next"))); - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_17.value)), undefined, true); - _17[Symbol.dispose](); - } else if (pick === 3) { - const _22: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next"))); - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_22.value)), undefined, true); - _22[Symbol.dispose](); - } else if (pick === 4) { - const _25: Overrides.Overrides = it; - rs.iterExtendBytes(out, rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterFrom(_25, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), true, undefined, "next", 1)), undefined, true); - } else if (pick === 5) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(rs.heapFrom(rs.iterToVec(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next", 1), rs.le, rs.ge, rs.lt))), undefined, true); - } else if (pick === 6) { - const _33: Pairs.Pairs = new Pairs.Pairs(it, log); - const part4 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.vecIntoIter(Pairs.collect$iter_Iterator_mut_ends_Overrides_Vec_tuple2_u8_u8(_33)), true, undefined, undefined, undefined, 2, true); - rs.iterExtendBytes(out, _9(part4), undefined, true); - } else if (pick === 7) { - const _40: Pairs.Pairs = new Pairs.Pairs(it, log); - const part3 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterFrom(_40, Pairs.next$iter_Iterator_mut_ends_Overrides), true, undefined, undefined, "next", 2); - rs.iterExtendBytes(out, _9(part3), undefined, true); - } else if (pick === 8) { - const _46: Pairs.Pairs = new Pairs.Pairs(it, log); - const part2 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterBox(rs.iterFrom(_46, Pairs.next$iter_Iterator_mut_ends_Overrides)), true, undefined, undefined, "next", 2); - rs.iterExtendBytes(out, _9(part2), undefined, true); - } else if (pick === 9) { - rs.byteVecPush(out, rs.iterEq(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.same) ? 1 : 0); - } else if (pick === 10) { - rs.byteVecPush(out, !rs.iterEq(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.same) ? 1 : 0); - } else if (pick === 11) { - if (!(rs.usizeRem(k, 2) === 0)) { - rs.byteVecPush(out, rs.iterCmp(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.cmp) === 1 ? 1 : 0); - } else { - rs.byteVecPush(out, rs.iterCmp(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.cmp) === -1 ? 1 : 0); - } - } else if (pick === 12) { - if (!(rs.usizeRem(k, 2) === 0)) { - const order2 = rs.iterCmp(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.cmp); - rs.byteVecPush(out, order2 !== undefined && order2 >= 0 ? 1 : 0); - } else { - const order = rs.iterCmp(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.cmp); - rs.byteVecPush(out, order !== undefined && order <= 0 ? 1 : 0); - } - } else if (pick === 13) { - rs.byteVecPush(out, _8(rs.iterCmp(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.cmp))); + const _8: (a0: rs.Ordering | undefined) => rs.u8 = (o: rs.Ordering | undefined): rs.u8 => { + return option_mapOr$14runhi(o, 255, (o2: rs.Ordering): rs.u8 => { + return o2 & 0xff; + }); + }; + if (pick === 0) { + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next")))), undefined, true); + } else if (pick === 1) { + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next")))), undefined, true); + } else if (pick === 2) { + const _17: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next"))); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_17.value)), undefined, true); + _17[Symbol.dispose](); + } else if (pick === 3) { + const _22: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next"))); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_22.value)), undefined, true); + _22[Symbol.dispose](); + } else if (pick === 4) { + const _25: Overrides.Overrides = it; + rs.iterExtendBytes(out, rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterFrom(_25, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), true, undefined, "next", 1)), undefined, true); + } else if (pick === 5) { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(rs.heapFrom(rs.iterToVec(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next", 1), rs.le, rs.ge, rs.lt))), undefined, true); + } else if (pick === 6) { + const _33: Pairs.Pairs = new Pairs.Pairs(it, log); + const part4 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.vecIntoIter(Pairs.collect$iter_Iterator_mut_ends_Overrides_Vec_tuple2_u8_u8(_33)), true, undefined, undefined, undefined, 2, true); + rs.iterExtendBytes(out, _9(part4), undefined, true); + } else if (pick === 7) { + const _40: Pairs.Pairs = new Pairs.Pairs(it, log); + const part3 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterFrom(_40, Pairs.next$iter_Iterator_mut_ends_Overrides), true, undefined, undefined, "next", 2); + rs.iterExtendBytes(out, _9(part3), undefined, true); + } else if (pick === 8) { + const _46: Pairs.Pairs = new Pairs.Pairs(it, log); + const part2 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterBox(rs.iterFrom(_46, Pairs.next$iter_Iterator_mut_ends_Overrides)), true, undefined, undefined, "next", 2); + rs.iterExtendBytes(out, _9(part2), undefined, true); + } else if (pick === 9) { + rs.byteVecPush(out, rs.iterEq(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.same) ? 1 : 0); + } else if (pick === 10) { + rs.byteVecPush(out, !rs.iterEq(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.same) ? 1 : 0); + } else if (pick === 11) { + if (!(rs.usizeRem(k, 2) === 0)) { + rs.byteVecPush(out, rs.iterCmp(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.cmp) === 1 ? 1 : 0); } else { - if (pick === 14) { - rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), k)) & 0xff); - const iter: rs.Place = rs.place(() => it, (value3) => it = value3); - while (true) { - const _88: rs.u8 | rs.Done = Overrides.next$iter_Iterator(iter.v); - if (_88 === rs.DONE) { - break b0; - } - rs.byteVecPush(out, _88); - } + rs.byteVecPush(out, rs.iterCmp(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.cmp) === -1 ? 1 : 0); + } + } else if (pick === 12) { + if (!(rs.usizeRem(k, 2) === 0)) { + const order2 = rs.iterCmp(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.cmp); + rs.byteVecPush(out, order2 !== undefined && order2 >= 0 ? 1 : 0); + } else { + const order = rs.iterCmp(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.cmp); + rs.byteVecPush(out, order !== undefined && order <= 0 ? 1 : 0); + } + } else if (pick === 13) { + rs.byteVecPush(out, _8(rs.iterCmp(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.cmp))); + } else if (pick === 14) { + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), k)) & 0xff); + const iter: rs.Place = rs.place(() => it, (value3) => it = value3); + while (true) { + const _88: rs.u8 | rs.Done = Overrides.next$iter_Iterator(iter.v); + if (_88 === rs.DONE) { + break; } - put(out, rs.iterToOption(Overrides.next$iter_Iterator(it))); - putVec(out, rs.iterToByteVec(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next")); + rs.byteVecPush(out, _88); } + } else { + put(out, rs.iterToOption(Overrides.next$iter_Iterator(it))); + putVec(out, rs.iterToByteVec(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next")); } } diff --git a/ts/fixtures/lang/errors/expected/errors.Failure.ts b/ts/fixtures/lang/errors/expected/errors.Failure.ts index 52454ee5a..5f4d909b6 100644 --- a/ts/fixtures/lang/errors/expected/errors.Failure.ts +++ b/ts/fixtures/lang/errors/expected/errors.Failure.ts @@ -7,18 +7,12 @@ import * as Leaf from "./errors.Leaf.ts"; export function fmt$fmt_Debug(self: Failure, f: rs.Formatter): rs.Result { if (self.tag === "Short") { - const _5: string = "Short"; - const _6: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _5), _6)); + return rs.fmtDebugFields(f, "Short", [(f: rs.Formatter) => rs.u8Debug(self._0, f)]); } if (self.tag === "Wrapped") { - const _9: string = "Wrapped"; - const _10: rs.Fmt = (f: rs.Formatter) => Leaf.fmt$fmt_Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _9), _10)); + return rs.fmtDebugFields(f, "Wrapped", [(f: rs.Formatter) => Leaf.fmt$fmt_Debug(self._0, f)]); } - const _13: string = "Parse"; - const _14: rs.Fmt = (f: rs.Formatter) => rs.fmtParseIntErrorDebug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _13), _14)); + return rs.fmtDebugFields(f, "Parse", [(f: rs.Formatter) => rs.fmtParseIntErrorDebug(self._0, f)]); } /** An error whose source is the crate's, std's, or none. */ diff --git a/ts/fixtures/lang/errors/expected/errors.Leaf.ts b/ts/fixtures/lang/errors/expected/errors.Leaf.ts index 746e026ce..a3db36af3 100644 --- a/ts/fixtures/lang/errors/expected/errors.Leaf.ts +++ b/ts/fixtures/lang/errors/expected/errors.Leaf.ts @@ -5,10 +5,7 @@ import { DROPPED } from "./errors.ts"; import { set$1ljkjlf, get$0q7640n } from "./std/thread/local.ts"; export function fmt$fmt_Debug(self: Leaf, f: rs.Formatter): rs.Result { - const _3: string = "Leaf"; - const _4: string = "code"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.code, f); - return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5)); + return rs.fmtDebugFields(f, "Leaf code", [(f: rs.Formatter) => rs.u8Debug(self.code, f)]); } /** The crate's error without a source of its own, which counts its drops. */ diff --git a/ts/fixtures/lang/errors/expected/errors.Transported.ts b/ts/fixtures/lang/errors/expected/errors.Transported.ts index 97a28ebe0..35196496e 100644 --- a/ts/fixtures/lang/errors/expected/errors.Transported.ts +++ b/ts/fixtures/lang/errors/expected/errors.Transported.ts @@ -5,9 +5,7 @@ import type * as Error from "./core/error.Error.ts"; import type * as Coded from "./errors.Coded.ts"; export function fmt$fmt_Debug(self: Transported, f: rs.Formatter): rs.Result { - const _3: string = "Transported"; - const _4: rs.Fmt = (f: rs.Formatter) => self._0.fmt$Debug(f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Transported", [(f: rs.Formatter) => self._0.fmt$Debug(f)]); } /** A boxed `Coded`, forwarding `Error` to it, as moq's boxed transport error does. */ diff --git a/ts/fixtures/lang/fields/expected/fields.Couple.ts b/ts/fixtures/lang/fields/expected/fields.Couple.ts index d8f6a90b9..e6b4e6d64 100644 --- a/ts/fixtures/lang/fields/expected/fields.Couple.ts +++ b/ts/fixtures/lang/fields/expected/fields.Couple.ts @@ -4,13 +4,9 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug(self: Couple, f: rs.Formatter): rs.Result { const arg = new rs.ByteSlice(self.headData, self.headStart, self.headLen); - const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg), f, rs.u8Debug); + const _4: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg), f, rs.u8Debug); const arg2 = new rs.ByteSlice(self.wordData, self.wordStart, self.wordLen); - const _3: string = "Couple"; - const _4: string = "head"; - const _7: string = "word"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Couple head word", [_4, (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug)]); } export function eq$cmp_PartialEq(self: Couple, other: Couple): boolean { diff --git a/ts/fixtures/lang/fields/expected/fields.Exposed.ts b/ts/fixtures/lang/fields/expected/fields.Exposed.ts index fedeb6186..a25ae22b9 100644 --- a/ts/fixtures/lang/fields/expected/fields.Exposed.ts +++ b/ts/fixtures/lang/fields/expected/fields.Exposed.ts @@ -3,12 +3,7 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug(self: Exposed, f: rs.Formatter): rs.Result { - const _3: string = "Exposed"; - const _4: string = "buf"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(self.buf), f, rs.u8Debug); - const _7: string = "at"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.at, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Exposed buf at", [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(self.buf), f, rs.u8Debug), (f: rs.Formatter) => rs.u8Debug(self.at, f)]); } /** A `pub` field, which stays whole. */ diff --git a/ts/fixtures/lang/fields/expected/fields.Glued.ts b/ts/fixtures/lang/fields/expected/fields.Glued.ts index 237352562..74bcebcd8 100644 --- a/ts/fixtures/lang/fields/expected/fields.Glued.ts +++ b/ts/fixtures/lang/fields/expected/fields.Glued.ts @@ -6,9 +6,7 @@ export function fmt$fmt_Debug(self: Glued, f: rs.Formatter): rs.Result rs.fmtList(rs.byteSliceView(arg), f, rs.u8Debug); const arg2 = new rs.ByteSlice(self._1Data, self._1Start, self._1Len); - const _3: string = "Glued"; - const _6: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug); - return rs.debugTupleFinish(rs.debugTupleField(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4), _6)); + return rs.fmtDebugFields(f, "Glued", [_4, (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug)]); } /** A tuple struct of two slices, one a constant's. */ diff --git a/ts/fixtures/lang/fields/expected/fields.Scanner.ts b/ts/fixtures/lang/fields/expected/fields.Scanner.ts index 1bdf3c9fe..03b72ec59 100644 --- a/ts/fixtures/lang/fields/expected/fields.Scanner.ts +++ b/ts/fixtures/lang/fields/expected/fields.Scanner.ts @@ -11,12 +11,7 @@ export function clone$Clone(self: Scanner): Scanner { export function fmt$fmt_Debug(self: Scanner, f: rs.Formatter): rs.Result { const arg = new rs.ByteSlice(self.bufData, self.bufStart, self.bufLen); - const _3: string = "Scanner"; - const _4: string = "buf"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg), f, rs.u8Debug); - const _7: string = "read"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.usizeDebug(self.read, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Scanner buf read", [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg), f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDebug(self.read, f)]); } export function eq$cmp_PartialEq(self: Scanner, other: Scanner): boolean { diff --git a/ts/fixtures/lang/floats/expected/floats.Reading.ts b/ts/fixtures/lang/floats/expected/floats.Reading.ts index d39210ead..a907dce33 100644 --- a/ts/fixtures/lang/floats/expected/floats.Reading.ts +++ b/ts/fixtures/lang/floats/expected/floats.Reading.ts @@ -3,14 +3,7 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug(self: Reading, f: rs.Formatter): rs.Result { - const _3: string = "Reading"; - const _4: string = "level"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.f64Debug(self.level, f); - const _7: string = "peak"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(self.peak, f, rs.f64Debug); - const _10: string = "history"; - const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtList(self.history.items, f, rs.f64Debug); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11)); + return rs.fmtDebugFields(f, "Reading level peak history", [(f: rs.Formatter) => rs.f64Debug(self.level, f), (f: rs.Formatter) => rs.fmtOption(self.peak, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtList(self.history.items, f, rs.f64Debug)]); } /** A reading whose derived `Debug` writes each `f64` with the placeholder's options. */ diff --git a/ts/fixtures/lang/floats/expected/floats.ts b/ts/fixtures/lang/floats/expected/floats.ts index 14acf42f5..baaee2d2a 100644 --- a/ts/fixtures/lang/floats/expected/floats.ts +++ b/ts/fixtures/lang/floats/expected/floats.ts @@ -276,74 +276,70 @@ export function mulAdds(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void let _52!: [rs.f64, rs.f64, rs.f64]; let _102!: rs.f64; let ea4!: rs.i64; - b0: { - if (!(rs.u8Rem(kind, 2) === 0)) { - let state: rs.u64 = rs.u64Or(takeBits(data)[0], 1); - let iterStart: rs.i32 = 0; - const iterEnd: rs.i32 = 32; - while (true) { - if (!(iterStart++ < iterEnd)) { - break b0; - } - const r: rs.u64 = step(rs.place(() => state, (value) => state = value)); - const pick: (a0: rs.u32, a1: rs.u64) => rs.i64 = (shift: rs.u32, n: rs.u64): rs.i64 => { - return rs.i64Cast(rs.u64Rem(rs.u64Shr(r, shift), n)); - }; - const ea: rs.i64 = rs.i64Sub(pick(8, 64), 32); - const e: rs.i64 = rs.i64Sub(pick(16, 64), 32); - const a2: rs.f64 = near(step(rs.place(() => state, (value2) => state = value2)), ea); - const b2: rs.f64 = near(step(rs.place(() => state, (value3) => state = value3)), rs.i64Sub(e, ea)); - const c2: rs.u64 = step(rs.place(() => state, (value4) => state = value4)); - const _53: rs.u64 = rs.u64Rem(r, 6); - if (_53 === 0) { - _52 = [rs.f64FromBits(r), rs.f64FromBits(step(rs.place(() => state, (value5) => state = value5))), rs.f64FromBits(c2)] as [rs.f64, rs.f64, rs.f64]; - } else if (_53 === 1) { - _52 = [a2, b2, -(a2 * b2)] as [rs.f64, rs.f64, rs.f64]; - } else if (_53 === 2) { - if (!(rs.u64Shr(r, 63) === 0)) { - const c4: rs.f64 = near(c2, e); - _52 = [a2, (rs.f64NextUp(Math.abs(c4)) - Math.abs(c4)) * 0.5 / a2, c4] as [rs.f64, rs.f64, rs.f64]; - } else { - const p: rs.f64 = Math.abs(a2 * b2); - const _70: rs.usize = rs.i64Low(pick(24, 5)); - if (!(_70 < 5)) { - rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _70); - } - const half: rs.f64 = [0.5, -0.5, 0.25, -0.75, 1.5][_70]; - _52 = [a2, b2, (rs.f64NextUp(p) - p) * half] as [rs.f64, rs.f64, rs.f64]; - } - } else if (_53 === 3) { - const ea2: rs.i64 = rs.i64Sub(pick(24, 1000), 500); - const e2: rs.i64 = rs.i64Sub(-1000, pick(40, 100)); - const _97: [rs.f64, rs.f64] = [near(r, ea2), near(c2, rs.i64Sub(e2, ea2))]; - const a4: rs.f64 = _97[0]; - const b4: rs.f64 = _97[1]; - if (!(rs.u64Shr(r, 63) === 0)) { - _102 = near(rs.u64Shr(c2, 1), rs.i64Sub(rs.i64Add(e2, pick(48, 60)), 30)); - } else { - _102 = -(a4 * b4); - } - _52 = [a4, b4, _102] as [rs.f64, rs.f64, rs.f64]; - } else if (_53 === 4) { - const ea3: rs.i64 = rs.i64Add(990, pick(24, 60)); - const a5: rs.f64 = near(r, ea3); - const b5: rs.f64 = near(c2, rs.i64Sub(rs.i64Add(rs.i64Sub(1023, ea3), pick(40, 4)), 1)); - _52 = [a5, b5, rs.f64Copysign(near(rs.u64Shr(c2, 1), rs.i64Add(1020, pick(48, 4))), -(a5 * b5))] as [rs.f64, rs.f64, rs.f64]; + if (!(rs.u8Rem(kind, 2) === 0)) { + let state: rs.u64 = rs.u64Or(takeBits(data)[0], 1); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 32; + while (iterStart++ < iterEnd) { + const r: rs.u64 = step(rs.place(() => state, (value) => state = value)); + const pick: (a0: rs.u32, a1: rs.u64) => rs.i64 = (shift: rs.u32, n: rs.u64): rs.i64 => { + return rs.i64Cast(rs.u64Rem(rs.u64Shr(r, shift), n)); + }; + const ea: rs.i64 = rs.i64Sub(pick(8, 64), 32); + const e: rs.i64 = rs.i64Sub(pick(16, 64), 32); + const a2: rs.f64 = near(step(rs.place(() => state, (value2) => state = value2)), ea); + const b2: rs.f64 = near(step(rs.place(() => state, (value3) => state = value3)), rs.i64Sub(e, ea)); + const c2: rs.u64 = step(rs.place(() => state, (value4) => state = value4)); + const _53: rs.u64 = rs.u64Rem(r, 6); + if (_53 === 0) { + _52 = [rs.f64FromBits(r), rs.f64FromBits(step(rs.place(() => state, (value5) => state = value5))), rs.f64FromBits(c2)] as [rs.f64, rs.f64, rs.f64]; + } else if (_53 === 1) { + _52 = [a2, b2, -(a2 * b2)] as [rs.f64, rs.f64, rs.f64]; + } else if (_53 === 2) { + if (!(rs.u64Shr(r, 63) === 0)) { + const c4: rs.f64 = near(c2, e); + _52 = [a2, (rs.f64NextUp(Math.abs(c4)) - Math.abs(c4)) * 0.5 / a2, c4] as [rs.f64, rs.f64, rs.f64]; } else { - if (!(rs.u64Shr(r, 63) === 0)) { - ea4 = rs.i64Sub(pick(24, 1000), 500); - } else { - ea4 = rs.i64Add(990, pick(24, 10)); + const p: rs.f64 = Math.abs(a2 * b2); + const _70: rs.usize = rs.i64Low(pick(24, 5)); + if (!(_70 < 5)) { + rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _70); } - const _161: [rs.f64, rs.f64] = [near(r, ea4), near(c2, rs.i64Sub(rs.i64Sub(rs.i64Add(-968, pick(40, 8)), 4), ea4))]; - const a6: rs.f64 = _161[0]; - const b6: rs.f64 = _161[1]; - const p2: rs.f64 = Math.abs(a6 * b6); - _52 = [a6, b6, (rs.f64NextUp(p2) - p2) * 0.5] as [rs.f64, rs.f64, rs.f64]; + const half: rs.f64 = [0.5, -0.5, 0.25, -0.75, 1.5][_70]; + _52 = [a2, b2, (rs.f64NextUp(p) - p) * half] as [rs.f64, rs.f64, rs.f64]; } - putMulAdd(out, _52[0], _52[1], _52[2]); + } else if (_53 === 3) { + const ea2: rs.i64 = rs.i64Sub(pick(24, 1000), 500); + const e2: rs.i64 = rs.i64Sub(-1000, pick(40, 100)); + const _97: [rs.f64, rs.f64] = [near(r, ea2), near(c2, rs.i64Sub(e2, ea2))]; + const a4: rs.f64 = _97[0]; + const b4: rs.f64 = _97[1]; + if (!(rs.u64Shr(r, 63) === 0)) { + _102 = near(rs.u64Shr(c2, 1), rs.i64Sub(rs.i64Add(e2, pick(48, 60)), 30)); + } else { + _102 = -(a4 * b4); + } + _52 = [a4, b4, _102] as [rs.f64, rs.f64, rs.f64]; + } else if (_53 === 4) { + const ea3: rs.i64 = rs.i64Add(990, pick(24, 60)); + const a5: rs.f64 = near(r, ea3); + const b5: rs.f64 = near(c2, rs.i64Sub(rs.i64Add(rs.i64Sub(1023, ea3), pick(40, 4)), 1)); + _52 = [a5, b5, rs.f64Copysign(near(rs.u64Shr(c2, 1), rs.i64Add(1020, pick(48, 4))), -(a5 * b5))] as [rs.f64, rs.f64, rs.f64]; + } else { + if (!(rs.u64Shr(r, 63) === 0)) { + ea4 = rs.i64Sub(pick(24, 1000), 500); + } else { + ea4 = rs.i64Add(990, pick(24, 10)); + } + const _161: [rs.f64, rs.f64] = [near(r, ea4), near(c2, rs.i64Sub(rs.i64Sub(rs.i64Add(-968, pick(40, 8)), 4), ea4))]; + const a6: rs.f64 = _161[0]; + const b6: rs.f64 = _161[1]; + const p2: rs.f64 = Math.abs(a6 * b6); + _52 = [a6, b6, (rs.f64NextUp(p2) - p2) * 0.5] as [rs.f64, rs.f64, rs.f64]; } + putMulAdd(out, _52[0], _52[1], _52[2]); } + } else { const _9: [rs.f64, rs.ByteSlice] = take(data); const a: rs.f64 = _9[0]; const _12: [rs.f64, rs.ByteSlice] = take(_9[1]); @@ -383,49 +379,44 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _6: [rs.f64, rs.ByteSlice] = take(data); const a: rs.f64 = _6[0]; const p: rs.usize = option_unwrapOr$1fr498u(rs.byteSliceFirst(_6[1]), 0) as rs.usize; - b0: { - const w: rs.usize = rs.usizeDiv(p, 4); - const _13: rs.u8 = rs.u8Rem(kind, 5); - if (_13 === 0) { - const args17 = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64Debug(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64UpperExp(a, f), rs.fmtCount(p)]; - put(out, rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " ", args17[3], " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[0]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[1]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[2]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[3]), " ", rs.fmtSpec({ plus: true }, args17[0]), " ", rs.fmtSpec({ plus: true }, args17[1]), " ", rs.fmtSpec({ plus: true, precision: rs.fmtCountOf(args17[4]) }, args17[2])]).v); - const args18 = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64Debug(a, f), (f: rs.Formatter) => rs.f64UpperExp(a, f), rs.fmtCount(w), rs.fmtCount(p)]; - put(out, rs.fmtFormat([rs.fmtSpec({ zero: true, width: 8, precision: 3 }, args18[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args18[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args18[0]), "|", rs.fmtSpec({ align: "^", width: 12 }, args18[2]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args18[0]), "|", rs.fmtSpec({ alternate: true }, args18[2]), "|", rs.fmtSpec({ debugHex: "x" }, args18[2]), "|", rs.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args18[3]), "|", rs.fmtSpec({ zero: true, width: 10 }, args18[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 10 }, args18[2]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args18[4]), precision: rs.fmtCountOf(args18[5]) }, args18[0]), "|", rs.fmtSpec({ fill: "é", align: "<", width: rs.fmtCountOf(args18[4]) }, args18[2])]).v); - put(out, rs.fmtToString((f: rs.Formatter) => rs.f64Display(a, f)).v); - } else if (_13 === 1) { - const args16 = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64Debug(a, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 1100 }, args16[0]), " ", rs.fmtSpec({ precision: 800 }, args16[1]), " ", rs.fmtSpec({ precision: 1100 }, args16[2]), " ", rs.fmtSpec({ precision: 65535 }, args16[0])]).v); - } else if (_13 === 2) { - const _72: [rs.f64, rs.ByteSlice] = take(_6[1]); - const b: rs.f64 = _72[0]; - const c: rs.f64 = take(_72[1])[0]; - putF64(out, rs.f64Clamp(a, b, c)); - } else if (_13 === 3) { - const _78: rs.f64 | undefined = a * 0.5; - const _80: rs.Vec = rs.vecFrom([a, -0.0, 1e-7, 1e16, NaN]); - const part = { level: a, peak: _78, history: _80 }; - const args15 = [(f: rs.Formatter) => Reading.fmt$fmt_Debug(part, f)]; - put(out, rs.fmtFormat([args15[0], "|", rs.fmtSpec({ alternate: true }, args15[0]), "|", rs.fmtSpec({ precision: 2 }, args15[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args15[0])]).v); - } else { - let state: rs.u64 = rs.u64Or(takeBits(data)[0], 1); - let iterStart: rs.i32 = 0; - const iterEnd: rs.i32 = 64; - while (iterStart++ < iterEnd) { - const x: rs.f64 = rs.f64FromBits(step(rs.place(() => state, (value) => state = value))); - const args13 = [(f: rs.Formatter) => rs.f64Display(x, f), (f: rs.Formatter) => rs.f64Debug(x, f), (f: rs.Formatter) => rs.f64LowerExp(x, f)]; - put(out, rs.fmtFormat([args13[0], " ", args13[1], " ", args13[2]]).v); - } - let iterStart2: rs.i32 = 0; - const iterEnd2: rs.i32 = 64; - while (true) { - if (!(iterStart2++ < iterEnd2)) { - break b0; - } - const r2: rs.u64 = step(rs.place(() => state, (value2) => state = value2)); - const x2: rs.f64 = rs.u64ToF64(rs.u64Shr(r2, 11)) / rs.u64ToF64(rs.u64Shl(1, rs.u64Add(rs.u64Rem(r2, 24), 1))); - const args14 = [(f: rs.Formatter) => rs.f64Debug(x2, f), (f: rs.Formatter) => rs.f64LowerExp(x2, f)]; - put(out, rs.fmtFormat([args14[0], " ", args14[1]]).v); - } + const w: rs.usize = rs.usizeDiv(p, 4); + const _13: rs.u8 = rs.u8Rem(kind, 5); + if (_13 === 0) { + const args17 = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64Debug(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64UpperExp(a, f), rs.fmtCount(p)]; + put(out, rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " ", args17[3], " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[0]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[1]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[2]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[3]), " ", rs.fmtSpec({ plus: true }, args17[0]), " ", rs.fmtSpec({ plus: true }, args17[1]), " ", rs.fmtSpec({ plus: true, precision: rs.fmtCountOf(args17[4]) }, args17[2])]).v); + const args18 = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64Debug(a, f), (f: rs.Formatter) => rs.f64UpperExp(a, f), rs.fmtCount(w), rs.fmtCount(p)]; + put(out, rs.fmtFormat([rs.fmtSpec({ zero: true, width: 8, precision: 3 }, args18[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args18[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args18[0]), "|", rs.fmtSpec({ align: "^", width: 12 }, args18[2]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args18[0]), "|", rs.fmtSpec({ alternate: true }, args18[2]), "|", rs.fmtSpec({ debugHex: "x" }, args18[2]), "|", rs.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args18[3]), "|", rs.fmtSpec({ zero: true, width: 10 }, args18[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 10 }, args18[2]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args18[4]), precision: rs.fmtCountOf(args18[5]) }, args18[0]), "|", rs.fmtSpec({ fill: "é", align: "<", width: rs.fmtCountOf(args18[4]) }, args18[2])]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.f64Display(a, f)).v); + } else if (_13 === 1) { + const args16 = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64Debug(a, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 1100 }, args16[0]), " ", rs.fmtSpec({ precision: 800 }, args16[1]), " ", rs.fmtSpec({ precision: 1100 }, args16[2]), " ", rs.fmtSpec({ precision: 65535 }, args16[0])]).v); + } else if (_13 === 2) { + const _72: [rs.f64, rs.ByteSlice] = take(_6[1]); + const b: rs.f64 = _72[0]; + const c: rs.f64 = take(_72[1])[0]; + putF64(out, rs.f64Clamp(a, b, c)); + } else if (_13 === 3) { + const _78: rs.f64 | undefined = a * 0.5; + const _80: rs.Vec = rs.vecFrom([a, -0.0, 1e-7, 1e16, NaN]); + const part = { level: a, peak: _78, history: _80 }; + const args15 = [(f: rs.Formatter) => Reading.fmt$fmt_Debug(part, f)]; + put(out, rs.fmtFormat([args15[0], "|", rs.fmtSpec({ alternate: true }, args15[0]), "|", rs.fmtSpec({ precision: 2 }, args15[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args15[0])]).v); + } else { + let state: rs.u64 = rs.u64Or(takeBits(data)[0], 1); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 64; + while (iterStart++ < iterEnd) { + const x: rs.f64 = rs.f64FromBits(step(rs.place(() => state, (value) => state = value))); + const args13 = [(f: rs.Formatter) => rs.f64Display(x, f), (f: rs.Formatter) => rs.f64Debug(x, f), (f: rs.Formatter) => rs.f64LowerExp(x, f)]; + put(out, rs.fmtFormat([args13[0], " ", args13[1], " ", args13[2]]).v); + } + let iterStart2: rs.i32 = 0; + const iterEnd2: rs.i32 = 64; + while (iterStart2++ < iterEnd2) { + const r2: rs.u64 = step(rs.place(() => state, (value2) => state = value2)); + const x2: rs.f64 = rs.u64ToF64(rs.u64Shr(r2, 11)) / rs.u64ToF64(rs.u64Shl(1, rs.u64Add(rs.u64Rem(r2, 24), 1))); + const args14 = [(f: rs.Formatter) => rs.f64Debug(x2, f), (f: rs.Formatter) => rs.f64LowerExp(x2, f)]; + put(out, rs.fmtFormat([args14[0], " ", args14[1]]).v); } } } @@ -436,47 +427,42 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void */ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let _60!: rs.usize; - b0: { - const _4: rs.u8 = rs.u8Rem(kind, 3); - if (_4 === 0) { - const _6: rs.Result = rs.strFromUtf8(data); - if (_6.ok) { - one(_6.value, out); - } - } else if (_4 === 1) { - const s: rs.String = rs.stringNew(); - for (const b of rs.byteSliceView(data)) { - const _21: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)); - const _22: rs.usize = rs.usizeRem(b as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)).length); - rs.idx(_21, _22); - rs.stringPush(s, _21.data[_21.start + _22] as rs.char); - } - one(s.v, out); - } else { - let state: rs.u64 = rs.u64Or(takeBits(data)[0], 1); - let iterStart: rs.i32 = 0; - const iterEnd: rs.i32 = 16; - while (true) { - if (!(iterStart++ < iterEnd)) { - break b0; - } - const r: rs.u64 = step(rs.place(() => state, (value) => state = value)); - const len: rs.usize = rs.u64Low(rs.u64Add(rs.u64Rem(r, 40), 1)); - const point: rs.usize = rs.usizeRem(rs.u64Low(rs.u64Shr(r, 8)), rs.usizeAdd(len, 1)); - const s2: rs.String = rs.stringNew(); - let iterStart2: rs.usize = 0; - const iterEnd2: rs.usize = len; - while ((_60 = iterStart2++) < iterEnd2) { - if (_60 === point) { - rs.stringPush(s2, 46); - } - const _69: rs.char = rs.u8Add(48, rs.u64Low(rs.u64Rem(step(rs.place(() => state, (value2) => state = value2)), 10)) & 0xff) as rs.char; - rs.stringPush(s2, _69); + const _4: rs.u8 = rs.u8Rem(kind, 3); + if (_4 === 0) { + const _6: rs.Result = rs.strFromUtf8(data); + if (_6.ok) { + one(_6.value, out); + } + } else if (_4 === 1) { + const s: rs.String = rs.stringNew(); + for (const b of rs.byteSliceView(data)) { + const _21: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)); + const _22: rs.usize = rs.usizeRem(b as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)).length); + rs.idx(_21, _22); + rs.stringPush(s, _21.data[_21.start + _22] as rs.char); + } + one(s.v, out); + } else { + let state: rs.u64 = rs.u64Or(takeBits(data)[0], 1); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 16; + while (iterStart++ < iterEnd) { + const r: rs.u64 = step(rs.place(() => state, (value) => state = value)); + const len: rs.usize = rs.u64Low(rs.u64Add(rs.u64Rem(r, 40), 1)); + const point: rs.usize = rs.usizeRem(rs.u64Low(rs.u64Shr(r, 8)), rs.usizeAdd(len, 1)); + const s2: rs.String = rs.stringNew(); + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = len; + while ((_60 = iterStart2++) < iterEnd2) { + if (_60 === point) { + rs.stringPush(s2, 46); } - const _85: rs.i64 = rs.i64Sub(rs.i64Cast(rs.u64Rem(rs.u64Shr(r, 16), 700)), 350); - const args3 = [(f: rs.Formatter) => rs.fmtPad(f, s2.v), (f: rs.Formatter) => rs.i64Display(_85, f)]; - one(rs.fmtFormat([args3[0], "e", args3[1]]).v, out); + const _69: rs.char = rs.u8Add(48, rs.u64Low(rs.u64Rem(step(rs.place(() => state, (value2) => state = value2)), 10)) & 0xff) as rs.char; + rs.stringPush(s2, _69); } + const _85: rs.i64 = rs.i64Sub(rs.i64Cast(rs.u64Rem(rs.u64Shr(r, 16), 700)), 350); + const args3 = [(f: rs.Formatter) => rs.fmtPad(f, s2.v), (f: rs.Formatter) => rs.i64Display(_85, f)]; + one(rs.fmtFormat([args3[0], "e", args3[1]]).v, out); } } } diff --git a/ts/fixtures/lang/hashes/expected/hashes.Switch.ts b/ts/fixtures/lang/hashes/expected/hashes.Switch.ts index 2b4ea4dcb..2dcd0872d 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Switch.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Switch.ts @@ -39,20 +39,12 @@ export function finish$hash_Hasher(self: Switch): rs.u64 { export const hasher$hash_Hasher: rs.HasherImpl> = { write: write$hash_Hasher as (a0: rs.Place, a1: rs.ByteSlice) => undefined, finish: (h: rs.Place) => finish$hash_Hasher(h.v), u8: writeU8$hash_Hasher as (a0: rs.Place, a1: rs.u8) => undefined }; export function write$hash_Hasher(self: rs.Place, bytes: rs.ByteSlice): void { - b0: { - if (self.v.tag === "Log") { - record(self.v._0, 119, bytes); - } else { - const iterS: Uint8Array = rs.byteSliceView(bytes); - let iterI: number = 0; - while (true) { - const _8: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; - if (_8 === rs.DONE) { - break b0; - } - const _12: rs.u64 = rs.u64WrappingAdd(rs.u64WrappingMul(self.v._1, 31), _8 as rs.u64); - self.v._1 = _12; - } + if (self.v.tag === "Log") { + record(self.v._0, 119, bytes); + } else { + for (const b of rs.byteSliceView(bytes)) { + const _12: rs.u64 = rs.u64WrappingAdd(rs.u64WrappingMul(self.v._1, 31), b as rs.u64); + self.v._1 = _12; } } } diff --git a/ts/fixtures/lang/hashes/expected/hashes.Tallied.ts b/ts/fixtures/lang/hashes/expected/hashes.Tallied.ts index 506a9e320..83cf97931 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Tallied.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Tallied.ts @@ -15,12 +15,7 @@ export function clone$Clone(self: Tallied): Tallied { } export function fmt$fmt_Debug(self: Tallied, f: rs.Formatter): rs.Result { - const _3: string = "Tallied"; - const _4: string = "tag"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.tag, f); - const _7: string = "state"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtWriteStr(f, "BuildHasherDefault"); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Tallied tag state", [(f: rs.Formatter) => rs.u8Debug(self.tag, f), (f: rs.Formatter) => rs.fmtWriteStr(f, "BuildHasherDefault")]); } export function eq$cmp_PartialEq(self: Tallied, other: Tallied): boolean { diff --git a/ts/fixtures/lang/hashes/expected/hashes.ts b/ts/fixtures/lang/hashes/expected/hashes.ts index 3a7a4ad97..f95719575 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.ts @@ -1215,79 +1215,44 @@ export function compared$collections_HashSet_hashes_Sided_hashes_Spread(a: rs.Ha * as JS does, and maps in a `Vec` and in a type that derives `PartialEq`. */ export function equal(data: rs.ByteSlice, out: rs.ByteVec): void { - const _8: (a0: rs.u8, a1: rs.ByteSlice) => rs.HashSet = (side: rs.u8, bytes: rs.ByteSlice): rs.HashSet => { - const _52: Spread.Spread = { _0: side as rs.u64 }; - const s: rs.HashSet = rs.hashNew(rs.hashing(Sided.hash$Hash_hash_DefaultHasher as (a0: Sided.Sided, a1: rs.Hasher) => undefined, Sided.eq$cmp_PartialEq), _52) as rs.HashSet; + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const map: (a0: rs.u8, a1: rs.ByteSlice) => rs.HashMap = (side: rs.u8, bytes: rs.ByteSlice): rs.HashMap => { + const _52: Spread.Spread = { _0: rs.u64Add(rs.u64Mul(side as rs.u64, 65537), first as rs.u64) }; + const m: rs.HashMap = rs.hashNew(rs.hashing(Sided.hash$Hash_hash_DefaultHasher as (a0: Sided.Sided, a1: rs.Hasher) => undefined, Sided.eq$cmp_PartialEq), _52) as rs.HashMap; const iterS: Uint8Array = rs.byteSliceView(bytes); let iterI: number = 0; while (true) { - const _9: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; - if (_9 === rs.DONE) { - return s; + const _155: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_155 === rs.DONE) { + return m; } - rs.hashAdd(s, { n: _9 & 127, side }); + const b: rs.u8 = _155; + const _212: Sided.Sided = { n: b & 127, side }; + const _23: Sided.Sided = { n: b >> 6, side: rs.u8Add(side, 2) }; + rs.hashInsert(m, _212, _23); } }; - const _96: (a0: rs.ByteSlice) => rs.HashMap = (bytes2: rs.ByteSlice): rs.HashMap => { - const m: rs.HashMap = rs.hashNew() as rs.HashMap; + const _8: (a0: rs.u8, a1: rs.ByteSlice) => rs.HashSet = (side2: rs.u8, bytes2: rs.ByteSlice): rs.HashSet => { + const _53: Spread.Spread = { _0: side2 as rs.u64 }; + const s: rs.HashSet = rs.hashNew(rs.hashing(Sided.hash$Hash_hash_DefaultHasher as (a0: Sided.Sided, a1: rs.Hasher) => undefined, Sided.eq$cmp_PartialEq), _53) as rs.HashSet; const iterS2: Uint8Array = rs.byteSliceView(bytes2); let iterI2: number = 0; while (true) { - const _64: rs.u8 | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; - if (_64 === rs.DONE) { - return m; - } - const b2: rs.u8 = _64; - const _102: rs.u16 = b2 as rs.u16; - const _113: rs.Place = rs.entryOrInsertWithMut(rs.entry(m, rs.u8Rem(b2, 8)), (): rs.u16 => { - return 0; - }); - _113.v = rs.u16Add(_113.v, _102); - } - }; - const _123: (a0: rs.ByteSlice) => rs.HashSet = (bytes3: rs.ByteSlice): rs.HashSet => { - const _3: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes3)), (_2: rs.u8): rs.String => { - return text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(_2, 4)))); - }); - return rs.hashExtendKeys(rs.hashNew(rs.HASH_TEXT) as rs.HashSet, _3, undefined, undefined, 117440512); - }; - const _175: (a0: rs.ByteSlice) => hashes_Index.Index = (bytes4: rs.ByteSlice): hashes_Index.Index => { - const _46: rs.Iter<[rs.u8, rs.String]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes4)), (_22: rs.u8): [rs.u8, rs.String] => { - const b4: rs.u8 = _22; - return [rs.u8Rem(b4, 8), text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(b4, 3))))] as [rs.u8, rs.String]; - }); - const _33: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, _46, undefined, undefined, undefined, 58720256); - const _75: rs.Iter<[rs.u8, boolean]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes4)), (_23: rs.u8): [rs.u8, boolean] => { - const b5: rs.u8 = _23; - return [rs.u8Rem(b5, 5), rs.u8Rem(b5, 2) === 0] as [rs.u8, boolean]; - }); - return { names: _33, seen: rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same]))) as rs.HashSet<[rs.u8, boolean]>, _75, undefined, undefined, 469762048) }; - }; - const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); - const map: (a0: rs.u8, a1: rs.ByteSlice) => rs.HashMap = (side2: rs.u8, bytes5: rs.ByteSlice): rs.HashMap => { - const _58: Spread.Spread = { _0: rs.u64Add(rs.u64Mul(side2 as rs.u64, 65537), first as rs.u64) }; - const m2: rs.HashMap = rs.hashNew(rs.hashing(Sided.hash$Hash_hash_DefaultHasher as (a0: Sided.Sided, a1: rs.Hasher) => undefined, Sided.eq$cmp_PartialEq), _58) as rs.HashMap; - const iterS3: Uint8Array = rs.byteSliceView(bytes5); - let iterI3: number = 0; - while (true) { - const _1510: rs.u8 | rs.Done = iterI3 < iterS3.length ? iterS3[iterI3++] : rs.DONE; - if (_1510 === rs.DONE) { - return m2; + const _92: rs.u8 | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_92 === rs.DONE) { + return s; } - const b6: rs.u8 = _1510; - const _212: Sided.Sided = { n: b6 & 127, side: side2 }; - const _232: Sided.Sided = { n: b6 >> 6, side: rs.u8Add(side2, 2) }; - rs.hashInsert(m2, _212, _232); + rs.hashAdd(s, { n: _92 & 127, side: side2 }); } }; const reversed: rs.ByteVec = rs.iterToByteVec(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), undefined, true); - const flipped: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_210: [rs.usize, rs.u8]): rs.u8 => { - const i: rs.usize = _210[0]; - const b7: rs.u8 = _210[1]; + const flipped: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_2: [rs.usize, rs.u8]): rs.u8 => { + const i: rs.usize = _2[0]; + const b3: rs.u8 = _2[1]; if (!(i === rs.usizeDiv(data.length, 2))) { - return b7; + return b3; } - return b7 ^ 65; + return b3 ^ 65; }), undefined, true); const shorter: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.usizeSaturatingSub(data.length, 1)); const left: rs.HashMap = map(1, data); @@ -1326,6 +1291,23 @@ export function equal(data: rs.ByteSlice, out: rs.ByteVec): void { compared$collections_HashSet_hashes_Sided_hashes_Spread(right2, left2, _89, out); } compared$collections_HashMap_hashes_Sided_hashes_Sided_hashes_Spread(rs.hashNew(rs.hashing(Sided.hash$Hash_hash_DefaultHasher as (a0: Sided.Sided, a1: rs.Hasher) => undefined, Sided.eq$cmp_PartialEq), Spread.default$Default()) as rs.HashMap, rs.hashNew(rs.hashing(Sided.hash$Hash_hash_DefaultHasher as (a0: Sided.Sided, a1: rs.Hasher) => undefined, Sided.eq$cmp_PartialEq), Spread.default$Default()) as rs.HashMap, 0, out); + const _96: (a0: rs.ByteSlice) => rs.HashMap = (bytes3: rs.ByteSlice): rs.HashMap => { + const m2: rs.HashMap = rs.hashNew() as rs.HashMap; + const iterS3: Uint8Array = rs.byteSliceView(bytes3); + let iterI3: number = 0; + while (true) { + const _69: rs.u8 | rs.Done = iterI3 < iterS3.length ? iterS3[iterI3++] : rs.DONE; + if (_69 === rs.DONE) { + return m2; + } + const b4: rs.u8 = _69; + const _104: rs.u16 = b4 as rs.u16; + const _117: rs.Place = rs.entryOrInsertWithMut(rs.entry(m2, rs.u8Rem(b4, 8)), (): rs.u16 => { + return 0; + }); + _117.v = rs.u16Add(_117.v, _104); + } + }; const _101: rs.HashMap = _96(data); const part6 = rs.byteVecSlice(reversed); const _105: rs.HashMap = _96(part6); @@ -1334,6 +1316,12 @@ export function equal(data: rs.ByteSlice, out: rs.ByteVec): void { const part7 = rs.byteVecSlice(flipped); const _118: rs.HashMap = _96(part7); rs.byteVecPush(out, !rs.hashEq(rs.same)(_114, _118) ? 1 : 0); + const _123: (a0: rs.ByteSlice) => rs.HashSet = (bytes4: rs.ByteSlice): rs.HashSet => { + const _3: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes4)), (_210: rs.u8): rs.String => { + return text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(_210, 4)))); + }); + return rs.hashExtendKeys(rs.hashNew(rs.HASH_TEXT) as rs.HashSet, _3, undefined, undefined, 117440512); + }; const _128: rs.HashSet = _123(data); const part8 = rs.byteVecSlice(reversed); const _132: rs.HashSet = _123(part8); @@ -1349,6 +1337,18 @@ export function equal(data: rs.ByteSlice, out: rs.ByteVec): void { const part11 = rs.byteVecSlice(flipped); const _163: rs.Vec> = rs.vecFrom([_165, _123(part11)]); rs.byteVecPush(out, rs.eqSeq(rs.hashEq())(_152, _163) ? 1 : 0); + const _175: (a0: rs.ByteSlice) => hashes_Index.Index = (bytes5: rs.ByteSlice): hashes_Index.Index => { + const _46: rs.Iter<[rs.u8, rs.String]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes5)), (_211: rs.u8): [rs.u8, rs.String] => { + const b6: rs.u8 = _211; + return [rs.u8Rem(b6, 8), text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(b6, 3))))] as [rs.u8, rs.String]; + }); + const _33: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, _46, undefined, undefined, undefined, 58720256); + const _78: rs.Iter<[rs.u8, boolean]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes5)), (_213: rs.u8): [rs.u8, boolean] => { + const b7: rs.u8 = _213; + return [rs.u8Rem(b7, 5), rs.u8Rem(b7, 2) === 0] as [rs.u8, boolean]; + }); + return { names: _33, seen: rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same]))) as rs.HashSet<[rs.u8, boolean]>, _78, undefined, undefined, 469762048) }; + }; const _180: hashes_Index.Index = _175(data); const part12 = rs.byteVecSlice(reversed); rs.byteVecPush(out, hashes_Index.eq$cmp_PartialEq(_180, _175(part12)) ? 1 : 0); diff --git a/ts/fixtures/lang/heap/expected/heap.Fault.ts b/ts/fixtures/lang/heap/expected/heap.Fault.ts index 3232f600f..10ddd68a8 100644 --- a/ts/fixtures/lang/heap/expected/heap.Fault.ts +++ b/ts/fixtures/lang/heap/expected/heap.Fault.ts @@ -6,10 +6,7 @@ export function fmt$fmt_Debug(self: Fault, f: rs.Formatter): rs.Result rs.fmtLayoutDebug(self.layout, f); - return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _6), _7, _8)); + return rs.fmtDebugFields(f, "Alloc layout", [(f: rs.Formatter) => rs.fmtLayoutDebug(self.layout, f)]); } export type Fault = { tag: "Overflow" } | { tag: "Alloc"; layout: rs.Layout }; diff --git a/ts/fixtures/lang/heap/expected/heap.ts b/ts/fixtures/lang/heap/expected/heap.ts index 2ce6d4a0c..bde27a855 100644 --- a/ts/fixtures/lang/heap/expected/heap.ts +++ b/ts/fixtures/lang/heap/expected/heap.ts @@ -168,7 +168,8 @@ export function layouts(data: rs.ByteSlice, out: rs.ByteVec): void { const made: rs.Result = rs.layoutFromSizeAlign(size, align); rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(made, f, rs.fmtLayoutDebug, rs.fmtLayoutErrorDebug)]).v), undefined, true); if (!made.ok) { - rs.iterExtendBytes(out, rs.strBytes(rs.fmtToString((f: rs.Formatter) => rs.fmtLayoutErrorDisplay(rs.LAYOUT_ERROR, f)).v), undefined, true); + const _48: rs.LayoutError = rs.LAYOUT_ERROR; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtToString((f: rs.Formatter) => rs.fmtLayoutErrorDisplay(_48, f)).v), undefined, true); } const part3 = rs.layoutArray(rs.usizeShr(size, rs.u8Rem(b, 8)), 8, 8); rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(part3, f, rs.fmtLayoutDebug, rs.fmtLayoutErrorDebug)]).v), undefined, true); diff --git a/ts/fixtures/lang/inlines/expected/inlines.Block.ts b/ts/fixtures/lang/inlines/expected/inlines.Block.ts index c930877e2..61052ac21 100644 --- a/ts/fixtures/lang/inlines/expected/inlines.Block.ts +++ b/ts/fixtures/lang/inlines/expected/inlines.Block.ts @@ -5,15 +5,13 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug_0(self: Block, f: rs.Formatter): rs.Result { const _3: string = "Block"; const _6: rs.ByteSlice = rs.byteSliceFrom(self._0); - const _4: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_6), f, rs.u8Debug); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, _3, [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_6), f, rs.u8Debug)]); } export function fmt$fmt_Debug_3(self: Block, f: rs.Formatter): rs.Result { const _3: string = "Block"; const _6: rs.ByteSlice = rs.byteSliceFrom(self._0); - const _4: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_6), f, rs.u8Debug); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, _3, [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_6), f, rs.u8Debug)]); } /** Bytes of a length, which copy. */ diff --git a/ts/fixtures/lang/inlines/expected/inlines.Full.ts b/ts/fixtures/lang/inlines/expected/inlines.Full.ts index b64665589..ad39af657 100644 --- a/ts/fixtures/lang/inlines/expected/inlines.Full.ts +++ b/ts/fixtures/lang/inlines/expected/inlines.Full.ts @@ -3,9 +3,7 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug_3(self: Full, f: rs.Formatter): rs.Result { - const _3: string = "Full"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.fmtStr(self._0.v, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Full", [(f: rs.Formatter) => rs.fmtStr(self._0.v, f)]); } /** What didn't fit in a [`Text`], and the capacity it didn't fit in. */ diff --git a/ts/fixtures/lang/inlines/expected/inlines.Mod.ts b/ts/fixtures/lang/inlines/expected/inlines.Mod.ts index d90679ee7..1cc13e0f7 100644 --- a/ts/fixtures/lang/inlines/expected/inlines.Mod.ts +++ b/ts/fixtures/lang/inlines/expected/inlines.Mod.ts @@ -3,15 +3,11 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug_4294967291(self: Mod, f: rs.Formatter): rs.Result { - const _3: string = "Mod"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.u32Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Mod", [(f: rs.Formatter) => rs.u32Debug(self._0, f)]); } export function fmt$fmt_Debug_7(self: Mod, f: rs.Formatter): rs.Result { - const _3: string = "Mod"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.u32Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Mod", [(f: rs.Formatter) => rs.u32Debug(self._0, f)]); } /** An integer modulo `M`, whose `+` wraps there. */ diff --git a/ts/fixtures/lang/inlines/expected/inlines.Small.ts b/ts/fixtures/lang/inlines/expected/inlines.Small.ts index dfcc4fc67..055de6362 100644 --- a/ts/fixtures/lang/inlines/expected/inlines.Small.ts +++ b/ts/fixtures/lang/inlines/expected/inlines.Small.ts @@ -6,27 +6,17 @@ import { copy$array_u8 } from "./lib.ts"; export function fmt$fmt_Debug_2(self: Small, f: rs.Formatter): rs.Result { if (self.tag === "Inline") { const __self0: rs.ByteSlice = rs.byteSliceFrom(self._0); - const _6: string = "Inline"; - const _7: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(__self0), f, rs.u8Debug); - const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._1, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.debugTupleField(rs.fmtDebugTuple(f, _6), _7), _8)); + return rs.fmtDebugFields(f, "Inline", [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(__self0), f, rs.u8Debug), (f: rs.Formatter) => rs.u8Debug(self._1, f)]); } - const _11: string = "Heap"; - const _12: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self._0), f, rs.u8Debug); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _11), _12)); + return rs.fmtDebugFields(f, "Heap", [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(self._0), f, rs.u8Debug)]); } export function fmt$fmt_Debug_4(self: Small, f: rs.Formatter): rs.Result { if (self.tag === "Inline") { const __self0: rs.ByteSlice = rs.byteSliceFrom(self._0); - const _6: string = "Inline"; - const _7: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(__self0), f, rs.u8Debug); - const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._1, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.debugTupleField(rs.fmtDebugTuple(f, _6), _7), _8)); + return rs.fmtDebugFields(f, "Inline", [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(__self0), f, rs.u8Debug), (f: rs.Formatter) => rs.u8Debug(self._1, f)]); } - const _11: string = "Heap"; - const _12: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self._0), f, rs.u8Debug); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _11), _12)); + return rs.fmtDebugFields(f, "Heap", [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(self._0), f, rs.u8Debug)]); } /** What `N` bytes hold, inline or else on the heap, as an enum generic over its length. */ diff --git a/ts/fixtures/lang/ints/expected/ints.ts b/ts/fixtures/lang/ints/expected/ints.ts index cd1d02bd8..e25c9c18f 100644 --- a/ts/fixtures/lang/ints/expected/ints.ts +++ b/ts/fixtures/lang/ints/expected/ints.ts @@ -11,19 +11,6 @@ import * as Scaled from "./ints.Scaled.ts"; /** Apply operation `op` to operands taken from `data`. */ export function u8Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _68: (a0: rs.ByteVec, a1: rs.u8) => undefined = (out2: rs.ByteVec, v3: rs.u8): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); - rs.byteVecPush(out2, rs.u8FromBeBytes(rs.u8ToBeBytes(v3)) === v3 ? 1 : 0); - }; - const _69: (a0: rs.ByteVec, a1: rs.u8 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.u8 | undefined): undefined => { - if (v4 === undefined) { - rs.byteVecPush(out3, 0); - } else { - const v5: rs.u8 = v4; - rs.byteVecPush(out3, 1); - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u128ToBeBytes(v5 as rs.u128))); - } - }; const buf: Uint8Array = Uint8Array.of(0); const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); @@ -41,6 +28,19 @@ export function u8Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); const c: rs.u8 = ([rs.u8FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.u8, rs.ByteSlice])[0]; const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 8); + const _68: (a0: rs.ByteVec, a1: rs.u8) => undefined = (out2: rs.ByteVec, v3: rs.u8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); + rs.byteVecPush(out2, rs.u8FromBeBytes(rs.u8ToBeBytes(v3)) === v3 ? 1 : 0); + }; + const _69: (a0: rs.ByteVec, a1: rs.u8 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.u8 | undefined): undefined => { + if (v4 === undefined) { + rs.byteVecPush(out3, 0); + } else { + const v5: rs.u8 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u128ToBeBytes(v5 as rs.u128))); + } + }; const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { _68(out, rs.u8Add(a, b)); @@ -174,19 +174,6 @@ export function u8Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `op` to operands taken from `data`. */ export function u16Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _68: (a0: rs.ByteVec, a1: rs.u16) => undefined = (out2: rs.ByteVec, v3: rs.u16): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); - rs.byteVecPush(out2, rs.u16FromBeBytes(rs.u16ToBeBytes(v3)) === v3 ? 1 : 0); - }; - const _69: (a0: rs.ByteVec, a1: rs.u16 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.u16 | undefined): undefined => { - if (v4 === undefined) { - rs.byteVecPush(out3, 0); - } else { - const v5: rs.u16 = v4; - rs.byteVecPush(out3, 1); - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u128ToBeBytes(v5 as rs.u128))); - } - }; const buf: Uint8Array = rs.bytes(2); const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); @@ -204,6 +191,19 @@ export function u16Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); const c: rs.u16 = ([rs.u16FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.u16, rs.ByteSlice])[0]; const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 16); + const _68: (a0: rs.ByteVec, a1: rs.u16) => undefined = (out2: rs.ByteVec, v3: rs.u16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); + rs.byteVecPush(out2, rs.u16FromBeBytes(rs.u16ToBeBytes(v3)) === v3 ? 1 : 0); + }; + const _69: (a0: rs.ByteVec, a1: rs.u16 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.u16 | undefined): undefined => { + if (v4 === undefined) { + rs.byteVecPush(out3, 0); + } else { + const v5: rs.u16 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u128ToBeBytes(v5 as rs.u128))); + } + }; const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { _68(out, rs.u16Add(a, b)); @@ -337,19 +337,6 @@ export function u16Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `op` to operands taken from `data`. */ export function u32Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _68: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out2: rs.ByteVec, v3: rs.u32): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); - rs.byteVecPush(out2, rs.u32FromBeBytes(rs.u32ToBeBytes(v3)) === v3 ? 1 : 0); - }; - const _69: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.u32 | undefined): undefined => { - if (v4 === undefined) { - rs.byteVecPush(out3, 0); - } else { - const v5: rs.u32 = v4; - rs.byteVecPush(out3, 1); - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u128ToBeBytes(v5 as rs.u128))); - } - }; const buf: Uint8Array = rs.bytes(4); const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); @@ -367,6 +354,19 @@ export function u32Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); const c: rs.u32 = ([rs.u32FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.u32, rs.ByteSlice])[0]; const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 32); + const _68: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out2: rs.ByteVec, v3: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); + rs.byteVecPush(out2, rs.u32FromBeBytes(rs.u32ToBeBytes(v3)) === v3 ? 1 : 0); + }; + const _69: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.u32 | undefined): undefined => { + if (v4 === undefined) { + rs.byteVecPush(out3, 0); + } else { + const v5: rs.u32 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u128ToBeBytes(v5 as rs.u128))); + } + }; const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { _68(out, rs.u32Add(a, b)); @@ -500,19 +500,6 @@ export function u32Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `op` to operands taken from `data`. */ export function u64Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _68: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, v3: rs.u64): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(rs.u128Cast(v3)))); - rs.byteVecPush(out2, rs.u64Eq(rs.u64FromBeBytes(rs.u64ToBeBytes(v3)), v3) ? 1 : 0); - }; - const _69: (a0: rs.ByteVec, a1: rs.u64 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.u64 | undefined): undefined => { - if (v4 === undefined) { - rs.byteVecPush(out3, 0); - } else { - const v5: rs.u64 = v4; - rs.byteVecPush(out3, 1); - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u128ToBeBytes(rs.u128Cast(v5)))); - } - }; const buf: Uint8Array = rs.bytes(8); const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); @@ -530,6 +517,19 @@ export function u64Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); const c: rs.u64 = ([rs.u64FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.u64, rs.ByteSlice])[0]; const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 64); + const _68: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, v3: rs.u64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(rs.u128Cast(v3)))); + rs.byteVecPush(out2, rs.u64Eq(rs.u64FromBeBytes(rs.u64ToBeBytes(v3)), v3) ? 1 : 0); + }; + const _69: (a0: rs.ByteVec, a1: rs.u64 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.u64 | undefined): undefined => { + if (v4 === undefined) { + rs.byteVecPush(out3, 0); + } else { + const v5: rs.u64 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u128ToBeBytes(rs.u128Cast(v5)))); + } + }; const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { _68(out, rs.u64Add(a, b)); @@ -663,19 +663,6 @@ export function u64Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `op` to operands taken from `data`. */ export function u128Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _68: (a0: rs.ByteVec, a1: rs.u128) => undefined = (out2: rs.ByteVec, v3: rs.u128): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3))); - rs.byteVecPush(out2, rs.u128Eq(rs.u128FromBeBytes(rs.u128ToBeBytes(v3)), v3) ? 1 : 0); - }; - const _69: (a0: rs.ByteVec, a1: rs.u128 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.u128 | undefined): undefined => { - if (v4 === undefined) { - rs.byteVecPush(out3, 0); - } else { - const v5: rs.u128 = v4; - rs.byteVecPush(out3, 1); - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u128ToBeBytes(v5))); - } - }; const buf: Uint8Array = rs.bytes(16); const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); @@ -693,6 +680,19 @@ export function u128Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); const c: rs.u128 = ([rs.u128FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.u128, rs.ByteSlice])[0]; const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 128); + const _68: (a0: rs.ByteVec, a1: rs.u128) => undefined = (out2: rs.ByteVec, v3: rs.u128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3))); + rs.byteVecPush(out2, rs.u128Eq(rs.u128FromBeBytes(rs.u128ToBeBytes(v3)), v3) ? 1 : 0); + }; + const _69: (a0: rs.ByteVec, a1: rs.u128 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.u128 | undefined): undefined => { + if (v4 === undefined) { + rs.byteVecPush(out3, 0); + } else { + const v5: rs.u128 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u128ToBeBytes(v5))); + } + }; const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { _68(out, rs.u128Add(a, b)); @@ -826,19 +826,6 @@ export function u128Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `op` to operands taken from `data`. */ export function usizeOp(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _68: (a0: rs.ByteVec, a1: rs.usize) => undefined = (out2: rs.ByteVec, v3: rs.usize): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); - rs.byteVecPush(out2, rs.usizeFromBeBytes(rs.usizeToBeBytes(v3)) === v3 ? 1 : 0); - }; - const _69: (a0: rs.ByteVec, a1: rs.usize | undefined) => undefined = (out3: rs.ByteVec, v4: rs.usize | undefined): undefined => { - if (v4 === undefined) { - rs.byteVecPush(out3, 0); - } else { - const v5: rs.usize = v4; - rs.byteVecPush(out3, 1); - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u128ToBeBytes(v5 as rs.u128))); - } - }; const buf: Uint8Array = rs.bytes(4); const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); @@ -856,6 +843,19 @@ export function usizeOp(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); const c: rs.usize = ([rs.usizeFromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.usize, rs.ByteSlice])[0]; const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 32); + const _68: (a0: rs.ByteVec, a1: rs.usize) => undefined = (out2: rs.ByteVec, v3: rs.usize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); + rs.byteVecPush(out2, rs.usizeFromBeBytes(rs.usizeToBeBytes(v3)) === v3 ? 1 : 0); + }; + const _69: (a0: rs.ByteVec, a1: rs.usize | undefined) => undefined = (out3: rs.ByteVec, v4: rs.usize | undefined): undefined => { + if (v4 === undefined) { + rs.byteVecPush(out3, 0); + } else { + const v5: rs.usize = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u128ToBeBytes(v5 as rs.u128))); + } + }; const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { _68(out, rs.usizeAdd(a, b)); @@ -989,19 +989,6 @@ export function usizeOp(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `op` to operands taken from `data`. */ export function i8Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _68: (a0: rs.ByteVec, a1: rs.i8) => undefined = (out2: rs.ByteVec, v3: rs.i8): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); - rs.byteVecPush(out2, rs.i8FromBeBytes(rs.i8ToBeBytes(v3)) === v3 ? 1 : 0); - }; - const _69: (a0: rs.ByteVec, a1: rs.i8 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.i8 | undefined): undefined => { - if (v4 === undefined) { - rs.byteVecPush(out3, 0); - } else { - const v5: rs.i8 = v4; - rs.byteVecPush(out3, 1); - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.i128ToBeBytes(v5 as rs.i128))); - } - }; const buf: Uint8Array = Uint8Array.of(0); const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); @@ -1019,6 +1006,19 @@ export function i8Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); const c: rs.i8 = ([rs.i8FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.i8, rs.ByteSlice])[0]; const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 8); + const _68: (a0: rs.ByteVec, a1: rs.i8) => undefined = (out2: rs.ByteVec, v3: rs.i8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); + rs.byteVecPush(out2, rs.i8FromBeBytes(rs.i8ToBeBytes(v3)) === v3 ? 1 : 0); + }; + const _69: (a0: rs.ByteVec, a1: rs.i8 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.i8 | undefined): undefined => { + if (v4 === undefined) { + rs.byteVecPush(out3, 0); + } else { + const v5: rs.i8 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.i128ToBeBytes(v5 as rs.i128))); + } + }; const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { _68(out, rs.i8Add(a, b)); @@ -1152,19 +1152,6 @@ export function i8Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `op` to operands taken from `data`. */ export function i16Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _68: (a0: rs.ByteVec, a1: rs.i16) => undefined = (out2: rs.ByteVec, v3: rs.i16): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); - rs.byteVecPush(out2, rs.i16FromBeBytes(rs.i16ToBeBytes(v3)) === v3 ? 1 : 0); - }; - const _69: (a0: rs.ByteVec, a1: rs.i16 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.i16 | undefined): undefined => { - if (v4 === undefined) { - rs.byteVecPush(out3, 0); - } else { - const v5: rs.i16 = v4; - rs.byteVecPush(out3, 1); - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.i128ToBeBytes(v5 as rs.i128))); - } - }; const buf: Uint8Array = rs.bytes(2); const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); @@ -1182,6 +1169,19 @@ export function i16Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); const c: rs.i16 = ([rs.i16FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.i16, rs.ByteSlice])[0]; const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 16); + const _68: (a0: rs.ByteVec, a1: rs.i16) => undefined = (out2: rs.ByteVec, v3: rs.i16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); + rs.byteVecPush(out2, rs.i16FromBeBytes(rs.i16ToBeBytes(v3)) === v3 ? 1 : 0); + }; + const _69: (a0: rs.ByteVec, a1: rs.i16 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.i16 | undefined): undefined => { + if (v4 === undefined) { + rs.byteVecPush(out3, 0); + } else { + const v5: rs.i16 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.i128ToBeBytes(v5 as rs.i128))); + } + }; const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { _68(out, rs.i16Add(a, b)); @@ -1315,19 +1315,6 @@ export function i16Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `op` to operands taken from `data`. */ export function i32Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _68: (a0: rs.ByteVec, a1: rs.i32) => undefined = (out2: rs.ByteVec, v3: rs.i32): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); - rs.byteVecPush(out2, rs.i32FromBeBytes(rs.i32ToBeBytes(v3)) === v3 ? 1 : 0); - }; - const _69: (a0: rs.ByteVec, a1: rs.i32 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.i32 | undefined): undefined => { - if (v4 === undefined) { - rs.byteVecPush(out3, 0); - } else { - const v5: rs.i32 = v4; - rs.byteVecPush(out3, 1); - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.i128ToBeBytes(v5 as rs.i128))); - } - }; const buf: Uint8Array = rs.bytes(4); const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); @@ -1345,6 +1332,19 @@ export function i32Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); const c: rs.i32 = ([rs.i32FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.i32, rs.ByteSlice])[0]; const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 32); + const _68: (a0: rs.ByteVec, a1: rs.i32) => undefined = (out2: rs.ByteVec, v3: rs.i32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); + rs.byteVecPush(out2, rs.i32FromBeBytes(rs.i32ToBeBytes(v3)) === v3 ? 1 : 0); + }; + const _69: (a0: rs.ByteVec, a1: rs.i32 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.i32 | undefined): undefined => { + if (v4 === undefined) { + rs.byteVecPush(out3, 0); + } else { + const v5: rs.i32 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.i128ToBeBytes(v5 as rs.i128))); + } + }; const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { _68(out, rs.i32Add(a, b)); @@ -1478,19 +1478,6 @@ export function i32Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `op` to operands taken from `data`. */ export function i64Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _68: (a0: rs.ByteVec, a1: rs.i64) => undefined = (out2: rs.ByteVec, v3: rs.i64): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i128Cast(v3)))); - rs.byteVecPush(out2, rs.i64Eq(rs.i64FromBeBytes(rs.i64ToBeBytes(v3)), v3) ? 1 : 0); - }; - const _69: (a0: rs.ByteVec, a1: rs.i64 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.i64 | undefined): undefined => { - if (v4 === undefined) { - rs.byteVecPush(out3, 0); - } else { - const v5: rs.i64 = v4; - rs.byteVecPush(out3, 1); - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i128Cast(v5)))); - } - }; const buf: Uint8Array = rs.bytes(8); const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); @@ -1508,15 +1495,28 @@ export function i64Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); const c: rs.i64 = ([rs.i64FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.i64, rs.ByteSlice])[0]; const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 64); - const _70: rs.u8 = rs.u8Rem(op, 32); - if (_70 === 0) { - _68(out, rs.i64Add(a, b)); - } else if (_70 === 1) { - _68(out, rs.i64Sub(a, b)); - } else if (_70 === 2) { - _68(out, rs.i64Mul(a, b)); - } else if (_70 === 3) { - _68(out, rs.i64Div(a, b)); + const _68: (a0: rs.ByteVec, a1: rs.i64) => undefined = (out2: rs.ByteVec, v3: rs.i64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i128Cast(v3)))); + rs.byteVecPush(out2, rs.i64Eq(rs.i64FromBeBytes(rs.i64ToBeBytes(v3)), v3) ? 1 : 0); + }; + const _69: (a0: rs.ByteVec, a1: rs.i64 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.i64 | undefined): undefined => { + if (v4 === undefined) { + rs.byteVecPush(out3, 0); + } else { + const v5: rs.i64 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i128Cast(v5)))); + } + }; + const _70: rs.u8 = rs.u8Rem(op, 32); + if (_70 === 0) { + _68(out, rs.i64Add(a, b)); + } else if (_70 === 1) { + _68(out, rs.i64Sub(a, b)); + } else if (_70 === 2) { + _68(out, rs.i64Mul(a, b)); + } else if (_70 === 3) { + _68(out, rs.i64Div(a, b)); } else if (_70 === 4) { _68(out, rs.i64Rem(a, b)); } else if (_70 === 5) { @@ -1641,19 +1641,6 @@ export function i64Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `op` to operands taken from `data`. */ export function i128Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _68: (a0: rs.ByteVec, a1: rs.i128) => undefined = (out2: rs.ByteVec, v3: rs.i128): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3))); - rs.byteVecPush(out2, rs.i128Eq(rs.i128FromBeBytes(rs.i128ToBeBytes(v3)), v3) ? 1 : 0); - }; - const _69: (a0: rs.ByteVec, a1: rs.i128 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.i128 | undefined): undefined => { - if (v4 === undefined) { - rs.byteVecPush(out3, 0); - } else { - const v5: rs.i128 = v4; - rs.byteVecPush(out3, 1); - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.i128ToBeBytes(v5))); - } - }; const buf: Uint8Array = rs.bytes(16); const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); @@ -1671,6 +1658,19 @@ export function i128Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); const c: rs.i128 = ([rs.i128FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.i128, rs.ByteSlice])[0]; const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 128); + const _68: (a0: rs.ByteVec, a1: rs.i128) => undefined = (out2: rs.ByteVec, v3: rs.i128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3))); + rs.byteVecPush(out2, rs.i128Eq(rs.i128FromBeBytes(rs.i128ToBeBytes(v3)), v3) ? 1 : 0); + }; + const _69: (a0: rs.ByteVec, a1: rs.i128 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.i128 | undefined): undefined => { + if (v4 === undefined) { + rs.byteVecPush(out3, 0); + } else { + const v5: rs.i128 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.i128ToBeBytes(v5))); + } + }; const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { _68(out, rs.i128Add(a, b)); @@ -1804,19 +1804,6 @@ export function i128Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `op` to operands taken from `data`. */ export function isizeOp(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _68: (a0: rs.ByteVec, a1: rs.isize) => undefined = (out2: rs.ByteVec, v3: rs.isize): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); - rs.byteVecPush(out2, rs.isizeFromBeBytes(rs.isizeToBeBytes(v3)) === v3 ? 1 : 0); - }; - const _69: (a0: rs.ByteVec, a1: rs.isize | undefined) => undefined = (out3: rs.ByteVec, v4: rs.isize | undefined): undefined => { - if (v4 === undefined) { - rs.byteVecPush(out3, 0); - } else { - const v5: rs.isize = v4; - rs.byteVecPush(out3, 1); - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.i128ToBeBytes(v5 as rs.i128))); - } - }; const buf: Uint8Array = rs.bytes(4); const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); @@ -1834,6 +1821,19 @@ export function isizeOp(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); const c: rs.isize = ([rs.isizeFromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.isize, rs.ByteSlice])[0]; const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 32); + const _68: (a0: rs.ByteVec, a1: rs.isize) => undefined = (out2: rs.ByteVec, v3: rs.isize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); + rs.byteVecPush(out2, rs.isizeFromBeBytes(rs.isizeToBeBytes(v3)) === v3 ? 1 : 0); + }; + const _69: (a0: rs.ByteVec, a1: rs.isize | undefined) => undefined = (out3: rs.ByteVec, v4: rs.isize | undefined): undefined => { + if (v4 === undefined) { + rs.byteVecPush(out3, 0); + } else { + const v5: rs.isize = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.i128ToBeBytes(v5 as rs.i128))); + } + }; const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { _68(out, rs.isizeAdd(a, b)); @@ -3021,2495 +3021,2481 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat let kind49!: rs.i32; let over48!: boolean; let max48!: rs.u8; - b0: { - const _4: rs.u8 = rs.u8Rem(kind, 12); - if (_4 === 0) { - if (dataLen !== 0) { - const first: rs.u8 = dataData[dataStart]; - const rest: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix: rs.u32 = rs.u32Add(2, rs.u32Rem(first as rs.u32, 35)); - const _15: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); - if (_15 === 0) { - const _19: rs.Result = rs.strFromUtf8(rest); - if (_19.ok) { - const iter: rs.Iter = rs.strChars(_19.value); - while (true) { - const _25: rs.char | rs.Done = iter.next(); - if (_25 === rs.DONE) { - break; - } - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_25, radix), 99)))); - } - const radix2: rs.u32 = radix; - const _40: rs.Result = num_fromStrRadix$1osjin2(_19.value, radix2); - if (_40.ok) { - const arg48 = _40.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg48, f)]).v); - } else { - const e: rs.ParseIntError = _40.error; - const _56: rs.IntErrorKind = e.kind; - if (_56 === "Empty") { - kind2 = 0; - } else if (_56 === "InvalidDigit") { - kind2 = 1; - } else if (_56 === "PosOverflow") { - kind2 = 2; - } else if (_56 === "NegOverflow") { - kind2 = 3; - } else { - kind2 = 4; - } - if (!(e.kind === "PosOverflow" as rs.IntErrorKind)) { - over = e.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over = true; - } - const _76: rs.IntErrorKind = e.kind; - const args287 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _76), (f: rs.Formatter) => rs.i32Display(kind2, f), (f: rs.Formatter) => rs.fmtBool(over, f)]; - put(out, rs.fmtFormat([args287[0], "|", args287[1], "|", args287[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args287[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args287[0]), "|", args287[3], "|", args287[4]]).v); - } - if (radix2 === 10) { - const parsed: rs.Result = parse$1brosjp(_19.value); - const from: rs.Result = num_fromStr$1t58fis(_19.value); - if (from.ok) { - max = rs.u8Mul(from.value === 255 ? 1 : 0, 4); - } else { - max = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed.ok ? 1 : 0, max)); + const _4: rs.u8 = rs.u8Rem(kind, 12); + if (_4 === 0) { + if (dataLen !== 0) { + const first: rs.u8 = dataData[dataStart]; + const rest: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix: rs.u32 = rs.u32Add(2, rs.u32Rem(first as rs.u32, 35)); + const _15: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); + if (_15 === 0) { + const _19: rs.Result = rs.strFromUtf8(rest); + if (_19.ok) { + const iter: rs.Iter = rs.strChars(_19.value); + while (true) { + const _25: rs.char | rs.Done = iter.next(); + if (_25 === rs.DONE) { + break; } + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_25, radix), 99)))); } - } else if (_15 === 1) { - const s: rs.String = rs.stringNew(); - for (const b of rs.byteSliceView(rest)) { - const _116: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _117: rs.usize = rs.usizeRem(b as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rs.idx(_116, _117); - rs.stringPush(s, _116.data[_116.start + _117] as rs.char); - } - const _128: string = s.v; - const radix3: rs.u32 = radix; - const _131: rs.Result = num_fromStrRadix$1osjin2(_128, radix3); - if (_131.ok) { - const arg47 = _131.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg47, f)]).v); + const radix2: rs.u32 = radix; + const _40: rs.Result = num_fromStrRadix$1osjin2(_19.value, radix2); + if (_40.ok) { + const arg48 = _40.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg48, f)]).v); } else { - const e2: rs.ParseIntError = _131.error; - const _147: rs.IntErrorKind = e2.kind; - if (_147 === "Empty") { - kind3 = 0; - } else if (_147 === "InvalidDigit") { - kind3 = 1; - } else if (_147 === "PosOverflow") { - kind3 = 2; - } else if (_147 === "NegOverflow") { - kind3 = 3; + const e: rs.ParseIntError = _40.error; + const _56: rs.IntErrorKind = e.kind; + if (_56 === "Empty") { + kind2 = 0; + } else if (_56 === "InvalidDigit") { + kind2 = 1; + } else if (_56 === "PosOverflow") { + kind2 = 2; + } else if (_56 === "NegOverflow") { + kind2 = 3; } else { - kind3 = 4; + kind2 = 4; } - if (!(e2.kind === "PosOverflow" as rs.IntErrorKind)) { - over2 = e2.kind !== "NegOverflow" as rs.IntErrorKind; + if (!(e.kind === "PosOverflow" as rs.IntErrorKind)) { + over = e.kind !== "NegOverflow" as rs.IntErrorKind; } else { - over2 = true; + over = true; } - const _167: rs.IntErrorKind = e2.kind; - const args285 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e2, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e2, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _167), (f: rs.Formatter) => rs.i32Display(kind3, f), (f: rs.Formatter) => rs.fmtBool(over2, f)]; - put(out, rs.fmtFormat([args285[0], "|", args285[1], "|", args285[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args285[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args285[0]), "|", args285[3], "|", args285[4]]).v); - } - if (radix3 === 10) { - const parsed2: rs.Result = parse$1brosjp(_128); - const from2: rs.Result = num_fromStr$1t58fis(_128); - if (from2.ok) { - max2 = rs.u8Mul(from2.value === 255 ? 1 : 0, 4); + const _76: rs.IntErrorKind = e.kind; + const args287 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _76), (f: rs.Formatter) => rs.i32Display(kind2, f), (f: rs.Formatter) => rs.fmtBool(over, f)]; + put(out, rs.fmtFormat([args287[0], "|", args287[1], "|", args287[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args287[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args287[0]), "|", args287[3], "|", args287[4]]).v); + } + if (radix2 === 10) { + const parsed: rs.Result = parse$1brosjp(_19.value); + const from: rs.Result = num_fromStr$1t58fis(_19.value); + if (from.ok) { + max = rs.u8Mul(from.value === 255 ? 1 : 0, 4); } else { - max2 = 2; + max = 2; } - rs.byteVecPush(out, rs.u8Add(parsed2.ok ? 1 : 0, max2)); + rs.byteVecPush(out, rs.u8Add(parsed.ok ? 1 : 0, max)); } + } + } else if (_15 === 1) { + const s: rs.String = rs.stringNew(); + for (const b of rs.byteSliceView(rest)) { + const _116: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _117: rs.usize = rs.usizeRem(b as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_116, _117); + rs.stringPush(s, _116.data[_116.start + _117] as rs.char); + } + const _128: string = s.v; + const radix3: rs.u32 = radix; + const _131: rs.Result = num_fromStrRadix$1osjin2(_128, radix3); + if (_131.ok) { + const arg47 = _131.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg47, f)]).v); } else { - if (_15 === 2) { - const iter3: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); - while (true) { - const _199: rs.u32 | rs.Done = iter3.next(); - if (_199 === rs.DONE) { - break b0; - } - const radix4: rs.u32 = _199; - for (const _207 of edges(255, 0, 8, radix4).items) { - const _215: string = _207.v; - const radix5: rs.u32 = radix4; - const _218: rs.Result = num_fromStrRadix$1osjin2(_215, radix5); - if (_218.ok) { - const arg46 = _218.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg46, f)]).v); - } else { - const e3: rs.ParseIntError = _218.error; - const _234: rs.IntErrorKind = e3.kind; - if (_234 === "Empty") { - kind4 = 0; - } else if (_234 === "InvalidDigit") { - kind4 = 1; - } else if (_234 === "PosOverflow") { - kind4 = 2; - } else if (_234 === "NegOverflow") { - kind4 = 3; - } else { - kind4 = 4; - } - if (!(e3.kind === "PosOverflow" as rs.IntErrorKind)) { - over3 = e3.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over3 = true; - } - const _254: rs.IntErrorKind = e3.kind; - const args283 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e3, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e3, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _254), (f: rs.Formatter) => rs.i32Display(kind4, f), (f: rs.Formatter) => rs.fmtBool(over3, f)]; - put(out, rs.fmtFormat([args283[0], "|", args283[1], "|", args283[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args283[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args283[0]), "|", args283[3], "|", args283[4]]).v); - } - if (radix5 === 10) { - const parsed3: rs.Result = parse$1brosjp(_215); - const from3: rs.Result = num_fromStr$1t58fis(_215); - if (from3.ok) { - max3 = rs.u8Mul(from3.value === 255 ? 1 : 0, 4); - } else { - max3 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed3.ok ? 1 : 0, max3)); - } - } - } - } - const radix6: rs.u32 = ((first as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest), 0) as rs.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest, 1), (b24: rs.u8): boolean => { - return (b24 & 1) === 1; - })) { - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix6), 99)))); + const e2: rs.ParseIntError = _131.error; + const _147: rs.IntErrorKind = e2.kind; + if (_147 === "Empty") { + kind3 = 0; + } else if (_147 === "InvalidDigit") { + kind3 = 1; + } else if (_147 === "PosOverflow") { + kind3 = 2; + } else if (_147 === "NegOverflow") { + kind3 = 3; + } else { + kind3 = 4; } - if (!(rest.length > 2)) { - text = rs.byteSliceFrom(Uint8Array.of()); + if (!(e2.kind === "PosOverflow" as rs.IntErrorKind)) { + over2 = e2.kind !== "NegOverflow" as rs.IntErrorKind; } else { - text = rs.byteSliceRange(rest, 2); - } - const _310: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text), "1"); - const radix7: rs.u32 = radix6; - const _315: rs.Result = num_fromStrRadix$1osjin2(_310, radix7); - if (_315.ok) { - const arg45 = _315.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg45, f)]).v); + over2 = true; + } + const _167: rs.IntErrorKind = e2.kind; + const args285 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e2, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e2, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _167), (f: rs.Formatter) => rs.i32Display(kind3, f), (f: rs.Formatter) => rs.fmtBool(over2, f)]; + put(out, rs.fmtFormat([args285[0], "|", args285[1], "|", args285[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args285[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args285[0]), "|", args285[3], "|", args285[4]]).v); + } + if (radix3 === 10) { + const parsed2: rs.Result = parse$1brosjp(_128); + const from2: rs.Result = num_fromStr$1t58fis(_128); + if (from2.ok) { + max2 = rs.u8Mul(from2.value === 255 ? 1 : 0, 4); } else { - const e4: rs.ParseIntError = _315.error; - const _331: rs.IntErrorKind = e4.kind; - if (_331 === "Empty") { - kind5 = 0; - } else if (_331 === "InvalidDigit") { - kind5 = 1; - } else if (_331 === "PosOverflow") { - kind5 = 2; - } else if (_331 === "NegOverflow") { - kind5 = 3; - } else { - kind5 = 4; - } - if (!(e4.kind === "PosOverflow" as rs.IntErrorKind)) { - over4 = e4.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over4 = true; - } - const _351: rs.IntErrorKind = e4.kind; - const args281 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e4, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e4, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _351), (f: rs.Formatter) => rs.i32Display(kind5, f), (f: rs.Formatter) => rs.fmtBool(over4, f)]; - put(out, rs.fmtFormat([args281[0], "|", args281[1], "|", args281[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args281[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args281[0]), "|", args281[3], "|", args281[4]]).v); - } - if (radix7 === 10) { - const parsed4: rs.Result = parse$1brosjp(_310); - const from4: rs.Result = num_fromStr$1t58fis(_310); - if (from4.ok) { - max4 = rs.u8Mul(from4.value === 255 ? 1 : 0, 4); - } else { - max4 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed4.ok ? 1 : 0, max4)); + max2 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed2.ok ? 1 : 0, max2)); } - } - } else if (_4 === 1) { - if (dataLen !== 0) { - const first2: rs.u8 = dataData[dataStart]; - const rest2: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix8: rs.u32 = rs.u32Add(2, rs.u32Rem(first2 as rs.u32, 35)); - const _389: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); - if (_389 === 0) { - const _393: rs.Result = rs.strFromUtf8(rest2); - if (_393.ok) { - const iter5: rs.Iter = rs.strChars(_393.value); - while (true) { - const _399: rs.char | rs.Done = iter5.next(); - if (_399 === rs.DONE) { - break; - } - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_399, radix8), 99)))); - } - const radix9: rs.u32 = radix8; - const _414: rs.Result = num_fromStrRadix$1wu02v6(_393.value, radix9); - if (_414.ok) { - const arg44 = _414.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg44, f)]).v); + } else if (_15 === 2) { + const iter3: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); + while (true) { + const _199: rs.u32 | rs.Done = iter3.next(); + if (_199 === rs.DONE) { + break; + } + const radix4: rs.u32 = _199; + for (const _207 of edges(255, 0, 8, radix4).items) { + const _215: string = _207.v; + const radix5: rs.u32 = radix4; + const _218: rs.Result = num_fromStrRadix$1osjin2(_215, radix5); + if (_218.ok) { + const arg46 = _218.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg46, f)]).v); } else { - const e5: rs.ParseIntError = _414.error; - const _430: rs.IntErrorKind = e5.kind; - if (_430 === "Empty") { - kind6 = 0; - } else if (_430 === "InvalidDigit") { - kind6 = 1; - } else if (_430 === "PosOverflow") { - kind6 = 2; - } else if (_430 === "NegOverflow") { - kind6 = 3; + const e3: rs.ParseIntError = _218.error; + const _234: rs.IntErrorKind = e3.kind; + if (_234 === "Empty") { + kind4 = 0; + } else if (_234 === "InvalidDigit") { + kind4 = 1; + } else if (_234 === "PosOverflow") { + kind4 = 2; + } else if (_234 === "NegOverflow") { + kind4 = 3; } else { - kind6 = 4; + kind4 = 4; } - if (!(e5.kind === "PosOverflow" as rs.IntErrorKind)) { - over5 = e5.kind !== "NegOverflow" as rs.IntErrorKind; + if (!(e3.kind === "PosOverflow" as rs.IntErrorKind)) { + over3 = e3.kind !== "NegOverflow" as rs.IntErrorKind; } else { - over5 = true; + over3 = true; } - const _450: rs.IntErrorKind = e5.kind; - const args279 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e5, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e5, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _450), (f: rs.Formatter) => rs.i32Display(kind6, f), (f: rs.Formatter) => rs.fmtBool(over5, f)]; - put(out, rs.fmtFormat([args279[0], "|", args279[1], "|", args279[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args279[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args279[0]), "|", args279[3], "|", args279[4]]).v); + const _254: rs.IntErrorKind = e3.kind; + const args283 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e3, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e3, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _254), (f: rs.Formatter) => rs.i32Display(kind4, f), (f: rs.Formatter) => rs.fmtBool(over3, f)]; + put(out, rs.fmtFormat([args283[0], "|", args283[1], "|", args283[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args283[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args283[0]), "|", args283[3], "|", args283[4]]).v); } - if (radix9 === 10) { - const parsed5: rs.Result = parse$0un0sth(_393.value); - const from5: rs.Result = num_fromStr$1gvvety(_393.value); - if (from5.ok) { - max5 = rs.u8Mul(from5.value === 65535 ? 1 : 0, 4); + if (radix5 === 10) { + const parsed3: rs.Result = parse$1brosjp(_215); + const from3: rs.Result = num_fromStr$1t58fis(_215); + if (from3.ok) { + max3 = rs.u8Mul(from3.value === 255 ? 1 : 0, 4); } else { - max5 = 2; + max3 = 2; } - rs.byteVecPush(out, rs.u8Add(parsed5.ok ? 1 : 0, max5)); + rs.byteVecPush(out, rs.u8Add(parsed3.ok ? 1 : 0, max3)); } } - } else if (_389 === 1) { - const s3: rs.String = rs.stringNew(); - for (const b2 of rs.byteSliceView(rest2)) { - const _490: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _491: rs.usize = rs.usizeRem(b2 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rs.idx(_490, _491); - rs.stringPush(s3, _490.data[_490.start + _491] as rs.char); - } - const _502: string = s3.v; - const radix10: rs.u32 = radix8; - const _505: rs.Result = num_fromStrRadix$1wu02v6(_502, radix10); - if (_505.ok) { - const arg43 = _505.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg43, f)]).v); + } + } else { + const radix6: rs.u32 = ((first as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest, 1), (b24: rs.u8): boolean => { + return (b24 & 1) === 1; + })) { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix6), 99)))); + } + if (!(rest.length > 2)) { + text = rs.byteSliceFrom(Uint8Array.of()); + } else { + text = rs.byteSliceRange(rest, 2); + } + const _310: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text), "1"); + const radix7: rs.u32 = radix6; + const _315: rs.Result = num_fromStrRadix$1osjin2(_310, radix7); + if (_315.ok) { + const arg45 = _315.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg45, f)]).v); + } else { + const e4: rs.ParseIntError = _315.error; + const _331: rs.IntErrorKind = e4.kind; + if (_331 === "Empty") { + kind5 = 0; + } else if (_331 === "InvalidDigit") { + kind5 = 1; + } else if (_331 === "PosOverflow") { + kind5 = 2; + } else if (_331 === "NegOverflow") { + kind5 = 3; } else { - const e6: rs.ParseIntError = _505.error; - const _521: rs.IntErrorKind = e6.kind; - if (_521 === "Empty") { - kind7 = 0; - } else if (_521 === "InvalidDigit") { - kind7 = 1; - } else if (_521 === "PosOverflow") { - kind7 = 2; - } else if (_521 === "NegOverflow") { - kind7 = 3; - } else { - kind7 = 4; + kind5 = 4; + } + if (!(e4.kind === "PosOverflow" as rs.IntErrorKind)) { + over4 = e4.kind !== "NegOverflow" as rs.IntErrorKind; + } else { + over4 = true; + } + const _351: rs.IntErrorKind = e4.kind; + const args281 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e4, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e4, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _351), (f: rs.Formatter) => rs.i32Display(kind5, f), (f: rs.Formatter) => rs.fmtBool(over4, f)]; + put(out, rs.fmtFormat([args281[0], "|", args281[1], "|", args281[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args281[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args281[0]), "|", args281[3], "|", args281[4]]).v); + } + if (radix7 === 10) { + const parsed4: rs.Result = parse$1brosjp(_310); + const from4: rs.Result = num_fromStr$1t58fis(_310); + if (from4.ok) { + max4 = rs.u8Mul(from4.value === 255 ? 1 : 0, 4); + } else { + max4 = 2; + } + rs.byteVecPush(out, rs.u8Add(parsed4.ok ? 1 : 0, max4)); + } + } + } + } else if (_4 === 1) { + if (dataLen !== 0) { + const first2: rs.u8 = dataData[dataStart]; + const rest2: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix8: rs.u32 = rs.u32Add(2, rs.u32Rem(first2 as rs.u32, 35)); + const _389: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); + if (_389 === 0) { + const _393: rs.Result = rs.strFromUtf8(rest2); + if (_393.ok) { + const iter5: rs.Iter = rs.strChars(_393.value); + while (true) { + const _399: rs.char | rs.Done = iter5.next(); + if (_399 === rs.DONE) { + break; } - if (!(e6.kind === "PosOverflow" as rs.IntErrorKind)) { - over6 = e6.kind !== "NegOverflow" as rs.IntErrorKind; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_399, radix8), 99)))); + } + const radix9: rs.u32 = radix8; + const _414: rs.Result = num_fromStrRadix$1wu02v6(_393.value, radix9); + if (_414.ok) { + const arg44 = _414.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg44, f)]).v); + } else { + const e5: rs.ParseIntError = _414.error; + const _430: rs.IntErrorKind = e5.kind; + if (_430 === "Empty") { + kind6 = 0; + } else if (_430 === "InvalidDigit") { + kind6 = 1; + } else if (_430 === "PosOverflow") { + kind6 = 2; + } else if (_430 === "NegOverflow") { + kind6 = 3; } else { - over6 = true; + kind6 = 4; } - const _541: rs.IntErrorKind = e6.kind; - const args277 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e6, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e6, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _541), (f: rs.Formatter) => rs.i32Display(kind7, f), (f: rs.Formatter) => rs.fmtBool(over6, f)]; - put(out, rs.fmtFormat([args277[0], "|", args277[1], "|", args277[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args277[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args277[0]), "|", args277[3], "|", args277[4]]).v); - } - if (radix10 === 10) { - const parsed6: rs.Result = parse$0un0sth(_502); - const from6: rs.Result = num_fromStr$1gvvety(_502); - if (from6.ok) { - max6 = rs.u8Mul(from6.value === 65535 ? 1 : 0, 4); + if (!(e5.kind === "PosOverflow" as rs.IntErrorKind)) { + over5 = e5.kind !== "NegOverflow" as rs.IntErrorKind; } else { - max6 = 2; + over5 = true; } - rs.byteVecPush(out, rs.u8Add(parsed6.ok ? 1 : 0, max6)); + const _450: rs.IntErrorKind = e5.kind; + const args279 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e5, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e5, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _450), (f: rs.Formatter) => rs.i32Display(kind6, f), (f: rs.Formatter) => rs.fmtBool(over5, f)]; + put(out, rs.fmtFormat([args279[0], "|", args279[1], "|", args279[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args279[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args279[0]), "|", args279[3], "|", args279[4]]).v); } - } else { - if (_389 === 2) { - const iter7: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); - while (true) { - const _573: rs.u32 | rs.Done = iter7.next(); - if (_573 === rs.DONE) { - break b0; - } - const radix11: rs.u32 = _573; - for (const _581 of edges(65535, 0, 16, radix11).items) { - const _589: string = _581.v; - const radix12: rs.u32 = radix11; - const _592: rs.Result = num_fromStrRadix$1wu02v6(_589, radix12); - if (_592.ok) { - const arg42 = _592.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg42, f)]).v); - } else { - const e7: rs.ParseIntError = _592.error; - const _608: rs.IntErrorKind = e7.kind; - if (_608 === "Empty") { - kind8 = 0; - } else if (_608 === "InvalidDigit") { - kind8 = 1; - } else if (_608 === "PosOverflow") { - kind8 = 2; - } else if (_608 === "NegOverflow") { - kind8 = 3; - } else { - kind8 = 4; - } - if (!(e7.kind === "PosOverflow" as rs.IntErrorKind)) { - over7 = e7.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over7 = true; - } - const _628: rs.IntErrorKind = e7.kind; - const args275 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e7, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e7, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _628), (f: rs.Formatter) => rs.i32Display(kind8, f), (f: rs.Formatter) => rs.fmtBool(over7, f)]; - put(out, rs.fmtFormat([args275[0], "|", args275[1], "|", args275[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args275[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args275[0]), "|", args275[3], "|", args275[4]]).v); - } - if (radix12 === 10) { - const parsed7: rs.Result = parse$0un0sth(_589); - const from7: rs.Result = num_fromStr$1gvvety(_589); - if (from7.ok) { - max7 = rs.u8Mul(from7.value === 65535 ? 1 : 0, 4); - } else { - max7 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed7.ok ? 1 : 0, max7)); - } - } + if (radix9 === 10) { + const parsed5: rs.Result = parse$0un0sth(_393.value); + const from5: rs.Result = num_fromStr$1gvvety(_393.value); + if (from5.ok) { + max5 = rs.u8Mul(from5.value === 65535 ? 1 : 0, 4); + } else { + max5 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed5.ok ? 1 : 0, max5)); } - const radix13: rs.u32 = ((first2 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest2), 0) as rs.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest2, 1), (b23: rs.u8): boolean => { - return (b23 & 1) === 1; - })) { - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix13), 99)))); + } + } else if (_389 === 1) { + const s3: rs.String = rs.stringNew(); + for (const b2 of rs.byteSliceView(rest2)) { + const _490: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _491: rs.usize = rs.usizeRem(b2 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_490, _491); + rs.stringPush(s3, _490.data[_490.start + _491] as rs.char); + } + const _502: string = s3.v; + const radix10: rs.u32 = radix8; + const _505: rs.Result = num_fromStrRadix$1wu02v6(_502, radix10); + if (_505.ok) { + const arg43 = _505.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg43, f)]).v); + } else { + const e6: rs.ParseIntError = _505.error; + const _521: rs.IntErrorKind = e6.kind; + if (_521 === "Empty") { + kind7 = 0; + } else if (_521 === "InvalidDigit") { + kind7 = 1; + } else if (_521 === "PosOverflow") { + kind7 = 2; + } else if (_521 === "NegOverflow") { + kind7 = 3; + } else { + kind7 = 4; } - if (!(rest2.length > 2)) { - text2 = rs.byteSliceFrom(Uint8Array.of()); + if (!(e6.kind === "PosOverflow" as rs.IntErrorKind)) { + over6 = e6.kind !== "NegOverflow" as rs.IntErrorKind; } else { - text2 = rs.byteSliceRange(rest2, 2); - } - const _684: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text2), "1"); - const radix14: rs.u32 = radix13; - const _689: rs.Result = num_fromStrRadix$1wu02v6(_684, radix14); - if (_689.ok) { - const arg41 = _689.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg41, f)]).v); + over6 = true; + } + const _541: rs.IntErrorKind = e6.kind; + const args277 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e6, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e6, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _541), (f: rs.Formatter) => rs.i32Display(kind7, f), (f: rs.Formatter) => rs.fmtBool(over6, f)]; + put(out, rs.fmtFormat([args277[0], "|", args277[1], "|", args277[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args277[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args277[0]), "|", args277[3], "|", args277[4]]).v); + } + if (radix10 === 10) { + const parsed6: rs.Result = parse$0un0sth(_502); + const from6: rs.Result = num_fromStr$1gvvety(_502); + if (from6.ok) { + max6 = rs.u8Mul(from6.value === 65535 ? 1 : 0, 4); } else { - const e8: rs.ParseIntError = _689.error; - const _705: rs.IntErrorKind = e8.kind; - if (_705 === "Empty") { - kind9 = 0; - } else if (_705 === "InvalidDigit") { - kind9 = 1; - } else if (_705 === "PosOverflow") { - kind9 = 2; - } else if (_705 === "NegOverflow") { - kind9 = 3; - } else { - kind9 = 4; - } - if (!(e8.kind === "PosOverflow" as rs.IntErrorKind)) { - over8 = e8.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over8 = true; - } - const _725: rs.IntErrorKind = e8.kind; - const args273 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e8, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e8, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _725), (f: rs.Formatter) => rs.i32Display(kind9, f), (f: rs.Formatter) => rs.fmtBool(over8, f)]; - put(out, rs.fmtFormat([args273[0], "|", args273[1], "|", args273[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args273[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args273[0]), "|", args273[3], "|", args273[4]]).v); - } - if (radix14 === 10) { - const parsed8: rs.Result = parse$0un0sth(_684); - const from8: rs.Result = num_fromStr$1gvvety(_684); - if (from8.ok) { - max8 = rs.u8Mul(from8.value === 65535 ? 1 : 0, 4); - } else { - max8 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed8.ok ? 1 : 0, max8)); + max6 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed6.ok ? 1 : 0, max6)); } - } - } else if (_4 === 2) { - if (dataLen !== 0) { - const first3: rs.u8 = dataData[dataStart]; - const rest3: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix15: rs.u32 = rs.u32Add(2, rs.u32Rem(first3 as rs.u32, 35)); - const _763: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); - if (_763 === 0) { - const _767: rs.Result = rs.strFromUtf8(rest3); - if (_767.ok) { - const iter9: rs.Iter = rs.strChars(_767.value); - while (true) { - const _773: rs.char | rs.Done = iter9.next(); - if (_773 === rs.DONE) { - break; - } - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_773, radix15), 99)))); - } - const radix16: rs.u32 = radix15; - const _788: rs.Result = num_fromStrRadix$1ftrr55(_767.value, radix16); - if (_788.ok) { - const arg40 = _788.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg40, f)]).v); + } else if (_389 === 2) { + const iter7: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); + while (true) { + const _573: rs.u32 | rs.Done = iter7.next(); + if (_573 === rs.DONE) { + break; + } + const radix11: rs.u32 = _573; + for (const _581 of edges(65535, 0, 16, radix11).items) { + const _589: string = _581.v; + const radix12: rs.u32 = radix11; + const _592: rs.Result = num_fromStrRadix$1wu02v6(_589, radix12); + if (_592.ok) { + const arg42 = _592.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg42, f)]).v); } else { - const e9: rs.ParseIntError = _788.error; - const _804: rs.IntErrorKind = e9.kind; - if (_804 === "Empty") { - kind10 = 0; - } else if (_804 === "InvalidDigit") { - kind10 = 1; - } else if (_804 === "PosOverflow") { - kind10 = 2; - } else if (_804 === "NegOverflow") { - kind10 = 3; + const e7: rs.ParseIntError = _592.error; + const _608: rs.IntErrorKind = e7.kind; + if (_608 === "Empty") { + kind8 = 0; + } else if (_608 === "InvalidDigit") { + kind8 = 1; + } else if (_608 === "PosOverflow") { + kind8 = 2; + } else if (_608 === "NegOverflow") { + kind8 = 3; } else { - kind10 = 4; + kind8 = 4; } - if (!(e9.kind === "PosOverflow" as rs.IntErrorKind)) { - over9 = e9.kind !== "NegOverflow" as rs.IntErrorKind; + if (!(e7.kind === "PosOverflow" as rs.IntErrorKind)) { + over7 = e7.kind !== "NegOverflow" as rs.IntErrorKind; } else { - over9 = true; + over7 = true; } - const _824: rs.IntErrorKind = e9.kind; - const args271 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e9, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e9, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _824), (f: rs.Formatter) => rs.i32Display(kind10, f), (f: rs.Formatter) => rs.fmtBool(over9, f)]; - put(out, rs.fmtFormat([args271[0], "|", args271[1], "|", args271[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args271[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args271[0]), "|", args271[3], "|", args271[4]]).v); + const _628: rs.IntErrorKind = e7.kind; + const args275 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e7, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e7, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _628), (f: rs.Formatter) => rs.i32Display(kind8, f), (f: rs.Formatter) => rs.fmtBool(over7, f)]; + put(out, rs.fmtFormat([args275[0], "|", args275[1], "|", args275[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args275[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args275[0]), "|", args275[3], "|", args275[4]]).v); } - if (radix16 === 10) { - const parsed9: rs.Result = parse$069xxen(_767.value); - const from9: rs.Result = num_fromStr$1rjp7t4(_767.value); - if (from9.ok) { - max9 = rs.u8Mul(from9.value === 4294967295 ? 1 : 0, 4); + if (radix12 === 10) { + const parsed7: rs.Result = parse$0un0sth(_589); + const from7: rs.Result = num_fromStr$1gvvety(_589); + if (from7.ok) { + max7 = rs.u8Mul(from7.value === 65535 ? 1 : 0, 4); } else { - max9 = 2; + max7 = 2; } - rs.byteVecPush(out, rs.u8Add(parsed9.ok ? 1 : 0, max9)); + rs.byteVecPush(out, rs.u8Add(parsed7.ok ? 1 : 0, max7)); } } - } else if (_763 === 1) { - const s5: rs.String = rs.stringNew(); - for (const b3 of rs.byteSliceView(rest3)) { - const _864: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _865: rs.usize = rs.usizeRem(b3 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rs.idx(_864, _865); - rs.stringPush(s5, _864.data[_864.start + _865] as rs.char); - } - const _876: string = s5.v; - const radix17: rs.u32 = radix15; - const _879: rs.Result = num_fromStrRadix$1ftrr55(_876, radix17); - if (_879.ok) { - const arg39 = _879.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg39, f)]).v); + } + } else { + const radix13: rs.u32 = ((first2 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest2), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest2, 1), (b23: rs.u8): boolean => { + return (b23 & 1) === 1; + })) { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix13), 99)))); + } + if (!(rest2.length > 2)) { + text2 = rs.byteSliceFrom(Uint8Array.of()); + } else { + text2 = rs.byteSliceRange(rest2, 2); + } + const _684: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text2), "1"); + const radix14: rs.u32 = radix13; + const _689: rs.Result = num_fromStrRadix$1wu02v6(_684, radix14); + if (_689.ok) { + const arg41 = _689.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg41, f)]).v); + } else { + const e8: rs.ParseIntError = _689.error; + const _705: rs.IntErrorKind = e8.kind; + if (_705 === "Empty") { + kind9 = 0; + } else if (_705 === "InvalidDigit") { + kind9 = 1; + } else if (_705 === "PosOverflow") { + kind9 = 2; + } else if (_705 === "NegOverflow") { + kind9 = 3; } else { - const e10: rs.ParseIntError = _879.error; - const _895: rs.IntErrorKind = e10.kind; - if (_895 === "Empty") { - kind11 = 0; - } else if (_895 === "InvalidDigit") { - kind11 = 1; - } else if (_895 === "PosOverflow") { - kind11 = 2; - } else if (_895 === "NegOverflow") { - kind11 = 3; - } else { - kind11 = 4; + kind9 = 4; + } + if (!(e8.kind === "PosOverflow" as rs.IntErrorKind)) { + over8 = e8.kind !== "NegOverflow" as rs.IntErrorKind; + } else { + over8 = true; + } + const _725: rs.IntErrorKind = e8.kind; + const args273 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e8, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e8, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _725), (f: rs.Formatter) => rs.i32Display(kind9, f), (f: rs.Formatter) => rs.fmtBool(over8, f)]; + put(out, rs.fmtFormat([args273[0], "|", args273[1], "|", args273[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args273[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args273[0]), "|", args273[3], "|", args273[4]]).v); + } + if (radix14 === 10) { + const parsed8: rs.Result = parse$0un0sth(_684); + const from8: rs.Result = num_fromStr$1gvvety(_684); + if (from8.ok) { + max8 = rs.u8Mul(from8.value === 65535 ? 1 : 0, 4); + } else { + max8 = 2; + } + rs.byteVecPush(out, rs.u8Add(parsed8.ok ? 1 : 0, max8)); + } + } + } + } else if (_4 === 2) { + if (dataLen !== 0) { + const first3: rs.u8 = dataData[dataStart]; + const rest3: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix15: rs.u32 = rs.u32Add(2, rs.u32Rem(first3 as rs.u32, 35)); + const _763: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); + if (_763 === 0) { + const _767: rs.Result = rs.strFromUtf8(rest3); + if (_767.ok) { + const iter9: rs.Iter = rs.strChars(_767.value); + while (true) { + const _773: rs.char | rs.Done = iter9.next(); + if (_773 === rs.DONE) { + break; } - if (!(e10.kind === "PosOverflow" as rs.IntErrorKind)) { - over10 = e10.kind !== "NegOverflow" as rs.IntErrorKind; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_773, radix15), 99)))); + } + const radix16: rs.u32 = radix15; + const _788: rs.Result = num_fromStrRadix$1ftrr55(_767.value, radix16); + if (_788.ok) { + const arg40 = _788.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg40, f)]).v); + } else { + const e9: rs.ParseIntError = _788.error; + const _804: rs.IntErrorKind = e9.kind; + if (_804 === "Empty") { + kind10 = 0; + } else if (_804 === "InvalidDigit") { + kind10 = 1; + } else if (_804 === "PosOverflow") { + kind10 = 2; + } else if (_804 === "NegOverflow") { + kind10 = 3; } else { - over10 = true; + kind10 = 4; } - const _915: rs.IntErrorKind = e10.kind; - const args269 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e10, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e10, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _915), (f: rs.Formatter) => rs.i32Display(kind11, f), (f: rs.Formatter) => rs.fmtBool(over10, f)]; - put(out, rs.fmtFormat([args269[0], "|", args269[1], "|", args269[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args269[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args269[0]), "|", args269[3], "|", args269[4]]).v); - } - if (radix17 === 10) { - const parsed10: rs.Result = parse$069xxen(_876); - const from10: rs.Result = num_fromStr$1rjp7t4(_876); - if (from10.ok) { - max10 = rs.u8Mul(from10.value === 4294967295 ? 1 : 0, 4); + if (!(e9.kind === "PosOverflow" as rs.IntErrorKind)) { + over9 = e9.kind !== "NegOverflow" as rs.IntErrorKind; } else { - max10 = 2; + over9 = true; } - rs.byteVecPush(out, rs.u8Add(parsed10.ok ? 1 : 0, max10)); + const _824: rs.IntErrorKind = e9.kind; + const args271 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e9, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e9, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _824), (f: rs.Formatter) => rs.i32Display(kind10, f), (f: rs.Formatter) => rs.fmtBool(over9, f)]; + put(out, rs.fmtFormat([args271[0], "|", args271[1], "|", args271[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args271[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args271[0]), "|", args271[3], "|", args271[4]]).v); } - } else { - if (_763 === 2) { - const iter11: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); - while (true) { - const _947: rs.u32 | rs.Done = iter11.next(); - if (_947 === rs.DONE) { - break b0; - } - const radix18: rs.u32 = _947; - for (const _955 of edges(4294967295, 0, 32, radix18).items) { - const _963: string = _955.v; - const radix19: rs.u32 = radix18; - const _966: rs.Result = num_fromStrRadix$1ftrr55(_963, radix19); - if (_966.ok) { - const arg38 = _966.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg38, f)]).v); - } else { - const e11: rs.ParseIntError = _966.error; - const _982: rs.IntErrorKind = e11.kind; - if (_982 === "Empty") { - kind12 = 0; - } else if (_982 === "InvalidDigit") { - kind12 = 1; - } else if (_982 === "PosOverflow") { - kind12 = 2; - } else if (_982 === "NegOverflow") { - kind12 = 3; - } else { - kind12 = 4; - } - if (!(e11.kind === "PosOverflow" as rs.IntErrorKind)) { - over11 = e11.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over11 = true; - } - const _1002: rs.IntErrorKind = e11.kind; - const args267 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e11, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e11, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1002), (f: rs.Formatter) => rs.i32Display(kind12, f), (f: rs.Formatter) => rs.fmtBool(over11, f)]; - put(out, rs.fmtFormat([args267[0], "|", args267[1], "|", args267[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args267[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args267[0]), "|", args267[3], "|", args267[4]]).v); - } - if (radix19 === 10) { - const parsed11: rs.Result = parse$069xxen(_963); - const from11: rs.Result = num_fromStr$1rjp7t4(_963); - if (from11.ok) { - max11 = rs.u8Mul(from11.value === 4294967295 ? 1 : 0, 4); - } else { - max11 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed11.ok ? 1 : 0, max11)); - } - } + if (radix16 === 10) { + const parsed9: rs.Result = parse$069xxen(_767.value); + const from9: rs.Result = num_fromStr$1rjp7t4(_767.value); + if (from9.ok) { + max9 = rs.u8Mul(from9.value === 4294967295 ? 1 : 0, 4); + } else { + max9 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed9.ok ? 1 : 0, max9)); } - const radix20: rs.u32 = ((first3 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest3), 0) as rs.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest3, 1), (b22: rs.u8): boolean => { - return (b22 & 1) === 1; - })) { - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix20), 99)))); + } + } else if (_763 === 1) { + const s5: rs.String = rs.stringNew(); + for (const b3 of rs.byteSliceView(rest3)) { + const _864: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _865: rs.usize = rs.usizeRem(b3 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_864, _865); + rs.stringPush(s5, _864.data[_864.start + _865] as rs.char); + } + const _876: string = s5.v; + const radix17: rs.u32 = radix15; + const _879: rs.Result = num_fromStrRadix$1ftrr55(_876, radix17); + if (_879.ok) { + const arg39 = _879.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg39, f)]).v); + } else { + const e10: rs.ParseIntError = _879.error; + const _895: rs.IntErrorKind = e10.kind; + if (_895 === "Empty") { + kind11 = 0; + } else if (_895 === "InvalidDigit") { + kind11 = 1; + } else if (_895 === "PosOverflow") { + kind11 = 2; + } else if (_895 === "NegOverflow") { + kind11 = 3; + } else { + kind11 = 4; } - if (!(rest3.length > 2)) { - text3 = rs.byteSliceFrom(Uint8Array.of()); + if (!(e10.kind === "PosOverflow" as rs.IntErrorKind)) { + over10 = e10.kind !== "NegOverflow" as rs.IntErrorKind; } else { - text3 = rs.byteSliceRange(rest3, 2); - } - const _1058: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text3), "1"); - const radix21: rs.u32 = radix20; - const _1063: rs.Result = num_fromStrRadix$1ftrr55(_1058, radix21); - if (_1063.ok) { - const arg37 = _1063.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg37, f)]).v); + over10 = true; + } + const _915: rs.IntErrorKind = e10.kind; + const args269 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e10, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e10, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _915), (f: rs.Formatter) => rs.i32Display(kind11, f), (f: rs.Formatter) => rs.fmtBool(over10, f)]; + put(out, rs.fmtFormat([args269[0], "|", args269[1], "|", args269[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args269[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args269[0]), "|", args269[3], "|", args269[4]]).v); + } + if (radix17 === 10) { + const parsed10: rs.Result = parse$069xxen(_876); + const from10: rs.Result = num_fromStr$1rjp7t4(_876); + if (from10.ok) { + max10 = rs.u8Mul(from10.value === 4294967295 ? 1 : 0, 4); } else { - const e12: rs.ParseIntError = _1063.error; - const _1079: rs.IntErrorKind = e12.kind; - if (_1079 === "Empty") { - kind13 = 0; - } else if (_1079 === "InvalidDigit") { - kind13 = 1; - } else if (_1079 === "PosOverflow") { - kind13 = 2; - } else if (_1079 === "NegOverflow") { - kind13 = 3; - } else { - kind13 = 4; - } - if (!(e12.kind === "PosOverflow" as rs.IntErrorKind)) { - over12 = e12.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over12 = true; - } - const _1099: rs.IntErrorKind = e12.kind; - const args265 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e12, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e12, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1099), (f: rs.Formatter) => rs.i32Display(kind13, f), (f: rs.Formatter) => rs.fmtBool(over12, f)]; - put(out, rs.fmtFormat([args265[0], "|", args265[1], "|", args265[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args265[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args265[0]), "|", args265[3], "|", args265[4]]).v); - } - if (radix21 === 10) { - const parsed12: rs.Result = parse$069xxen(_1058); - const from12: rs.Result = num_fromStr$1rjp7t4(_1058); - if (from12.ok) { - max12 = rs.u8Mul(from12.value === 4294967295 ? 1 : 0, 4); - } else { - max12 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed12.ok ? 1 : 0, max12)); + max10 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed10.ok ? 1 : 0, max10)); } - } - } else if (_4 === 3) { - if (dataLen !== 0) { - const first4: rs.u8 = dataData[dataStart]; - const rest4: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix22: rs.u32 = rs.u32Add(2, rs.u32Rem(first4 as rs.u32, 35)); - const _1137: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); - if (_1137 === 0) { - const _1141: rs.Result = rs.strFromUtf8(rest4); - if (_1141.ok) { - const iter13: rs.Iter = rs.strChars(_1141.value); - while (true) { - const _1147: rs.char | rs.Done = iter13.next(); - if (_1147 === rs.DONE) { - break; - } - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_1147, radix22), 99)))); - } - const radix23: rs.u32 = radix22; - const _1162: rs.Result = num_fromStrRadix$0al5jri(_1141.value, radix23); - if (_1162.ok) { - const arg36 = _1162.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg36, f)]).v); + } else if (_763 === 2) { + const iter11: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); + while (true) { + const _947: rs.u32 | rs.Done = iter11.next(); + if (_947 === rs.DONE) { + break; + } + const radix18: rs.u32 = _947; + for (const _955 of edges(4294967295, 0, 32, radix18).items) { + const _963: string = _955.v; + const radix19: rs.u32 = radix18; + const _966: rs.Result = num_fromStrRadix$1ftrr55(_963, radix19); + if (_966.ok) { + const arg38 = _966.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg38, f)]).v); } else { - const e13: rs.ParseIntError = _1162.error; - const _1178: rs.IntErrorKind = e13.kind; - if (_1178 === "Empty") { - kind14 = 0; - } else if (_1178 === "InvalidDigit") { - kind14 = 1; - } else if (_1178 === "PosOverflow") { - kind14 = 2; - } else if (_1178 === "NegOverflow") { - kind14 = 3; + const e11: rs.ParseIntError = _966.error; + const _982: rs.IntErrorKind = e11.kind; + if (_982 === "Empty") { + kind12 = 0; + } else if (_982 === "InvalidDigit") { + kind12 = 1; + } else if (_982 === "PosOverflow") { + kind12 = 2; + } else if (_982 === "NegOverflow") { + kind12 = 3; } else { - kind14 = 4; + kind12 = 4; } - if (!(e13.kind === "PosOverflow" as rs.IntErrorKind)) { - over13 = e13.kind !== "NegOverflow" as rs.IntErrorKind; + if (!(e11.kind === "PosOverflow" as rs.IntErrorKind)) { + over11 = e11.kind !== "NegOverflow" as rs.IntErrorKind; } else { - over13 = true; + over11 = true; } - const _1198: rs.IntErrorKind = e13.kind; - const args263 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e13, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e13, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1198), (f: rs.Formatter) => rs.i32Display(kind14, f), (f: rs.Formatter) => rs.fmtBool(over13, f)]; - put(out, rs.fmtFormat([args263[0], "|", args263[1], "|", args263[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args263[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args263[0]), "|", args263[3], "|", args263[4]]).v); + const _1002: rs.IntErrorKind = e11.kind; + const args267 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e11, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e11, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1002), (f: rs.Formatter) => rs.i32Display(kind12, f), (f: rs.Formatter) => rs.fmtBool(over11, f)]; + put(out, rs.fmtFormat([args267[0], "|", args267[1], "|", args267[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args267[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args267[0]), "|", args267[3], "|", args267[4]]).v); } - if (radix23 === 10) { - const parsed13: rs.Result = parse$092epd5(_1141.value); - const from13: rs.Result = num_fromStr$0bkyuqf(_1141.value); - if (from13.ok) { - max13 = rs.u8Mul(rs.u64Eq(from13.value, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64) ? 1 : 0, 4); + if (radix19 === 10) { + const parsed11: rs.Result = parse$069xxen(_963); + const from11: rs.Result = num_fromStr$1rjp7t4(_963); + if (from11.ok) { + max11 = rs.u8Mul(from11.value === 4294967295 ? 1 : 0, 4); } else { - max13 = 2; + max11 = 2; } - rs.byteVecPush(out, rs.u8Add(parsed13.ok ? 1 : 0, max13)); + rs.byteVecPush(out, rs.u8Add(parsed11.ok ? 1 : 0, max11)); } } - } else if (_1137 === 1) { - const s7: rs.String = rs.stringNew(); - for (const b4 of rs.byteSliceView(rest4)) { - const _1238: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _1239: rs.usize = rs.usizeRem(b4 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rs.idx(_1238, _1239); - rs.stringPush(s7, _1238.data[_1238.start + _1239] as rs.char); - } - const _1250: string = s7.v; - const radix24: rs.u32 = radix22; - const _1253: rs.Result = num_fromStrRadix$0al5jri(_1250, radix24); - if (_1253.ok) { - const arg35 = _1253.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg35, f)]).v); + } + } else { + const radix20: rs.u32 = ((first3 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest3), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest3, 1), (b22: rs.u8): boolean => { + return (b22 & 1) === 1; + })) { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix20), 99)))); + } + if (!(rest3.length > 2)) { + text3 = rs.byteSliceFrom(Uint8Array.of()); + } else { + text3 = rs.byteSliceRange(rest3, 2); + } + const _1058: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text3), "1"); + const radix21: rs.u32 = radix20; + const _1063: rs.Result = num_fromStrRadix$1ftrr55(_1058, radix21); + if (_1063.ok) { + const arg37 = _1063.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg37, f)]).v); + } else { + const e12: rs.ParseIntError = _1063.error; + const _1079: rs.IntErrorKind = e12.kind; + if (_1079 === "Empty") { + kind13 = 0; + } else if (_1079 === "InvalidDigit") { + kind13 = 1; + } else if (_1079 === "PosOverflow") { + kind13 = 2; + } else if (_1079 === "NegOverflow") { + kind13 = 3; + } else { + kind13 = 4; + } + if (!(e12.kind === "PosOverflow" as rs.IntErrorKind)) { + over12 = e12.kind !== "NegOverflow" as rs.IntErrorKind; } else { - const e14: rs.ParseIntError = _1253.error; - const _1269: rs.IntErrorKind = e14.kind; - if (_1269 === "Empty") { - kind15 = 0; - } else if (_1269 === "InvalidDigit") { - kind15 = 1; - } else if (_1269 === "PosOverflow") { - kind15 = 2; - } else if (_1269 === "NegOverflow") { - kind15 = 3; - } else { - kind15 = 4; + over12 = true; + } + const _1099: rs.IntErrorKind = e12.kind; + const args265 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e12, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e12, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1099), (f: rs.Formatter) => rs.i32Display(kind13, f), (f: rs.Formatter) => rs.fmtBool(over12, f)]; + put(out, rs.fmtFormat([args265[0], "|", args265[1], "|", args265[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args265[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args265[0]), "|", args265[3], "|", args265[4]]).v); + } + if (radix21 === 10) { + const parsed12: rs.Result = parse$069xxen(_1058); + const from12: rs.Result = num_fromStr$1rjp7t4(_1058); + if (from12.ok) { + max12 = rs.u8Mul(from12.value === 4294967295 ? 1 : 0, 4); + } else { + max12 = 2; + } + rs.byteVecPush(out, rs.u8Add(parsed12.ok ? 1 : 0, max12)); + } + } + } + } else if (_4 === 3) { + if (dataLen !== 0) { + const first4: rs.u8 = dataData[dataStart]; + const rest4: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix22: rs.u32 = rs.u32Add(2, rs.u32Rem(first4 as rs.u32, 35)); + const _1137: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); + if (_1137 === 0) { + const _1141: rs.Result = rs.strFromUtf8(rest4); + if (_1141.ok) { + const iter13: rs.Iter = rs.strChars(_1141.value); + while (true) { + const _1147: rs.char | rs.Done = iter13.next(); + if (_1147 === rs.DONE) { + break; } - if (!(e14.kind === "PosOverflow" as rs.IntErrorKind)) { - over14 = e14.kind !== "NegOverflow" as rs.IntErrorKind; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_1147, radix22), 99)))); + } + const radix23: rs.u32 = radix22; + const _1162: rs.Result = num_fromStrRadix$0al5jri(_1141.value, radix23); + if (_1162.ok) { + const arg36 = _1162.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg36, f)]).v); + } else { + const e13: rs.ParseIntError = _1162.error; + const _1178: rs.IntErrorKind = e13.kind; + if (_1178 === "Empty") { + kind14 = 0; + } else if (_1178 === "InvalidDigit") { + kind14 = 1; + } else if (_1178 === "PosOverflow") { + kind14 = 2; + } else if (_1178 === "NegOverflow") { + kind14 = 3; } else { - over14 = true; + kind14 = 4; } - const _1289: rs.IntErrorKind = e14.kind; - const args261 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e14, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e14, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1289), (f: rs.Formatter) => rs.i32Display(kind15, f), (f: rs.Formatter) => rs.fmtBool(over14, f)]; - put(out, rs.fmtFormat([args261[0], "|", args261[1], "|", args261[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args261[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args261[0]), "|", args261[3], "|", args261[4]]).v); - } - if (radix24 === 10) { - const parsed14: rs.Result = parse$092epd5(_1250); - const from14: rs.Result = num_fromStr$0bkyuqf(_1250); - if (from14.ok) { - max14 = rs.u8Mul(rs.u64Eq(from14.value, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64) ? 1 : 0, 4); + if (!(e13.kind === "PosOverflow" as rs.IntErrorKind)) { + over13 = e13.kind !== "NegOverflow" as rs.IntErrorKind; } else { - max14 = 2; + over13 = true; } - rs.byteVecPush(out, rs.u8Add(parsed14.ok ? 1 : 0, max14)); + const _1198: rs.IntErrorKind = e13.kind; + const args263 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e13, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e13, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1198), (f: rs.Formatter) => rs.i32Display(kind14, f), (f: rs.Formatter) => rs.fmtBool(over13, f)]; + put(out, rs.fmtFormat([args263[0], "|", args263[1], "|", args263[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args263[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args263[0]), "|", args263[3], "|", args263[4]]).v); } - } else { - if (_1137 === 2) { - const iter15: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); - while (true) { - const _1321: rs.u32 | rs.Done = iter15.next(); - if (_1321 === rs.DONE) { - break b0; - } - const radix25: rs.u32 = _1321; - for (const _1329 of edges({ hi: 0, w2: 0, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, 0, 64, radix25).items) { - const _1337: string = _1329.v; - const radix26: rs.u32 = radix25; - const _1340: rs.Result = num_fromStrRadix$0al5jri(_1337, radix26); - if (_1340.ok) { - const arg34 = _1340.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg34, f)]).v); - } else { - const e15: rs.ParseIntError = _1340.error; - const _1356: rs.IntErrorKind = e15.kind; - if (_1356 === "Empty") { - kind16 = 0; - } else if (_1356 === "InvalidDigit") { - kind16 = 1; - } else if (_1356 === "PosOverflow") { - kind16 = 2; - } else if (_1356 === "NegOverflow") { - kind16 = 3; - } else { - kind16 = 4; - } - if (!(e15.kind === "PosOverflow" as rs.IntErrorKind)) { - over15 = e15.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over15 = true; - } - const _1376: rs.IntErrorKind = e15.kind; - const args259 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e15, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e15, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1376), (f: rs.Formatter) => rs.i32Display(kind16, f), (f: rs.Formatter) => rs.fmtBool(over15, f)]; - put(out, rs.fmtFormat([args259[0], "|", args259[1], "|", args259[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args259[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args259[0]), "|", args259[3], "|", args259[4]]).v); - } - if (radix26 === 10) { - const parsed15: rs.Result = parse$092epd5(_1337); - const from15: rs.Result = num_fromStr$0bkyuqf(_1337); - if (from15.ok) { - max15 = rs.u8Mul(rs.u64Eq(from15.value, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64) ? 1 : 0, 4); - } else { - max15 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed15.ok ? 1 : 0, max15)); - } - } + if (radix23 === 10) { + const parsed13: rs.Result = parse$092epd5(_1141.value); + const from13: rs.Result = num_fromStr$0bkyuqf(_1141.value); + if (from13.ok) { + max13 = rs.u8Mul(rs.u64Eq(from13.value, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64) ? 1 : 0, 4); + } else { + max13 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed13.ok ? 1 : 0, max13)); } - const radix27: rs.u32 = ((first4 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest4), 0) as rs.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest4, 1), (b21: rs.u8): boolean => { - return (b21 & 1) === 1; - })) { - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix27), 99)))); + } + } else if (_1137 === 1) { + const s7: rs.String = rs.stringNew(); + for (const b4 of rs.byteSliceView(rest4)) { + const _1238: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _1239: rs.usize = rs.usizeRem(b4 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_1238, _1239); + rs.stringPush(s7, _1238.data[_1238.start + _1239] as rs.char); + } + const _1250: string = s7.v; + const radix24: rs.u32 = radix22; + const _1253: rs.Result = num_fromStrRadix$0al5jri(_1250, radix24); + if (_1253.ok) { + const arg35 = _1253.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg35, f)]).v); + } else { + const e14: rs.ParseIntError = _1253.error; + const _1269: rs.IntErrorKind = e14.kind; + if (_1269 === "Empty") { + kind15 = 0; + } else if (_1269 === "InvalidDigit") { + kind15 = 1; + } else if (_1269 === "PosOverflow") { + kind15 = 2; + } else if (_1269 === "NegOverflow") { + kind15 = 3; + } else { + kind15 = 4; } - if (!(rest4.length > 2)) { - text4 = rs.byteSliceFrom(Uint8Array.of()); + if (!(e14.kind === "PosOverflow" as rs.IntErrorKind)) { + over14 = e14.kind !== "NegOverflow" as rs.IntErrorKind; } else { - text4 = rs.byteSliceRange(rest4, 2); - } - const _1432: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text4), "1"); - const radix28: rs.u32 = radix27; - const _1437: rs.Result = num_fromStrRadix$0al5jri(_1432, radix28); - if (_1437.ok) { - const arg33 = _1437.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg33, f)]).v); + over14 = true; + } + const _1289: rs.IntErrorKind = e14.kind; + const args261 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e14, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e14, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1289), (f: rs.Formatter) => rs.i32Display(kind15, f), (f: rs.Formatter) => rs.fmtBool(over14, f)]; + put(out, rs.fmtFormat([args261[0], "|", args261[1], "|", args261[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args261[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args261[0]), "|", args261[3], "|", args261[4]]).v); + } + if (radix24 === 10) { + const parsed14: rs.Result = parse$092epd5(_1250); + const from14: rs.Result = num_fromStr$0bkyuqf(_1250); + if (from14.ok) { + max14 = rs.u8Mul(rs.u64Eq(from14.value, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64) ? 1 : 0, 4); } else { - const e16: rs.ParseIntError = _1437.error; - const _1453: rs.IntErrorKind = e16.kind; - if (_1453 === "Empty") { - kind17 = 0; - } else if (_1453 === "InvalidDigit") { - kind17 = 1; - } else if (_1453 === "PosOverflow") { - kind17 = 2; - } else if (_1453 === "NegOverflow") { - kind17 = 3; - } else { - kind17 = 4; - } - if (!(e16.kind === "PosOverflow" as rs.IntErrorKind)) { - over16 = e16.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over16 = true; - } - const _1473: rs.IntErrorKind = e16.kind; - const args257 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e16, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e16, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1473), (f: rs.Formatter) => rs.i32Display(kind17, f), (f: rs.Formatter) => rs.fmtBool(over16, f)]; - put(out, rs.fmtFormat([args257[0], "|", args257[1], "|", args257[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args257[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args257[0]), "|", args257[3], "|", args257[4]]).v); - } - if (radix28 === 10) { - const parsed16: rs.Result = parse$092epd5(_1432); - const from16: rs.Result = num_fromStr$0bkyuqf(_1432); - if (from16.ok) { - max16 = rs.u8Mul(rs.u64Eq(from16.value, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64) ? 1 : 0, 4); - } else { - max16 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed16.ok ? 1 : 0, max16)); + max14 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed14.ok ? 1 : 0, max14)); } - } - } else if (_4 === 4) { - if (dataLen !== 0) { - const first5: rs.u8 = dataData[dataStart]; - const rest5: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix29: rs.u32 = rs.u32Add(2, rs.u32Rem(first5 as rs.u32, 35)); - const _1511: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); - if (_1511 === 0) { - const _1515: rs.Result = rs.strFromUtf8(rest5); - if (_1515.ok) { - const iter17: rs.Iter = rs.strChars(_1515.value); - while (true) { - const _1521: rs.char | rs.Done = iter17.next(); - if (_1521 === rs.DONE) { - break; - } - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_1521, radix29), 99)))); - } - const radix30: rs.u32 = radix29; - const _1536: rs.Result = num_fromStrRadix$09i2k2a(_1515.value, radix30); - if (_1536.ok) { - const arg32 = _1536.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg32, f)]).v); + } else if (_1137 === 2) { + const iter15: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); + while (true) { + const _1321: rs.u32 | rs.Done = iter15.next(); + if (_1321 === rs.DONE) { + break; + } + const radix25: rs.u32 = _1321; + for (const _1329 of edges({ hi: 0, w2: 0, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, 0, 64, radix25).items) { + const _1337: string = _1329.v; + const radix26: rs.u32 = radix25; + const _1340: rs.Result = num_fromStrRadix$0al5jri(_1337, radix26); + if (_1340.ok) { + const arg34 = _1340.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg34, f)]).v); } else { - const e17: rs.ParseIntError = _1536.error; - const _1552: rs.IntErrorKind = e17.kind; - if (_1552 === "Empty") { - kind18 = 0; - } else if (_1552 === "InvalidDigit") { - kind18 = 1; - } else if (_1552 === "PosOverflow") { - kind18 = 2; - } else if (_1552 === "NegOverflow") { - kind18 = 3; + const e15: rs.ParseIntError = _1340.error; + const _1356: rs.IntErrorKind = e15.kind; + if (_1356 === "Empty") { + kind16 = 0; + } else if (_1356 === "InvalidDigit") { + kind16 = 1; + } else if (_1356 === "PosOverflow") { + kind16 = 2; + } else if (_1356 === "NegOverflow") { + kind16 = 3; } else { - kind18 = 4; + kind16 = 4; } - if (!(e17.kind === "PosOverflow" as rs.IntErrorKind)) { - over17 = e17.kind !== "NegOverflow" as rs.IntErrorKind; + if (!(e15.kind === "PosOverflow" as rs.IntErrorKind)) { + over15 = e15.kind !== "NegOverflow" as rs.IntErrorKind; } else { - over17 = true; + over15 = true; } - const _1572: rs.IntErrorKind = e17.kind; - const args255 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e17, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e17, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1572), (f: rs.Formatter) => rs.i32Display(kind18, f), (f: rs.Formatter) => rs.fmtBool(over17, f)]; - put(out, rs.fmtFormat([args255[0], "|", args255[1], "|", args255[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args255[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args255[0]), "|", args255[3], "|", args255[4]]).v); + const _1376: rs.IntErrorKind = e15.kind; + const args259 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e15, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e15, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1376), (f: rs.Formatter) => rs.i32Display(kind16, f), (f: rs.Formatter) => rs.fmtBool(over15, f)]; + put(out, rs.fmtFormat([args259[0], "|", args259[1], "|", args259[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args259[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args259[0]), "|", args259[3], "|", args259[4]]).v); } - if (radix30 === 10) { - const parsed17: rs.Result = parse$11owssr(_1515.value); - const from17: rs.Result = num_fromStr$0ihvy10(_1515.value); - if (from17.ok) { - max17 = rs.u8Mul(rs.u128Eq(from17.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128) ? 1 : 0, 4); + if (radix26 === 10) { + const parsed15: rs.Result = parse$092epd5(_1337); + const from15: rs.Result = num_fromStr$0bkyuqf(_1337); + if (from15.ok) { + max15 = rs.u8Mul(rs.u64Eq(from15.value, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64) ? 1 : 0, 4); } else { - max17 = 2; + max15 = 2; } - rs.byteVecPush(out, rs.u8Add(parsed17.ok ? 1 : 0, max17)); - } - } - } else if (_1511 === 1) { - const s9: rs.String = rs.stringNew(); - for (const b5 of rs.byteSliceView(rest5)) { - const _1612: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _1613: rs.usize = rs.usizeRem(b5 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rs.idx(_1612, _1613); - rs.stringPush(s9, _1612.data[_1612.start + _1613] as rs.char); - } - const _1624: string = s9.v; - const radix31: rs.u32 = radix29; - const _1627: rs.Result = num_fromStrRadix$09i2k2a(_1624, radix31); - if (_1627.ok) { - const arg31 = _1627.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg31, f)]).v); - } else { - const e18: rs.ParseIntError = _1627.error; - const _1643: rs.IntErrorKind = e18.kind; - if (_1643 === "Empty") { - kind19 = 0; - } else if (_1643 === "InvalidDigit") { - kind19 = 1; - } else if (_1643 === "PosOverflow") { - kind19 = 2; - } else if (_1643 === "NegOverflow") { - kind19 = 3; - } else { - kind19 = 4; - } - if (!(e18.kind === "PosOverflow" as rs.IntErrorKind)) { - over18 = e18.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over18 = true; + rs.byteVecPush(out, rs.u8Add(parsed15.ok ? 1 : 0, max15)); } - const _1663: rs.IntErrorKind = e18.kind; - const args253 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e18, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e18, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1663), (f: rs.Formatter) => rs.i32Display(kind19, f), (f: rs.Formatter) => rs.fmtBool(over18, f)]; - put(out, rs.fmtFormat([args253[0], "|", args253[1], "|", args253[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args253[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args253[0]), "|", args253[3], "|", args253[4]]).v); - } - if (radix31 === 10) { - const parsed18: rs.Result = parse$11owssr(_1624); - const from18: rs.Result = num_fromStr$0ihvy10(_1624); - if (from18.ok) { - max18 = rs.u8Mul(rs.u128Eq(from18.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128) ? 1 : 0, 4); - } else { - max18 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed18.ok ? 1 : 0, max18)); } + } + } else { + const radix27: rs.u32 = ((first4 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest4), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest4, 1), (b21: rs.u8): boolean => { + return (b21 & 1) === 1; + })) { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix27), 99)))); + } + if (!(rest4.length > 2)) { + text4 = rs.byteSliceFrom(Uint8Array.of()); } else { - if (_1511 === 2) { - const iter19: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); - while (true) { - const _1695: rs.u32 | rs.Done = iter19.next(); - if (_1695 === rs.DONE) { - break b0; - } - const radix32: rs.u32 = _1695; - for (const _1702 of edges({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, 0, 128, radix32).items) { - const _1710: string = _1702.v; - const radix33: rs.u32 = radix32; - const _1713: rs.Result = num_fromStrRadix$09i2k2a(_1710, radix33); - if (_1713.ok) { - const arg30 = _1713.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg30, f)]).v); - } else { - const e19: rs.ParseIntError = _1713.error; - const _1729: rs.IntErrorKind = e19.kind; - if (_1729 === "Empty") { - kind20 = 0; - } else if (_1729 === "InvalidDigit") { - kind20 = 1; - } else if (_1729 === "PosOverflow") { - kind20 = 2; - } else if (_1729 === "NegOverflow") { - kind20 = 3; - } else { - kind20 = 4; - } - if (!(e19.kind === "PosOverflow" as rs.IntErrorKind)) { - over19 = e19.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over19 = true; - } - const _1749: rs.IntErrorKind = e19.kind; - const args251 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e19, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e19, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1749), (f: rs.Formatter) => rs.i32Display(kind20, f), (f: rs.Formatter) => rs.fmtBool(over19, f)]; - put(out, rs.fmtFormat([args251[0], "|", args251[1], "|", args251[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args251[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args251[0]), "|", args251[3], "|", args251[4]]).v); - } - if (radix33 === 10) { - const parsed19: rs.Result = parse$11owssr(_1710); - const from19: rs.Result = num_fromStr$0ihvy10(_1710); - if (from19.ok) { - max19 = rs.u8Mul(rs.u128Eq(from19.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128) ? 1 : 0, 4); - } else { - max19 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed19.ok ? 1 : 0, max19)); - } - } - } + text4 = rs.byteSliceRange(rest4, 2); + } + const _1432: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text4), "1"); + const radix28: rs.u32 = radix27; + const _1437: rs.Result = num_fromStrRadix$0al5jri(_1432, radix28); + if (_1437.ok) { + const arg33 = _1437.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg33, f)]).v); + } else { + const e16: rs.ParseIntError = _1437.error; + const _1453: rs.IntErrorKind = e16.kind; + if (_1453 === "Empty") { + kind17 = 0; + } else if (_1453 === "InvalidDigit") { + kind17 = 1; + } else if (_1453 === "PosOverflow") { + kind17 = 2; + } else if (_1453 === "NegOverflow") { + kind17 = 3; + } else { + kind17 = 4; } - const radix34: rs.u32 = ((first5 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest5), 0) as rs.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest5, 1), (b20: rs.u8): boolean => { - return (b20 & 1) === 1; - })) { - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix34), 99)))); + if (!(e16.kind === "PosOverflow" as rs.IntErrorKind)) { + over16 = e16.kind !== "NegOverflow" as rs.IntErrorKind; + } else { + over16 = true; } - if (!(rest5.length > 2)) { - text5 = rs.byteSliceFrom(Uint8Array.of()); + const _1473: rs.IntErrorKind = e16.kind; + const args257 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e16, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e16, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1473), (f: rs.Formatter) => rs.i32Display(kind17, f), (f: rs.Formatter) => rs.fmtBool(over16, f)]; + put(out, rs.fmtFormat([args257[0], "|", args257[1], "|", args257[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args257[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args257[0]), "|", args257[3], "|", args257[4]]).v); + } + if (radix28 === 10) { + const parsed16: rs.Result = parse$092epd5(_1432); + const from16: rs.Result = num_fromStr$0bkyuqf(_1432); + if (from16.ok) { + max16 = rs.u8Mul(rs.u64Eq(from16.value, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64) ? 1 : 0, 4); } else { - text5 = rs.byteSliceRange(rest5, 2); - } - const _1805: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text5), "1"); - const radix35: rs.u32 = radix34; - const _1810: rs.Result = num_fromStrRadix$09i2k2a(_1805, radix35); - if (_1810.ok) { - const arg29 = _1810.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg29, f)]).v); + max16 = 2; + } + rs.byteVecPush(out, rs.u8Add(parsed16.ok ? 1 : 0, max16)); + } + } + } + } else if (_4 === 4) { + if (dataLen !== 0) { + const first5: rs.u8 = dataData[dataStart]; + const rest5: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix29: rs.u32 = rs.u32Add(2, rs.u32Rem(first5 as rs.u32, 35)); + const _1511: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); + if (_1511 === 0) { + const _1515: rs.Result = rs.strFromUtf8(rest5); + if (_1515.ok) { + const iter17: rs.Iter = rs.strChars(_1515.value); + while (true) { + const _1521: rs.char | rs.Done = iter17.next(); + if (_1521 === rs.DONE) { + break; + } + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_1521, radix29), 99)))); + } + const radix30: rs.u32 = radix29; + const _1536: rs.Result = num_fromStrRadix$09i2k2a(_1515.value, radix30); + if (_1536.ok) { + const arg32 = _1536.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg32, f)]).v); } else { - const e20: rs.ParseIntError = _1810.error; - const _1826: rs.IntErrorKind = e20.kind; - if (_1826 === "Empty") { - kind21 = 0; - } else if (_1826 === "InvalidDigit") { - kind21 = 1; - } else if (_1826 === "PosOverflow") { - kind21 = 2; - } else if (_1826 === "NegOverflow") { - kind21 = 3; + const e17: rs.ParseIntError = _1536.error; + const _1552: rs.IntErrorKind = e17.kind; + if (_1552 === "Empty") { + kind18 = 0; + } else if (_1552 === "InvalidDigit") { + kind18 = 1; + } else if (_1552 === "PosOverflow") { + kind18 = 2; + } else if (_1552 === "NegOverflow") { + kind18 = 3; } else { - kind21 = 4; + kind18 = 4; } - if (!(e20.kind === "PosOverflow" as rs.IntErrorKind)) { - over20 = e20.kind !== "NegOverflow" as rs.IntErrorKind; + if (!(e17.kind === "PosOverflow" as rs.IntErrorKind)) { + over17 = e17.kind !== "NegOverflow" as rs.IntErrorKind; } else { - over20 = true; + over17 = true; } - const _1846: rs.IntErrorKind = e20.kind; - const args249 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e20, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e20, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1846), (f: rs.Formatter) => rs.i32Display(kind21, f), (f: rs.Formatter) => rs.fmtBool(over20, f)]; - put(out, rs.fmtFormat([args249[0], "|", args249[1], "|", args249[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args249[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args249[0]), "|", args249[3], "|", args249[4]]).v); - } - if (radix35 === 10) { - const parsed20: rs.Result = parse$11owssr(_1805); - const from20: rs.Result = num_fromStr$0ihvy10(_1805); - if (from20.ok) { - max20 = rs.u8Mul(rs.u128Eq(from20.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128) ? 1 : 0, 4); + const _1572: rs.IntErrorKind = e17.kind; + const args255 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e17, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e17, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1572), (f: rs.Formatter) => rs.i32Display(kind18, f), (f: rs.Formatter) => rs.fmtBool(over17, f)]; + put(out, rs.fmtFormat([args255[0], "|", args255[1], "|", args255[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args255[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args255[0]), "|", args255[3], "|", args255[4]]).v); + } + if (radix30 === 10) { + const parsed17: rs.Result = parse$11owssr(_1515.value); + const from17: rs.Result = num_fromStr$0ihvy10(_1515.value); + if (from17.ok) { + max17 = rs.u8Mul(rs.u128Eq(from17.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128) ? 1 : 0, 4); } else { - max20 = 2; + max17 = 2; } - rs.byteVecPush(out, rs.u8Add(parsed20.ok ? 1 : 0, max20)); + rs.byteVecPush(out, rs.u8Add(parsed17.ok ? 1 : 0, max17)); } } - } - } else if (_4 === 5) { - if (dataLen !== 0) { - const first6: rs.u8 = dataData[dataStart]; - const rest6: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix36: rs.u32 = rs.u32Add(2, rs.u32Rem(first6 as rs.u32, 35)); - const _1884: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); - if (_1884 === 0) { - const _1888: rs.Result = rs.strFromUtf8(rest6); - if (_1888.ok) { - const iter21: rs.Iter = rs.strChars(_1888.value); - while (true) { - const _1894: rs.char | rs.Done = iter21.next(); - if (_1894 === rs.DONE) { - break; - } - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_1894, radix36), 99)))); - } - const radix37: rs.u32 = radix36; - const _1909: rs.Result = num_fromStrRadix$1479ec4(_1888.value, radix37); - if (_1909.ok) { - const arg28 = _1909.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg28, f)]).v); - } else { - const e21: rs.ParseIntError = _1909.error; - const _1925: rs.IntErrorKind = e21.kind; - if (_1925 === "Empty") { - kind22 = 0; - } else if (_1925 === "InvalidDigit") { - kind22 = 1; - } else if (_1925 === "PosOverflow") { - kind22 = 2; - } else if (_1925 === "NegOverflow") { - kind22 = 3; - } else { - kind22 = 4; - } - if (!(e21.kind === "PosOverflow" as rs.IntErrorKind)) { - over21 = e21.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over21 = true; + } else if (_1511 === 1) { + const s9: rs.String = rs.stringNew(); + for (const b5 of rs.byteSliceView(rest5)) { + const _1612: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _1613: rs.usize = rs.usizeRem(b5 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_1612, _1613); + rs.stringPush(s9, _1612.data[_1612.start + _1613] as rs.char); + } + const _1624: string = s9.v; + const radix31: rs.u32 = radix29; + const _1627: rs.Result = num_fromStrRadix$09i2k2a(_1624, radix31); + if (_1627.ok) { + const arg31 = _1627.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg31, f)]).v); + } else { + const e18: rs.ParseIntError = _1627.error; + const _1643: rs.IntErrorKind = e18.kind; + if (_1643 === "Empty") { + kind19 = 0; + } else if (_1643 === "InvalidDigit") { + kind19 = 1; + } else if (_1643 === "PosOverflow") { + kind19 = 2; + } else if (_1643 === "NegOverflow") { + kind19 = 3; + } else { + kind19 = 4; + } + if (!(e18.kind === "PosOverflow" as rs.IntErrorKind)) { + over18 = e18.kind !== "NegOverflow" as rs.IntErrorKind; + } else { + over18 = true; + } + const _1663: rs.IntErrorKind = e18.kind; + const args253 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e18, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e18, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1663), (f: rs.Formatter) => rs.i32Display(kind19, f), (f: rs.Formatter) => rs.fmtBool(over18, f)]; + put(out, rs.fmtFormat([args253[0], "|", args253[1], "|", args253[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args253[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args253[0]), "|", args253[3], "|", args253[4]]).v); + } + if (radix31 === 10) { + const parsed18: rs.Result = parse$11owssr(_1624); + const from18: rs.Result = num_fromStr$0ihvy10(_1624); + if (from18.ok) { + max18 = rs.u8Mul(rs.u128Eq(from18.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128) ? 1 : 0, 4); + } else { + max18 = 2; + } + rs.byteVecPush(out, rs.u8Add(parsed18.ok ? 1 : 0, max18)); + } + } else if (_1511 === 2) { + const iter19: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); + while (true) { + const _1695: rs.u32 | rs.Done = iter19.next(); + if (_1695 === rs.DONE) { + break; + } + const radix32: rs.u32 = _1695; + for (const _1702 of edges({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, 0, 128, radix32).items) { + const _1710: string = _1702.v; + const radix33: rs.u32 = radix32; + const _1713: rs.Result = num_fromStrRadix$09i2k2a(_1710, radix33); + if (_1713.ok) { + const arg30 = _1713.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg30, f)]).v); + } else { + const e19: rs.ParseIntError = _1713.error; + const _1729: rs.IntErrorKind = e19.kind; + if (_1729 === "Empty") { + kind20 = 0; + } else if (_1729 === "InvalidDigit") { + kind20 = 1; + } else if (_1729 === "PosOverflow") { + kind20 = 2; + } else if (_1729 === "NegOverflow") { + kind20 = 3; + } else { + kind20 = 4; + } + if (!(e19.kind === "PosOverflow" as rs.IntErrorKind)) { + over19 = e19.kind !== "NegOverflow" as rs.IntErrorKind; + } else { + over19 = true; } - const _1945: rs.IntErrorKind = e21.kind; - const args247 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e21, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e21, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1945), (f: rs.Formatter) => rs.i32Display(kind22, f), (f: rs.Formatter) => rs.fmtBool(over21, f)]; - put(out, rs.fmtFormat([args247[0], "|", args247[1], "|", args247[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args247[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args247[0]), "|", args247[3], "|", args247[4]]).v); + const _1749: rs.IntErrorKind = e19.kind; + const args251 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e19, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e19, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1749), (f: rs.Formatter) => rs.i32Display(kind20, f), (f: rs.Formatter) => rs.fmtBool(over19, f)]; + put(out, rs.fmtFormat([args251[0], "|", args251[1], "|", args251[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args251[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args251[0]), "|", args251[3], "|", args251[4]]).v); } - if (radix37 === 10) { - const parsed21: rs.Result = parse$07zoymb(_1888.value); - const from21: rs.Result = num_fromStr$1jgkxdq(_1888.value); - if (from21.ok) { - max21 = rs.u8Mul(from21.value === 4294967295 ? 1 : 0, 4); + if (radix33 === 10) { + const parsed19: rs.Result = parse$11owssr(_1710); + const from19: rs.Result = num_fromStr$0ihvy10(_1710); + if (from19.ok) { + max19 = rs.u8Mul(rs.u128Eq(from19.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128) ? 1 : 0, 4); } else { - max21 = 2; + max19 = 2; } - rs.byteVecPush(out, rs.u8Add(parsed21.ok ? 1 : 0, max21)); + rs.byteVecPush(out, rs.u8Add(parsed19.ok ? 1 : 0, max19)); } } - } else if (_1884 === 1) { - const s11: rs.String = rs.stringNew(); - for (const b6 of rs.byteSliceView(rest6)) { - const _1985: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _1986: rs.usize = rs.usizeRem(b6 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rs.idx(_1985, _1986); - rs.stringPush(s11, _1985.data[_1985.start + _1986] as rs.char); - } - const _1997: string = s11.v; - const radix38: rs.u32 = radix36; - const _2000: rs.Result = num_fromStrRadix$1479ec4(_1997, radix38); - if (_2000.ok) { - const arg27 = _2000.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg27, f)]).v); + } + } else { + const radix34: rs.u32 = ((first5 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest5), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest5, 1), (b20: rs.u8): boolean => { + return (b20 & 1) === 1; + })) { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix34), 99)))); + } + if (!(rest5.length > 2)) { + text5 = rs.byteSliceFrom(Uint8Array.of()); + } else { + text5 = rs.byteSliceRange(rest5, 2); + } + const _1805: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text5), "1"); + const radix35: rs.u32 = radix34; + const _1810: rs.Result = num_fromStrRadix$09i2k2a(_1805, radix35); + if (_1810.ok) { + const arg29 = _1810.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg29, f)]).v); + } else { + const e20: rs.ParseIntError = _1810.error; + const _1826: rs.IntErrorKind = e20.kind; + if (_1826 === "Empty") { + kind21 = 0; + } else if (_1826 === "InvalidDigit") { + kind21 = 1; + } else if (_1826 === "PosOverflow") { + kind21 = 2; + } else if (_1826 === "NegOverflow") { + kind21 = 3; + } else { + kind21 = 4; + } + if (!(e20.kind === "PosOverflow" as rs.IntErrorKind)) { + over20 = e20.kind !== "NegOverflow" as rs.IntErrorKind; } else { - const e22: rs.ParseIntError = _2000.error; - const _2016: rs.IntErrorKind = e22.kind; - if (_2016 === "Empty") { - kind23 = 0; - } else if (_2016 === "InvalidDigit") { - kind23 = 1; - } else if (_2016 === "PosOverflow") { - kind23 = 2; - } else if (_2016 === "NegOverflow") { - kind23 = 3; - } else { - kind23 = 4; + over20 = true; + } + const _1846: rs.IntErrorKind = e20.kind; + const args249 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e20, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e20, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1846), (f: rs.Formatter) => rs.i32Display(kind21, f), (f: rs.Formatter) => rs.fmtBool(over20, f)]; + put(out, rs.fmtFormat([args249[0], "|", args249[1], "|", args249[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args249[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args249[0]), "|", args249[3], "|", args249[4]]).v); + } + if (radix35 === 10) { + const parsed20: rs.Result = parse$11owssr(_1805); + const from20: rs.Result = num_fromStr$0ihvy10(_1805); + if (from20.ok) { + max20 = rs.u8Mul(rs.u128Eq(from20.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128) ? 1 : 0, 4); + } else { + max20 = 2; + } + rs.byteVecPush(out, rs.u8Add(parsed20.ok ? 1 : 0, max20)); + } + } + } + } else if (_4 === 5) { + if (dataLen !== 0) { + const first6: rs.u8 = dataData[dataStart]; + const rest6: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix36: rs.u32 = rs.u32Add(2, rs.u32Rem(first6 as rs.u32, 35)); + const _1884: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); + if (_1884 === 0) { + const _1888: rs.Result = rs.strFromUtf8(rest6); + if (_1888.ok) { + const iter21: rs.Iter = rs.strChars(_1888.value); + while (true) { + const _1894: rs.char | rs.Done = iter21.next(); + if (_1894 === rs.DONE) { + break; } - if (!(e22.kind === "PosOverflow" as rs.IntErrorKind)) { - over22 = e22.kind !== "NegOverflow" as rs.IntErrorKind; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_1894, radix36), 99)))); + } + const radix37: rs.u32 = radix36; + const _1909: rs.Result = num_fromStrRadix$1479ec4(_1888.value, radix37); + if (_1909.ok) { + const arg28 = _1909.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg28, f)]).v); + } else { + const e21: rs.ParseIntError = _1909.error; + const _1925: rs.IntErrorKind = e21.kind; + if (_1925 === "Empty") { + kind22 = 0; + } else if (_1925 === "InvalidDigit") { + kind22 = 1; + } else if (_1925 === "PosOverflow") { + kind22 = 2; + } else if (_1925 === "NegOverflow") { + kind22 = 3; } else { - over22 = true; + kind22 = 4; } - const _2036: rs.IntErrorKind = e22.kind; - const args245 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e22, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e22, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2036), (f: rs.Formatter) => rs.i32Display(kind23, f), (f: rs.Formatter) => rs.fmtBool(over22, f)]; - put(out, rs.fmtFormat([args245[0], "|", args245[1], "|", args245[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args245[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args245[0]), "|", args245[3], "|", args245[4]]).v); - } - if (radix38 === 10) { - const parsed22: rs.Result = parse$07zoymb(_1997); - const from22: rs.Result = num_fromStr$1jgkxdq(_1997); - if (from22.ok) { - max22 = rs.u8Mul(from22.value === 4294967295 ? 1 : 0, 4); + if (!(e21.kind === "PosOverflow" as rs.IntErrorKind)) { + over21 = e21.kind !== "NegOverflow" as rs.IntErrorKind; } else { - max22 = 2; + over21 = true; } - rs.byteVecPush(out, rs.u8Add(parsed22.ok ? 1 : 0, max22)); + const _1945: rs.IntErrorKind = e21.kind; + const args247 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e21, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e21, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1945), (f: rs.Formatter) => rs.i32Display(kind22, f), (f: rs.Formatter) => rs.fmtBool(over21, f)]; + put(out, rs.fmtFormat([args247[0], "|", args247[1], "|", args247[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args247[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args247[0]), "|", args247[3], "|", args247[4]]).v); } - } else { - if (_1884 === 2) { - const iter23: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); - while (true) { - const _2068: rs.u32 | rs.Done = iter23.next(); - if (_2068 === rs.DONE) { - break b0; - } - const radix39: rs.u32 = _2068; - for (const _2076 of edges(4294967295, 0, 32, radix39).items) { - const _2084: string = _2076.v; - const radix40: rs.u32 = radix39; - const _2087: rs.Result = num_fromStrRadix$1479ec4(_2084, radix40); - if (_2087.ok) { - const arg26 = _2087.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg26, f)]).v); - } else { - const e23: rs.ParseIntError = _2087.error; - const _2103: rs.IntErrorKind = e23.kind; - if (_2103 === "Empty") { - kind24 = 0; - } else if (_2103 === "InvalidDigit") { - kind24 = 1; - } else if (_2103 === "PosOverflow") { - kind24 = 2; - } else if (_2103 === "NegOverflow") { - kind24 = 3; - } else { - kind24 = 4; - } - if (!(e23.kind === "PosOverflow" as rs.IntErrorKind)) { - over23 = e23.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over23 = true; - } - const _2123: rs.IntErrorKind = e23.kind; - const args243 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e23, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e23, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2123), (f: rs.Formatter) => rs.i32Display(kind24, f), (f: rs.Formatter) => rs.fmtBool(over23, f)]; - put(out, rs.fmtFormat([args243[0], "|", args243[1], "|", args243[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args243[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args243[0]), "|", args243[3], "|", args243[4]]).v); - } - if (radix40 === 10) { - const parsed23: rs.Result = parse$07zoymb(_2084); - const from23: rs.Result = num_fromStr$1jgkxdq(_2084); - if (from23.ok) { - max23 = rs.u8Mul(from23.value === 4294967295 ? 1 : 0, 4); - } else { - max23 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed23.ok ? 1 : 0, max23)); - } - } + if (radix37 === 10) { + const parsed21: rs.Result = parse$07zoymb(_1888.value); + const from21: rs.Result = num_fromStr$1jgkxdq(_1888.value); + if (from21.ok) { + max21 = rs.u8Mul(from21.value === 4294967295 ? 1 : 0, 4); + } else { + max21 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed21.ok ? 1 : 0, max21)); } - const radix41: rs.u32 = ((first6 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest6), 0) as rs.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest6, 1), (b19: rs.u8): boolean => { - return (b19 & 1) === 1; - })) { - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix41), 99)))); + } + } else if (_1884 === 1) { + const s11: rs.String = rs.stringNew(); + for (const b6 of rs.byteSliceView(rest6)) { + const _1985: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _1986: rs.usize = rs.usizeRem(b6 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_1985, _1986); + rs.stringPush(s11, _1985.data[_1985.start + _1986] as rs.char); + } + const _1997: string = s11.v; + const radix38: rs.u32 = radix36; + const _2000: rs.Result = num_fromStrRadix$1479ec4(_1997, radix38); + if (_2000.ok) { + const arg27 = _2000.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg27, f)]).v); + } else { + const e22: rs.ParseIntError = _2000.error; + const _2016: rs.IntErrorKind = e22.kind; + if (_2016 === "Empty") { + kind23 = 0; + } else if (_2016 === "InvalidDigit") { + kind23 = 1; + } else if (_2016 === "PosOverflow") { + kind23 = 2; + } else if (_2016 === "NegOverflow") { + kind23 = 3; + } else { + kind23 = 4; } - if (!(rest6.length > 2)) { - text6 = rs.byteSliceFrom(Uint8Array.of()); + if (!(e22.kind === "PosOverflow" as rs.IntErrorKind)) { + over22 = e22.kind !== "NegOverflow" as rs.IntErrorKind; } else { - text6 = rs.byteSliceRange(rest6, 2); - } - const _2179: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text6), "1"); - const radix42: rs.u32 = radix41; - const _2184: rs.Result = num_fromStrRadix$1479ec4(_2179, radix42); - if (_2184.ok) { - const arg25 = _2184.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg25, f)]).v); + over22 = true; + } + const _2036: rs.IntErrorKind = e22.kind; + const args245 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e22, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e22, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2036), (f: rs.Formatter) => rs.i32Display(kind23, f), (f: rs.Formatter) => rs.fmtBool(over22, f)]; + put(out, rs.fmtFormat([args245[0], "|", args245[1], "|", args245[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args245[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args245[0]), "|", args245[3], "|", args245[4]]).v); + } + if (radix38 === 10) { + const parsed22: rs.Result = parse$07zoymb(_1997); + const from22: rs.Result = num_fromStr$1jgkxdq(_1997); + if (from22.ok) { + max22 = rs.u8Mul(from22.value === 4294967295 ? 1 : 0, 4); } else { - const e24: rs.ParseIntError = _2184.error; - const _2200: rs.IntErrorKind = e24.kind; - if (_2200 === "Empty") { - kind25 = 0; - } else if (_2200 === "InvalidDigit") { - kind25 = 1; - } else if (_2200 === "PosOverflow") { - kind25 = 2; - } else if (_2200 === "NegOverflow") { - kind25 = 3; - } else { - kind25 = 4; - } - if (!(e24.kind === "PosOverflow" as rs.IntErrorKind)) { - over24 = e24.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over24 = true; - } - const _2220: rs.IntErrorKind = e24.kind; - const args241 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e24, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e24, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2220), (f: rs.Formatter) => rs.i32Display(kind25, f), (f: rs.Formatter) => rs.fmtBool(over24, f)]; - put(out, rs.fmtFormat([args241[0], "|", args241[1], "|", args241[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args241[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args241[0]), "|", args241[3], "|", args241[4]]).v); - } - if (radix42 === 10) { - const parsed24: rs.Result = parse$07zoymb(_2179); - const from24: rs.Result = num_fromStr$1jgkxdq(_2179); - if (from24.ok) { - max24 = rs.u8Mul(from24.value === 4294967295 ? 1 : 0, 4); - } else { - max24 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed24.ok ? 1 : 0, max24)); + max22 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed22.ok ? 1 : 0, max22)); } - } - } else if (_4 === 6) { - if (dataLen !== 0) { - const first7: rs.u8 = dataData[dataStart]; - const rest7: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix43: rs.u32 = rs.u32Add(2, rs.u32Rem(first7 as rs.u32, 35)); - const _2258: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); - if (_2258 === 0) { - const _2262: rs.Result = rs.strFromUtf8(rest7); - if (_2262.ok) { - const iter25: rs.Iter = rs.strChars(_2262.value); - while (true) { - const _2268: rs.char | rs.Done = iter25.next(); - if (_2268 === rs.DONE) { - break; - } - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_2268, radix43), 99)))); - } - const radix44: rs.u32 = radix43; - const _2283: rs.Result = num_fromStrRadix$0qyezqs(_2262.value, radix44); - if (_2283.ok) { - const arg24 = _2283.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg24, f)]).v); + } else if (_1884 === 2) { + const iter23: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); + while (true) { + const _2068: rs.u32 | rs.Done = iter23.next(); + if (_2068 === rs.DONE) { + break; + } + const radix39: rs.u32 = _2068; + for (const _2076 of edges(4294967295, 0, 32, radix39).items) { + const _2084: string = _2076.v; + const radix40: rs.u32 = radix39; + const _2087: rs.Result = num_fromStrRadix$1479ec4(_2084, radix40); + if (_2087.ok) { + const arg26 = _2087.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg26, f)]).v); } else { - const e25: rs.ParseIntError = _2283.error; - const _2299: rs.IntErrorKind = e25.kind; - if (_2299 === "Empty") { - kind26 = 0; - } else if (_2299 === "InvalidDigit") { - kind26 = 1; - } else if (_2299 === "PosOverflow") { - kind26 = 2; - } else if (_2299 === "NegOverflow") { - kind26 = 3; + const e23: rs.ParseIntError = _2087.error; + const _2103: rs.IntErrorKind = e23.kind; + if (_2103 === "Empty") { + kind24 = 0; + } else if (_2103 === "InvalidDigit") { + kind24 = 1; + } else if (_2103 === "PosOverflow") { + kind24 = 2; + } else if (_2103 === "NegOverflow") { + kind24 = 3; } else { - kind26 = 4; + kind24 = 4; } - if (!(e25.kind === "PosOverflow" as rs.IntErrorKind)) { - over25 = e25.kind !== "NegOverflow" as rs.IntErrorKind; + if (!(e23.kind === "PosOverflow" as rs.IntErrorKind)) { + over23 = e23.kind !== "NegOverflow" as rs.IntErrorKind; } else { - over25 = true; + over23 = true; } - const _2319: rs.IntErrorKind = e25.kind; - const args239 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e25, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e25, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2319), (f: rs.Formatter) => rs.i32Display(kind26, f), (f: rs.Formatter) => rs.fmtBool(over25, f)]; - put(out, rs.fmtFormat([args239[0], "|", args239[1], "|", args239[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args239[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args239[0]), "|", args239[3], "|", args239[4]]).v); + const _2123: rs.IntErrorKind = e23.kind; + const args243 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e23, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e23, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2123), (f: rs.Formatter) => rs.i32Display(kind24, f), (f: rs.Formatter) => rs.fmtBool(over23, f)]; + put(out, rs.fmtFormat([args243[0], "|", args243[1], "|", args243[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args243[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args243[0]), "|", args243[3], "|", args243[4]]).v); } - if (radix44 === 10) { - const parsed25: rs.Result = parse$02m1946(_2262.value); - const from25: rs.Result = num_fromStr$1amqoj7(_2262.value); - if (from25.ok) { - max25 = rs.u8Mul(from25.value === 127 ? 1 : 0, 4); + if (radix40 === 10) { + const parsed23: rs.Result = parse$07zoymb(_2084); + const from23: rs.Result = num_fromStr$1jgkxdq(_2084); + if (from23.ok) { + max23 = rs.u8Mul(from23.value === 4294967295 ? 1 : 0, 4); } else { - max25 = 2; + max23 = 2; } - rs.byteVecPush(out, rs.u8Add(parsed25.ok ? 1 : 0, max25)); + rs.byteVecPush(out, rs.u8Add(parsed23.ok ? 1 : 0, max23)); } } - } else if (_2258 === 1) { - const s13: rs.String = rs.stringNew(); - for (const b7 of rs.byteSliceView(rest7)) { - const _2359: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _2360: rs.usize = rs.usizeRem(b7 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rs.idx(_2359, _2360); - rs.stringPush(s13, _2359.data[_2359.start + _2360] as rs.char); - } - const _2371: string = s13.v; - const radix45: rs.u32 = radix43; - const _2374: rs.Result = num_fromStrRadix$0qyezqs(_2371, radix45); - if (_2374.ok) { - const arg23 = _2374.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg23, f)]).v); + } + } else { + const radix41: rs.u32 = ((first6 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest6), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest6, 1), (b19: rs.u8): boolean => { + return (b19 & 1) === 1; + })) { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix41), 99)))); + } + if (!(rest6.length > 2)) { + text6 = rs.byteSliceFrom(Uint8Array.of()); + } else { + text6 = rs.byteSliceRange(rest6, 2); + } + const _2179: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text6), "1"); + const radix42: rs.u32 = radix41; + const _2184: rs.Result = num_fromStrRadix$1479ec4(_2179, radix42); + if (_2184.ok) { + const arg25 = _2184.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg25, f)]).v); + } else { + const e24: rs.ParseIntError = _2184.error; + const _2200: rs.IntErrorKind = e24.kind; + if (_2200 === "Empty") { + kind25 = 0; + } else if (_2200 === "InvalidDigit") { + kind25 = 1; + } else if (_2200 === "PosOverflow") { + kind25 = 2; + } else if (_2200 === "NegOverflow") { + kind25 = 3; + } else { + kind25 = 4; + } + if (!(e24.kind === "PosOverflow" as rs.IntErrorKind)) { + over24 = e24.kind !== "NegOverflow" as rs.IntErrorKind; } else { - const e26: rs.ParseIntError = _2374.error; - const _2390: rs.IntErrorKind = e26.kind; - if (_2390 === "Empty") { - kind27 = 0; - } else if (_2390 === "InvalidDigit") { - kind27 = 1; - } else if (_2390 === "PosOverflow") { - kind27 = 2; - } else if (_2390 === "NegOverflow") { - kind27 = 3; - } else { - kind27 = 4; + over24 = true; + } + const _2220: rs.IntErrorKind = e24.kind; + const args241 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e24, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e24, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2220), (f: rs.Formatter) => rs.i32Display(kind25, f), (f: rs.Formatter) => rs.fmtBool(over24, f)]; + put(out, rs.fmtFormat([args241[0], "|", args241[1], "|", args241[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args241[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args241[0]), "|", args241[3], "|", args241[4]]).v); + } + if (radix42 === 10) { + const parsed24: rs.Result = parse$07zoymb(_2179); + const from24: rs.Result = num_fromStr$1jgkxdq(_2179); + if (from24.ok) { + max24 = rs.u8Mul(from24.value === 4294967295 ? 1 : 0, 4); + } else { + max24 = 2; + } + rs.byteVecPush(out, rs.u8Add(parsed24.ok ? 1 : 0, max24)); + } + } + } + } else if (_4 === 6) { + if (dataLen !== 0) { + const first7: rs.u8 = dataData[dataStart]; + const rest7: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix43: rs.u32 = rs.u32Add(2, rs.u32Rem(first7 as rs.u32, 35)); + const _2258: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); + if (_2258 === 0) { + const _2262: rs.Result = rs.strFromUtf8(rest7); + if (_2262.ok) { + const iter25: rs.Iter = rs.strChars(_2262.value); + while (true) { + const _2268: rs.char | rs.Done = iter25.next(); + if (_2268 === rs.DONE) { + break; } - if (!(e26.kind === "PosOverflow" as rs.IntErrorKind)) { - over26 = e26.kind !== "NegOverflow" as rs.IntErrorKind; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_2268, radix43), 99)))); + } + const radix44: rs.u32 = radix43; + const _2283: rs.Result = num_fromStrRadix$0qyezqs(_2262.value, radix44); + if (_2283.ok) { + const arg24 = _2283.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg24, f)]).v); + } else { + const e25: rs.ParseIntError = _2283.error; + const _2299: rs.IntErrorKind = e25.kind; + if (_2299 === "Empty") { + kind26 = 0; + } else if (_2299 === "InvalidDigit") { + kind26 = 1; + } else if (_2299 === "PosOverflow") { + kind26 = 2; + } else if (_2299 === "NegOverflow") { + kind26 = 3; } else { - over26 = true; + kind26 = 4; } - const _2410: rs.IntErrorKind = e26.kind; - const args237 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e26, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e26, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2410), (f: rs.Formatter) => rs.i32Display(kind27, f), (f: rs.Formatter) => rs.fmtBool(over26, f)]; - put(out, rs.fmtFormat([args237[0], "|", args237[1], "|", args237[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args237[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args237[0]), "|", args237[3], "|", args237[4]]).v); - } - if (radix45 === 10) { - const parsed26: rs.Result = parse$02m1946(_2371); - const from26: rs.Result = num_fromStr$1amqoj7(_2371); - if (from26.ok) { - max26 = rs.u8Mul(from26.value === 127 ? 1 : 0, 4); + if (!(e25.kind === "PosOverflow" as rs.IntErrorKind)) { + over25 = e25.kind !== "NegOverflow" as rs.IntErrorKind; } else { - max26 = 2; + over25 = true; } - rs.byteVecPush(out, rs.u8Add(parsed26.ok ? 1 : 0, max26)); + const _2319: rs.IntErrorKind = e25.kind; + const args239 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e25, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e25, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2319), (f: rs.Formatter) => rs.i32Display(kind26, f), (f: rs.Formatter) => rs.fmtBool(over25, f)]; + put(out, rs.fmtFormat([args239[0], "|", args239[1], "|", args239[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args239[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args239[0]), "|", args239[3], "|", args239[4]]).v); } - } else { - if (_2258 === 2) { - const iter27: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); - while (true) { - const _2442: rs.u32 | rs.Done = iter27.next(); - if (_2442 === rs.DONE) { - break b0; - } - const radix46: rs.u32 = _2442; - for (const _2453 of edges(127, rs.u128Add(127, 1), 8, radix46).items) { - const _2461: string = _2453.v; - const radix47: rs.u32 = radix46; - const _2464: rs.Result = num_fromStrRadix$0qyezqs(_2461, radix47); - if (_2464.ok) { - const arg22 = _2464.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg22, f)]).v); - } else { - const e27: rs.ParseIntError = _2464.error; - const _2480: rs.IntErrorKind = e27.kind; - if (_2480 === "Empty") { - kind28 = 0; - } else if (_2480 === "InvalidDigit") { - kind28 = 1; - } else if (_2480 === "PosOverflow") { - kind28 = 2; - } else if (_2480 === "NegOverflow") { - kind28 = 3; - } else { - kind28 = 4; - } - if (!(e27.kind === "PosOverflow" as rs.IntErrorKind)) { - over27 = e27.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over27 = true; - } - const _2500: rs.IntErrorKind = e27.kind; - const args235 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e27, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e27, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2500), (f: rs.Formatter) => rs.i32Display(kind28, f), (f: rs.Formatter) => rs.fmtBool(over27, f)]; - put(out, rs.fmtFormat([args235[0], "|", args235[1], "|", args235[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args235[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args235[0]), "|", args235[3], "|", args235[4]]).v); - } - if (radix47 === 10) { - const parsed27: rs.Result = parse$02m1946(_2461); - const from27: rs.Result = num_fromStr$1amqoj7(_2461); - if (from27.ok) { - max27 = rs.u8Mul(from27.value === 127 ? 1 : 0, 4); - } else { - max27 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed27.ok ? 1 : 0, max27)); - } - } + if (radix44 === 10) { + const parsed25: rs.Result = parse$02m1946(_2262.value); + const from25: rs.Result = num_fromStr$1amqoj7(_2262.value); + if (from25.ok) { + max25 = rs.u8Mul(from25.value === 127 ? 1 : 0, 4); + } else { + max25 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed25.ok ? 1 : 0, max25)); } - const radix48: rs.u32 = ((first7 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest7), 0) as rs.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest7, 1), (b18: rs.u8): boolean => { - return (b18 & 1) === 1; - })) { - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix48), 99)))); + } + } else if (_2258 === 1) { + const s13: rs.String = rs.stringNew(); + for (const b7 of rs.byteSliceView(rest7)) { + const _2359: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _2360: rs.usize = rs.usizeRem(b7 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_2359, _2360); + rs.stringPush(s13, _2359.data[_2359.start + _2360] as rs.char); + } + const _2371: string = s13.v; + const radix45: rs.u32 = radix43; + const _2374: rs.Result = num_fromStrRadix$0qyezqs(_2371, radix45); + if (_2374.ok) { + const arg23 = _2374.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg23, f)]).v); + } else { + const e26: rs.ParseIntError = _2374.error; + const _2390: rs.IntErrorKind = e26.kind; + if (_2390 === "Empty") { + kind27 = 0; + } else if (_2390 === "InvalidDigit") { + kind27 = 1; + } else if (_2390 === "PosOverflow") { + kind27 = 2; + } else if (_2390 === "NegOverflow") { + kind27 = 3; + } else { + kind27 = 4; } - if (!(rest7.length > 2)) { - text7 = rs.byteSliceFrom(Uint8Array.of()); + if (!(e26.kind === "PosOverflow" as rs.IntErrorKind)) { + over26 = e26.kind !== "NegOverflow" as rs.IntErrorKind; } else { - text7 = rs.byteSliceRange(rest7, 2); - } - const _2556: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text7), "1"); - const radix49: rs.u32 = radix48; - const _2561: rs.Result = num_fromStrRadix$0qyezqs(_2556, radix49); - if (_2561.ok) { - const arg21 = _2561.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg21, f)]).v); + over26 = true; + } + const _2410: rs.IntErrorKind = e26.kind; + const args237 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e26, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e26, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2410), (f: rs.Formatter) => rs.i32Display(kind27, f), (f: rs.Formatter) => rs.fmtBool(over26, f)]; + put(out, rs.fmtFormat([args237[0], "|", args237[1], "|", args237[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args237[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args237[0]), "|", args237[3], "|", args237[4]]).v); + } + if (radix45 === 10) { + const parsed26: rs.Result = parse$02m1946(_2371); + const from26: rs.Result = num_fromStr$1amqoj7(_2371); + if (from26.ok) { + max26 = rs.u8Mul(from26.value === 127 ? 1 : 0, 4); } else { - const e28: rs.ParseIntError = _2561.error; - const _2577: rs.IntErrorKind = e28.kind; - if (_2577 === "Empty") { - kind29 = 0; - } else if (_2577 === "InvalidDigit") { - kind29 = 1; - } else if (_2577 === "PosOverflow") { - kind29 = 2; - } else if (_2577 === "NegOverflow") { - kind29 = 3; - } else { - kind29 = 4; - } - if (!(e28.kind === "PosOverflow" as rs.IntErrorKind)) { - over28 = e28.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over28 = true; - } - const _2597: rs.IntErrorKind = e28.kind; - const args233 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e28, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e28, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2597), (f: rs.Formatter) => rs.i32Display(kind29, f), (f: rs.Formatter) => rs.fmtBool(over28, f)]; - put(out, rs.fmtFormat([args233[0], "|", args233[1], "|", args233[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args233[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args233[0]), "|", args233[3], "|", args233[4]]).v); - } - if (radix49 === 10) { - const parsed28: rs.Result = parse$02m1946(_2556); - const from28: rs.Result = num_fromStr$1amqoj7(_2556); - if (from28.ok) { - max28 = rs.u8Mul(from28.value === 127 ? 1 : 0, 4); - } else { - max28 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed28.ok ? 1 : 0, max28)); + max26 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed26.ok ? 1 : 0, max26)); } - } - } else if (_4 === 7) { - if (dataLen !== 0) { - const first8: rs.u8 = dataData[dataStart]; - const rest8: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix50: rs.u32 = rs.u32Add(2, rs.u32Rem(first8 as rs.u32, 35)); - const _2635: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); - if (_2635 === 0) { - const _2639: rs.Result = rs.strFromUtf8(rest8); - if (_2639.ok) { - const iter29: rs.Iter = rs.strChars(_2639.value); - while (true) { - const _2645: rs.char | rs.Done = iter29.next(); - if (_2645 === rs.DONE) { - break; - } - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_2645, radix50), 99)))); - } - const radix51: rs.u32 = radix50; - const _2660: rs.Result = num_fromStrRadix$19vdb8q(_2639.value, radix51); - if (_2660.ok) { - const arg20 = _2660.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg20, f)]).v); + } else if (_2258 === 2) { + const iter27: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); + while (true) { + const _2442: rs.u32 | rs.Done = iter27.next(); + if (_2442 === rs.DONE) { + break; + } + const radix46: rs.u32 = _2442; + for (const _2453 of edges(127, rs.u128Add(127, 1), 8, radix46).items) { + const _2461: string = _2453.v; + const radix47: rs.u32 = radix46; + const _2464: rs.Result = num_fromStrRadix$0qyezqs(_2461, radix47); + if (_2464.ok) { + const arg22 = _2464.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg22, f)]).v); } else { - const e29: rs.ParseIntError = _2660.error; - const _2676: rs.IntErrorKind = e29.kind; - if (_2676 === "Empty") { - kind30 = 0; - } else if (_2676 === "InvalidDigit") { - kind30 = 1; - } else if (_2676 === "PosOverflow") { - kind30 = 2; - } else if (_2676 === "NegOverflow") { - kind30 = 3; + const e27: rs.ParseIntError = _2464.error; + const _2480: rs.IntErrorKind = e27.kind; + if (_2480 === "Empty") { + kind28 = 0; + } else if (_2480 === "InvalidDigit") { + kind28 = 1; + } else if (_2480 === "PosOverflow") { + kind28 = 2; + } else if (_2480 === "NegOverflow") { + kind28 = 3; } else { - kind30 = 4; + kind28 = 4; } - if (!(e29.kind === "PosOverflow" as rs.IntErrorKind)) { - over29 = e29.kind !== "NegOverflow" as rs.IntErrorKind; + if (!(e27.kind === "PosOverflow" as rs.IntErrorKind)) { + over27 = e27.kind !== "NegOverflow" as rs.IntErrorKind; } else { - over29 = true; + over27 = true; } - const _2696: rs.IntErrorKind = e29.kind; - const args231 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e29, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e29, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2696), (f: rs.Formatter) => rs.i32Display(kind30, f), (f: rs.Formatter) => rs.fmtBool(over29, f)]; - put(out, rs.fmtFormat([args231[0], "|", args231[1], "|", args231[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args231[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args231[0]), "|", args231[3], "|", args231[4]]).v); + const _2500: rs.IntErrorKind = e27.kind; + const args235 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e27, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e27, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2500), (f: rs.Formatter) => rs.i32Display(kind28, f), (f: rs.Formatter) => rs.fmtBool(over27, f)]; + put(out, rs.fmtFormat([args235[0], "|", args235[1], "|", args235[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args235[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args235[0]), "|", args235[3], "|", args235[4]]).v); } - if (radix51 === 10) { - const parsed29: rs.Result = parse$00ajhlu(_2639.value); - const from29: rs.Result = num_fromStr$0ehcbzz(_2639.value); - if (from29.ok) { - max29 = rs.u8Mul(from29.value === 32767 ? 1 : 0, 4); + if (radix47 === 10) { + const parsed27: rs.Result = parse$02m1946(_2461); + const from27: rs.Result = num_fromStr$1amqoj7(_2461); + if (from27.ok) { + max27 = rs.u8Mul(from27.value === 127 ? 1 : 0, 4); } else { - max29 = 2; + max27 = 2; } - rs.byteVecPush(out, rs.u8Add(parsed29.ok ? 1 : 0, max29)); + rs.byteVecPush(out, rs.u8Add(parsed27.ok ? 1 : 0, max27)); } } - } else if (_2635 === 1) { - const s15: rs.String = rs.stringNew(); - for (const b8 of rs.byteSliceView(rest8)) { - const _2736: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _2737: rs.usize = rs.usizeRem(b8 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rs.idx(_2736, _2737); - rs.stringPush(s15, _2736.data[_2736.start + _2737] as rs.char); - } - const _2748: string = s15.v; - const radix52: rs.u32 = radix50; - const _2751: rs.Result = num_fromStrRadix$19vdb8q(_2748, radix52); - if (_2751.ok) { - const arg19 = _2751.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg19, f)]).v); + } + } else { + const radix48: rs.u32 = ((first7 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest7), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest7, 1), (b18: rs.u8): boolean => { + return (b18 & 1) === 1; + })) { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix48), 99)))); + } + if (!(rest7.length > 2)) { + text7 = rs.byteSliceFrom(Uint8Array.of()); + } else { + text7 = rs.byteSliceRange(rest7, 2); + } + const _2556: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text7), "1"); + const radix49: rs.u32 = radix48; + const _2561: rs.Result = num_fromStrRadix$0qyezqs(_2556, radix49); + if (_2561.ok) { + const arg21 = _2561.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg21, f)]).v); + } else { + const e28: rs.ParseIntError = _2561.error; + const _2577: rs.IntErrorKind = e28.kind; + if (_2577 === "Empty") { + kind29 = 0; + } else if (_2577 === "InvalidDigit") { + kind29 = 1; + } else if (_2577 === "PosOverflow") { + kind29 = 2; + } else if (_2577 === "NegOverflow") { + kind29 = 3; + } else { + kind29 = 4; + } + if (!(e28.kind === "PosOverflow" as rs.IntErrorKind)) { + over28 = e28.kind !== "NegOverflow" as rs.IntErrorKind; } else { - const e30: rs.ParseIntError = _2751.error; - const _2767: rs.IntErrorKind = e30.kind; - if (_2767 === "Empty") { - kind31 = 0; - } else if (_2767 === "InvalidDigit") { - kind31 = 1; - } else if (_2767 === "PosOverflow") { - kind31 = 2; - } else if (_2767 === "NegOverflow") { - kind31 = 3; - } else { - kind31 = 4; + over28 = true; + } + const _2597: rs.IntErrorKind = e28.kind; + const args233 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e28, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e28, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2597), (f: rs.Formatter) => rs.i32Display(kind29, f), (f: rs.Formatter) => rs.fmtBool(over28, f)]; + put(out, rs.fmtFormat([args233[0], "|", args233[1], "|", args233[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args233[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args233[0]), "|", args233[3], "|", args233[4]]).v); + } + if (radix49 === 10) { + const parsed28: rs.Result = parse$02m1946(_2556); + const from28: rs.Result = num_fromStr$1amqoj7(_2556); + if (from28.ok) { + max28 = rs.u8Mul(from28.value === 127 ? 1 : 0, 4); + } else { + max28 = 2; + } + rs.byteVecPush(out, rs.u8Add(parsed28.ok ? 1 : 0, max28)); + } + } + } + } else if (_4 === 7) { + if (dataLen !== 0) { + const first8: rs.u8 = dataData[dataStart]; + const rest8: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix50: rs.u32 = rs.u32Add(2, rs.u32Rem(first8 as rs.u32, 35)); + const _2635: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); + if (_2635 === 0) { + const _2639: rs.Result = rs.strFromUtf8(rest8); + if (_2639.ok) { + const iter29: rs.Iter = rs.strChars(_2639.value); + while (true) { + const _2645: rs.char | rs.Done = iter29.next(); + if (_2645 === rs.DONE) { + break; } - if (!(e30.kind === "PosOverflow" as rs.IntErrorKind)) { - over30 = e30.kind !== "NegOverflow" as rs.IntErrorKind; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_2645, radix50), 99)))); + } + const radix51: rs.u32 = radix50; + const _2660: rs.Result = num_fromStrRadix$19vdb8q(_2639.value, radix51); + if (_2660.ok) { + const arg20 = _2660.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg20, f)]).v); + } else { + const e29: rs.ParseIntError = _2660.error; + const _2676: rs.IntErrorKind = e29.kind; + if (_2676 === "Empty") { + kind30 = 0; + } else if (_2676 === "InvalidDigit") { + kind30 = 1; + } else if (_2676 === "PosOverflow") { + kind30 = 2; + } else if (_2676 === "NegOverflow") { + kind30 = 3; } else { - over30 = true; + kind30 = 4; } - const _2787: rs.IntErrorKind = e30.kind; - const args229 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e30, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e30, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2787), (f: rs.Formatter) => rs.i32Display(kind31, f), (f: rs.Formatter) => rs.fmtBool(over30, f)]; - put(out, rs.fmtFormat([args229[0], "|", args229[1], "|", args229[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args229[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args229[0]), "|", args229[3], "|", args229[4]]).v); - } - if (radix52 === 10) { - const parsed30: rs.Result = parse$00ajhlu(_2748); - const from30: rs.Result = num_fromStr$0ehcbzz(_2748); - if (from30.ok) { - max30 = rs.u8Mul(from30.value === 32767 ? 1 : 0, 4); + if (!(e29.kind === "PosOverflow" as rs.IntErrorKind)) { + over29 = e29.kind !== "NegOverflow" as rs.IntErrorKind; } else { - max30 = 2; + over29 = true; } - rs.byteVecPush(out, rs.u8Add(parsed30.ok ? 1 : 0, max30)); + const _2696: rs.IntErrorKind = e29.kind; + const args231 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e29, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e29, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2696), (f: rs.Formatter) => rs.i32Display(kind30, f), (f: rs.Formatter) => rs.fmtBool(over29, f)]; + put(out, rs.fmtFormat([args231[0], "|", args231[1], "|", args231[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args231[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args231[0]), "|", args231[3], "|", args231[4]]).v); } - } else { - if (_2635 === 2) { - const iter31: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); - while (true) { - const _2819: rs.u32 | rs.Done = iter31.next(); - if (_2819 === rs.DONE) { - break b0; - } - const radix53: rs.u32 = _2819; - for (const _2830 of edges(32767, rs.u128Add(32767, 1), 16, radix53).items) { - const _2838: string = _2830.v; - const radix54: rs.u32 = radix53; - const _2841: rs.Result = num_fromStrRadix$19vdb8q(_2838, radix54); - if (_2841.ok) { - const arg18 = _2841.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg18, f)]).v); - } else { - const e31: rs.ParseIntError = _2841.error; - const _2857: rs.IntErrorKind = e31.kind; - if (_2857 === "Empty") { - kind32 = 0; - } else if (_2857 === "InvalidDigit") { - kind32 = 1; - } else if (_2857 === "PosOverflow") { - kind32 = 2; - } else if (_2857 === "NegOverflow") { - kind32 = 3; - } else { - kind32 = 4; - } - if (!(e31.kind === "PosOverflow" as rs.IntErrorKind)) { - over31 = e31.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over31 = true; - } - const _2877: rs.IntErrorKind = e31.kind; - const args227 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e31, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e31, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2877), (f: rs.Formatter) => rs.i32Display(kind32, f), (f: rs.Formatter) => rs.fmtBool(over31, f)]; - put(out, rs.fmtFormat([args227[0], "|", args227[1], "|", args227[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args227[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args227[0]), "|", args227[3], "|", args227[4]]).v); - } - if (radix54 === 10) { - const parsed31: rs.Result = parse$00ajhlu(_2838); - const from31: rs.Result = num_fromStr$0ehcbzz(_2838); - if (from31.ok) { - max31 = rs.u8Mul(from31.value === 32767 ? 1 : 0, 4); - } else { - max31 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed31.ok ? 1 : 0, max31)); - } - } + if (radix51 === 10) { + const parsed29: rs.Result = parse$00ajhlu(_2639.value); + const from29: rs.Result = num_fromStr$0ehcbzz(_2639.value); + if (from29.ok) { + max29 = rs.u8Mul(from29.value === 32767 ? 1 : 0, 4); + } else { + max29 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed29.ok ? 1 : 0, max29)); } - const radix55: rs.u32 = ((first8 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest8), 0) as rs.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest8, 1), (b17: rs.u8): boolean => { - return (b17 & 1) === 1; - })) { - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix55), 99)))); + } + } else if (_2635 === 1) { + const s15: rs.String = rs.stringNew(); + for (const b8 of rs.byteSliceView(rest8)) { + const _2736: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _2737: rs.usize = rs.usizeRem(b8 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_2736, _2737); + rs.stringPush(s15, _2736.data[_2736.start + _2737] as rs.char); + } + const _2748: string = s15.v; + const radix52: rs.u32 = radix50; + const _2751: rs.Result = num_fromStrRadix$19vdb8q(_2748, radix52); + if (_2751.ok) { + const arg19 = _2751.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg19, f)]).v); + } else { + const e30: rs.ParseIntError = _2751.error; + const _2767: rs.IntErrorKind = e30.kind; + if (_2767 === "Empty") { + kind31 = 0; + } else if (_2767 === "InvalidDigit") { + kind31 = 1; + } else if (_2767 === "PosOverflow") { + kind31 = 2; + } else if (_2767 === "NegOverflow") { + kind31 = 3; + } else { + kind31 = 4; } - if (!(rest8.length > 2)) { - text8 = rs.byteSliceFrom(Uint8Array.of()); + if (!(e30.kind === "PosOverflow" as rs.IntErrorKind)) { + over30 = e30.kind !== "NegOverflow" as rs.IntErrorKind; } else { - text8 = rs.byteSliceRange(rest8, 2); - } - const _2933: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text8), "1"); - const radix56: rs.u32 = radix55; - const _2938: rs.Result = num_fromStrRadix$19vdb8q(_2933, radix56); - if (_2938.ok) { - const arg17 = _2938.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg17, f)]).v); + over30 = true; + } + const _2787: rs.IntErrorKind = e30.kind; + const args229 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e30, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e30, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2787), (f: rs.Formatter) => rs.i32Display(kind31, f), (f: rs.Formatter) => rs.fmtBool(over30, f)]; + put(out, rs.fmtFormat([args229[0], "|", args229[1], "|", args229[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args229[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args229[0]), "|", args229[3], "|", args229[4]]).v); + } + if (radix52 === 10) { + const parsed30: rs.Result = parse$00ajhlu(_2748); + const from30: rs.Result = num_fromStr$0ehcbzz(_2748); + if (from30.ok) { + max30 = rs.u8Mul(from30.value === 32767 ? 1 : 0, 4); } else { - const e32: rs.ParseIntError = _2938.error; - const _2954: rs.IntErrorKind = e32.kind; - if (_2954 === "Empty") { - kind33 = 0; - } else if (_2954 === "InvalidDigit") { - kind33 = 1; - } else if (_2954 === "PosOverflow") { - kind33 = 2; - } else if (_2954 === "NegOverflow") { - kind33 = 3; - } else { - kind33 = 4; - } - if (!(e32.kind === "PosOverflow" as rs.IntErrorKind)) { - over32 = e32.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over32 = true; - } - const _2974: rs.IntErrorKind = e32.kind; - const args225 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e32, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e32, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2974), (f: rs.Formatter) => rs.i32Display(kind33, f), (f: rs.Formatter) => rs.fmtBool(over32, f)]; - put(out, rs.fmtFormat([args225[0], "|", args225[1], "|", args225[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args225[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args225[0]), "|", args225[3], "|", args225[4]]).v); - } - if (radix56 === 10) { - const parsed32: rs.Result = parse$00ajhlu(_2933); - const from32: rs.Result = num_fromStr$0ehcbzz(_2933); - if (from32.ok) { - max32 = rs.u8Mul(from32.value === 32767 ? 1 : 0, 4); - } else { - max32 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed32.ok ? 1 : 0, max32)); + max30 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed30.ok ? 1 : 0, max30)); } - } - } else if (_4 === 8) { - if (dataLen !== 0) { - const first9: rs.u8 = dataData[dataStart]; - const rest9: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix57: rs.u32 = rs.u32Add(2, rs.u32Rem(first9 as rs.u32, 35)); - const _3012: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); - if (_3012 === 0) { - const _3016: rs.Result = rs.strFromUtf8(rest9); - if (_3016.ok) { - const iter33: rs.Iter = rs.strChars(_3016.value); - while (true) { - const _3022: rs.char | rs.Done = iter33.next(); - if (_3022 === rs.DONE) { - break; - } - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_3022, radix57), 99)))); - } - const radix58: rs.u32 = radix57; - const _3037: rs.Result = num_fromStrRadix$1ct8u92(_3016.value, radix58); - if (_3037.ok) { - const arg16 = _3037.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg16, f)]).v); + } else if (_2635 === 2) { + const iter31: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); + while (true) { + const _2819: rs.u32 | rs.Done = iter31.next(); + if (_2819 === rs.DONE) { + break; + } + const radix53: rs.u32 = _2819; + for (const _2830 of edges(32767, rs.u128Add(32767, 1), 16, radix53).items) { + const _2838: string = _2830.v; + const radix54: rs.u32 = radix53; + const _2841: rs.Result = num_fromStrRadix$19vdb8q(_2838, radix54); + if (_2841.ok) { + const arg18 = _2841.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg18, f)]).v); } else { - const e33: rs.ParseIntError = _3037.error; - const _3053: rs.IntErrorKind = e33.kind; - if (_3053 === "Empty") { - kind34 = 0; - } else if (_3053 === "InvalidDigit") { - kind34 = 1; - } else if (_3053 === "PosOverflow") { - kind34 = 2; - } else if (_3053 === "NegOverflow") { - kind34 = 3; + const e31: rs.ParseIntError = _2841.error; + const _2857: rs.IntErrorKind = e31.kind; + if (_2857 === "Empty") { + kind32 = 0; + } else if (_2857 === "InvalidDigit") { + kind32 = 1; + } else if (_2857 === "PosOverflow") { + kind32 = 2; + } else if (_2857 === "NegOverflow") { + kind32 = 3; } else { - kind34 = 4; + kind32 = 4; } - if (!(e33.kind === "PosOverflow" as rs.IntErrorKind)) { - over33 = e33.kind !== "NegOverflow" as rs.IntErrorKind; + if (!(e31.kind === "PosOverflow" as rs.IntErrorKind)) { + over31 = e31.kind !== "NegOverflow" as rs.IntErrorKind; } else { - over33 = true; + over31 = true; } - const _3073: rs.IntErrorKind = e33.kind; - const args223 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e33, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e33, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3073), (f: rs.Formatter) => rs.i32Display(kind34, f), (f: rs.Formatter) => rs.fmtBool(over33, f)]; - put(out, rs.fmtFormat([args223[0], "|", args223[1], "|", args223[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args223[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args223[0]), "|", args223[3], "|", args223[4]]).v); + const _2877: rs.IntErrorKind = e31.kind; + const args227 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e31, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e31, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2877), (f: rs.Formatter) => rs.i32Display(kind32, f), (f: rs.Formatter) => rs.fmtBool(over31, f)]; + put(out, rs.fmtFormat([args227[0], "|", args227[1], "|", args227[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args227[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args227[0]), "|", args227[3], "|", args227[4]]).v); } - if (radix58 === 10) { - const parsed33: rs.Result = parse$14v13am(_3016.value); - const from33: rs.Result = num_fromStr$1ckv470(_3016.value); - if (from33.ok) { - max33 = rs.u8Mul(from33.value === 2147483647 ? 1 : 0, 4); + if (radix54 === 10) { + const parsed31: rs.Result = parse$00ajhlu(_2838); + const from31: rs.Result = num_fromStr$0ehcbzz(_2838); + if (from31.ok) { + max31 = rs.u8Mul(from31.value === 32767 ? 1 : 0, 4); } else { - max33 = 2; + max31 = 2; } - rs.byteVecPush(out, rs.u8Add(parsed33.ok ? 1 : 0, max33)); + rs.byteVecPush(out, rs.u8Add(parsed31.ok ? 1 : 0, max31)); } } - } else if (_3012 === 1) { - const s17: rs.String = rs.stringNew(); - for (const b9 of rs.byteSliceView(rest9)) { - const _3113: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _3114: rs.usize = rs.usizeRem(b9 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rs.idx(_3113, _3114); - rs.stringPush(s17, _3113.data[_3113.start + _3114] as rs.char); - } - const _3125: string = s17.v; - const radix59: rs.u32 = radix57; - const _3128: rs.Result = num_fromStrRadix$1ct8u92(_3125, radix59); - if (_3128.ok) { - const arg15 = _3128.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg15, f)]).v); + } + } else { + const radix55: rs.u32 = ((first8 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest8), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest8, 1), (b17: rs.u8): boolean => { + return (b17 & 1) === 1; + })) { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix55), 99)))); + } + if (!(rest8.length > 2)) { + text8 = rs.byteSliceFrom(Uint8Array.of()); + } else { + text8 = rs.byteSliceRange(rest8, 2); + } + const _2933: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text8), "1"); + const radix56: rs.u32 = radix55; + const _2938: rs.Result = num_fromStrRadix$19vdb8q(_2933, radix56); + if (_2938.ok) { + const arg17 = _2938.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg17, f)]).v); + } else { + const e32: rs.ParseIntError = _2938.error; + const _2954: rs.IntErrorKind = e32.kind; + if (_2954 === "Empty") { + kind33 = 0; + } else if (_2954 === "InvalidDigit") { + kind33 = 1; + } else if (_2954 === "PosOverflow") { + kind33 = 2; + } else if (_2954 === "NegOverflow") { + kind33 = 3; + } else { + kind33 = 4; + } + if (!(e32.kind === "PosOverflow" as rs.IntErrorKind)) { + over32 = e32.kind !== "NegOverflow" as rs.IntErrorKind; } else { - const e34: rs.ParseIntError = _3128.error; - const _3144: rs.IntErrorKind = e34.kind; - if (_3144 === "Empty") { - kind35 = 0; - } else if (_3144 === "InvalidDigit") { - kind35 = 1; - } else if (_3144 === "PosOverflow") { - kind35 = 2; - } else if (_3144 === "NegOverflow") { - kind35 = 3; - } else { - kind35 = 4; + over32 = true; + } + const _2974: rs.IntErrorKind = e32.kind; + const args225 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e32, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e32, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2974), (f: rs.Formatter) => rs.i32Display(kind33, f), (f: rs.Formatter) => rs.fmtBool(over32, f)]; + put(out, rs.fmtFormat([args225[0], "|", args225[1], "|", args225[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args225[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args225[0]), "|", args225[3], "|", args225[4]]).v); + } + if (radix56 === 10) { + const parsed32: rs.Result = parse$00ajhlu(_2933); + const from32: rs.Result = num_fromStr$0ehcbzz(_2933); + if (from32.ok) { + max32 = rs.u8Mul(from32.value === 32767 ? 1 : 0, 4); + } else { + max32 = 2; + } + rs.byteVecPush(out, rs.u8Add(parsed32.ok ? 1 : 0, max32)); + } + } + } + } else if (_4 === 8) { + if (dataLen !== 0) { + const first9: rs.u8 = dataData[dataStart]; + const rest9: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix57: rs.u32 = rs.u32Add(2, rs.u32Rem(first9 as rs.u32, 35)); + const _3012: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); + if (_3012 === 0) { + const _3016: rs.Result = rs.strFromUtf8(rest9); + if (_3016.ok) { + const iter33: rs.Iter = rs.strChars(_3016.value); + while (true) { + const _3022: rs.char | rs.Done = iter33.next(); + if (_3022 === rs.DONE) { + break; } - if (!(e34.kind === "PosOverflow" as rs.IntErrorKind)) { - over34 = e34.kind !== "NegOverflow" as rs.IntErrorKind; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_3022, radix57), 99)))); + } + const radix58: rs.u32 = radix57; + const _3037: rs.Result = num_fromStrRadix$1ct8u92(_3016.value, radix58); + if (_3037.ok) { + const arg16 = _3037.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg16, f)]).v); + } else { + const e33: rs.ParseIntError = _3037.error; + const _3053: rs.IntErrorKind = e33.kind; + if (_3053 === "Empty") { + kind34 = 0; + } else if (_3053 === "InvalidDigit") { + kind34 = 1; + } else if (_3053 === "PosOverflow") { + kind34 = 2; + } else if (_3053 === "NegOverflow") { + kind34 = 3; } else { - over34 = true; + kind34 = 4; } - const _3164: rs.IntErrorKind = e34.kind; - const args221 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e34, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e34, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3164), (f: rs.Formatter) => rs.i32Display(kind35, f), (f: rs.Formatter) => rs.fmtBool(over34, f)]; - put(out, rs.fmtFormat([args221[0], "|", args221[1], "|", args221[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args221[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args221[0]), "|", args221[3], "|", args221[4]]).v); - } - if (radix59 === 10) { - const parsed34: rs.Result = parse$14v13am(_3125); - const from34: rs.Result = num_fromStr$1ckv470(_3125); - if (from34.ok) { - max34 = rs.u8Mul(from34.value === 2147483647 ? 1 : 0, 4); + if (!(e33.kind === "PosOverflow" as rs.IntErrorKind)) { + over33 = e33.kind !== "NegOverflow" as rs.IntErrorKind; } else { - max34 = 2; + over33 = true; } - rs.byteVecPush(out, rs.u8Add(parsed34.ok ? 1 : 0, max34)); + const _3073: rs.IntErrorKind = e33.kind; + const args223 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e33, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e33, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3073), (f: rs.Formatter) => rs.i32Display(kind34, f), (f: rs.Formatter) => rs.fmtBool(over33, f)]; + put(out, rs.fmtFormat([args223[0], "|", args223[1], "|", args223[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args223[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args223[0]), "|", args223[3], "|", args223[4]]).v); } - } else { - if (_3012 === 2) { - const iter35: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); - while (true) { - const _3196: rs.u32 | rs.Done = iter35.next(); - if (_3196 === rs.DONE) { - break b0; - } - const radix60: rs.u32 = _3196; - for (const _3207 of edges(2147483647, rs.u128Add(2147483647, 1), 32, radix60).items) { - const _3215: string = _3207.v; - const radix61: rs.u32 = radix60; - const _3218: rs.Result = num_fromStrRadix$1ct8u92(_3215, radix61); - if (_3218.ok) { - const arg14 = _3218.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg14, f)]).v); - } else { - const e35: rs.ParseIntError = _3218.error; - const _3234: rs.IntErrorKind = e35.kind; - if (_3234 === "Empty") { - kind36 = 0; - } else if (_3234 === "InvalidDigit") { - kind36 = 1; - } else if (_3234 === "PosOverflow") { - kind36 = 2; - } else if (_3234 === "NegOverflow") { - kind36 = 3; - } else { - kind36 = 4; - } - if (!(e35.kind === "PosOverflow" as rs.IntErrorKind)) { - over35 = e35.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over35 = true; - } - const _3254: rs.IntErrorKind = e35.kind; - const args219 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e35, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e35, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3254), (f: rs.Formatter) => rs.i32Display(kind36, f), (f: rs.Formatter) => rs.fmtBool(over35, f)]; - put(out, rs.fmtFormat([args219[0], "|", args219[1], "|", args219[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args219[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args219[0]), "|", args219[3], "|", args219[4]]).v); - } - if (radix61 === 10) { - const parsed35: rs.Result = parse$14v13am(_3215); - const from35: rs.Result = num_fromStr$1ckv470(_3215); - if (from35.ok) { - max35 = rs.u8Mul(from35.value === 2147483647 ? 1 : 0, 4); - } else { - max35 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed35.ok ? 1 : 0, max35)); - } - } + if (radix58 === 10) { + const parsed33: rs.Result = parse$14v13am(_3016.value); + const from33: rs.Result = num_fromStr$1ckv470(_3016.value); + if (from33.ok) { + max33 = rs.u8Mul(from33.value === 2147483647 ? 1 : 0, 4); + } else { + max33 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed33.ok ? 1 : 0, max33)); } - const radix62: rs.u32 = ((first9 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest9), 0) as rs.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest9, 1), (b16: rs.u8): boolean => { - return (b16 & 1) === 1; - })) { - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix62), 99)))); + } + } else if (_3012 === 1) { + const s17: rs.String = rs.stringNew(); + for (const b9 of rs.byteSliceView(rest9)) { + const _3113: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _3114: rs.usize = rs.usizeRem(b9 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_3113, _3114); + rs.stringPush(s17, _3113.data[_3113.start + _3114] as rs.char); + } + const _3125: string = s17.v; + const radix59: rs.u32 = radix57; + const _3128: rs.Result = num_fromStrRadix$1ct8u92(_3125, radix59); + if (_3128.ok) { + const arg15 = _3128.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg15, f)]).v); + } else { + const e34: rs.ParseIntError = _3128.error; + const _3144: rs.IntErrorKind = e34.kind; + if (_3144 === "Empty") { + kind35 = 0; + } else if (_3144 === "InvalidDigit") { + kind35 = 1; + } else if (_3144 === "PosOverflow") { + kind35 = 2; + } else if (_3144 === "NegOverflow") { + kind35 = 3; + } else { + kind35 = 4; } - if (!(rest9.length > 2)) { - text9 = rs.byteSliceFrom(Uint8Array.of()); + if (!(e34.kind === "PosOverflow" as rs.IntErrorKind)) { + over34 = e34.kind !== "NegOverflow" as rs.IntErrorKind; } else { - text9 = rs.byteSliceRange(rest9, 2); - } - const _3310: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text9), "1"); - const radix63: rs.u32 = radix62; - const _3315: rs.Result = num_fromStrRadix$1ct8u92(_3310, radix63); - if (_3315.ok) { - const arg13 = _3315.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg13, f)]).v); + over34 = true; + } + const _3164: rs.IntErrorKind = e34.kind; + const args221 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e34, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e34, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3164), (f: rs.Formatter) => rs.i32Display(kind35, f), (f: rs.Formatter) => rs.fmtBool(over34, f)]; + put(out, rs.fmtFormat([args221[0], "|", args221[1], "|", args221[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args221[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args221[0]), "|", args221[3], "|", args221[4]]).v); + } + if (radix59 === 10) { + const parsed34: rs.Result = parse$14v13am(_3125); + const from34: rs.Result = num_fromStr$1ckv470(_3125); + if (from34.ok) { + max34 = rs.u8Mul(from34.value === 2147483647 ? 1 : 0, 4); } else { - const e36: rs.ParseIntError = _3315.error; - const _3331: rs.IntErrorKind = e36.kind; - if (_3331 === "Empty") { - kind37 = 0; - } else if (_3331 === "InvalidDigit") { - kind37 = 1; - } else if (_3331 === "PosOverflow") { - kind37 = 2; - } else if (_3331 === "NegOverflow") { - kind37 = 3; - } else { - kind37 = 4; - } - if (!(e36.kind === "PosOverflow" as rs.IntErrorKind)) { - over36 = e36.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over36 = true; - } - const _3351: rs.IntErrorKind = e36.kind; - const args217 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e36, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e36, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3351), (f: rs.Formatter) => rs.i32Display(kind37, f), (f: rs.Formatter) => rs.fmtBool(over36, f)]; - put(out, rs.fmtFormat([args217[0], "|", args217[1], "|", args217[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args217[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args217[0]), "|", args217[3], "|", args217[4]]).v); - } - if (radix63 === 10) { - const parsed36: rs.Result = parse$14v13am(_3310); - const from36: rs.Result = num_fromStr$1ckv470(_3310); - if (from36.ok) { - max36 = rs.u8Mul(from36.value === 2147483647 ? 1 : 0, 4); - } else { - max36 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed36.ok ? 1 : 0, max36)); + max34 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed34.ok ? 1 : 0, max34)); } - } - } else if (_4 === 9) { - if (dataLen !== 0) { - const first10: rs.u8 = dataData[dataStart]; - const rest10: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix64: rs.u32 = rs.u32Add(2, rs.u32Rem(first10 as rs.u32, 35)); - const _3389: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); - if (_3389 === 0) { - const _3393: rs.Result = rs.strFromUtf8(rest10); - if (_3393.ok) { - const iter37: rs.Iter = rs.strChars(_3393.value); - while (true) { - const _3399: rs.char | rs.Done = iter37.next(); - if (_3399 === rs.DONE) { - break; - } - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_3399, radix64), 99)))); - } - const radix65: rs.u32 = radix64; - const _3414: rs.Result = num_fromStrRadix$04fc4zz(_3393.value, radix65); - if (_3414.ok) { - const arg12 = _3414.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg12, f)]).v); + } else if (_3012 === 2) { + const iter35: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); + while (true) { + const _3196: rs.u32 | rs.Done = iter35.next(); + if (_3196 === rs.DONE) { + break; + } + const radix60: rs.u32 = _3196; + for (const _3207 of edges(2147483647, rs.u128Add(2147483647, 1), 32, radix60).items) { + const _3215: string = _3207.v; + const radix61: rs.u32 = radix60; + const _3218: rs.Result = num_fromStrRadix$1ct8u92(_3215, radix61); + if (_3218.ok) { + const arg14 = _3218.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg14, f)]).v); } else { - const e37: rs.ParseIntError = _3414.error; - const _3430: rs.IntErrorKind = e37.kind; - if (_3430 === "Empty") { - kind38 = 0; - } else if (_3430 === "InvalidDigit") { - kind38 = 1; - } else if (_3430 === "PosOverflow") { - kind38 = 2; - } else if (_3430 === "NegOverflow") { - kind38 = 3; + const e35: rs.ParseIntError = _3218.error; + const _3234: rs.IntErrorKind = e35.kind; + if (_3234 === "Empty") { + kind36 = 0; + } else if (_3234 === "InvalidDigit") { + kind36 = 1; + } else if (_3234 === "PosOverflow") { + kind36 = 2; + } else if (_3234 === "NegOverflow") { + kind36 = 3; } else { - kind38 = 4; + kind36 = 4; } - if (!(e37.kind === "PosOverflow" as rs.IntErrorKind)) { - over37 = e37.kind !== "NegOverflow" as rs.IntErrorKind; + if (!(e35.kind === "PosOverflow" as rs.IntErrorKind)) { + over35 = e35.kind !== "NegOverflow" as rs.IntErrorKind; } else { - over37 = true; + over35 = true; } - const _3450: rs.IntErrorKind = e37.kind; - const args215 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e37, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e37, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3450), (f: rs.Formatter) => rs.i32Display(kind38, f), (f: rs.Formatter) => rs.fmtBool(over37, f)]; - put(out, rs.fmtFormat([args215[0], "|", args215[1], "|", args215[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args215[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args215[0]), "|", args215[3], "|", args215[4]]).v); + const _3254: rs.IntErrorKind = e35.kind; + const args219 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e35, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e35, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3254), (f: rs.Formatter) => rs.i32Display(kind36, f), (f: rs.Formatter) => rs.fmtBool(over35, f)]; + put(out, rs.fmtFormat([args219[0], "|", args219[1], "|", args219[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args219[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args219[0]), "|", args219[3], "|", args219[4]]).v); } - if (radix65 === 10) { - const parsed37: rs.Result = parse$0px1msj(_3393.value); - const from37: rs.Result = num_fromStr$00n8jbp(_3393.value); - if (from37.ok) { - max37 = rs.u8Mul(rs.i64Eq(from37.value, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64) ? 1 : 0, 4); + if (radix61 === 10) { + const parsed35: rs.Result = parse$14v13am(_3215); + const from35: rs.Result = num_fromStr$1ckv470(_3215); + if (from35.ok) { + max35 = rs.u8Mul(from35.value === 2147483647 ? 1 : 0, 4); } else { - max37 = 2; + max35 = 2; } - rs.byteVecPush(out, rs.u8Add(parsed37.ok ? 1 : 0, max37)); + rs.byteVecPush(out, rs.u8Add(parsed35.ok ? 1 : 0, max35)); } } - } else if (_3389 === 1) { - const s19: rs.String = rs.stringNew(); - for (const b10 of rs.byteSliceView(rest10)) { - const _3490: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _3491: rs.usize = rs.usizeRem(b10 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rs.idx(_3490, _3491); - rs.stringPush(s19, _3490.data[_3490.start + _3491] as rs.char); - } - const _3502: string = s19.v; - const radix66: rs.u32 = radix64; - const _3505: rs.Result = num_fromStrRadix$04fc4zz(_3502, radix66); - if (_3505.ok) { - const arg11 = _3505.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg11, f)]).v); + } + } else { + const radix62: rs.u32 = ((first9 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest9), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest9, 1), (b16: rs.u8): boolean => { + return (b16 & 1) === 1; + })) { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix62), 99)))); + } + if (!(rest9.length > 2)) { + text9 = rs.byteSliceFrom(Uint8Array.of()); + } else { + text9 = rs.byteSliceRange(rest9, 2); + } + const _3310: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text9), "1"); + const radix63: rs.u32 = radix62; + const _3315: rs.Result = num_fromStrRadix$1ct8u92(_3310, radix63); + if (_3315.ok) { + const arg13 = _3315.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg13, f)]).v); + } else { + const e36: rs.ParseIntError = _3315.error; + const _3331: rs.IntErrorKind = e36.kind; + if (_3331 === "Empty") { + kind37 = 0; + } else if (_3331 === "InvalidDigit") { + kind37 = 1; + } else if (_3331 === "PosOverflow") { + kind37 = 2; + } else if (_3331 === "NegOverflow") { + kind37 = 3; } else { - const e38: rs.ParseIntError = _3505.error; - const _3521: rs.IntErrorKind = e38.kind; - if (_3521 === "Empty") { - kind39 = 0; - } else if (_3521 === "InvalidDigit") { - kind39 = 1; - } else if (_3521 === "PosOverflow") { - kind39 = 2; - } else if (_3521 === "NegOverflow") { - kind39 = 3; - } else { - kind39 = 4; + kind37 = 4; + } + if (!(e36.kind === "PosOverflow" as rs.IntErrorKind)) { + over36 = e36.kind !== "NegOverflow" as rs.IntErrorKind; + } else { + over36 = true; + } + const _3351: rs.IntErrorKind = e36.kind; + const args217 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e36, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e36, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3351), (f: rs.Formatter) => rs.i32Display(kind37, f), (f: rs.Formatter) => rs.fmtBool(over36, f)]; + put(out, rs.fmtFormat([args217[0], "|", args217[1], "|", args217[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args217[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args217[0]), "|", args217[3], "|", args217[4]]).v); + } + if (radix63 === 10) { + const parsed36: rs.Result = parse$14v13am(_3310); + const from36: rs.Result = num_fromStr$1ckv470(_3310); + if (from36.ok) { + max36 = rs.u8Mul(from36.value === 2147483647 ? 1 : 0, 4); + } else { + max36 = 2; + } + rs.byteVecPush(out, rs.u8Add(parsed36.ok ? 1 : 0, max36)); + } + } + } + } else if (_4 === 9) { + if (dataLen !== 0) { + const first10: rs.u8 = dataData[dataStart]; + const rest10: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix64: rs.u32 = rs.u32Add(2, rs.u32Rem(first10 as rs.u32, 35)); + const _3389: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); + if (_3389 === 0) { + const _3393: rs.Result = rs.strFromUtf8(rest10); + if (_3393.ok) { + const iter37: rs.Iter = rs.strChars(_3393.value); + while (true) { + const _3399: rs.char | rs.Done = iter37.next(); + if (_3399 === rs.DONE) { + break; } - if (!(e38.kind === "PosOverflow" as rs.IntErrorKind)) { - over38 = e38.kind !== "NegOverflow" as rs.IntErrorKind; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_3399, radix64), 99)))); + } + const radix65: rs.u32 = radix64; + const _3414: rs.Result = num_fromStrRadix$04fc4zz(_3393.value, radix65); + if (_3414.ok) { + const arg12 = _3414.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg12, f)]).v); + } else { + const e37: rs.ParseIntError = _3414.error; + const _3430: rs.IntErrorKind = e37.kind; + if (_3430 === "Empty") { + kind38 = 0; + } else if (_3430 === "InvalidDigit") { + kind38 = 1; + } else if (_3430 === "PosOverflow") { + kind38 = 2; + } else if (_3430 === "NegOverflow") { + kind38 = 3; } else { - over38 = true; + kind38 = 4; } - const _3541: rs.IntErrorKind = e38.kind; - const args213 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e38, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e38, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3541), (f: rs.Formatter) => rs.i32Display(kind39, f), (f: rs.Formatter) => rs.fmtBool(over38, f)]; - put(out, rs.fmtFormat([args213[0], "|", args213[1], "|", args213[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args213[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args213[0]), "|", args213[3], "|", args213[4]]).v); - } - if (radix66 === 10) { - const parsed38: rs.Result = parse$0px1msj(_3502); - const from38: rs.Result = num_fromStr$00n8jbp(_3502); - if (from38.ok) { - max38 = rs.u8Mul(rs.i64Eq(from38.value, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64) ? 1 : 0, 4); + if (!(e37.kind === "PosOverflow" as rs.IntErrorKind)) { + over37 = e37.kind !== "NegOverflow" as rs.IntErrorKind; } else { - max38 = 2; + over37 = true; } - rs.byteVecPush(out, rs.u8Add(parsed38.ok ? 1 : 0, max38)); + const _3450: rs.IntErrorKind = e37.kind; + const args215 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e37, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e37, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3450), (f: rs.Formatter) => rs.i32Display(kind38, f), (f: rs.Formatter) => rs.fmtBool(over37, f)]; + put(out, rs.fmtFormat([args215[0], "|", args215[1], "|", args215[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args215[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args215[0]), "|", args215[3], "|", args215[4]]).v); } - } else { - if (_3389 === 2) { - const iter39: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); - while (true) { - const _3573: rs.u32 | rs.Done = iter39.next(); - if (_3573 === rs.DONE) { - break b0; - } - const radix67: rs.u32 = _3573; - for (const _3584 of edges({ hi: 0, w2: 0, w1: 0x7fffffff, lo: 0xffffffff } as rs.u128, rs.u128Add({ hi: 0, w2: 0, w1: 0x7fffffff, lo: 0xffffffff } as rs.u128, 1), 64, radix67).items) { - const _3592: string = _3584.v; - const radix68: rs.u32 = radix67; - const _3595: rs.Result = num_fromStrRadix$04fc4zz(_3592, radix68); - if (_3595.ok) { - const arg10 = _3595.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg10, f)]).v); - } else { - const e39: rs.ParseIntError = _3595.error; - const _3611: rs.IntErrorKind = e39.kind; - if (_3611 === "Empty") { - kind40 = 0; - } else if (_3611 === "InvalidDigit") { - kind40 = 1; - } else if (_3611 === "PosOverflow") { - kind40 = 2; - } else if (_3611 === "NegOverflow") { - kind40 = 3; - } else { - kind40 = 4; - } - if (!(e39.kind === "PosOverflow" as rs.IntErrorKind)) { - over39 = e39.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over39 = true; - } - const _3631: rs.IntErrorKind = e39.kind; - const args211 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e39, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e39, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3631), (f: rs.Formatter) => rs.i32Display(kind40, f), (f: rs.Formatter) => rs.fmtBool(over39, f)]; - put(out, rs.fmtFormat([args211[0], "|", args211[1], "|", args211[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args211[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args211[0]), "|", args211[3], "|", args211[4]]).v); - } - if (radix68 === 10) { - const parsed39: rs.Result = parse$0px1msj(_3592); - const from39: rs.Result = num_fromStr$00n8jbp(_3592); - if (from39.ok) { - max39 = rs.u8Mul(rs.i64Eq(from39.value, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64) ? 1 : 0, 4); - } else { - max39 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed39.ok ? 1 : 0, max39)); - } - } + if (radix65 === 10) { + const parsed37: rs.Result = parse$0px1msj(_3393.value); + const from37: rs.Result = num_fromStr$00n8jbp(_3393.value); + if (from37.ok) { + max37 = rs.u8Mul(rs.i64Eq(from37.value, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64) ? 1 : 0, 4); + } else { + max37 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed37.ok ? 1 : 0, max37)); } - const radix69: rs.u32 = ((first10 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest10), 0) as rs.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest10, 1), (b15: rs.u8): boolean => { - return (b15 & 1) === 1; - })) { - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix69), 99)))); + } + } else if (_3389 === 1) { + const s19: rs.String = rs.stringNew(); + for (const b10 of rs.byteSliceView(rest10)) { + const _3490: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _3491: rs.usize = rs.usizeRem(b10 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_3490, _3491); + rs.stringPush(s19, _3490.data[_3490.start + _3491] as rs.char); + } + const _3502: string = s19.v; + const radix66: rs.u32 = radix64; + const _3505: rs.Result = num_fromStrRadix$04fc4zz(_3502, radix66); + if (_3505.ok) { + const arg11 = _3505.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg11, f)]).v); + } else { + const e38: rs.ParseIntError = _3505.error; + const _3521: rs.IntErrorKind = e38.kind; + if (_3521 === "Empty") { + kind39 = 0; + } else if (_3521 === "InvalidDigit") { + kind39 = 1; + } else if (_3521 === "PosOverflow") { + kind39 = 2; + } else if (_3521 === "NegOverflow") { + kind39 = 3; + } else { + kind39 = 4; } - if (!(rest10.length > 2)) { - text10 = rs.byteSliceFrom(Uint8Array.of()); + if (!(e38.kind === "PosOverflow" as rs.IntErrorKind)) { + over38 = e38.kind !== "NegOverflow" as rs.IntErrorKind; } else { - text10 = rs.byteSliceRange(rest10, 2); - } - const _3687: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text10), "1"); - const radix70: rs.u32 = radix69; - const _3692: rs.Result = num_fromStrRadix$04fc4zz(_3687, radix70); - if (_3692.ok) { - const arg9 = _3692.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg9, f)]).v); + over38 = true; + } + const _3541: rs.IntErrorKind = e38.kind; + const args213 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e38, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e38, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3541), (f: rs.Formatter) => rs.i32Display(kind39, f), (f: rs.Formatter) => rs.fmtBool(over38, f)]; + put(out, rs.fmtFormat([args213[0], "|", args213[1], "|", args213[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args213[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args213[0]), "|", args213[3], "|", args213[4]]).v); + } + if (radix66 === 10) { + const parsed38: rs.Result = parse$0px1msj(_3502); + const from38: rs.Result = num_fromStr$00n8jbp(_3502); + if (from38.ok) { + max38 = rs.u8Mul(rs.i64Eq(from38.value, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64) ? 1 : 0, 4); } else { - const e40: rs.ParseIntError = _3692.error; - const _3708: rs.IntErrorKind = e40.kind; - if (_3708 === "Empty") { - kind41 = 0; - } else if (_3708 === "InvalidDigit") { - kind41 = 1; - } else if (_3708 === "PosOverflow") { - kind41 = 2; - } else if (_3708 === "NegOverflow") { - kind41 = 3; - } else { - kind41 = 4; - } - if (!(e40.kind === "PosOverflow" as rs.IntErrorKind)) { - over40 = e40.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over40 = true; - } - const _3728: rs.IntErrorKind = e40.kind; - const args209 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e40, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e40, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3728), (f: rs.Formatter) => rs.i32Display(kind41, f), (f: rs.Formatter) => rs.fmtBool(over40, f)]; - put(out, rs.fmtFormat([args209[0], "|", args209[1], "|", args209[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args209[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args209[0]), "|", args209[3], "|", args209[4]]).v); - } - if (radix70 === 10) { - const parsed40: rs.Result = parse$0px1msj(_3687); - const from40: rs.Result = num_fromStr$00n8jbp(_3687); - if (from40.ok) { - max40 = rs.u8Mul(rs.i64Eq(from40.value, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64) ? 1 : 0, 4); - } else { - max40 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed40.ok ? 1 : 0, max40)); + max38 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed38.ok ? 1 : 0, max38)); } - } - } else if (_4 === 10) { - if (dataLen !== 0) { - const first11: rs.u8 = dataData[dataStart]; - const rest11: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix71: rs.u32 = rs.u32Add(2, rs.u32Rem(first11 as rs.u32, 35)); - const _3766: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); - if (_3766 === 0) { - const _3770: rs.Result = rs.strFromUtf8(rest11); - if (_3770.ok) { - const iter41: rs.Iter = rs.strChars(_3770.value); - while (true) { - const _3776: rs.char | rs.Done = iter41.next(); - if (_3776 === rs.DONE) { - break; - } - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_3776, radix71), 99)))); - } - const radix72: rs.u32 = radix71; - const _3791: rs.Result = num_fromStrRadix$0cysu2u(_3770.value, radix72); - if (_3791.ok) { - const arg8 = _3791.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg8, f)]).v); + } else if (_3389 === 2) { + const iter39: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); + while (true) { + const _3573: rs.u32 | rs.Done = iter39.next(); + if (_3573 === rs.DONE) { + break; + } + const radix67: rs.u32 = _3573; + for (const _3584 of edges({ hi: 0, w2: 0, w1: 0x7fffffff, lo: 0xffffffff } as rs.u128, rs.u128Add({ hi: 0, w2: 0, w1: 0x7fffffff, lo: 0xffffffff } as rs.u128, 1), 64, radix67).items) { + const _3592: string = _3584.v; + const radix68: rs.u32 = radix67; + const _3595: rs.Result = num_fromStrRadix$04fc4zz(_3592, radix68); + if (_3595.ok) { + const arg10 = _3595.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg10, f)]).v); } else { - const e41: rs.ParseIntError = _3791.error; - const _3807: rs.IntErrorKind = e41.kind; - if (_3807 === "Empty") { - kind42 = 0; - } else if (_3807 === "InvalidDigit") { - kind42 = 1; - } else if (_3807 === "PosOverflow") { - kind42 = 2; - } else if (_3807 === "NegOverflow") { - kind42 = 3; + const e39: rs.ParseIntError = _3595.error; + const _3611: rs.IntErrorKind = e39.kind; + if (_3611 === "Empty") { + kind40 = 0; + } else if (_3611 === "InvalidDigit") { + kind40 = 1; + } else if (_3611 === "PosOverflow") { + kind40 = 2; + } else if (_3611 === "NegOverflow") { + kind40 = 3; } else { - kind42 = 4; + kind40 = 4; } - if (!(e41.kind === "PosOverflow" as rs.IntErrorKind)) { - over41 = e41.kind !== "NegOverflow" as rs.IntErrorKind; + if (!(e39.kind === "PosOverflow" as rs.IntErrorKind)) { + over39 = e39.kind !== "NegOverflow" as rs.IntErrorKind; } else { - over41 = true; + over39 = true; } - const _3827: rs.IntErrorKind = e41.kind; - const args207 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e41, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e41, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3827), (f: rs.Formatter) => rs.i32Display(kind42, f), (f: rs.Formatter) => rs.fmtBool(over41, f)]; - put(out, rs.fmtFormat([args207[0], "|", args207[1], "|", args207[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args207[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args207[0]), "|", args207[3], "|", args207[4]]).v); + const _3631: rs.IntErrorKind = e39.kind; + const args211 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e39, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e39, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3631), (f: rs.Formatter) => rs.i32Display(kind40, f), (f: rs.Formatter) => rs.fmtBool(over39, f)]; + put(out, rs.fmtFormat([args211[0], "|", args211[1], "|", args211[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args211[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args211[0]), "|", args211[3], "|", args211[4]]).v); } - if (radix72 === 10) { - const parsed41: rs.Result = parse$1kyj9pm(_3770.value); - const from41: rs.Result = num_fromStr$1el0yvy(_3770.value); - if (from41.ok) { - max41 = rs.u8Mul(rs.i128Eq(from41.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128) ? 1 : 0, 4); + if (radix68 === 10) { + const parsed39: rs.Result = parse$0px1msj(_3592); + const from39: rs.Result = num_fromStr$00n8jbp(_3592); + if (from39.ok) { + max39 = rs.u8Mul(rs.i64Eq(from39.value, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64) ? 1 : 0, 4); } else { - max41 = 2; + max39 = 2; } - rs.byteVecPush(out, rs.u8Add(parsed41.ok ? 1 : 0, max41)); + rs.byteVecPush(out, rs.u8Add(parsed39.ok ? 1 : 0, max39)); } } - } else if (_3766 === 1) { - const s21: rs.String = rs.stringNew(); - for (const b11 of rs.byteSliceView(rest11)) { - const _3867: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _3868: rs.usize = rs.usizeRem(b11 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rs.idx(_3867, _3868); - rs.stringPush(s21, _3867.data[_3867.start + _3868] as rs.char); - } - const _3879: string = s21.v; - const radix73: rs.u32 = radix71; - const _3882: rs.Result = num_fromStrRadix$0cysu2u(_3879, radix73); - if (_3882.ok) { - const arg7 = _3882.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg7, f)]).v); + } + } else { + const radix69: rs.u32 = ((first10 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest10), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest10, 1), (b15: rs.u8): boolean => { + return (b15 & 1) === 1; + })) { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix69), 99)))); + } + if (!(rest10.length > 2)) { + text10 = rs.byteSliceFrom(Uint8Array.of()); + } else { + text10 = rs.byteSliceRange(rest10, 2); + } + const _3687: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text10), "1"); + const radix70: rs.u32 = radix69; + const _3692: rs.Result = num_fromStrRadix$04fc4zz(_3687, radix70); + if (_3692.ok) { + const arg9 = _3692.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg9, f)]).v); + } else { + const e40: rs.ParseIntError = _3692.error; + const _3708: rs.IntErrorKind = e40.kind; + if (_3708 === "Empty") { + kind41 = 0; + } else if (_3708 === "InvalidDigit") { + kind41 = 1; + } else if (_3708 === "PosOverflow") { + kind41 = 2; + } else if (_3708 === "NegOverflow") { + kind41 = 3; + } else { + kind41 = 4; + } + if (!(e40.kind === "PosOverflow" as rs.IntErrorKind)) { + over40 = e40.kind !== "NegOverflow" as rs.IntErrorKind; } else { - const e42: rs.ParseIntError = _3882.error; - const _3898: rs.IntErrorKind = e42.kind; - if (_3898 === "Empty") { - kind43 = 0; - } else if (_3898 === "InvalidDigit") { - kind43 = 1; - } else if (_3898 === "PosOverflow") { - kind43 = 2; - } else if (_3898 === "NegOverflow") { - kind43 = 3; - } else { - kind43 = 4; + over40 = true; + } + const _3728: rs.IntErrorKind = e40.kind; + const args209 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e40, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e40, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3728), (f: rs.Formatter) => rs.i32Display(kind41, f), (f: rs.Formatter) => rs.fmtBool(over40, f)]; + put(out, rs.fmtFormat([args209[0], "|", args209[1], "|", args209[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args209[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args209[0]), "|", args209[3], "|", args209[4]]).v); + } + if (radix70 === 10) { + const parsed40: rs.Result = parse$0px1msj(_3687); + const from40: rs.Result = num_fromStr$00n8jbp(_3687); + if (from40.ok) { + max40 = rs.u8Mul(rs.i64Eq(from40.value, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64) ? 1 : 0, 4); + } else { + max40 = 2; + } + rs.byteVecPush(out, rs.u8Add(parsed40.ok ? 1 : 0, max40)); + } + } + } + } else if (_4 === 10) { + if (dataLen !== 0) { + const first11: rs.u8 = dataData[dataStart]; + const rest11: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix71: rs.u32 = rs.u32Add(2, rs.u32Rem(first11 as rs.u32, 35)); + const _3766: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); + if (_3766 === 0) { + const _3770: rs.Result = rs.strFromUtf8(rest11); + if (_3770.ok) { + const iter41: rs.Iter = rs.strChars(_3770.value); + while (true) { + const _3776: rs.char | rs.Done = iter41.next(); + if (_3776 === rs.DONE) { + break; } - if (!(e42.kind === "PosOverflow" as rs.IntErrorKind)) { - over42 = e42.kind !== "NegOverflow" as rs.IntErrorKind; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_3776, radix71), 99)))); + } + const radix72: rs.u32 = radix71; + const _3791: rs.Result = num_fromStrRadix$0cysu2u(_3770.value, radix72); + if (_3791.ok) { + const arg8 = _3791.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg8, f)]).v); + } else { + const e41: rs.ParseIntError = _3791.error; + const _3807: rs.IntErrorKind = e41.kind; + if (_3807 === "Empty") { + kind42 = 0; + } else if (_3807 === "InvalidDigit") { + kind42 = 1; + } else if (_3807 === "PosOverflow") { + kind42 = 2; + } else if (_3807 === "NegOverflow") { + kind42 = 3; } else { - over42 = true; + kind42 = 4; } - const _3918: rs.IntErrorKind = e42.kind; - const args205 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e42, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e42, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3918), (f: rs.Formatter) => rs.i32Display(kind43, f), (f: rs.Formatter) => rs.fmtBool(over42, f)]; - put(out, rs.fmtFormat([args205[0], "|", args205[1], "|", args205[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args205[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args205[0]), "|", args205[3], "|", args205[4]]).v); - } - if (radix73 === 10) { - const parsed42: rs.Result = parse$1kyj9pm(_3879); - const from42: rs.Result = num_fromStr$1el0yvy(_3879); - if (from42.ok) { - max42 = rs.u8Mul(rs.i128Eq(from42.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128) ? 1 : 0, 4); + if (!(e41.kind === "PosOverflow" as rs.IntErrorKind)) { + over41 = e41.kind !== "NegOverflow" as rs.IntErrorKind; } else { - max42 = 2; + over41 = true; } - rs.byteVecPush(out, rs.u8Add(parsed42.ok ? 1 : 0, max42)); + const _3827: rs.IntErrorKind = e41.kind; + const args207 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e41, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e41, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3827), (f: rs.Formatter) => rs.i32Display(kind42, f), (f: rs.Formatter) => rs.fmtBool(over41, f)]; + put(out, rs.fmtFormat([args207[0], "|", args207[1], "|", args207[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args207[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args207[0]), "|", args207[3], "|", args207[4]]).v); } - } else { - if (_3766 === 2) { - const iter43: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); - while (true) { - const _3950: rs.u32 | rs.Done = iter43.next(); - if (_3950 === rs.DONE) { - break b0; - } - const radix74: rs.u32 = _3950; - for (const _3961 of edges({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, rs.u128Add({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, 1), 128, radix74).items) { - const _3969: string = _3961.v; - const radix75: rs.u32 = radix74; - const _3972: rs.Result = num_fromStrRadix$0cysu2u(_3969, radix75); - if (_3972.ok) { - const arg6 = _3972.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg6, f)]).v); - } else { - const e43: rs.ParseIntError = _3972.error; - const _3988: rs.IntErrorKind = e43.kind; - if (_3988 === "Empty") { - kind44 = 0; - } else if (_3988 === "InvalidDigit") { - kind44 = 1; - } else if (_3988 === "PosOverflow") { - kind44 = 2; - } else if (_3988 === "NegOverflow") { - kind44 = 3; - } else { - kind44 = 4; - } - if (!(e43.kind === "PosOverflow" as rs.IntErrorKind)) { - over43 = e43.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over43 = true; - } - const _4008: rs.IntErrorKind = e43.kind; - const args203 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e43, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e43, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4008), (f: rs.Formatter) => rs.i32Display(kind44, f), (f: rs.Formatter) => rs.fmtBool(over43, f)]; - put(out, rs.fmtFormat([args203[0], "|", args203[1], "|", args203[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args203[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args203[0]), "|", args203[3], "|", args203[4]]).v); - } - if (radix75 === 10) { - const parsed43: rs.Result = parse$1kyj9pm(_3969); - const from43: rs.Result = num_fromStr$1el0yvy(_3969); - if (from43.ok) { - max43 = rs.u8Mul(rs.i128Eq(from43.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128) ? 1 : 0, 4); - } else { - max43 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed43.ok ? 1 : 0, max43)); - } - } + if (radix72 === 10) { + const parsed41: rs.Result = parse$1kyj9pm(_3770.value); + const from41: rs.Result = num_fromStr$1el0yvy(_3770.value); + if (from41.ok) { + max41 = rs.u8Mul(rs.i128Eq(from41.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128) ? 1 : 0, 4); + } else { + max41 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed41.ok ? 1 : 0, max41)); } - const radix76: rs.u32 = ((first11 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest11), 0) as rs.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest11, 1), (b14: rs.u8): boolean => { - return (b14 & 1) === 1; - })) { - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix76), 99)))); + } + } else if (_3766 === 1) { + const s21: rs.String = rs.stringNew(); + for (const b11 of rs.byteSliceView(rest11)) { + const _3867: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _3868: rs.usize = rs.usizeRem(b11 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_3867, _3868); + rs.stringPush(s21, _3867.data[_3867.start + _3868] as rs.char); + } + const _3879: string = s21.v; + const radix73: rs.u32 = radix71; + const _3882: rs.Result = num_fromStrRadix$0cysu2u(_3879, radix73); + if (_3882.ok) { + const arg7 = _3882.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg7, f)]).v); + } else { + const e42: rs.ParseIntError = _3882.error; + const _3898: rs.IntErrorKind = e42.kind; + if (_3898 === "Empty") { + kind43 = 0; + } else if (_3898 === "InvalidDigit") { + kind43 = 1; + } else if (_3898 === "PosOverflow") { + kind43 = 2; + } else if (_3898 === "NegOverflow") { + kind43 = 3; + } else { + kind43 = 4; } - if (!(rest11.length > 2)) { - text11 = rs.byteSliceFrom(Uint8Array.of()); + if (!(e42.kind === "PosOverflow" as rs.IntErrorKind)) { + over42 = e42.kind !== "NegOverflow" as rs.IntErrorKind; } else { - text11 = rs.byteSliceRange(rest11, 2); - } - const _4064: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text11), "1"); - const radix77: rs.u32 = radix76; - const _4069: rs.Result = num_fromStrRadix$0cysu2u(_4064, radix77); - if (_4069.ok) { - const arg5 = _4069.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg5, f)]).v); + over42 = true; + } + const _3918: rs.IntErrorKind = e42.kind; + const args205 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e42, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e42, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3918), (f: rs.Formatter) => rs.i32Display(kind43, f), (f: rs.Formatter) => rs.fmtBool(over42, f)]; + put(out, rs.fmtFormat([args205[0], "|", args205[1], "|", args205[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args205[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args205[0]), "|", args205[3], "|", args205[4]]).v); + } + if (radix73 === 10) { + const parsed42: rs.Result = parse$1kyj9pm(_3879); + const from42: rs.Result = num_fromStr$1el0yvy(_3879); + if (from42.ok) { + max42 = rs.u8Mul(rs.i128Eq(from42.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128) ? 1 : 0, 4); } else { - const e44: rs.ParseIntError = _4069.error; - const _4085: rs.IntErrorKind = e44.kind; - if (_4085 === "Empty") { - kind45 = 0; - } else if (_4085 === "InvalidDigit") { - kind45 = 1; - } else if (_4085 === "PosOverflow") { - kind45 = 2; - } else if (_4085 === "NegOverflow") { - kind45 = 3; - } else { - kind45 = 4; - } - if (!(e44.kind === "PosOverflow" as rs.IntErrorKind)) { - over44 = e44.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over44 = true; - } - const _4105: rs.IntErrorKind = e44.kind; - const args201 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e44, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e44, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4105), (f: rs.Formatter) => rs.i32Display(kind45, f), (f: rs.Formatter) => rs.fmtBool(over44, f)]; - put(out, rs.fmtFormat([args201[0], "|", args201[1], "|", args201[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args201[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args201[0]), "|", args201[3], "|", args201[4]]).v); - } - if (radix77 === 10) { - const parsed44: rs.Result = parse$1kyj9pm(_4064); - const from44: rs.Result = num_fromStr$1el0yvy(_4064); - if (from44.ok) { - max44 = rs.u8Mul(rs.i128Eq(from44.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128) ? 1 : 0, 4); - } else { - max44 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed44.ok ? 1 : 0, max44)); + max42 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed42.ok ? 1 : 0, max42)); } - } - } else if (_4 === 11) { - if (dataLen !== 0) { - const first12: rs.u8 = dataData[dataStart]; - const rest12: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix78: rs.u32 = rs.u32Add(2, rs.u32Rem(first12 as rs.u32, 35)); - const _4143: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); - if (_4143 === 0) { - const _4147: rs.Result = rs.strFromUtf8(rest12); - if (_4147.ok) { - const iter45: rs.Iter = rs.strChars(_4147.value); - while (true) { - const _4153: rs.char | rs.Done = iter45.next(); - if (_4153 === rs.DONE) { - break; - } - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_4153, radix78), 99)))); - } - const radix79: rs.u32 = radix78; - const _4168: rs.Result = num_fromStrRadix$1nys6eo(_4147.value, radix79); - if (_4168.ok) { - const arg4 = _4168.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg4, f)]).v); + } else if (_3766 === 2) { + const iter43: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); + while (true) { + const _3950: rs.u32 | rs.Done = iter43.next(); + if (_3950 === rs.DONE) { + break; + } + const radix74: rs.u32 = _3950; + for (const _3961 of edges({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, rs.u128Add({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, 1), 128, radix74).items) { + const _3969: string = _3961.v; + const radix75: rs.u32 = radix74; + const _3972: rs.Result = num_fromStrRadix$0cysu2u(_3969, radix75); + if (_3972.ok) { + const arg6 = _3972.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg6, f)]).v); } else { - const e45: rs.ParseIntError = _4168.error; - const _4184: rs.IntErrorKind = e45.kind; - if (_4184 === "Empty") { - kind46 = 0; - } else if (_4184 === "InvalidDigit") { - kind46 = 1; - } else if (_4184 === "PosOverflow") { - kind46 = 2; - } else if (_4184 === "NegOverflow") { - kind46 = 3; + const e43: rs.ParseIntError = _3972.error; + const _3988: rs.IntErrorKind = e43.kind; + if (_3988 === "Empty") { + kind44 = 0; + } else if (_3988 === "InvalidDigit") { + kind44 = 1; + } else if (_3988 === "PosOverflow") { + kind44 = 2; + } else if (_3988 === "NegOverflow") { + kind44 = 3; } else { - kind46 = 4; + kind44 = 4; } - if (!(e45.kind === "PosOverflow" as rs.IntErrorKind)) { - over45 = e45.kind !== "NegOverflow" as rs.IntErrorKind; + if (!(e43.kind === "PosOverflow" as rs.IntErrorKind)) { + over43 = e43.kind !== "NegOverflow" as rs.IntErrorKind; } else { - over45 = true; + over43 = true; } - const _4204: rs.IntErrorKind = e45.kind; - const args199 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e45, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e45, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4204), (f: rs.Formatter) => rs.i32Display(kind46, f), (f: rs.Formatter) => rs.fmtBool(over45, f)]; - put(out, rs.fmtFormat([args199[0], "|", args199[1], "|", args199[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args199[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args199[0]), "|", args199[3], "|", args199[4]]).v); + const _4008: rs.IntErrorKind = e43.kind; + const args203 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e43, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e43, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4008), (f: rs.Formatter) => rs.i32Display(kind44, f), (f: rs.Formatter) => rs.fmtBool(over43, f)]; + put(out, rs.fmtFormat([args203[0], "|", args203[1], "|", args203[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args203[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args203[0]), "|", args203[3], "|", args203[4]]).v); } - if (radix79 === 10) { - const parsed45: rs.Result = parse$1g90yxu(_4147.value); - const from45: rs.Result = num_fromStr$0ytcpik(_4147.value); - if (from45.ok) { - max45 = rs.u8Mul(from45.value === 2147483647 ? 1 : 0, 4); + if (radix75 === 10) { + const parsed43: rs.Result = parse$1kyj9pm(_3969); + const from43: rs.Result = num_fromStr$1el0yvy(_3969); + if (from43.ok) { + max43 = rs.u8Mul(rs.i128Eq(from43.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128) ? 1 : 0, 4); } else { - max45 = 2; + max43 = 2; } - rs.byteVecPush(out, rs.u8Add(parsed45.ok ? 1 : 0, max45)); + rs.byteVecPush(out, rs.u8Add(parsed43.ok ? 1 : 0, max43)); } } - } else if (_4143 === 1) { - const s23: rs.String = rs.stringNew(); - for (const b12 of rs.byteSliceView(rest12)) { - const _4244: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _4245: rs.usize = rs.usizeRem(b12 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rs.idx(_4244, _4245); - rs.stringPush(s23, _4244.data[_4244.start + _4245] as rs.char); - } - const _4256: string = s23.v; - const radix80: rs.u32 = radix78; - const _4259: rs.Result = num_fromStrRadix$1nys6eo(_4256, radix80); - if (_4259.ok) { - const arg3 = _4259.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg3, f)]).v); + } + } else { + const radix76: rs.u32 = ((first11 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest11), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest11, 1), (b14: rs.u8): boolean => { + return (b14 & 1) === 1; + })) { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix76), 99)))); + } + if (!(rest11.length > 2)) { + text11 = rs.byteSliceFrom(Uint8Array.of()); + } else { + text11 = rs.byteSliceRange(rest11, 2); + } + const _4064: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text11), "1"); + const radix77: rs.u32 = radix76; + const _4069: rs.Result = num_fromStrRadix$0cysu2u(_4064, radix77); + if (_4069.ok) { + const arg5 = _4069.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg5, f)]).v); + } else { + const e44: rs.ParseIntError = _4069.error; + const _4085: rs.IntErrorKind = e44.kind; + if (_4085 === "Empty") { + kind45 = 0; + } else if (_4085 === "InvalidDigit") { + kind45 = 1; + } else if (_4085 === "PosOverflow") { + kind45 = 2; + } else if (_4085 === "NegOverflow") { + kind45 = 3; + } else { + kind45 = 4; + } + if (!(e44.kind === "PosOverflow" as rs.IntErrorKind)) { + over44 = e44.kind !== "NegOverflow" as rs.IntErrorKind; } else { - const e46: rs.ParseIntError = _4259.error; - const _4275: rs.IntErrorKind = e46.kind; - if (_4275 === "Empty") { - kind47 = 0; - } else if (_4275 === "InvalidDigit") { - kind47 = 1; - } else if (_4275 === "PosOverflow") { - kind47 = 2; - } else if (_4275 === "NegOverflow") { - kind47 = 3; + over44 = true; + } + const _4105: rs.IntErrorKind = e44.kind; + const args201 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e44, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e44, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4105), (f: rs.Formatter) => rs.i32Display(kind45, f), (f: rs.Formatter) => rs.fmtBool(over44, f)]; + put(out, rs.fmtFormat([args201[0], "|", args201[1], "|", args201[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args201[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args201[0]), "|", args201[3], "|", args201[4]]).v); + } + if (radix77 === 10) { + const parsed44: rs.Result = parse$1kyj9pm(_4064); + const from44: rs.Result = num_fromStr$1el0yvy(_4064); + if (from44.ok) { + max44 = rs.u8Mul(rs.i128Eq(from44.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128) ? 1 : 0, 4); + } else { + max44 = 2; + } + rs.byteVecPush(out, rs.u8Add(parsed44.ok ? 1 : 0, max44)); + } + } + } + } else if (_4 === 11) { + if (dataLen !== 0) { + const first12: rs.u8 = dataData[dataStart]; + const rest12: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix78: rs.u32 = rs.u32Add(2, rs.u32Rem(first12 as rs.u32, 35)); + const _4143: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); + if (_4143 === 0) { + const _4147: rs.Result = rs.strFromUtf8(rest12); + if (_4147.ok) { + const iter45: rs.Iter = rs.strChars(_4147.value); + while (true) { + const _4153: rs.char | rs.Done = iter45.next(); + if (_4153 === rs.DONE) { + break; + } + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_4153, radix78), 99)))); + } + const radix79: rs.u32 = radix78; + const _4168: rs.Result = num_fromStrRadix$1nys6eo(_4147.value, radix79); + if (_4168.ok) { + const arg4 = _4168.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg4, f)]).v); + } else { + const e45: rs.ParseIntError = _4168.error; + const _4184: rs.IntErrorKind = e45.kind; + if (_4184 === "Empty") { + kind46 = 0; + } else if (_4184 === "InvalidDigit") { + kind46 = 1; + } else if (_4184 === "PosOverflow") { + kind46 = 2; + } else if (_4184 === "NegOverflow") { + kind46 = 3; } else { - kind47 = 4; + kind46 = 4; } - if (!(e46.kind === "PosOverflow" as rs.IntErrorKind)) { - over46 = e46.kind !== "NegOverflow" as rs.IntErrorKind; + if (!(e45.kind === "PosOverflow" as rs.IntErrorKind)) { + over45 = e45.kind !== "NegOverflow" as rs.IntErrorKind; } else { - over46 = true; + over45 = true; } - const _4295: rs.IntErrorKind = e46.kind; - const args197 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e46, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e46, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4295), (f: rs.Formatter) => rs.i32Display(kind47, f), (f: rs.Formatter) => rs.fmtBool(over46, f)]; - put(out, rs.fmtFormat([args197[0], "|", args197[1], "|", args197[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args197[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args197[0]), "|", args197[3], "|", args197[4]]).v); - } - if (radix80 === 10) { - const parsed46: rs.Result = parse$1g90yxu(_4256); - const from46: rs.Result = num_fromStr$0ytcpik(_4256); - if (from46.ok) { - max46 = rs.u8Mul(from46.value === 2147483647 ? 1 : 0, 4); + const _4204: rs.IntErrorKind = e45.kind; + const args199 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e45, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e45, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4204), (f: rs.Formatter) => rs.i32Display(kind46, f), (f: rs.Formatter) => rs.fmtBool(over45, f)]; + put(out, rs.fmtFormat([args199[0], "|", args199[1], "|", args199[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args199[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args199[0]), "|", args199[3], "|", args199[4]]).v); + } + if (radix79 === 10) { + const parsed45: rs.Result = parse$1g90yxu(_4147.value); + const from45: rs.Result = num_fromStr$0ytcpik(_4147.value); + if (from45.ok) { + max45 = rs.u8Mul(from45.value === 2147483647 ? 1 : 0, 4); } else { - max46 = 2; + max45 = 2; } - rs.byteVecPush(out, rs.u8Add(parsed46.ok ? 1 : 0, max46)); + rs.byteVecPush(out, rs.u8Add(parsed45.ok ? 1 : 0, max45)); } + } + } else if (_4143 === 1) { + const s23: rs.String = rs.stringNew(); + for (const b12 of rs.byteSliceView(rest12)) { + const _4244: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _4245: rs.usize = rs.usizeRem(b12 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_4244, _4245); + rs.stringPush(s23, _4244.data[_4244.start + _4245] as rs.char); + } + const _4256: string = s23.v; + const radix80: rs.u32 = radix78; + const _4259: rs.Result = num_fromStrRadix$1nys6eo(_4256, radix80); + if (_4259.ok) { + const arg3 = _4259.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg3, f)]).v); } else { - if (_4143 === 2) { - const iter47: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); - while (true) { - const _4327: rs.u32 | rs.Done = iter47.next(); - if (_4327 === rs.DONE) { - break b0; + const e46: rs.ParseIntError = _4259.error; + const _4275: rs.IntErrorKind = e46.kind; + if (_4275 === "Empty") { + kind47 = 0; + } else if (_4275 === "InvalidDigit") { + kind47 = 1; + } else if (_4275 === "PosOverflow") { + kind47 = 2; + } else if (_4275 === "NegOverflow") { + kind47 = 3; + } else { + kind47 = 4; + } + if (!(e46.kind === "PosOverflow" as rs.IntErrorKind)) { + over46 = e46.kind !== "NegOverflow" as rs.IntErrorKind; + } else { + over46 = true; + } + const _4295: rs.IntErrorKind = e46.kind; + const args197 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e46, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e46, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4295), (f: rs.Formatter) => rs.i32Display(kind47, f), (f: rs.Formatter) => rs.fmtBool(over46, f)]; + put(out, rs.fmtFormat([args197[0], "|", args197[1], "|", args197[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args197[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args197[0]), "|", args197[3], "|", args197[4]]).v); + } + if (radix80 === 10) { + const parsed46: rs.Result = parse$1g90yxu(_4256); + const from46: rs.Result = num_fromStr$0ytcpik(_4256); + if (from46.ok) { + max46 = rs.u8Mul(from46.value === 2147483647 ? 1 : 0, 4); + } else { + max46 = 2; + } + rs.byteVecPush(out, rs.u8Add(parsed46.ok ? 1 : 0, max46)); + } + } else if (_4143 === 2) { + const iter47: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); + while (true) { + const _4327: rs.u32 | rs.Done = iter47.next(); + if (_4327 === rs.DONE) { + break; + } + const radix81: rs.u32 = _4327; + for (const _4338 of edges(2147483647, rs.u128Add(2147483647, 1), 32, radix81).items) { + const _4346: string = _4338.v; + const radix82: rs.u32 = radix81; + const _4349: rs.Result = num_fromStrRadix$1nys6eo(_4346, radix82); + if (_4349.ok) { + const arg2 = _4349.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg2, f)]).v); + } else { + const e47: rs.ParseIntError = _4349.error; + const _4365: rs.IntErrorKind = e47.kind; + if (_4365 === "Empty") { + kind48 = 0; + } else if (_4365 === "InvalidDigit") { + kind48 = 1; + } else if (_4365 === "PosOverflow") { + kind48 = 2; + } else if (_4365 === "NegOverflow") { + kind48 = 3; + } else { + kind48 = 4; } - const radix81: rs.u32 = _4327; - for (const _4338 of edges(2147483647, rs.u128Add(2147483647, 1), 32, radix81).items) { - const _4346: string = _4338.v; - const radix82: rs.u32 = radix81; - const _4349: rs.Result = num_fromStrRadix$1nys6eo(_4346, radix82); - if (_4349.ok) { - const arg2 = _4349.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg2, f)]).v); - } else { - const e47: rs.ParseIntError = _4349.error; - const _4365: rs.IntErrorKind = e47.kind; - if (_4365 === "Empty") { - kind48 = 0; - } else if (_4365 === "InvalidDigit") { - kind48 = 1; - } else if (_4365 === "PosOverflow") { - kind48 = 2; - } else if (_4365 === "NegOverflow") { - kind48 = 3; - } else { - kind48 = 4; - } - if (!(e47.kind === "PosOverflow" as rs.IntErrorKind)) { - over47 = e47.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over47 = true; - } - const _4385: rs.IntErrorKind = e47.kind; - const args195 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e47, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e47, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4385), (f: rs.Formatter) => rs.i32Display(kind48, f), (f: rs.Formatter) => rs.fmtBool(over47, f)]; - put(out, rs.fmtFormat([args195[0], "|", args195[1], "|", args195[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args195[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args195[0]), "|", args195[3], "|", args195[4]]).v); - } - if (radix82 === 10) { - const parsed47: rs.Result = parse$1g90yxu(_4346); - const from47: rs.Result = num_fromStr$0ytcpik(_4346); - if (from47.ok) { - max47 = rs.u8Mul(from47.value === 2147483647 ? 1 : 0, 4); - } else { - max47 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed47.ok ? 1 : 0, max47)); - } + if (!(e47.kind === "PosOverflow" as rs.IntErrorKind)) { + over47 = e47.kind !== "NegOverflow" as rs.IntErrorKind; + } else { + over47 = true; } + const _4385: rs.IntErrorKind = e47.kind; + const args195 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e47, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e47, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4385), (f: rs.Formatter) => rs.i32Display(kind48, f), (f: rs.Formatter) => rs.fmtBool(over47, f)]; + put(out, rs.fmtFormat([args195[0], "|", args195[1], "|", args195[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args195[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args195[0]), "|", args195[3], "|", args195[4]]).v); + } + if (radix82 === 10) { + const parsed47: rs.Result = parse$1g90yxu(_4346); + const from47: rs.Result = num_fromStr$0ytcpik(_4346); + if (from47.ok) { + max47 = rs.u8Mul(from47.value === 2147483647 ? 1 : 0, 4); + } else { + max47 = 2; + } + rs.byteVecPush(out, rs.u8Add(parsed47.ok ? 1 : 0, max47)); } } - const radix83: rs.u32 = ((first12 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest12), 0) as rs.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest12, 1), (b13: rs.u8): boolean => { - return (b13 & 1) === 1; - })) { - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix83), 99)))); + } + } else { + const radix83: rs.u32 = ((first12 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest12), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest12, 1), (b13: rs.u8): boolean => { + return (b13 & 1) === 1; + })) { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix83), 99)))); + } + if (!(rest12.length > 2)) { + text12 = rs.byteSliceFrom(Uint8Array.of()); + } else { + text12 = rs.byteSliceRange(rest12, 2); + } + const _4441: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text12), "1"); + const radix84: rs.u32 = radix83; + const _4446: rs.Result = num_fromStrRadix$1nys6eo(_4441, radix84); + if (_4446.ok) { + const arg = _4446.value; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg, f)]).v); + } else { + const e48: rs.ParseIntError = _4446.error; + const _4462: rs.IntErrorKind = e48.kind; + if (_4462 === "Empty") { + kind49 = 0; + } else if (_4462 === "InvalidDigit") { + kind49 = 1; + } else if (_4462 === "PosOverflow") { + kind49 = 2; + } else if (_4462 === "NegOverflow") { + kind49 = 3; + } else { + kind49 = 4; } - if (!(rest12.length > 2)) { - text12 = rs.byteSliceFrom(Uint8Array.of()); + if (!(e48.kind === "PosOverflow" as rs.IntErrorKind)) { + over48 = e48.kind !== "NegOverflow" as rs.IntErrorKind; } else { - text12 = rs.byteSliceRange(rest12, 2); - } - const _4441: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text12), "1"); - const radix84: rs.u32 = radix83; - const _4446: rs.Result = num_fromStrRadix$1nys6eo(_4441, radix84); - if (_4446.ok) { - const arg = _4446.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg, f)]).v); + over48 = true; + } + const _4482: rs.IntErrorKind = e48.kind; + const args193 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e48, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e48, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4482), (f: rs.Formatter) => rs.i32Display(kind49, f), (f: rs.Formatter) => rs.fmtBool(over48, f)]; + put(out, rs.fmtFormat([args193[0], "|", args193[1], "|", args193[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args193[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args193[0]), "|", args193[3], "|", args193[4]]).v); + } + if (radix84 === 10) { + const parsed48: rs.Result = parse$1g90yxu(_4441); + const from48: rs.Result = num_fromStr$0ytcpik(_4441); + if (from48.ok) { + max48 = rs.u8Mul(from48.value === 2147483647 ? 1 : 0, 4); } else { - const e48: rs.ParseIntError = _4446.error; - const _4462: rs.IntErrorKind = e48.kind; - if (_4462 === "Empty") { - kind49 = 0; - } else if (_4462 === "InvalidDigit") { - kind49 = 1; - } else if (_4462 === "PosOverflow") { - kind49 = 2; - } else if (_4462 === "NegOverflow") { - kind49 = 3; - } else { - kind49 = 4; - } - if (!(e48.kind === "PosOverflow" as rs.IntErrorKind)) { - over48 = e48.kind !== "NegOverflow" as rs.IntErrorKind; - } else { - over48 = true; - } - const _4482: rs.IntErrorKind = e48.kind; - const args193 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e48, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e48, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4482), (f: rs.Formatter) => rs.i32Display(kind49, f), (f: rs.Formatter) => rs.fmtBool(over48, f)]; - put(out, rs.fmtFormat([args193[0], "|", args193[1], "|", args193[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args193[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args193[0]), "|", args193[3], "|", args193[4]]).v); - } - if (radix84 === 10) { - const parsed48: rs.Result = parse$1g90yxu(_4441); - const from48: rs.Result = num_fromStr$0ytcpik(_4441); - if (from48.ok) { - max48 = rs.u8Mul(from48.value === 2147483647 ? 1 : 0, 4); - } else { - max48 = 2; - } - rs.byteVecPush(out, rs.u8Add(parsed48.ok ? 1 : 0, max48)); + max48 = 2; } + rs.byteVecPush(out, rs.u8Add(parsed48.ok ? 1 : 0, max48)); } } - } else { - rs.panic("internal error: entered unreachable code"); } + } else { + rs.panic("internal error: entered unreachable code"); } } diff --git a/ts/fixtures/lang/iters/expected/iters.ts b/ts/fixtures/lang/iters/expected/iters.ts index bbe1ffdc7..62888f99b 100644 --- a/ts/fixtures/lang/iters/expected/iters.ts +++ b/ts/fixtures/lang/iters/expected/iters.ts @@ -27,141 +27,133 @@ import * as Wrapper from "./iters.Wrapper.ts"; /** Adaptor chains over the input bytes, each consumed one way. */ export function adaptors(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - b0: { - const _4: rs.u8 = rs.u8Rem(kind, 8); - if (_4 === 0) { - rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_217: rs.u8): rs.u8 => { - return rs.u8Div(_217, 2); - }), (b11: rs.u8): boolean => { - return rs.u8Rem(b11, 3) !== 0; - }), "next"))); - for (const _18 of rs.iterToVec(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(data)), (_218: rs.u8): rs.u16 | undefined => { - const b12: rs.u8 = _218; - return thenSome$1gvhopg(b12 < 100, rs.u16Mul(b12 as rs.u16, 200)); - }), "next", 2).items) { - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(_18))); + const _4: rs.u8 = rs.u8Rem(kind, 8); + if (_4 === 0) { + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_217: rs.u8): rs.u8 => { + return rs.u8Div(_217, 2); + }), (b11: rs.u8): boolean => { + return rs.u8Rem(b11, 3) !== 0; + }), "next"))); + for (const _18 of rs.iterToVec(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(data)), (_218: rs.u8): rs.u16 | undefined => { + const b12: rs.u8 = _218; + return thenSome$1gvhopg(b12 < 100, rs.u16Mul(b12 as rs.u16, 200)); + }), "next", 2).items) { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(_18))); + } + } else if (_4 === 1) { + const iter2: rs.Iter<[rs.usize, rs.u8]> = rs.iterStepBy(rs.iterSkip(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), 1), 2); + while (true) { + const _32: [rs.usize, rs.u8] | rs.Done = iter2.next(); + if (_32 === rs.DONE) { + break; } - } else { - if (_4 === 1) { - const iter2: rs.Iter<[rs.usize, rs.u8]> = rs.iterStepBy(rs.iterSkip(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), 1), 2); - while (true) { - const _32: [rs.usize, rs.u8] | rs.Done = iter2.next(); - if (_32 === rs.DONE) { - break; - } - const i: rs.usize = _32[0]; - const b: rs.u8 = _32[1]; - rs.byteVecPush(out, i & 0xff); - rs.byteVecPush(out, b); - } - const iter3: rs.Iter<[rs.usize, rs.u8]> = rs.iterTake(rs.iterEnumerate(rs.iterRev(rs.iterSlice(rs.byteSliceView(data)))), 3); - while (true) { - const _46: [rs.usize, rs.u8] | rs.Done = iter3.next(); - if (_46 === rs.DONE) { - break b0; - } - rs.byteVecPush(out, (_46[0] & 0xff) ^ _46[1]); - } + const i: rs.usize = _32[0]; + const b: rs.u8 = _32[1]; + rs.byteVecPush(out, i & 0xff); + rs.byteVecPush(out, b); + } + const iter3: rs.Iter<[rs.usize, rs.u8]> = rs.iterTake(rs.iterEnumerate(rs.iterRev(rs.iterSlice(rs.byteSliceView(data)))), 3); + while (true) { + const _46: [rs.usize, rs.u8] | rs.Done = iter3.next(); + if (_46 === rs.DONE) { + break; } - if (_4 === 2) { - const mid: number = rs.usizeDiv(data.length, 2); - if (mid > data.length) { - rs.panic("mid > len"); - } - const front: rs.ByteSlice = new rs.ByteSlice(data.data, data.start, mid); - const back: rs.ByteSlice = new rs.ByteSlice(data.data, data.start + mid, data.length - mid); - rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterMap(rs.iterZip(rs.iterSlice(rs.byteSliceView(front)), rs.iterRev(rs.iterSlice(rs.byteSliceView(back))), "len"), (_216: [rs.u8, rs.u8]): rs.u8 => { - return _216[0] ^ _216[1]; - }), undefined, true))); - rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterRev(rs.iterChain(rs.iterSlice(rs.byteSliceView(front)), rs.iterSlice(rs.byteSliceView(back)))), undefined, true))); - } else if (_4 === 3) { - const taken: rs.ByteVec = rs.iterToByteVec(rs.iterTakeWhile(rs.iterSlice(rs.byteSliceView(data)), (_213: rs.u8): boolean => { - return _213 !== 0; - }), "next"); - const skipped: rs.ByteVec = rs.iterToByteVec(rs.iterSkipWhile(rs.iterSlice(rs.byteSliceView(data)), (_214: rs.u8): boolean => { - return _214 < 128; - }), "next"); - const mapped: rs.ByteVec = rs.iterToByteVec(rs.iterMapWhile(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): rs.u8 | undefined => { - return rs.u8CheckedAdd(_215, 64); - }), "next"); - rs.byteVecPush(out, taken.length & 0xff); - rs.byteVecPush(out, skipped.length & 0xff); - rs.byteVecExtendFromSlice(out, rs.byteVecSlice(mapped)); - } else if (_4 === 4) { - const words: rs.Vec = chunksByZero$iters_ChunksByZero_slice_u8(data); - rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterFlatMap(rs.iterSlice(words.items), (w: rs.ByteVec): rs.Iter => { - return rs.iterRev(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(w)))); - }, undefined, true), "next"))); - rs.iterExtendBytes(out, rs.iterRev(rs.iterFlatten(rs.iterMap(rs.iterSlice(words.items), (w2: rs.ByteVec): rs.Iter => { - return rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(w2))), (_212: rs.u8): rs.u8 => { - return rs.u8WrappingAdd(_212, 3); - }); - }), undefined, true)), "next"); - } else { - if (_4 === 5) { - const it: rs.Peekable = rs.iterPeekable(rs.iterSlice(rs.byteSliceView(data))); - while (true) { - const _118: rs.u8 | rs.Done = it.next(); - if (_118 !== rs.DONE) { - const b2: rs.u8 = _118; - let run: rs.u8 = 1; - while (rs.peekableNextIf(it, (_211: rs.u8): boolean => { - return _211 === b2; - }) !== undefined) { - run = rs.u8Add(run, 1); - } - rs.byteVecPush(out, b2); - rs.byteVecPush(out, run); - const _133: rs.u8 | undefined = rs.peekablePeek(it); - if (_133 !== undefined) { - rs.byteVecPush(out, _133); - } - } else { - break b0; - } - } + rs.byteVecPush(out, (_46[0] & 0xff) ^ _46[1]); + } + } else if (_4 === 2) { + const mid: number = rs.usizeDiv(data.length, 2); + if (mid > data.length) { + rs.panic("mid > len"); + } + const front: rs.ByteSlice = new rs.ByteSlice(data.data, data.start, mid); + const back: rs.ByteSlice = new rs.ByteSlice(data.data, data.start + mid, data.length - mid); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterMap(rs.iterZip(rs.iterSlice(rs.byteSliceView(front)), rs.iterRev(rs.iterSlice(rs.byteSliceView(back))), "len"), (_216: [rs.u8, rs.u8]): rs.u8 => { + return _216[0] ^ _216[1]; + }), undefined, true))); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterRev(rs.iterChain(rs.iterSlice(rs.byteSliceView(front)), rs.iterSlice(rs.byteSliceView(back)))), undefined, true))); + } else if (_4 === 3) { + const taken: rs.ByteVec = rs.iterToByteVec(rs.iterTakeWhile(rs.iterSlice(rs.byteSliceView(data)), (_213: rs.u8): boolean => { + return _213 !== 0; + }), "next"); + const skipped: rs.ByteVec = rs.iterToByteVec(rs.iterSkipWhile(rs.iterSlice(rs.byteSliceView(data)), (_214: rs.u8): boolean => { + return _214 < 128; + }), "next"); + const mapped: rs.ByteVec = rs.iterToByteVec(rs.iterMapWhile(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): rs.u8 | undefined => { + return rs.u8CheckedAdd(_215, 64); + }), "next"); + rs.byteVecPush(out, taken.length & 0xff); + rs.byteVecPush(out, skipped.length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(mapped)); + } else if (_4 === 4) { + const words: rs.Vec = chunksByZero$iters_ChunksByZero_slice_u8(data); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterFlatMap(rs.iterSlice(words.items), (w: rs.ByteVec): rs.Iter => { + return rs.iterRev(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(w)))); + }, undefined, true), "next"))); + rs.iterExtendBytes(out, rs.iterRev(rs.iterFlatten(rs.iterMap(rs.iterSlice(words.items), (w2: rs.ByteVec): rs.Iter => { + return rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(w2))), (_212: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(_212, 3); + }); + }), undefined, true)), "next"); + } else if (_4 === 5) { + const it: rs.Peekable = rs.iterPeekable(rs.iterSlice(rs.byteSliceView(data))); + while (true) { + const _118: rs.u8 | rs.Done = it.next(); + if (_118 !== rs.DONE) { + const b2: rs.u8 = _118; + let run: rs.u8 = 1; + while (rs.peekableNextIf(it, (_211: rs.u8): boolean => { + return _211 === b2; + }) !== undefined) { + run = rs.u8Add(run, 1); } - if (_4 === 6) { - const it2: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); - rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterTake(rs.iterBorrow(it2), 2), undefined, true))); - rs.byteVecPush(out, it2.len() & 0xff); - const _152: rs.u8 | undefined = rs.iterToOption(it2.nextBack()); - if (_152 === undefined) { - rs.byteVecPush(out, 238); - } else { - rs.byteVecPush(out, _152); - } - rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterStepBy(rs.iterRev(it2), 3), "next"))); - } else { - const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Uint8Array => { - const b3: rs.u8 = _2; - return Uint8Array.of(b3, ~b3 & 0xff); - }), undefined, 2, true); - const copies: rs.Vec = rs.iterToVec(rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), rs.byteSliceToArray), undefined, 2, true); - if (!(copies.items.length === 0)) { - const _174: rs.ByteSlice = rs.byteSliceFrom(copies.items[rs.idx(copies.items, 0)]); - _174.data[_174.start] = 85; - } - const iter4: rs.Iter = rs.iterChain(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), rs.arraySliceIter(rs.arraySliceFrom(copies.items, rs.byteSliceFrom))); - while (true) { - const _187: rs.ByteSlice | rs.Done = iter4.next(); - if (_187 === rs.DONE) { - break; - } - rs.byteVecExtendFromSlice(out, _187); - } - const v2: rs.Vec = new rs.Vec(); - const _196: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): rs.u16 => { - return rs.u16Add(_22 as rs.u16, 1); - }); - rs.iterExtend(v2, _196, undefined, 2, true); - rs.byteVecPush(out, v2.items.length & 0xff); - rs.iterExtendBytes(out, rs.iterFilter(rs.iterSlice(rs.byteSliceView(data)), (_210: rs.u8): boolean => { - return _210 > 128; - }), "next"); + rs.byteVecPush(out, b2); + rs.byteVecPush(out, run); + const _133: rs.u8 | undefined = rs.peekablePeek(it); + if (_133 !== undefined) { + rs.byteVecPush(out, _133); } + } else { + break; + } + } + } else if (_4 === 6) { + const it2: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterTake(rs.iterBorrow(it2), 2), undefined, true))); + rs.byteVecPush(out, it2.len() & 0xff); + const _152: rs.u8 | undefined = rs.iterToOption(it2.nextBack()); + if (_152 === undefined) { + rs.byteVecPush(out, 238); + } else { + rs.byteVecPush(out, _152); + } + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterStepBy(rs.iterRev(it2), 3), "next"))); + } else { + const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Uint8Array => { + const b3: rs.u8 = _2; + return Uint8Array.of(b3, ~b3 & 0xff); + }), undefined, 2, true); + const copies: rs.Vec = rs.iterToVec(rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), rs.byteSliceToArray), undefined, 2, true); + if (!(copies.items.length === 0)) { + const _174: rs.ByteSlice = rs.byteSliceFrom(copies.items[rs.idx(copies.items, 0)]); + _174.data[_174.start] = 85; + } + const iter4: rs.Iter = rs.iterChain(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), rs.arraySliceIter(rs.arraySliceFrom(copies.items, rs.byteSliceFrom))); + while (true) { + const _187: rs.ByteSlice | rs.Done = iter4.next(); + if (_187 === rs.DONE) { + break; } + rs.byteVecExtendFromSlice(out, _187); } + const v2: rs.Vec = new rs.Vec(); + const _196: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): rs.u16 => { + return rs.u16Add(_22 as rs.u16, 1); + }); + rs.iterExtend(v2, _196, undefined, 2, true); + rs.byteVecPush(out, v2.items.length & 0xff); + rs.iterExtendBytes(out, rs.iterFilter(rs.iterSlice(rs.byteSliceView(data)), (_210: rs.u8): boolean => { + return _210 > 128; + }), "next"); } } @@ -422,14 +414,6 @@ export function peekedOthers(data: rs.ByteSlice, out: rs.ByteVec): void { return _33.data[_33.start]; }); }; - const _158: (a0: rs.Vec | undefined) => rs.u8 = (v: rs.Vec | undefined): rs.u8 => { - return option_mapOr$127irwp(v, 170, (v2: rs.Vec): rs.u8 => { - return v2.items.length & 0xff; - }); - }; - const _159: (a0: rs.u8) => rs.Vec = (b2: rs.u8): rs.Vec => { - return rs.vecFromElem(((rs.u8Rem(b2, 2) as rs.u16) << 9) & 0xffff, rs.u8Rem(b2, 3) as rs.usize, undefined); - }; const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.String => { return _3(_2); }), undefined, 12, true); @@ -480,12 +464,12 @@ export function peekedOthers(data: rs.ByteSlice, out: rs.ByteVec): void { const _107: rs.Vec = rs.vecFrom([first.v]); const part9 = option_map$1wdw03s(rs.peekableNextIfEq(it4, _107, (a011: rs.Vec, a16: rs.Vec): boolean => { return rs.eqSlice(rs.eqStr)(a011, a16); - }), (v3: rs.Vec): string => { - return v3.items[rs.idx(v3.items, 0)].v; + }), (v: rs.Vec): string => { + return v.items[rs.idx(v.items, 0)].v; }); rs.byteVecPush(out, _4(part9)); - const part10 = option_map$1wdw03s(rs.iterToOption(it4.next()), (v4: rs.Vec): string => { - return v4.items[rs.idx(v4.items, 0)].v; + const part10 = option_map$1wdw03s(rs.iterToOption(it4.next()), (v2: rs.Vec): string => { + return v2.items[rs.idx(v2.items, 0)].v; }); rs.byteVecPush(out, _4(part10)); const it5: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.iterSlice(words.items), (w3: rs.String): rs.StrCow => { @@ -505,6 +489,14 @@ export function peekedOthers(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.eqStr(a014, rs.strCowStr(a18)); })); rs.byteVecPush(out, _4(part13)); + const _158: (a0: rs.Vec | undefined) => rs.u8 = (v3: rs.Vec | undefined): rs.u8 => { + return option_mapOr$127irwp(v3, 170, (v4: rs.Vec): rs.u8 => { + return v4.items.length & 0xff; + }); + }; + const _159: (a0: rs.u8) => rs.Vec = (b4: rs.u8): rs.Vec => { + return rs.vecFromElem(((rs.u8Rem(b4, 2) as rs.u16) << 9) & 0xffff, rs.u8Rem(b4, 3) as rs.usize, undefined); + }; const it7: rs.Peekable> = rs.iterPeekable(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_26: rs.u8): rs.Vec => { return _159(_26); })); @@ -1045,16 +1037,6 @@ export function ranked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } return 0; }; - const _55: (a0: Tilt.Tilt | undefined) => rs.u8 = (t: Tilt.Tilt | undefined): rs.u8 => { - return option_mapOr$0p9po8x(t, 255, (t2: Tilt.Tilt): rs.u8 => { - return t2._0; - }); - }; - const _72: (a0: rs.u8) => [rs.u8, rs.u8 | undefined] = (b3: rs.u8): [rs.u8, rs.u8 | undefined] => { - return [rs.u8Rem(b3, 4), filter$0hq86nl(rs.u8Div(b3, 4), (b4: rs.u8): boolean => { - return rs.u8Rem(b4, 3) !== 0; - })] as [rs.u8, rs.u8 | undefined]; - }; const items: () => rs.Iter<[rs.usize, rs.u8]> = (): rs.Iter<[rs.usize, rs.u8]> => { return rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); }; @@ -1094,6 +1076,11 @@ export function ranked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return [rs.u8Rem(b11, 2) === 0, { _0: rs.u8Rem(b11, 8) }] as [boolean, Tilt.Tilt]; }, rs.cmpLt(rs.cmpTuple<[boolean, Tilt.Tilt], rs.Ordering | undefined>([rs.cmp, Tilt.partialCmp$cmp_PartialOrd]))); _4(out, part2); + const _55: (a0: Tilt.Tilt | undefined) => rs.u8 = (t6: Tilt.Tilt | undefined): rs.u8 => { + return option_mapOr$0p9po8x(t6, 255, (t7: Tilt.Tilt): rs.u8 => { + return t7._0; + }); + }; const part3 = rs.iterMinByKey(rs.iterSlice(tilts.items), (_214: Tilt.Tilt): Tilt.Tilt | undefined => { return _214; }, rs.cmpLt(rs.cmpReverse(rs.cmpOption(Tilt.partialCmp$cmp_PartialOrd)))); @@ -1104,6 +1091,11 @@ export function ranked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }, rs.cmpLt(rs.cmpTuple<[Tilt.Tilt, rs.u8], rs.Ordering | undefined>([rs.cmpReverse(Tilt.partialCmp$cmp_PartialOrd), rs.cmp]))); rs.byteVecPush(out, _55(part4)); } else if (_10 === 2) { + const _72: (a0: rs.u8) => [rs.u8, rs.u8 | undefined] = (b6: rs.u8): [rs.u8, rs.u8 | undefined] => { + return [rs.u8Rem(b6, 4), filter$0hq86nl(rs.u8Div(b6, 4), (b7: rs.u8): boolean => { + return rs.u8Rem(b7, 3) !== 0; + })] as [rs.u8, rs.u8 | undefined]; + }; const iter: rs.Iter<[rs.u8, rs.u8 | undefined] | undefined> = rs.iterSlice([rs.iterMax(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_210: rs.u8): [rs.u8, rs.u8 | undefined] => { return _72(_210); }), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8 | undefined], rs.Ordering | undefined>([rs.cmp, rs.cmpReverse(rs.cmpOption(rs.cmp))]))), rs.iterMin(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_211: rs.u8): [rs.u8, rs.u8 | undefined] => { @@ -1121,11 +1113,11 @@ export function ranked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(best[0], option_unwrapOr$1fr498u(best[1], 255)))); } } - rs.byteVecPush(out, option_mapOr$0p9po8x(rs.iterMax(rs.iterSlice(tilts.items), rs.cmpLt(Tilt.partialCmp$cmp_PartialOrd)), 255, (t6: Tilt.Tilt): rs.u8 => { - return t6._0; + rs.byteVecPush(out, option_mapOr$0p9po8x(rs.iterMax(rs.iterSlice(tilts.items), rs.cmpLt(Tilt.partialCmp$cmp_PartialOrd)), 255, (t4: Tilt.Tilt): rs.u8 => { + return t4._0; })); - rs.byteVecPush(out, option_mapOr$0p9po8x(rs.iterMin(rs.iterSlice(tilts.items), rs.cmpLt(Tilt.partialCmp$cmp_PartialOrd)), 255, (t7: Tilt.Tilt): rs.u8 => { - return t7._0; + rs.byteVecPush(out, option_mapOr$0p9po8x(rs.iterMin(rs.iterSlice(tilts.items), rs.cmpLt(Tilt.partialCmp$cmp_PartialOrd)), 255, (t5: Tilt.Tilt): rs.u8 => { + return t5._0; })); } else { rs.byteVecPush(out, option_mapOr$188iunt(rs.iterRposition(rs.iterSlice(rs.byteSliceView(data)), (_28: rs.u8): boolean => { @@ -1139,18 +1131,18 @@ export function ranked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const seen: rs.ByteVec = new rs.ByteVec(); const rest: rs.Iter = rs.iterSlice(tilts.items); rest.next(); - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterRposition(rest, (t3: Tilt.Tilt): boolean => { - rs.byteVecPush(seen, t3._0); - return t3._0 === 2; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterRposition(rest, (t: Tilt.Tilt): boolean => { + rs.byteVecPush(seen, t._0); + return t._0 === 2; }), 255, (i3: rs.usize): rs.u8 => { return i3 & 0xff; })); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(seen)); rs.byteVecPush(out, rest.len() & 0xff); - rs.byteVecPush(out, option_mapOr$0p9po8x(rs.iterRfind(rest, (t4: Tilt.Tilt): boolean => { - return t4._0 > 3; - }), 255, (t5: Tilt.Tilt): rs.u8 => { - return t5._0; + rs.byteVecPush(out, option_mapOr$0p9po8x(rs.iterRfind(rest, (t2: Tilt.Tilt): boolean => { + return t2._0 > 3; + }), 255, (t3: Tilt.Tilt): rs.u8 => { + return t3._0; })); rs.byteVecPush(out, rest.len() & 0xff); } @@ -1299,22 +1291,16 @@ export function fullRange(out: rs.ByteVec): undefined { /** Iterators of `Option`, which keep each `None` apart from their end. */ export function options(data: rs.ByteSlice, out: rs.ByteVec): void { - const _83: (a0: rs.u8, a1: rs.ByteVec) => rs.u8 | undefined = (b2: rs.u8, calls2: rs.ByteVec): rs.u8 | undefined => { - rs.byteVecPush(calls2, b2); - return option_map$1yjmt5m(rs.u8CheckedSub(b2, 1), (b3: rs.u8): rs.u8 => { - return rs.u8Div(b3, 2); - }); - }; - const all: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b4: rs.u8): rs.u8 | undefined => { - if (!(rs.u8Rem(b4, 3) === 0)) { - return b4; + const all: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b2: rs.u8): rs.u8 | undefined => { + if (!(rs.u8Rem(b2, 3) === 0)) { + return b2; } return undefined; }), undefined, 2, true); rs.byteVecPush(out, all.items.length & 0xff); - const iter: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b5: rs.u8): rs.u8 | undefined => { - if (!(rs.u8Rem(b5, 3) === 0)) { - return b5; + const iter: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b3: rs.u8): rs.u8 | undefined => { + if (!(rs.u8Rem(b3, 3) === 0)) { + return b3; } return undefined; }); @@ -1330,18 +1316,18 @@ export function options(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, item); } } - rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterFlatten(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b6: rs.u8): rs.u8 | undefined => { - if (!(rs.u8Rem(b6, 3) === 0)) { - return b6; + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterFlatten(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b4: rs.u8): rs.u8 | undefined => { + if (!(rs.u8Rem(b4, 3) === 0)) { + return b4; } return undefined; }), (value: rs.u8 | undefined) => rs.iterOption(value), true, undefined, true), "next"))); rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterSlice(all.items), (o: rs.u8 | undefined): boolean => { return o !== undefined; })) & 0xff); - rs.byteVecPush(out, option_unwrapOr$1fr498u(second$iter_Map_slice_Iter_u8_iters_options_closure0(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b7: rs.u8): rs.u8 | undefined => { - if (!(rs.u8Rem(b7, 3) === 0)) { - return b7; + rs.byteVecPush(out, option_unwrapOr$1fr498u(second$iter_Map_slice_Iter_u8_iters_options_closure0(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b5: rs.u8): rs.u8 | undefined => { + if (!(rs.u8Rem(b5, 3) === 0)) { + return b5; } return undefined; })), 205)); @@ -1372,6 +1358,12 @@ export function options(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(gappy)) & 0xff); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(gappy.next()), 238)); const calls: rs.ByteVec = new rs.ByteVec(); + const _83: (a0: rs.u8, a1: rs.ByteVec) => rs.u8 | undefined = (b6: rs.u8, calls2: rs.ByteVec): rs.u8 | undefined => { + rs.byteVecPush(calls2, b6); + return option_map$1yjmt5m(rs.u8CheckedSub(b6, 1), (b7: rs.u8): rs.u8 => { + return rs.u8Div(b7, 2); + }); + }; const first2: rs.u8 | undefined = rs.byteSliceFirst(data); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterTake(rs.iterSuccessors(first2, (b8: rs.u8): rs.u8 | undefined => { return _83(b8, calls); @@ -1493,14 +1485,16 @@ export function optionItems(data: rs.ByteSlice, out: rs.ByteVec): void { const iterE3: number = nested.items.length; while (iterI7 < iterE3) { const _94: number = iterI7++; - if (iterS7[_94] !== rs.None) { - if (iterS7[_94] !== undefined) { - iterS7[_94] = rs.u8WrappingAdd(iterS7[_94], 1); - continue; + b20: { + if (iterS7[_94] !== rs.None) { + if (iterS7[_94] !== undefined) { + iterS7[_94] = rs.u8WrappingAdd(iterS7[_94], 1); + break b20; + } + } + if (iterS7[_94] !== rs.None) { + iterS7[_94] = 166; } - } - if (iterS7[_94] !== rs.None) { - iterS7[_94] = 166; } } for (const _111 of words.items) { @@ -1519,15 +1513,18 @@ export function optionItems(data: rs.ByteSlice, out: rs.ByteVec): void { } rs.byteVecPush(out, _138); } - for (const a2 of rs.vecFrom(nested.items.slice()).items) { - if (a2 !== rs.None) { - if (a2 !== undefined) { - rs.byteVecPush(out, a2); - continue; + for (const _144 of rs.vecFrom(nested.items.slice()).items) { + b29: { + const a2: rs.u8 | undefined | rs.None = _144; + if (a2 !== rs.None) { + if (a2 !== undefined) { + rs.byteVecPush(out, a2); + break b29; + } + } + if (a2 === rs.None) { + rs.byteVecPush(out, 170); } - } - if (a2 === rs.None) { - rs.byteVecPush(out, 170); } } const itS: Array = nested.items; @@ -1937,111 +1934,6 @@ export function at$u8(items: rs.ByteSlice, i: rs.usize): rs.u8 | undefined { */ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let _18!: [rs.ByteSlice, rs.ByteSlice]; - const _45: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2: [rs.u8, rs.u8]): rs.u8 => { - return _2[0] ^ _2[1]; - }; - const _94: (a0: [rs.u8, rs.u8]) => rs.u8 = (_23: [rs.u8, rs.u8]): rs.u8 => { - return _23[0] ^ _23[1]; - }; - const _144: (a0: [rs.u8, rs.u8]) => rs.u8 = (_25: [rs.u8, rs.u8]): rs.u8 => { - return _25[0] ^ _25[1]; - }; - const _194: (a0: [rs.u8, rs.u8]) => rs.u8 = (_27: [rs.u8, rs.u8]): rs.u8 => { - return _27[0] ^ _27[1]; - }; - const _240: (a0: [rs.u8, rs.u8]) => rs.u8 = (_211: [rs.u8, rs.u8]): rs.u8 => { - return _211[0] ^ _211[1]; - }; - const _401: (a0: [rs.u8, rs.u8]) => rs.u8 = (_214: [rs.u8, rs.u8]): rs.u8 => { - return _214[0] ^ _214[1]; - }; - const _452: (a0: [rs.u8, rs.u8]) => rs.u8 = (_216: [rs.u8, rs.u8]): rs.u8 => { - return _216[0] ^ _216[1]; - }; - const _504: (a0: [rs.u8, rs.u8]) => rs.u8 = (_219: [rs.u8, rs.u8]): rs.u8 => { - return _219[0] ^ _219[1]; - }; - const _556: (a0: [rs.u8, rs.u8]) => rs.u8 = (_222: [rs.u8, rs.u8]): rs.u8 => { - return _222[0] ^ _222[1]; - }; - const _604: (a0: [rs.u8, rs.u8]) => rs.u8 = (_225: [rs.u8, rs.u8]): rs.u8 => { - return _225[0] ^ _225[1]; - }; - const _783: (a0: [rs.u8, rs.u8]) => rs.u8 = (_228: [rs.u8, rs.u8]): rs.u8 => { - return _228[0] ^ _228[1]; - }; - const _836: (a0: [rs.u8, rs.u8]) => rs.u8 = (_235: [rs.u8, rs.u8]): rs.u8 => { - return _235[0] ^ _235[1]; - }; - const _890: (a0: [rs.u8, rs.u8]) => rs.u8 = (_239: [rs.u8, rs.u8]): rs.u8 => { - return _239[0] ^ _239[1]; - }; - const _944: (a0: [rs.u8, rs.u8]) => rs.u8 = (_249: [rs.u8, rs.u8]): rs.u8 => { - return _249[0] ^ _249[1]; - }; - const _994: (a0: [rs.u8, rs.u8]) => rs.u8 = (_257: [rs.u8, rs.u8]): rs.u8 => { - return _257[0] ^ _257[1]; - }; - const _1187: (a0: [rs.u8, rs.u8]) => rs.u8 = (_260: [rs.u8, rs.u8]): rs.u8 => { - return _260[0] ^ _260[1]; - }; - const _1238: (a0: [rs.u8, rs.u8]) => rs.u8 = (_262: [rs.u8, rs.u8]): rs.u8 => { - return _262[0] ^ _262[1]; - }; - const _1290: (a0: [rs.u8, rs.u8]) => rs.u8 = (_265: [rs.u8, rs.u8]): rs.u8 => { - return _265[0] ^ _265[1]; - }; - const _1342: (a0: [rs.u8, rs.u8]) => rs.u8 = (_268: [rs.u8, rs.u8]): rs.u8 => { - return _268[0] ^ _268[1]; - }; - const _1390: (a0: [rs.u8, rs.u8]) => rs.u8 = (_271: [rs.u8, rs.u8]): rs.u8 => { - return _271[0] ^ _271[1]; - }; - const _1567: (a0: [rs.u8, rs.u8]) => rs.u8 = (_284: [rs.u8, rs.u8]): rs.u8 => { - return _284[0] ^ _284[1]; - }; - const _1618: (a0: [rs.u8, rs.u8]) => rs.u8 = (_288: [rs.u8, rs.u8]): rs.u8 => { - return _288[0] ^ _288[1]; - }; - const _1670: (a0: [rs.u8, rs.u8]) => rs.u8 = (_296: [rs.u8, rs.u8]): rs.u8 => { - return _296[0] ^ _296[1]; - }; - const _1722: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2107: [rs.u8, rs.u8]): rs.u8 => { - return _2107[0] ^ _2107[1]; - }; - const _1770: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2115: [rs.u8, rs.u8]): rs.u8 => { - return _2115[0] ^ _2115[1]; - }; - const _1946: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2118: [rs.u8, rs.u8]): rs.u8 => { - return _2118[0] ^ _2118[1]; - }; - const _1996: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2120: [rs.u8, rs.u8]): rs.u8 => { - return _2120[0] ^ _2120[1]; - }; - const _2047: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2123: [rs.u8, rs.u8]): rs.u8 => { - return _2123[0] ^ _2123[1]; - }; - const _2098: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2126: [rs.u8, rs.u8]): rs.u8 => { - return _2126[0] ^ _2126[1]; - }; - const _2145: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2129: [rs.u8, rs.u8]): rs.u8 => { - return _2129[0] ^ _2129[1]; - }; - const _2320: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2132: [rs.u8, rs.u8]): rs.u8 => { - return _2132[0] ^ _2132[1]; - }; - const _2377: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2140: [rs.u8, rs.u8]): rs.u8 => { - return _2140[0] ^ _2140[1]; - }; - const _2435: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2144: [rs.u8, rs.u8]): rs.u8 => { - return _2144[0] ^ _2144[1]; - }; - const _2493: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2154: [rs.u8, rs.u8]): rs.u8 => { - return _2154[0] ^ _2154[1]; - }; - const _2547: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2162: [rs.u8, rs.u8]): rs.u8 => { - return _2162[0] ^ _2162[1]; - }; const mid: number = rs.usizeRem(kind >> 5 as rs.usize, rs.usizeAdd(data.length, 1)); if (mid > data.length) { rs.panic("mid > len"); @@ -2054,8 +1946,8 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const a2: rs.ByteSlice = _18[0]; const b2: rs.ByteSlice = _18[1]; const other: boolean = (kind & 4) !== 0; - const n: rs.usize = option_mapOr$1d4bp7c(rs.byteSliceFirst(data), 0, (_2165: rs.u8): rs.usize => { - return rs.usizeRem(_2165 as rs.usize, 4); + const n: rs.usize = option_mapOr$1d4bp7c(rs.byteSliceFirst(data), 0, (_2: rs.u8): rs.usize => { + return rs.usizeRem(_2 as rs.usize, 4); }); const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const _28: rs.u8 = rs.u8Rem(kind, 4); @@ -2063,19 +1955,22 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if ((kind & 16) === 0) { const _31: rs.usize = rs.usizeRem(rs.usizeDiv(data.length, 8), 5); if (_31 === 0) { - const z: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21148: rs.u8): rs.u8 => { - const x603: rs.u8 = _21148; + const z: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21147: rs.u8): rs.u8 => { + const x602: rs.u8 = _21147; const _6355: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6355.value, x603 ^ 1); + rs.byteVecPush(_6355.value, x602 ^ 1); rs.refMutRelease(_6355); - return x603; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21149: rs.u8): rs.u8 => { - const x604: rs.u8 = _21149; + return x602; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21148: rs.u8): rs.u8 => { + const x603: rs.u8 = _21148; const _6356: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6356.value, x604 ^ 2); + rs.byteVecPush(_6356.value, x603 ^ 2); rs.refMutRelease(_6356); - return x604; + return x603; }), [true, true]); + const _45: (a0: [rs.u8, rs.u8]) => rs.u8 = (_21149: [rs.u8, rs.u8]): rs.u8 => { + return _21149[0] ^ _21149[1]; + }; const _46: rs.usize = rs.usizeRem(data.length, 8); if (_46 === 0) { rs.byteVecPush(out, rs.iterCount(z) & 0xff); @@ -2125,25 +2020,28 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { })); } } else if (_31 === 1) { - const z3: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21137: rs.u8): rs.u8 => { - const x591: rs.u8 = _21137; + const z3: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21135: rs.u8): rs.u8 => { + const x589: rs.u8 = _21135; const _6351: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6351.value, x591 ^ 1); + rs.byteVecPush(_6351.value, x589 ^ 1); rs.refMutRelease(_6351); - return x591; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21138: rs.u8): rs.u8 => { - const x592: rs.u8 = _21138; + return x589; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21136: rs.u8): rs.u8 => { + const x590: rs.u8 = _21136; const _6352: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6352.value, x592 ^ 2); + rs.byteVecPush(_6352.value, x590 ^ 2); rs.refMutRelease(_6352); - return x592; + return x590; }), [true, true]); + const _94: (a0: [rs.u8, rs.u8]) => rs.u8 = (_21137: [rs.u8, rs.u8]): rs.u8 => { + return _21137[0] ^ _21137[1]; + }; const _95: rs.usize = rs.usizeRem(data.length, 8); if (_95 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBox(z3)) & 0xff); } else if (_95 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z3)), 238, (_21147: [rs.u8, rs.u8]): rs.u8 => { - return _21147[0] ^ _21147[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z3)), 238, (_21146: [rs.u8, rs.u8]): rs.u8 => { + return _21146[0] ^ _21146[1]; })); } else if (_95 === 2) { const _102: (a0: [rs.u8, rs.u8]) => undefined = (p75: [rs.u8, rs.u8]): undefined => { @@ -2151,12 +2049,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBox(z3), _102); } else if (_95 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z3), (_21146: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_21146[0] as rs.u32, _21146[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z3), (_21145: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21145[0] as rs.u32, _21145[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_95 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z3), (_21145: [rs.u8, rs.u8]): rs.u8 => { - return _21145[0] ^ _21145[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z3), (_21144: [rs.u8, rs.u8]): rs.u8 => { + return _21144[0] ^ _21144[1]; }), "next")), undefined, true); } else if (_95 === 5) { const _110: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc34: rs.u8, p74: [rs.u8, rs.u8]): rs.u8 => { @@ -2164,50 +2062,53 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBox(z3), 0, _110)); } else if (_95 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z3), (_21144: [rs.u8, rs.u8]): rs.u8 => { - return _21144[0] ^ _21144[1]; - }), (x599: rs.u8): boolean => { - return x599 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z3), (_21143: [rs.u8, rs.u8]): rs.u8 => { + return _21143[0] ^ _21143[1]; + }), (x598: rs.u8): boolean => { + return x598 === 0; }) ? 1 : 0); } else { const z4: rs.Iter<[rs.u8, rs.u8]> = z3; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z4), (_21139: [rs.u8, rs.u8]): boolean => { - return _21139[0] > _21139[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z4), (_21138: [rs.u8, rs.u8]): boolean => { + return _21138[0] > _21138[1]; }), 238, (i41: rs.usize): rs.u8 => { return i41 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z4), (_21140: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_21140[0], 3) === 0; - }), 238, (_21141: [rs.u8, rs.u8]): rs.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z4), (_21139: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21139[0], 3) === 0; + }), 238, (_21140: [rs.u8, rs.u8]): rs.u8 => { + return _21140[0] ^ _21140[1]; + })); + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z4), n), 238, (_21141: [rs.u8, rs.u8]): rs.u8 => { return _21141[0] ^ _21141[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z4), n), 238, (_21142: [rs.u8, rs.u8]): rs.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z4.next()), 238, (_21142: [rs.u8, rs.u8]): rs.u8 => { return _21142[0] ^ _21142[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z4.next()), 238, (_21143: [rs.u8, rs.u8]): rs.u8 => { - return _21143[0] ^ _21143[1]; - })); } } else if (_31 === 2) { - const z5: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21126: rs.u8): rs.u8 => { - const x579: rs.u8 = _21126; + const z5: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21123: rs.u8): rs.u8 => { + const x576: rs.u8 = _21123; const _6347: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6347.value, x579 ^ 1); + rs.byteVecPush(_6347.value, x576 ^ 1); rs.refMutRelease(_6347); - return x579; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21127: rs.u8): rs.u8 => { - const x580: rs.u8 = _21127; + return x576; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21124: rs.u8): rs.u8 => { + const x577: rs.u8 = _21124; const _6348: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6348.value, x580 ^ 2); + rs.byteVecPush(_6348.value, x577 ^ 2); rs.refMutRelease(_6348); - return x580; + return x577; }), [true, true]), n); + const _144: (a0: [rs.u8, rs.u8]) => rs.u8 = (_21125: [rs.u8, rs.u8]): rs.u8 => { + return _21125[0] ^ _21125[1]; + }; const _145: rs.usize = rs.usizeRem(data.length, 8); if (_145 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBox(z5)) & 0xff); } else if (_145 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z5)), 238, (_21136: [rs.u8, rs.u8]): rs.u8 => { - return _21136[0] ^ _21136[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z5)), 238, (_21134: [rs.u8, rs.u8]): rs.u8 => { + return _21134[0] ^ _21134[1]; })); } else if (_145 === 2) { const _152: (a0: [rs.u8, rs.u8]) => undefined = (p73: [rs.u8, rs.u8]): undefined => { @@ -2215,12 +2116,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBox(z5), _152); } else if (_145 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z5), (_21135: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_21135[0] as rs.u32, _21135[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z5), (_21133: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21133[0] as rs.u32, _21133[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_145 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z5), (_21134: [rs.u8, rs.u8]): rs.u8 => { - return _21134[0] ^ _21134[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z5), (_21132: [rs.u8, rs.u8]): rs.u8 => { + return _21132[0] ^ _21132[1]; }), "next")), undefined, true); } else if (_145 === 5) { const _160: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc33: rs.u8, p72: [rs.u8, rs.u8]): rs.u8 => { @@ -2228,50 +2129,53 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBox(z5), 0, _160)); } else if (_145 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z5), (_21133: [rs.u8, rs.u8]): rs.u8 => { - return _21133[0] ^ _21133[1]; - }), (x587: rs.u8): boolean => { - return x587 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z5), (_21131: [rs.u8, rs.u8]): rs.u8 => { + return _21131[0] ^ _21131[1]; + }), (x585: rs.u8): boolean => { + return x585 === 0; }) ? 1 : 0); } else { const z6: rs.Iter<[rs.u8, rs.u8]> = z5; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z6), (_21128: [rs.u8, rs.u8]): boolean => { - return _21128[0] > _21128[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z6), (_21126: [rs.u8, rs.u8]): boolean => { + return _21126[0] > _21126[1]; }), 238, (i40: rs.usize): rs.u8 => { return i40 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z6), (_21129: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_21129[0], 3) === 0; - }), 238, (_21130: [rs.u8, rs.u8]): rs.u8 => { - return _21130[0] ^ _21130[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z6), (_21127: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21127[0], 3) === 0; + }), 238, (_21128: [rs.u8, rs.u8]): rs.u8 => { + return _21128[0] ^ _21128[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z6), n), 238, (_21131: [rs.u8, rs.u8]): rs.u8 => { - return _21131[0] ^ _21131[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z6), n), 238, (_21129: [rs.u8, rs.u8]): rs.u8 => { + return _21129[0] ^ _21129[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z6.next()), 238, (_21132: [rs.u8, rs.u8]): rs.u8 => { - return _21132[0] ^ _21132[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z6.next()), 238, (_21130: [rs.u8, rs.u8]): rs.u8 => { + return _21130[0] ^ _21130[1]; })); } } else if (_31 === 3) { - const _184: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21115: rs.u8): rs.u8 => { - const x567: rs.u8 = _21115; + const _184: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21111: rs.u8): rs.u8 => { + const x563: rs.u8 = _21111; const _6343: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6343.value, x567 ^ 1); + rs.byteVecPush(_6343.value, x563 ^ 1); rs.refMutRelease(_6343); - return x567; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21116: rs.u8): rs.u8 => { - const x568: rs.u8 = _21116; + return x563; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21112: rs.u8): rs.u8 => { + const x564: rs.u8 = _21112; const _6344: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6344.value, x568 ^ 2); + rs.byteVecPush(_6344.value, x564 ^ 2); rs.refMutRelease(_6344); - return x568; + return x564; }), [true, true]); + const _194: (a0: [rs.u8, rs.u8]) => rs.u8 = (_21113: [rs.u8, rs.u8]): rs.u8 => { + return _21113[0] ^ _21113[1]; + }; const _195: rs.usize = rs.usizeRem(data.length, 8); if (_195 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_184)))) & 0xff); } else if (_195 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_184)))), 238, (_21125: [rs.u8, rs.u8]): rs.u8 => { - return _21125[0] ^ _21125[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_184)))), 238, (_21122: [rs.u8, rs.u8]): rs.u8 => { + return _21122[0] ^ _21122[1]; })); } else if (_195 === 2) { const _202: (a0: [rs.u8, rs.u8]) => undefined = (p71: [rs.u8, rs.u8]): undefined => { @@ -2279,12 +2183,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_184))), _202); } else if (_195 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_184))), (_21124: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_21124[0] as rs.u32, _21124[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_184))), (_21121: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21121[0] as rs.u32, _21121[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_195 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_184))), (_21123: [rs.u8, rs.u8]): rs.u8 => { - return _21123[0] ^ _21123[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_184))), (_21120: [rs.u8, rs.u8]): rs.u8 => { + return _21120[0] ^ _21120[1]; }), "next")), undefined, true); } else if (_195 === 5) { const _210: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc32: rs.u8, p70: [rs.u8, rs.u8]): rs.u8 => { @@ -2292,49 +2196,52 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_184))), 0, _210)); } else if (_195 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_184))), (_21122: [rs.u8, rs.u8]): rs.u8 => { - return _21122[0] ^ _21122[1]; - }), (x575: rs.u8): boolean => { - return x575 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_184))), (_21119: [rs.u8, rs.u8]): rs.u8 => { + return _21119[0] ^ _21119[1]; + }), (x572: rs.u8): boolean => { + return x572 === 0; }) ? 1 : 0); } else { - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_184), (_21117: [rs.u8, rs.u8]): boolean => { - return _21117[0] > _21117[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_184), (_21114: [rs.u8, rs.u8]): boolean => { + return _21114[0] > _21114[1]; }), 238, (i39: rs.usize): rs.u8 => { return i39 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_184), (_21118: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_21118[0], 3) === 0; - }), 238, (_21119: [rs.u8, rs.u8]): rs.u8 => { - return _21119[0] ^ _21119[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_184), (_21115: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21115[0], 3) === 0; + }), 238, (_21116: [rs.u8, rs.u8]): rs.u8 => { + return _21116[0] ^ _21116[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_184), n), 238, (_21120: [rs.u8, rs.u8]): rs.u8 => { - return _21120[0] ^ _21120[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_184), n), 238, (_21117: [rs.u8, rs.u8]): rs.u8 => { + return _21117[0] ^ _21117[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_184.next()), 238, (_21121: [rs.u8, rs.u8]): rs.u8 => { - return _21121[0] ^ _21121[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_184.next()), 238, (_21118: [rs.u8, rs.u8]): rs.u8 => { + return _21118[0] ^ _21118[1]; })); } } else { - const _229: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21104: rs.u8): rs.u8 => { - const x555: rs.u8 = _21104; + const _229: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21099: rs.u8): rs.u8 => { + const x550: rs.u8 = _21099; const _6339: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6339.value, x555 ^ 1); + rs.byteVecPush(_6339.value, x550 ^ 1); rs.refMutRelease(_6339); - return x555; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21105: rs.u8): rs.u8 => { - const x556: rs.u8 = _21105; + return x550; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21100: rs.u8): rs.u8 => { + const x551: rs.u8 = _21100; const _6340: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6340.value, x556 ^ 2); + rs.byteVecPush(_6340.value, x551 ^ 2); rs.refMutRelease(_6340); - return x556; + return x551; }), [true, true]), n); + const _240: (a0: [rs.u8, rs.u8]) => rs.u8 = (_21101: [rs.u8, rs.u8]): rs.u8 => { + return _21101[0] ^ _21101[1]; + }; const _241: rs.usize = rs.usizeRem(data.length, 8); if (_241 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_229)))) & 0xff); } else if (_241 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_229)))), 238, (_21114: [rs.u8, rs.u8]): rs.u8 => { - return _21114[0] ^ _21114[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_229)))), 238, (_21110: [rs.u8, rs.u8]): rs.u8 => { + return _21110[0] ^ _21110[1]; })); } else if (_241 === 2) { const _248: (a0: [rs.u8, rs.u8]) => undefined = (p69: [rs.u8, rs.u8]): undefined => { @@ -2342,12 +2249,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_229))), _248); } else if (_241 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_229))), (_21113: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_21113[0] as rs.u32, _21113[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_229))), (_21109: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21109[0] as rs.u32, _21109[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_241 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_229))), (_21112: [rs.u8, rs.u8]): rs.u8 => { - return _21112[0] ^ _21112[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_229))), (_21108: [rs.u8, rs.u8]): rs.u8 => { + return _21108[0] ^ _21108[1]; }), "next")), undefined, true); } else if (_241 === 5) { const _256: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc31: rs.u8, p68: [rs.u8, rs.u8]): rs.u8 => { @@ -2355,151 +2262,151 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_229))), 0, _256)); } else if (_241 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_229))), (_21111: [rs.u8, rs.u8]): rs.u8 => { - return _21111[0] ^ _21111[1]; - }), (x563: rs.u8): boolean => { - return x563 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_229))), (_21107: [rs.u8, rs.u8]): rs.u8 => { + return _21107[0] ^ _21107[1]; + }), (x559: rs.u8): boolean => { + return x559 === 0; }) ? 1 : 0); } else { - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_229), (_21106: [rs.u8, rs.u8]): boolean => { - return _21106[0] > _21106[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_229), (_21102: [rs.u8, rs.u8]): boolean => { + return _21102[0] > _21102[1]; }), 238, (i38: rs.usize): rs.u8 => { return i38 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_229), (_21107: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_21107[0], 3) === 0; - }), 238, (_21108: [rs.u8, rs.u8]): rs.u8 => { - return _21108[0] ^ _21108[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_229), (_21103: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21103[0], 3) === 0; + }), 238, (_21104: [rs.u8, rs.u8]): rs.u8 => { + return _21104[0] ^ _21104[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_229), n), 238, (_21109: [rs.u8, rs.u8]): rs.u8 => { - return _21109[0] ^ _21109[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_229), n), 238, (_21105: [rs.u8, rs.u8]): rs.u8 => { + return _21105[0] ^ _21105[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_229.next()), 238, (_21110: [rs.u8, rs.u8]): rs.u8 => { - return _21110[0] ^ _21110[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_229.next()), 238, (_21106: [rs.u8, rs.u8]): rs.u8 => { + return _21106[0] ^ _21106[1]; })); } } } else { const _274: rs.usize = rs.usizeRem(data.length, 8); if (_274 === 0) { - rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21101: rs.u8): rs.u8 => { - const x552: rs.u8 = _21101; + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21096: rs.u8): rs.u8 => { + const x547: rs.u8 = _21096; const _6337: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6337.value, x552 ^ 1); + rs.byteVecPush(_6337.value, x547 ^ 1); rs.refMutRelease(_6337); - return x552; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21102: rs.u8): rs.u8 => { - const x553: rs.u8 = _21102; + return x547; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21097: rs.u8): rs.u8 => { + const x548: rs.u8 = _21097; const _6338: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6338.value, x553 ^ 2); + rs.byteVecPush(_6338.value, x548 ^ 2); rs.refMutRelease(_6338); - return x553; - }), [true, true]), (_21103: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_21103[0], 2) === 0; + return x548; + }), [true, true]), (_21098: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21098[0], 2) === 0; })) & 0xff); } else if (_274 === 1) { - rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21098: rs.u8): rs.u8 => { - const x549: rs.u8 = _21098; + rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21093: rs.u8): rs.u8 => { + const x544: rs.u8 = _21093; const _6335: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6335.value, x549 ^ 1); + rs.byteVecPush(_6335.value, x544 ^ 1); rs.refMutRelease(_6335); - return x549; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21099: rs.u8): rs.u8 => { - const x550: rs.u8 = _21099; + return x544; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21094: rs.u8): rs.u8 => { + const x545: rs.u8 = _21094; const _6336: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6336.value, x550 ^ 2); + rs.byteVecPush(_6336.value, x545 ^ 2); rs.refMutRelease(_6336); - return x550; - }), [true, true]), (_21100: [rs.u8, rs.u8]): rs.u8 | undefined => { - return rs.u8CheckedSub(_21100[0], _21100[1]); + return x545; + }), [true, true]), (_21095: [rs.u8, rs.u8]): rs.u8 | undefined => { + return rs.u8CheckedSub(_21095[0], _21095[1]); })) & 0xff); } else if (_274 === 2) { - rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21095: rs.u8): rs.u8 => { - const x546: rs.u8 = _21095; + rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21090: rs.u8): rs.u8 => { + const x541: rs.u8 = _21090; const _6333: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6333.value, x546 ^ 1); + rs.byteVecPush(_6333.value, x541 ^ 1); rs.refMutRelease(_6333); - return x546; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21096: rs.u8): rs.u8 => { - const x547: rs.u8 = _21096; + return x541; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21091: rs.u8): rs.u8 => { + const x542: rs.u8 = _21091; const _6334: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6334.value, x547 ^ 2); + rs.byteVecPush(_6334.value, x542 ^ 2); rs.refMutRelease(_6334); - return x547; - }), [true, true]), (_21097: [rs.u8, rs.u8]): boolean => { - return _21097[0] < 128; + return x542; + }), [true, true]), (_21092: [rs.u8, rs.u8]): boolean => { + return _21092[0] < 128; })) & 0xff); } else if (_274 === 3) { - rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21092: rs.u8): rs.u8 => { - const x544: rs.u8 = _21092; + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21087: rs.u8): rs.u8 => { + const x539: rs.u8 = _21087; const _6331: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6331.value, x544 ^ 1); + rs.byteVecPush(_6331.value, x539 ^ 1); rs.refMutRelease(_6331); - return x544; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21093: rs.u8): rs.u8 => { - const x545: rs.u8 = _21093; + return x539; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21088: rs.u8): rs.u8 => { + const x540: rs.u8 = _21088; const _6332: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6332.value, x545 ^ 2); + rs.byteVecPush(_6332.value, x540 ^ 2); rs.refMutRelease(_6332); - return x545; - }), [true, true])), (_21094: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { - return _21094[0] & 0xff; + return x540; + }), [true, true])), (_21089: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { + return _21089[0] & 0xff; })), 238)); } else if (_274 === 4) { - rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21090: rs.u8): rs.u8 => { - const x542: rs.u8 = _21090; + rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21085: rs.u8): rs.u8 => { + const x537: rs.u8 = _21085; const _6329: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6329.value, x542 ^ 1); + rs.byteVecPush(_6329.value, x537 ^ 1); rs.refMutRelease(_6329); - return x542; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21091: rs.u8): rs.u8 => { - const x543: rs.u8 = _21091; + return x537; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21086: rs.u8): rs.u8 => { + const x538: rs.u8 = _21086; const _6330: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6330.value, x543 ^ 2); + rs.byteVecPush(_6330.value, x538 ^ 2); rs.refMutRelease(_6330); - return x543; + return x538; }), [true, true]), rs.iterSlice([[1, 2] as [rs.u8, rs.u8]]))) & 0xff); } else if (_274 === 5) { - rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21088: rs.u8): rs.u8 => { - const x540: rs.u8 = _21088; + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21083: rs.u8): rs.u8 => { + const x535: rs.u8 = _21083; const _6327: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6327.value, x540 ^ 1); + rs.byteVecPush(_6327.value, x535 ^ 1); rs.refMutRelease(_6327); - return x540; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21089: rs.u8): rs.u8 => { - const x541: rs.u8 = _21089; + return x535; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21084: rs.u8): rs.u8 => { + const x536: rs.u8 = _21084; const _6328: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6328.value, x541 ^ 2); + rs.byteVecPush(_6328.value, x536 ^ 2); rs.refMutRelease(_6328); - return x541; + return x536; }), [true, true]), n, undefined, true)) & 0xff); } else if (_274 === 6) { - rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21086: rs.u8): rs.u8 => { - const x538: rs.u8 = _21086; + rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21081: rs.u8): rs.u8 => { + const x533: rs.u8 = _21081; const _6325: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6325.value, x538 ^ 1); + rs.byteVecPush(_6325.value, x533 ^ 1); rs.refMutRelease(_6325); - return x538; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21087: rs.u8): rs.u8 => { - const x539: rs.u8 = _21087; + return x533; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21082: rs.u8): rs.u8 => { + const x534: rs.u8 = _21082; const _6326: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6326.value, x539 ^ 2); + rs.byteVecPush(_6326.value, x534 ^ 2); rs.refMutRelease(_6326); - return x539; + return x534; }), [true, true]), n)) & 0xff); } else { - const p: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21084: rs.u8): rs.u8 => { - const x536: rs.u8 = _21084; + const p: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21079: rs.u8): rs.u8 => { + const x531: rs.u8 = _21079; const _6323: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6323.value, x536 ^ 1); + rs.byteVecPush(_6323.value, x531 ^ 1); rs.refMutRelease(_6323); - return x536; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21085: rs.u8): rs.u8 => { - const x537: rs.u8 = _21085; + return x531; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21080: rs.u8): rs.u8 => { + const x532: rs.u8 = _21080; const _6324: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6324.value, x537 ^ 2); + rs.byteVecPush(_6324.value, x532 ^ 2); rs.refMutRelease(_6324); - return x537; + return x532; }), [true, true])); rs.byteVecPush(out, (rs.peekablePeek(p) !== undefined ? 1 : 0) ^ (rs.iterCount(p) & 0xff)); } @@ -2509,87 +2416,93 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if ((kind & 16) === 0) { const _385: rs.usize = rs.usizeRem(rs.usizeDiv(data.length, 8), 5); if (_385 === 0) { - const z7: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21073: rs.u8): rs.u8 => { - const x524: rs.u8 = _21073; + const z7: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21067: rs.u8): rs.u8 => { + const x518: rs.u8 = _21067; const _6319: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6319.value, x524 ^ 3); + rs.byteVecPush(_6319.value, x518 ^ 3); rs.refMutRelease(_6319); - return x524; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21074: rs.u8): rs.u8 => { - const x525: rs.u8 = _21074; + return x518; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21068: rs.u8): rs.u8 => { + const x519: rs.u8 = _21068; const _6320: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6320.value, x525 ^ 4); + rs.byteVecPush(_6320.value, x519 ^ 4); rs.refMutRelease(_6320); - return x525; + return x519; }), "len"); + const _401: (a0: [rs.u8, rs.u8]) => rs.u8 = (_21069: [rs.u8, rs.u8]): rs.u8 => { + return _21069[0] ^ _21069[1]; + }; const _402: rs.usize = rs.usizeRem(data.length, 8); if (_402 === 0) { rs.byteVecPush(out, rs.iterCount(z7) & 0xff); } else if (_402 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(z7), 238, (_21083: [rs.u8, rs.u8]): rs.u8 => { - return _21083[0] ^ _21083[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(z7), 238, (_21078: [rs.u8, rs.u8]): rs.u8 => { + return _21078[0] ^ _21078[1]; })); } else if (_402 === 2) { rs.iterForEach(z7, (p67: [rs.u8, rs.u8]): undefined => { rs.byteVecPush(out, _401(p67)); }); } else if (_402 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(z7, (_21082: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_21082[0] as rs.u32, _21082[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(z7, (_21077: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21077[0] as rs.u32, _21077[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_402 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(z7, (_21081: [rs.u8, rs.u8]): rs.u8 => { - return _21081[0] ^ _21081[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(z7, (_21076: [rs.u8, rs.u8]): rs.u8 => { + return _21076[0] ^ _21076[1]; }), undefined, true)), undefined, true); } else if (_402 === 5) { rs.byteVecPush(out, rs.iterFold(z7, 0, (acc30: rs.u8, p66: [rs.u8, rs.u8]): rs.u8 => { return rs.u8WrappingMul(acc30, 3) ^ _401(p66); })); } else if (_402 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(z7, (_21080: [rs.u8, rs.u8]): rs.u8 => { - return _21080[0] ^ _21080[1]; - }), (x532: rs.u8): boolean => { - return x532 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(z7, (_21075: [rs.u8, rs.u8]): rs.u8 => { + return _21075[0] ^ _21075[1]; + }), (x527: rs.u8): boolean => { + return x527 === 0; }) ? 1 : 0); } else { const z8: rs.Iter<[rs.u8, rs.u8]> = z7; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(z8, (_21075: [rs.u8, rs.u8]): boolean => { - return _21075[0] > _21075[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(z8, (_21070: [rs.u8, rs.u8]): boolean => { + return _21070[0] > _21070[1]; }), 238, (i36: rs.usize): rs.u8 => { return i36 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(z8, (_21076: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_21076[0], 3) === 0; - }), 238, (_21077: [rs.u8, rs.u8]): rs.u8 => { - return _21077[0] ^ _21077[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(z8, (_21071: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21071[0], 3) === 0; + }), 238, (_21072: [rs.u8, rs.u8]): rs.u8 => { + return _21072[0] ^ _21072[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z8, n), 238, (_21078: [rs.u8, rs.u8]): rs.u8 => { - return _21078[0] ^ _21078[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z8, n), 238, (_21073: [rs.u8, rs.u8]): rs.u8 => { + return _21073[0] ^ _21073[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z8.next()), 238, (_21079: [rs.u8, rs.u8]): rs.u8 => { - return _21079[0] ^ _21079[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z8.next()), 238, (_21074: [rs.u8, rs.u8]): rs.u8 => { + return _21074[0] ^ _21074[1]; })); } } else if (_385 === 1) { - const z9: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21062: rs.u8): rs.u8 => { - const x512: rs.u8 = _21062; + const z9: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21055: rs.u8): rs.u8 => { + const x505: rs.u8 = _21055; const _6315: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6315.value, x512 ^ 3); + rs.byteVecPush(_6315.value, x505 ^ 3); rs.refMutRelease(_6315); - return x512; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21063: rs.u8): rs.u8 => { - const x513: rs.u8 = _21063; + return x505; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21056: rs.u8): rs.u8 => { + const x506: rs.u8 = _21056; const _6316: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6316.value, x513 ^ 4); + rs.byteVecPush(_6316.value, x506 ^ 4); rs.refMutRelease(_6316); - return x513; + return x506; }), "len"); + const _452: (a0: [rs.u8, rs.u8]) => rs.u8 = (_21057: [rs.u8, rs.u8]): rs.u8 => { + return _21057[0] ^ _21057[1]; + }; const _453: rs.usize = rs.usizeRem(data.length, 8); if (_453 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBox(z9)) & 0xff); } else if (_453 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z9)), 238, (_21072: [rs.u8, rs.u8]): rs.u8 => { - return _21072[0] ^ _21072[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z9)), 238, (_21066: [rs.u8, rs.u8]): rs.u8 => { + return _21066[0] ^ _21066[1]; })); } else if (_453 === 2) { const _460: (a0: [rs.u8, rs.u8]) => undefined = (p65: [rs.u8, rs.u8]): undefined => { @@ -2597,12 +2510,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBox(z9), _460); } else if (_453 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z9), (_21071: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_21071[0] as rs.u32, _21071[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z9), (_21065: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21065[0] as rs.u32, _21065[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_453 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z9), (_21070: [rs.u8, rs.u8]): rs.u8 => { - return _21070[0] ^ _21070[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z9), (_21064: [rs.u8, rs.u8]): rs.u8 => { + return _21064[0] ^ _21064[1]; }), "next")), undefined, true); } else if (_453 === 5) { const _468: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc29: rs.u8, p64: [rs.u8, rs.u8]): rs.u8 => { @@ -2610,50 +2523,53 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBox(z9), 0, _468)); } else if (_453 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z9), (_21069: [rs.u8, rs.u8]): rs.u8 => { - return _21069[0] ^ _21069[1]; - }), (x520: rs.u8): boolean => { - return x520 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z9), (_21063: [rs.u8, rs.u8]): rs.u8 => { + return _21063[0] ^ _21063[1]; + }), (x514: rs.u8): boolean => { + return x514 === 0; }) ? 1 : 0); } else { const z10: rs.Iter<[rs.u8, rs.u8]> = z9; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z10), (_21064: [rs.u8, rs.u8]): boolean => { - return _21064[0] > _21064[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z10), (_21058: [rs.u8, rs.u8]): boolean => { + return _21058[0] > _21058[1]; }), 238, (i35: rs.usize): rs.u8 => { return i35 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z10), (_21065: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_21065[0], 3) === 0; - }), 238, (_21066: [rs.u8, rs.u8]): rs.u8 => { - return _21066[0] ^ _21066[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z10), (_21059: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21059[0], 3) === 0; + }), 238, (_21060: [rs.u8, rs.u8]): rs.u8 => { + return _21060[0] ^ _21060[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z10), n), 238, (_21067: [rs.u8, rs.u8]): rs.u8 => { - return _21067[0] ^ _21067[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z10), n), 238, (_21061: [rs.u8, rs.u8]): rs.u8 => { + return _21061[0] ^ _21061[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z10.next()), 238, (_21068: [rs.u8, rs.u8]): rs.u8 => { - return _21068[0] ^ _21068[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z10.next()), 238, (_21062: [rs.u8, rs.u8]): rs.u8 => { + return _21062[0] ^ _21062[1]; })); } } else if (_385 === 2) { - const z11: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21051: rs.u8): rs.u8 => { - const x500: rs.u8 = _21051; + const z11: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21043: rs.u8): rs.u8 => { + const x492: rs.u8 = _21043; const _6311: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6311.value, x500 ^ 3); + rs.byteVecPush(_6311.value, x492 ^ 3); rs.refMutRelease(_6311); - return x500; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21052: rs.u8): rs.u8 => { - const x501: rs.u8 = _21052; + return x492; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21044: rs.u8): rs.u8 => { + const x493: rs.u8 = _21044; const _6312: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6312.value, x501 ^ 4); + rs.byteVecPush(_6312.value, x493 ^ 4); rs.refMutRelease(_6312); - return x501; + return x493; }), "len"), n); + const _504: (a0: [rs.u8, rs.u8]) => rs.u8 = (_21045: [rs.u8, rs.u8]): rs.u8 => { + return _21045[0] ^ _21045[1]; + }; const _505: rs.usize = rs.usizeRem(data.length, 8); if (_505 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBox(z11)) & 0xff); } else if (_505 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z11)), 238, (_21061: [rs.u8, rs.u8]): rs.u8 => { - return _21061[0] ^ _21061[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z11)), 238, (_21054: [rs.u8, rs.u8]): rs.u8 => { + return _21054[0] ^ _21054[1]; })); } else if (_505 === 2) { const _512: (a0: [rs.u8, rs.u8]) => undefined = (p63: [rs.u8, rs.u8]): undefined => { @@ -2661,12 +2577,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBox(z11), _512); } else if (_505 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z11), (_21060: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_21060[0] as rs.u32, _21060[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z11), (_21053: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21053[0] as rs.u32, _21053[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_505 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z11), (_21059: [rs.u8, rs.u8]): rs.u8 => { - return _21059[0] ^ _21059[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z11), (_21052: [rs.u8, rs.u8]): rs.u8 => { + return _21052[0] ^ _21052[1]; }), "next")), undefined, true); } else if (_505 === 5) { const _520: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc28: rs.u8, p62: [rs.u8, rs.u8]): rs.u8 => { @@ -2674,50 +2590,53 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBox(z11), 0, _520)); } else if (_505 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z11), (_21058: [rs.u8, rs.u8]): rs.u8 => { - return _21058[0] ^ _21058[1]; - }), (x508: rs.u8): boolean => { - return x508 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z11), (_21051: [rs.u8, rs.u8]): rs.u8 => { + return _21051[0] ^ _21051[1]; + }), (x501: rs.u8): boolean => { + return x501 === 0; }) ? 1 : 0); } else { const z12: rs.Iter<[rs.u8, rs.u8]> = z11; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z12), (_21053: [rs.u8, rs.u8]): boolean => { - return _21053[0] > _21053[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z12), (_21046: [rs.u8, rs.u8]): boolean => { + return _21046[0] > _21046[1]; }), 238, (i34: rs.usize): rs.u8 => { return i34 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z12), (_21054: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_21054[0], 3) === 0; - }), 238, (_21055: [rs.u8, rs.u8]): rs.u8 => { - return _21055[0] ^ _21055[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z12), (_21047: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21047[0], 3) === 0; + }), 238, (_21048: [rs.u8, rs.u8]): rs.u8 => { + return _21048[0] ^ _21048[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z12), n), 238, (_21056: [rs.u8, rs.u8]): rs.u8 => { - return _21056[0] ^ _21056[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z12), n), 238, (_21049: [rs.u8, rs.u8]): rs.u8 => { + return _21049[0] ^ _21049[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z12.next()), 238, (_21057: [rs.u8, rs.u8]): rs.u8 => { - return _21057[0] ^ _21057[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z12.next()), 238, (_21050: [rs.u8, rs.u8]): rs.u8 => { + return _21050[0] ^ _21050[1]; })); } } else if (_385 === 3) { - const _544: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21040: rs.u8): rs.u8 => { - const x488: rs.u8 = _21040; + const _544: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21031: rs.u8): rs.u8 => { + const x479: rs.u8 = _21031; const _6307: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6307.value, x488 ^ 3); + rs.byteVecPush(_6307.value, x479 ^ 3); rs.refMutRelease(_6307); - return x488; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21041: rs.u8): rs.u8 => { - const x489: rs.u8 = _21041; + return x479; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21032: rs.u8): rs.u8 => { + const x480: rs.u8 = _21032; const _6308: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6308.value, x489 ^ 4); + rs.byteVecPush(_6308.value, x480 ^ 4); rs.refMutRelease(_6308); - return x489; + return x480; }), "len"); + const _556: (a0: [rs.u8, rs.u8]) => rs.u8 = (_21033: [rs.u8, rs.u8]): rs.u8 => { + return _21033[0] ^ _21033[1]; + }; const _557: rs.usize = rs.usizeRem(data.length, 8); if (_557 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_544)))) & 0xff); } else if (_557 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_544)))), 238, (_21050: [rs.u8, rs.u8]): rs.u8 => { - return _21050[0] ^ _21050[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_544)))), 238, (_21042: [rs.u8, rs.u8]): rs.u8 => { + return _21042[0] ^ _21042[1]; })); } else if (_557 === 2) { const _564: (a0: [rs.u8, rs.u8]) => undefined = (p61: [rs.u8, rs.u8]): undefined => { @@ -2725,12 +2644,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_544))), _564); } else if (_557 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_544))), (_21049: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_21049[0] as rs.u32, _21049[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_544))), (_21041: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21041[0] as rs.u32, _21041[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_557 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_544))), (_21048: [rs.u8, rs.u8]): rs.u8 => { - return _21048[0] ^ _21048[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_544))), (_21040: [rs.u8, rs.u8]): rs.u8 => { + return _21040[0] ^ _21040[1]; }), "next")), undefined, true); } else if (_557 === 5) { const _572: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc27: rs.u8, p60: [rs.u8, rs.u8]): rs.u8 => { @@ -2738,49 +2657,52 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_544))), 0, _572)); } else if (_557 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_544))), (_21047: [rs.u8, rs.u8]): rs.u8 => { - return _21047[0] ^ _21047[1]; - }), (x496: rs.u8): boolean => { - return x496 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_544))), (_21039: [rs.u8, rs.u8]): rs.u8 => { + return _21039[0] ^ _21039[1]; + }), (x488: rs.u8): boolean => { + return x488 === 0; }) ? 1 : 0); } else { - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_544), (_21042: [rs.u8, rs.u8]): boolean => { - return _21042[0] > _21042[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_544), (_21034: [rs.u8, rs.u8]): boolean => { + return _21034[0] > _21034[1]; }), 238, (i33: rs.usize): rs.u8 => { return i33 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_544), (_21043: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_21043[0], 3) === 0; - }), 238, (_21044: [rs.u8, rs.u8]): rs.u8 => { - return _21044[0] ^ _21044[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_544), (_21035: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21035[0], 3) === 0; + }), 238, (_21036: [rs.u8, rs.u8]): rs.u8 => { + return _21036[0] ^ _21036[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_544), n), 238, (_21045: [rs.u8, rs.u8]): rs.u8 => { - return _21045[0] ^ _21045[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_544), n), 238, (_21037: [rs.u8, rs.u8]): rs.u8 => { + return _21037[0] ^ _21037[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_544.next()), 238, (_21046: [rs.u8, rs.u8]): rs.u8 => { - return _21046[0] ^ _21046[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_544.next()), 238, (_21038: [rs.u8, rs.u8]): rs.u8 => { + return _21038[0] ^ _21038[1]; })); } } else { - const _591: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21029: rs.u8): rs.u8 => { - const x476: rs.u8 = _21029; + const _591: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21019: rs.u8): rs.u8 => { + const x466: rs.u8 = _21019; const _6303: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6303.value, x476 ^ 3); + rs.byteVecPush(_6303.value, x466 ^ 3); rs.refMutRelease(_6303); - return x476; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21030: rs.u8): rs.u8 => { - const x477: rs.u8 = _21030; + return x466; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21020: rs.u8): rs.u8 => { + const x467: rs.u8 = _21020; const _6304: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6304.value, x477 ^ 4); + rs.byteVecPush(_6304.value, x467 ^ 4); rs.refMutRelease(_6304); - return x477; + return x467; }), "len"), n); + const _604: (a0: [rs.u8, rs.u8]) => rs.u8 = (_21021: [rs.u8, rs.u8]): rs.u8 => { + return _21021[0] ^ _21021[1]; + }; const _605: rs.usize = rs.usizeRem(data.length, 8); if (_605 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_591)))) & 0xff); } else if (_605 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_591)))), 238, (_21039: [rs.u8, rs.u8]): rs.u8 => { - return _21039[0] ^ _21039[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_591)))), 238, (_21030: [rs.u8, rs.u8]): rs.u8 => { + return _21030[0] ^ _21030[1]; })); } else if (_605 === 2) { const _612: (a0: [rs.u8, rs.u8]) => undefined = (p59: [rs.u8, rs.u8]): undefined => { @@ -2788,12 +2710,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_591))), _612); } else if (_605 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_591))), (_21038: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_21038[0] as rs.u32, _21038[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_591))), (_21029: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21029[0] as rs.u32, _21029[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_605 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_591))), (_21037: [rs.u8, rs.u8]): rs.u8 => { - return _21037[0] ^ _21037[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_591))), (_21028: [rs.u8, rs.u8]): rs.u8 => { + return _21028[0] ^ _21028[1]; }), "next")), undefined, true); } else if (_605 === 5) { const _620: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc26: rs.u8, p58: [rs.u8, rs.u8]): rs.u8 => { @@ -2801,151 +2723,151 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_591))), 0, _620)); } else if (_605 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_591))), (_21036: [rs.u8, rs.u8]): rs.u8 => { - return _21036[0] ^ _21036[1]; - }), (x484: rs.u8): boolean => { - return x484 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_591))), (_21027: [rs.u8, rs.u8]): rs.u8 => { + return _21027[0] ^ _21027[1]; + }), (x475: rs.u8): boolean => { + return x475 === 0; }) ? 1 : 0); } else { - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_591), (_21031: [rs.u8, rs.u8]): boolean => { - return _21031[0] > _21031[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_591), (_21022: [rs.u8, rs.u8]): boolean => { + return _21022[0] > _21022[1]; }), 238, (i32: rs.usize): rs.u8 => { return i32 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_591), (_21032: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_21032[0], 3) === 0; - }), 238, (_21033: [rs.u8, rs.u8]): rs.u8 => { - return _21033[0] ^ _21033[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_591), (_21023: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21023[0], 3) === 0; + }), 238, (_21024: [rs.u8, rs.u8]): rs.u8 => { + return _21024[0] ^ _21024[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_591), n), 238, (_21034: [rs.u8, rs.u8]): rs.u8 => { - return _21034[0] ^ _21034[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_591), n), 238, (_21025: [rs.u8, rs.u8]): rs.u8 => { + return _21025[0] ^ _21025[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_591.next()), 238, (_21035: [rs.u8, rs.u8]): rs.u8 => { - return _21035[0] ^ _21035[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_591.next()), 238, (_21026: [rs.u8, rs.u8]): rs.u8 => { + return _21026[0] ^ _21026[1]; })); } } } else { const _638: rs.usize = rs.usizeRem(data.length, 8); if (_638 === 0) { - rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21026: rs.u8): rs.u8 => { - const x473: rs.u8 = _21026; + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21016: rs.u8): rs.u8 => { + const x463: rs.u8 = _21016; const _6301: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6301.value, x473 ^ 3); + rs.byteVecPush(_6301.value, x463 ^ 3); rs.refMutRelease(_6301); - return x473; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21027: rs.u8): rs.u8 => { - const x474: rs.u8 = _21027; + return x463; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21017: rs.u8): rs.u8 => { + const x464: rs.u8 = _21017; const _6302: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6302.value, x474 ^ 4); + rs.byteVecPush(_6302.value, x464 ^ 4); rs.refMutRelease(_6302); - return x474; - }), "len"), (_21028: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_21028[0], 2) === 0; + return x464; + }), "len"), (_21018: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21018[0], 2) === 0; })) & 0xff); } else if (_638 === 1) { - rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21023: rs.u8): rs.u8 => { - const x470: rs.u8 = _21023; + rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21013: rs.u8): rs.u8 => { + const x460: rs.u8 = _21013; const _6299: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6299.value, x470 ^ 3); + rs.byteVecPush(_6299.value, x460 ^ 3); rs.refMutRelease(_6299); - return x470; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21024: rs.u8): rs.u8 => { - const x471: rs.u8 = _21024; + return x460; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21014: rs.u8): rs.u8 => { + const x461: rs.u8 = _21014; const _6300: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6300.value, x471 ^ 4); + rs.byteVecPush(_6300.value, x461 ^ 4); rs.refMutRelease(_6300); - return x471; - }), "len"), (_21025: [rs.u8, rs.u8]): rs.u8 | undefined => { - return rs.u8CheckedSub(_21025[0], _21025[1]); + return x461; + }), "len"), (_21015: [rs.u8, rs.u8]): rs.u8 | undefined => { + return rs.u8CheckedSub(_21015[0], _21015[1]); })) & 0xff); } else if (_638 === 2) { - rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21020: rs.u8): rs.u8 => { - const x467: rs.u8 = _21020; + rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21010: rs.u8): rs.u8 => { + const x457: rs.u8 = _21010; const _6297: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6297.value, x467 ^ 3); + rs.byteVecPush(_6297.value, x457 ^ 3); rs.refMutRelease(_6297); - return x467; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21021: rs.u8): rs.u8 => { - const x468: rs.u8 = _21021; + return x457; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21011: rs.u8): rs.u8 => { + const x458: rs.u8 = _21011; const _6298: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6298.value, x468 ^ 4); + rs.byteVecPush(_6298.value, x458 ^ 4); rs.refMutRelease(_6298); - return x468; - }), "len"), (_21022: [rs.u8, rs.u8]): boolean => { - return _21022[0] < 128; + return x458; + }), "len"), (_21012: [rs.u8, rs.u8]): boolean => { + return _21012[0] < 128; })) & 0xff); } else if (_638 === 3) { - rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21017: rs.u8): rs.u8 => { - const x465: rs.u8 = _21017; + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21007: rs.u8): rs.u8 => { + const x455: rs.u8 = _21007; const _6295: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6295.value, x465 ^ 3); + rs.byteVecPush(_6295.value, x455 ^ 3); rs.refMutRelease(_6295); - return x465; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21018: rs.u8): rs.u8 => { - const x466: rs.u8 = _21018; + return x455; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21008: rs.u8): rs.u8 => { + const x456: rs.u8 = _21008; const _6296: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6296.value, x466 ^ 4); + rs.byteVecPush(_6296.value, x456 ^ 4); rs.refMutRelease(_6296); - return x466; - }), "len")), (_21019: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { - return _21019[0] & 0xff; + return x456; + }), "len")), (_21009: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { + return _21009[0] & 0xff; })), 238)); } else if (_638 === 4) { - rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21015: rs.u8): rs.u8 => { - const x463: rs.u8 = _21015; + rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21005: rs.u8): rs.u8 => { + const x453: rs.u8 = _21005; const _6293: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6293.value, x463 ^ 3); + rs.byteVecPush(_6293.value, x453 ^ 3); rs.refMutRelease(_6293); - return x463; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21016: rs.u8): rs.u8 => { - const x464: rs.u8 = _21016; + return x453; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21006: rs.u8): rs.u8 => { + const x454: rs.u8 = _21006; const _6294: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6294.value, x464 ^ 4); + rs.byteVecPush(_6294.value, x454 ^ 4); rs.refMutRelease(_6294); - return x464; + return x454; }), "len"), rs.iterSlice([[1, 2] as [rs.u8, rs.u8]]))) & 0xff); } else if (_638 === 5) { - rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21013: rs.u8): rs.u8 => { - const x461: rs.u8 = _21013; + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21003: rs.u8): rs.u8 => { + const x451: rs.u8 = _21003; const _6291: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6291.value, x461 ^ 3); + rs.byteVecPush(_6291.value, x451 ^ 3); rs.refMutRelease(_6291); - return x461; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21014: rs.u8): rs.u8 => { - const x462: rs.u8 = _21014; + return x451; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21004: rs.u8): rs.u8 => { + const x452: rs.u8 = _21004; const _6292: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6292.value, x462 ^ 4); + rs.byteVecPush(_6292.value, x452 ^ 4); rs.refMutRelease(_6292); - return x462; + return x452; }), "len"), n)) & 0xff); } else if (_638 === 6) { - rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21011: rs.u8): rs.u8 => { - const x459: rs.u8 = _21011; + rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21001: rs.u8): rs.u8 => { + const x449: rs.u8 = _21001; const _6289: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6289.value, x459 ^ 3); + rs.byteVecPush(_6289.value, x449 ^ 3); rs.refMutRelease(_6289); - return x459; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21012: rs.u8): rs.u8 => { - const x460: rs.u8 = _21012; + return x449; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21002: rs.u8): rs.u8 => { + const x450: rs.u8 = _21002; const _6290: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6290.value, x460 ^ 4); + rs.byteVecPush(_6290.value, x450 ^ 4); rs.refMutRelease(_6290); - return x460; + return x450; }), "len"), n)) & 0xff); } else { - const p2: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21009: rs.u8): rs.u8 => { - const x457: rs.u8 = _21009; + const p2: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2999: rs.u8): rs.u8 => { + const x447: rs.u8 = _2999; const _6287: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6287.value, x457 ^ 3); + rs.byteVecPush(_6287.value, x447 ^ 3); rs.refMutRelease(_6287); - return x457; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21010: rs.u8): rs.u8 => { - const x458: rs.u8 = _21010; + return x447; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21000: rs.u8): rs.u8 => { + const x448: rs.u8 = _21000; const _6288: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6288.value, x458 ^ 4); + rs.byteVecPush(_6288.value, x448 ^ 4); rs.refMutRelease(_6288); - return x458; + return x448; }), "len")); rs.byteVecPush(out, (rs.peekablePeek(p2) !== undefined ? 1 : 0) ^ (rs.iterCount(p2) & 0xff)); } @@ -2953,87 +2875,93 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else if ((kind & 16) === 0) { const _765: rs.usize = rs.usizeRem(rs.usizeDiv(data.length, 8), 5); if (_765 === 0) { - const z13: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2998: rs.u8): rs.u8 => { - const x445: rs.u8 = _2998; + const z13: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2987: rs.u8): rs.u8 => { + const x434: rs.u8 = _2987; const _6283: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6283.value, x445 ^ 5); + rs.byteVecPush(_6283.value, x434 ^ 5); rs.refMutRelease(_6283); - return x445; - }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2999: rs.u8): rs.u8 => { - const x446: rs.u8 = _2999; + return x434; + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2988: rs.u8): rs.u8 => { + const x435: rs.u8 = _2988; const _6284: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6284.value, x446 ^ 6); + rs.byteVecPush(_6284.value, x435 ^ 6); rs.refMutRelease(_6284); - return x446; + return x435; }), "len"); + const _783: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2989: [rs.u8, rs.u8]): rs.u8 => { + return _2989[0] ^ _2989[1]; + }; const _784: rs.usize = rs.usizeRem(data.length, 8); if (_784 === 0) { rs.byteVecPush(out, rs.iterCount(z13) & 0xff); } else if (_784 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(z13), 238, (_21008: [rs.u8, rs.u8]): rs.u8 => { - return _21008[0] ^ _21008[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(z13), 238, (_2998: [rs.u8, rs.u8]): rs.u8 => { + return _2998[0] ^ _2998[1]; })); } else if (_784 === 2) { rs.iterForEach(z13, (p57: [rs.u8, rs.u8]): undefined => { rs.byteVecPush(out, _783(p57)); }); } else if (_784 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(z13, (_21007: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_21007[0] as rs.u32, _21007[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(z13, (_2997: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2997[0] as rs.u32, _2997[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_784 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(z13, (_21006: [rs.u8, rs.u8]): rs.u8 => { - return _21006[0] ^ _21006[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(z13, (_2996: [rs.u8, rs.u8]): rs.u8 => { + return _2996[0] ^ _2996[1]; }), undefined, true)), undefined, true); } else if (_784 === 5) { rs.byteVecPush(out, rs.iterFold(z13, 0, (acc25: rs.u8, p56: [rs.u8, rs.u8]): rs.u8 => { return rs.u8WrappingMul(acc25, 3) ^ _783(p56); })); } else if (_784 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(z13, (_21005: [rs.u8, rs.u8]): rs.u8 => { - return _21005[0] ^ _21005[1]; - }), (x453: rs.u8): boolean => { - return x453 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(z13, (_2995: [rs.u8, rs.u8]): rs.u8 => { + return _2995[0] ^ _2995[1]; + }), (x443: rs.u8): boolean => { + return x443 === 0; }) ? 1 : 0); } else { const z14: rs.Iter<[rs.u8, rs.u8]> = z13; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(z14, (_21000: [rs.u8, rs.u8]): boolean => { - return _21000[0] > _21000[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(z14, (_2990: [rs.u8, rs.u8]): boolean => { + return _2990[0] > _2990[1]; }), 238, (i30: rs.usize): rs.u8 => { return i30 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(z14, (_21001: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_21001[0], 3) === 0; - }), 238, (_21002: [rs.u8, rs.u8]): rs.u8 => { - return _21002[0] ^ _21002[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(z14, (_2991: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2991[0], 3) === 0; + }), 238, (_2992: [rs.u8, rs.u8]): rs.u8 => { + return _2992[0] ^ _2992[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z14, n), 238, (_21003: [rs.u8, rs.u8]): rs.u8 => { - return _21003[0] ^ _21003[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z14, n), 238, (_2993: [rs.u8, rs.u8]): rs.u8 => { + return _2993[0] ^ _2993[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z14.next()), 238, (_21004: [rs.u8, rs.u8]): rs.u8 => { - return _21004[0] ^ _21004[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z14.next()), 238, (_2994: [rs.u8, rs.u8]): rs.u8 => { + return _2994[0] ^ _2994[1]; })); } } else if (_765 === 1) { - const z15: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2987: rs.u8): rs.u8 => { - const x433: rs.u8 = _2987; + const z15: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2975: rs.u8): rs.u8 => { + const x421: rs.u8 = _2975; const _6279: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6279.value, x433 ^ 5); + rs.byteVecPush(_6279.value, x421 ^ 5); rs.refMutRelease(_6279); - return x433; - }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2988: rs.u8): rs.u8 => { - const x434: rs.u8 = _2988; + return x421; + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2976: rs.u8): rs.u8 => { + const x422: rs.u8 = _2976; const _6280: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6280.value, x434 ^ 6); + rs.byteVecPush(_6280.value, x422 ^ 6); rs.refMutRelease(_6280); - return x434; + return x422; }), "len"); + const _836: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2977: [rs.u8, rs.u8]): rs.u8 => { + return _2977[0] ^ _2977[1]; + }; const _837: rs.usize = rs.usizeRem(data.length, 8); if (_837 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBox(z15)) & 0xff); } else if (_837 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z15)), 238, (_2997: [rs.u8, rs.u8]): rs.u8 => { - return _2997[0] ^ _2997[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z15)), 238, (_2986: [rs.u8, rs.u8]): rs.u8 => { + return _2986[0] ^ _2986[1]; })); } else if (_837 === 2) { const _844: (a0: [rs.u8, rs.u8]) => undefined = (p55: [rs.u8, rs.u8]): undefined => { @@ -3041,12 +2969,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBox(z15), _844); } else if (_837 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z15), (_2996: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2996[0] as rs.u32, _2996[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z15), (_2985: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2985[0] as rs.u32, _2985[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_837 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z15), (_2995: [rs.u8, rs.u8]): rs.u8 => { - return _2995[0] ^ _2995[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z15), (_2984: [rs.u8, rs.u8]): rs.u8 => { + return _2984[0] ^ _2984[1]; }), "next")), undefined, true); } else if (_837 === 5) { const _852: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc24: rs.u8, p54: [rs.u8, rs.u8]): rs.u8 => { @@ -3054,50 +2982,53 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBox(z15), 0, _852)); } else if (_837 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z15), (_2994: [rs.u8, rs.u8]): rs.u8 => { - return _2994[0] ^ _2994[1]; - }), (x441: rs.u8): boolean => { - return x441 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z15), (_2983: [rs.u8, rs.u8]): rs.u8 => { + return _2983[0] ^ _2983[1]; + }), (x430: rs.u8): boolean => { + return x430 === 0; }) ? 1 : 0); } else { const z16: rs.Iter<[rs.u8, rs.u8]> = z15; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z16), (_2989: [rs.u8, rs.u8]): boolean => { - return _2989[0] > _2989[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z16), (_2978: [rs.u8, rs.u8]): boolean => { + return _2978[0] > _2978[1]; }), 238, (i29: rs.usize): rs.u8 => { return i29 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z16), (_2990: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2990[0], 3) === 0; - }), 238, (_2991: [rs.u8, rs.u8]): rs.u8 => { - return _2991[0] ^ _2991[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z16), (_2979: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2979[0], 3) === 0; + }), 238, (_2980: [rs.u8, rs.u8]): rs.u8 => { + return _2980[0] ^ _2980[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z16), n), 238, (_2992: [rs.u8, rs.u8]): rs.u8 => { - return _2992[0] ^ _2992[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z16), n), 238, (_2981: [rs.u8, rs.u8]): rs.u8 => { + return _2981[0] ^ _2981[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z16.next()), 238, (_2993: [rs.u8, rs.u8]): rs.u8 => { - return _2993[0] ^ _2993[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z16.next()), 238, (_2982: [rs.u8, rs.u8]): rs.u8 => { + return _2982[0] ^ _2982[1]; })); } } else if (_765 === 2) { - const z17: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2976: rs.u8): rs.u8 => { - const x421: rs.u8 = _2976; + const z17: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2963: rs.u8): rs.u8 => { + const x408: rs.u8 = _2963; const _6275: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6275.value, x421 ^ 5); + rs.byteVecPush(_6275.value, x408 ^ 5); rs.refMutRelease(_6275); - return x421; - }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2977: rs.u8): rs.u8 => { - const x422: rs.u8 = _2977; + return x408; + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2964: rs.u8): rs.u8 => { + const x409: rs.u8 = _2964; const _6276: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6276.value, x422 ^ 6); + rs.byteVecPush(_6276.value, x409 ^ 6); rs.refMutRelease(_6276); - return x422; + return x409; }), "len"), n); + const _890: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2965: [rs.u8, rs.u8]): rs.u8 => { + return _2965[0] ^ _2965[1]; + }; const _891: rs.usize = rs.usizeRem(data.length, 8); if (_891 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBox(z17)) & 0xff); } else if (_891 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z17)), 238, (_2986: [rs.u8, rs.u8]): rs.u8 => { - return _2986[0] ^ _2986[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z17)), 238, (_2974: [rs.u8, rs.u8]): rs.u8 => { + return _2974[0] ^ _2974[1]; })); } else if (_891 === 2) { const _898: (a0: [rs.u8, rs.u8]) => undefined = (p53: [rs.u8, rs.u8]): undefined => { @@ -3105,12 +3036,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBox(z17), _898); } else if (_891 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z17), (_2985: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2985[0] as rs.u32, _2985[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z17), (_2973: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2973[0] as rs.u32, _2973[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_891 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z17), (_2984: [rs.u8, rs.u8]): rs.u8 => { - return _2984[0] ^ _2984[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z17), (_2972: [rs.u8, rs.u8]): rs.u8 => { + return _2972[0] ^ _2972[1]; }), "next")), undefined, true); } else if (_891 === 5) { const _906: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc23: rs.u8, p52: [rs.u8, rs.u8]): rs.u8 => { @@ -3118,50 +3049,53 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBox(z17), 0, _906)); } else if (_891 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z17), (_2983: [rs.u8, rs.u8]): rs.u8 => { - return _2983[0] ^ _2983[1]; - }), (x429: rs.u8): boolean => { - return x429 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z17), (_2971: [rs.u8, rs.u8]): rs.u8 => { + return _2971[0] ^ _2971[1]; + }), (x417: rs.u8): boolean => { + return x417 === 0; }) ? 1 : 0); } else { const z18: rs.Iter<[rs.u8, rs.u8]> = z17; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z18), (_2978: [rs.u8, rs.u8]): boolean => { - return _2978[0] > _2978[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z18), (_2966: [rs.u8, rs.u8]): boolean => { + return _2966[0] > _2966[1]; }), 238, (i28: rs.usize): rs.u8 => { return i28 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z18), (_2979: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2979[0], 3) === 0; - }), 238, (_2980: [rs.u8, rs.u8]): rs.u8 => { - return _2980[0] ^ _2980[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z18), (_2967: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2967[0], 3) === 0; + }), 238, (_2968: [rs.u8, rs.u8]): rs.u8 => { + return _2968[0] ^ _2968[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z18), n), 238, (_2981: [rs.u8, rs.u8]): rs.u8 => { - return _2981[0] ^ _2981[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z18), n), 238, (_2969: [rs.u8, rs.u8]): rs.u8 => { + return _2969[0] ^ _2969[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z18.next()), 238, (_2982: [rs.u8, rs.u8]): rs.u8 => { - return _2982[0] ^ _2982[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z18.next()), 238, (_2970: [rs.u8, rs.u8]): rs.u8 => { + return _2970[0] ^ _2970[1]; })); } } else if (_765 === 3) { - const _930: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2965: rs.u8): rs.u8 => { - const x409: rs.u8 = _2965; + const _930: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2951: rs.u8): rs.u8 => { + const x395: rs.u8 = _2951; const _6271: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6271.value, x409 ^ 5); + rs.byteVecPush(_6271.value, x395 ^ 5); rs.refMutRelease(_6271); - return x409; - }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2966: rs.u8): rs.u8 => { - const x410: rs.u8 = _2966; + return x395; + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2952: rs.u8): rs.u8 => { + const x396: rs.u8 = _2952; const _6272: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6272.value, x410 ^ 6); + rs.byteVecPush(_6272.value, x396 ^ 6); rs.refMutRelease(_6272); - return x410; + return x396; }), "len"); + const _944: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2953: [rs.u8, rs.u8]): rs.u8 => { + return _2953[0] ^ _2953[1]; + }; const _945: rs.usize = rs.usizeRem(data.length, 8); if (_945 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_930)))) & 0xff); } else if (_945 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_930)))), 238, (_2975: [rs.u8, rs.u8]): rs.u8 => { - return _2975[0] ^ _2975[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_930)))), 238, (_2962: [rs.u8, rs.u8]): rs.u8 => { + return _2962[0] ^ _2962[1]; })); } else if (_945 === 2) { const _952: (a0: [rs.u8, rs.u8]) => undefined = (p51: [rs.u8, rs.u8]): undefined => { @@ -3169,12 +3103,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_930))), _952); } else if (_945 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_930))), (_2974: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2974[0] as rs.u32, _2974[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_930))), (_2961: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2961[0] as rs.u32, _2961[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_945 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_930))), (_2973: [rs.u8, rs.u8]): rs.u8 => { - return _2973[0] ^ _2973[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_930))), (_2960: [rs.u8, rs.u8]): rs.u8 => { + return _2960[0] ^ _2960[1]; }), "next")), undefined, true); } else if (_945 === 5) { const _960: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc22: rs.u8, p50: [rs.u8, rs.u8]): rs.u8 => { @@ -3182,49 +3116,52 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_930))), 0, _960)); } else if (_945 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_930))), (_2972: [rs.u8, rs.u8]): rs.u8 => { - return _2972[0] ^ _2972[1]; - }), (x417: rs.u8): boolean => { - return x417 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_930))), (_2959: [rs.u8, rs.u8]): rs.u8 => { + return _2959[0] ^ _2959[1]; + }), (x404: rs.u8): boolean => { + return x404 === 0; }) ? 1 : 0); } else { - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_930), (_2967: [rs.u8, rs.u8]): boolean => { - return _2967[0] > _2967[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_930), (_2954: [rs.u8, rs.u8]): boolean => { + return _2954[0] > _2954[1]; }), 238, (i27: rs.usize): rs.u8 => { return i27 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_930), (_2968: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2968[0], 3) === 0; - }), 238, (_2969: [rs.u8, rs.u8]): rs.u8 => { - return _2969[0] ^ _2969[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_930), (_2955: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2955[0], 3) === 0; + }), 238, (_2956: [rs.u8, rs.u8]): rs.u8 => { + return _2956[0] ^ _2956[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_930), n), 238, (_2970: [rs.u8, rs.u8]): rs.u8 => { - return _2970[0] ^ _2970[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_930), n), 238, (_2957: [rs.u8, rs.u8]): rs.u8 => { + return _2957[0] ^ _2957[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_930.next()), 238, (_2971: [rs.u8, rs.u8]): rs.u8 => { - return _2971[0] ^ _2971[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_930.next()), 238, (_2958: [rs.u8, rs.u8]): rs.u8 => { + return _2958[0] ^ _2958[1]; })); } } else { - const _979: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2954: rs.u8): rs.u8 => { - const x397: rs.u8 = _2954; + const _979: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2939: rs.u8): rs.u8 => { + const x382: rs.u8 = _2939; const _6267: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6267.value, x397 ^ 5); + rs.byteVecPush(_6267.value, x382 ^ 5); rs.refMutRelease(_6267); - return x397; - }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2955: rs.u8): rs.u8 => { - const x398: rs.u8 = _2955; + return x382; + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2940: rs.u8): rs.u8 => { + const x383: rs.u8 = _2940; const _6268: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6268.value, x398 ^ 6); + rs.byteVecPush(_6268.value, x383 ^ 6); rs.refMutRelease(_6268); - return x398; + return x383; }), "len"), n); + const _994: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2941: [rs.u8, rs.u8]): rs.u8 => { + return _2941[0] ^ _2941[1]; + }; const _995: rs.usize = rs.usizeRem(data.length, 8); if (_995 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_979)))) & 0xff); } else if (_995 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_979)))), 238, (_2964: [rs.u8, rs.u8]): rs.u8 => { - return _2964[0] ^ _2964[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_979)))), 238, (_2950: [rs.u8, rs.u8]): rs.u8 => { + return _2950[0] ^ _2950[1]; })); } else if (_995 === 2) { const _1002: (a0: [rs.u8, rs.u8]) => undefined = (p49: [rs.u8, rs.u8]): undefined => { @@ -3232,12 +3169,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_979))), _1002); } else if (_995 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_979))), (_2963: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2963[0] as rs.u32, _2963[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_979))), (_2949: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2949[0] as rs.u32, _2949[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_995 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_979))), (_2962: [rs.u8, rs.u8]): rs.u8 => { - return _2962[0] ^ _2962[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_979))), (_2948: [rs.u8, rs.u8]): rs.u8 => { + return _2948[0] ^ _2948[1]; }), "next")), undefined, true); } else if (_995 === 5) { const _1010: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc21: rs.u8, p48: [rs.u8, rs.u8]): rs.u8 => { @@ -3245,151 +3182,151 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_979))), 0, _1010)); } else if (_995 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_979))), (_2961: [rs.u8, rs.u8]): rs.u8 => { - return _2961[0] ^ _2961[1]; - }), (x405: rs.u8): boolean => { - return x405 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_979))), (_2947: [rs.u8, rs.u8]): rs.u8 => { + return _2947[0] ^ _2947[1]; + }), (x391: rs.u8): boolean => { + return x391 === 0; }) ? 1 : 0); } else { - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_979), (_2956: [rs.u8, rs.u8]): boolean => { - return _2956[0] > _2956[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_979), (_2942: [rs.u8, rs.u8]): boolean => { + return _2942[0] > _2942[1]; }), 238, (i26: rs.usize): rs.u8 => { return i26 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_979), (_2957: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2957[0], 3) === 0; - }), 238, (_2958: [rs.u8, rs.u8]): rs.u8 => { - return _2958[0] ^ _2958[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_979), (_2943: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2943[0], 3) === 0; + }), 238, (_2944: [rs.u8, rs.u8]): rs.u8 => { + return _2944[0] ^ _2944[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_979), n), 238, (_2959: [rs.u8, rs.u8]): rs.u8 => { - return _2959[0] ^ _2959[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_979), n), 238, (_2945: [rs.u8, rs.u8]): rs.u8 => { + return _2945[0] ^ _2945[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_979.next()), 238, (_2960: [rs.u8, rs.u8]): rs.u8 => { - return _2960[0] ^ _2960[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_979.next()), 238, (_2946: [rs.u8, rs.u8]): rs.u8 => { + return _2946[0] ^ _2946[1]; })); } } } else { const _1028: rs.usize = rs.usizeRem(data.length, 8); if (_1028 === 0) { - rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2951: rs.u8): rs.u8 => { - const x394: rs.u8 = _2951; + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2936: rs.u8): rs.u8 => { + const x379: rs.u8 = _2936; const _6265: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6265.value, x394 ^ 5); + rs.byteVecPush(_6265.value, x379 ^ 5); rs.refMutRelease(_6265); - return x394; - }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2952: rs.u8): rs.u8 => { - const x395: rs.u8 = _2952; + return x379; + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2937: rs.u8): rs.u8 => { + const x380: rs.u8 = _2937; const _6266: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6266.value, x395 ^ 6); + rs.byteVecPush(_6266.value, x380 ^ 6); rs.refMutRelease(_6266); - return x395; - }), "len"), (_2953: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2953[0], 2) === 0; + return x380; + }), "len"), (_2938: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2938[0], 2) === 0; })) & 0xff); } else if (_1028 === 1) { - rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2948: rs.u8): rs.u8 => { - const x391: rs.u8 = _2948; + rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2933: rs.u8): rs.u8 => { + const x376: rs.u8 = _2933; const _6263: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6263.value, x391 ^ 5); + rs.byteVecPush(_6263.value, x376 ^ 5); rs.refMutRelease(_6263); - return x391; - }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2949: rs.u8): rs.u8 => { - const x392: rs.u8 = _2949; + return x376; + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2934: rs.u8): rs.u8 => { + const x377: rs.u8 = _2934; const _6264: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6264.value, x392 ^ 6); + rs.byteVecPush(_6264.value, x377 ^ 6); rs.refMutRelease(_6264); - return x392; - }), "len"), (_2950: [rs.u8, rs.u8]): rs.u8 | undefined => { - return rs.u8CheckedSub(_2950[0], _2950[1]); + return x377; + }), "len"), (_2935: [rs.u8, rs.u8]): rs.u8 | undefined => { + return rs.u8CheckedSub(_2935[0], _2935[1]); })) & 0xff); } else if (_1028 === 2) { - rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2945: rs.u8): rs.u8 => { - const x388: rs.u8 = _2945; + rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2930: rs.u8): rs.u8 => { + const x373: rs.u8 = _2930; const _6261: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6261.value, x388 ^ 5); + rs.byteVecPush(_6261.value, x373 ^ 5); rs.refMutRelease(_6261); - return x388; - }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2946: rs.u8): rs.u8 => { - const x389: rs.u8 = _2946; + return x373; + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2931: rs.u8): rs.u8 => { + const x374: rs.u8 = _2931; const _6262: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6262.value, x389 ^ 6); + rs.byteVecPush(_6262.value, x374 ^ 6); rs.refMutRelease(_6262); - return x389; - }), "len"), (_2947: [rs.u8, rs.u8]): boolean => { - return _2947[0] < 128; + return x374; + }), "len"), (_2932: [rs.u8, rs.u8]): boolean => { + return _2932[0] < 128; })) & 0xff); } else if (_1028 === 3) { - rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2942: rs.u8): rs.u8 => { - const x386: rs.u8 = _2942; + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2927: rs.u8): rs.u8 => { + const x371: rs.u8 = _2927; const _6259: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6259.value, x386 ^ 5); + rs.byteVecPush(_6259.value, x371 ^ 5); rs.refMutRelease(_6259); - return x386; - }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2943: rs.u8): rs.u8 => { - const x387: rs.u8 = _2943; + return x371; + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2928: rs.u8): rs.u8 => { + const x372: rs.u8 = _2928; const _6260: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6260.value, x387 ^ 6); + rs.byteVecPush(_6260.value, x372 ^ 6); rs.refMutRelease(_6260); - return x387; - }), "len")), (_2944: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { - return _2944[0] & 0xff; + return x372; + }), "len")), (_2929: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { + return _2929[0] & 0xff; })), 238)); } else if (_1028 === 4) { - rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2940: rs.u8): rs.u8 => { - const x384: rs.u8 = _2940; + rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2925: rs.u8): rs.u8 => { + const x369: rs.u8 = _2925; const _6257: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6257.value, x384 ^ 5); + rs.byteVecPush(_6257.value, x369 ^ 5); rs.refMutRelease(_6257); - return x384; - }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2941: rs.u8): rs.u8 => { - const x385: rs.u8 = _2941; + return x369; + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2926: rs.u8): rs.u8 => { + const x370: rs.u8 = _2926; const _6258: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6258.value, x385 ^ 6); + rs.byteVecPush(_6258.value, x370 ^ 6); rs.refMutRelease(_6258); - return x385; + return x370; }), "len"), rs.iterSlice([[1, 2] as [rs.u8, rs.u8]]))) & 0xff); } else if (_1028 === 5) { - rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2938: rs.u8): rs.u8 => { - const x382: rs.u8 = _2938; + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2923: rs.u8): rs.u8 => { + const x367: rs.u8 = _2923; const _6255: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6255.value, x382 ^ 5); + rs.byteVecPush(_6255.value, x367 ^ 5); rs.refMutRelease(_6255); - return x382; - }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2939: rs.u8): rs.u8 => { - const x383: rs.u8 = _2939; + return x367; + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2924: rs.u8): rs.u8 => { + const x368: rs.u8 = _2924; const _6256: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6256.value, x383 ^ 6); + rs.byteVecPush(_6256.value, x368 ^ 6); rs.refMutRelease(_6256); - return x383; + return x368; }), "len"), n)) & 0xff); } else if (_1028 === 6) { - rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2936: rs.u8): rs.u8 => { - const x380: rs.u8 = _2936; + rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2921: rs.u8): rs.u8 => { + const x365: rs.u8 = _2921; const _6253: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6253.value, x380 ^ 5); + rs.byteVecPush(_6253.value, x365 ^ 5); rs.refMutRelease(_6253); - return x380; - }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2937: rs.u8): rs.u8 => { - const x381: rs.u8 = _2937; + return x365; + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2922: rs.u8): rs.u8 => { + const x366: rs.u8 = _2922; const _6254: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6254.value, x381 ^ 6); + rs.byteVecPush(_6254.value, x366 ^ 6); rs.refMutRelease(_6254); - return x381; + return x366; }), "len"), n)) & 0xff); } else { - const p3: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2934: rs.u8): rs.u8 => { - const x378: rs.u8 = _2934; + const p3: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2919: rs.u8): rs.u8 => { + const x363: rs.u8 = _2919; const _6251: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6251.value, x378 ^ 5); + rs.byteVecPush(_6251.value, x363 ^ 5); rs.refMutRelease(_6251); - return x378; - }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2935: rs.u8): rs.u8 => { - const x379: rs.u8 = _2935; + return x363; + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2920: rs.u8): rs.u8 => { + const x364: rs.u8 = _2920; const _6252: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6252.value, x379 ^ 6); + rs.byteVecPush(_6252.value, x364 ^ 6); rs.refMutRelease(_6252); - return x379; + return x364; }), "len")); rs.byteVecPush(out, (rs.peekablePeek(p3) !== undefined ? 1 : 0) ^ (rs.iterCount(p3) & 0xff)); } @@ -3399,83 +3336,89 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if ((kind & 16) === 0) { const _1171: rs.usize = rs.usizeRem(rs.usizeDiv(data.length, 8), 5); if (_1171 === 0) { - const z19: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x366: rs.u8): rs.u8 => { + const z19: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x350: rs.u8): rs.u8 => { const _6247: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6247.value, x366 ^ 7); + rs.byteVecPush(_6247.value, x350 ^ 7); rs.refMutRelease(_6247); - return x366; - }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x367: rs.u8): rs.u8 => { + return x350; + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x351: rs.u8): rs.u8 => { const _6248: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6248.value, x367 ^ 8); + rs.byteVecPush(_6248.value, x351 ^ 8); rs.refMutRelease(_6248); - return x367; + return x351; }), "index"); + const _1187: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2909: [rs.u8, rs.u8]): rs.u8 => { + return _2909[0] ^ _2909[1]; + }; const _1188: rs.usize = rs.usizeRem(data.length, 8); if (_1188 === 0) { rs.byteVecPush(out, rs.iterCount(z19) & 0xff); } else if (_1188 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(z19), 238, (_2933: [rs.u8, rs.u8]): rs.u8 => { - return _2933[0] ^ _2933[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(z19), 238, (_2918: [rs.u8, rs.u8]): rs.u8 => { + return _2918[0] ^ _2918[1]; })); } else if (_1188 === 2) { rs.iterForEach(z19, (p47: [rs.u8, rs.u8]): undefined => { rs.byteVecPush(out, _1187(p47)); }); } else if (_1188 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(z19, (_2932: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2932[0] as rs.u32, _2932[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(z19, (_2917: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2917[0] as rs.u32, _2917[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1188 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(z19, (_2931: [rs.u8, rs.u8]): rs.u8 => { - return _2931[0] ^ _2931[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(z19, (_2916: [rs.u8, rs.u8]): rs.u8 => { + return _2916[0] ^ _2916[1]; }), "index", true, 1)), undefined, true); } else if (_1188 === 5) { rs.byteVecPush(out, rs.iterFold(z19, 0, (acc20: rs.u8, p46: [rs.u8, rs.u8]): rs.u8 => { return rs.u8WrappingMul(acc20, 3) ^ _1187(p46); })); } else if (_1188 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(z19, (_2930: [rs.u8, rs.u8]): rs.u8 => { - return _2930[0] ^ _2930[1]; - }), (x374: rs.u8): boolean => { - return x374 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(z19, (_2915: [rs.u8, rs.u8]): rs.u8 => { + return _2915[0] ^ _2915[1]; + }), (x359: rs.u8): boolean => { + return x359 === 0; }) ? 1 : 0); } else { const z20: rs.Iter<[rs.u8, rs.u8]> = z19; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(z20, (_2925: [rs.u8, rs.u8]): boolean => { - return _2925[0] > _2925[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(z20, (_2910: [rs.u8, rs.u8]): boolean => { + return _2910[0] > _2910[1]; }), 238, (i24: rs.usize): rs.u8 => { return i24 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(z20, (_2926: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2926[0], 3) === 0; - }), 238, (_2927: [rs.u8, rs.u8]): rs.u8 => { - return _2927[0] ^ _2927[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(z20, (_2911: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2911[0], 3) === 0; + }), 238, (_2912: [rs.u8, rs.u8]): rs.u8 => { + return _2912[0] ^ _2912[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z20, n), 238, (_2928: [rs.u8, rs.u8]): rs.u8 => { - return _2928[0] ^ _2928[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z20, n), 238, (_2913: [rs.u8, rs.u8]): rs.u8 => { + return _2913[0] ^ _2913[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z20.next()), 238, (_2929: [rs.u8, rs.u8]): rs.u8 => { - return _2929[0] ^ _2929[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z20.next()), 238, (_2914: [rs.u8, rs.u8]): rs.u8 => { + return _2914[0] ^ _2914[1]; })); } } else if (_1171 === 1) { - const z21: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x354: rs.u8): rs.u8 => { + const z21: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x337: rs.u8): rs.u8 => { const _6243: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6243.value, x354 ^ 7); + rs.byteVecPush(_6243.value, x337 ^ 7); rs.refMutRelease(_6243); - return x354; - }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x355: rs.u8): rs.u8 => { + return x337; + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x338: rs.u8): rs.u8 => { const _6244: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6244.value, x355 ^ 8); + rs.byteVecPush(_6244.value, x338 ^ 8); rs.refMutRelease(_6244); - return x355; + return x338; }), "index"); + const _1238: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2899: [rs.u8, rs.u8]): rs.u8 => { + return _2899[0] ^ _2899[1]; + }; const _1239: rs.usize = rs.usizeRem(data.length, 8); if (_1239 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBox(z21)) & 0xff); } else if (_1239 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z21)), 238, (_2924: [rs.u8, rs.u8]): rs.u8 => { - return _2924[0] ^ _2924[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z21)), 238, (_2908: [rs.u8, rs.u8]): rs.u8 => { + return _2908[0] ^ _2908[1]; })); } else if (_1239 === 2) { const _1246: (a0: [rs.u8, rs.u8]) => undefined = (p45: [rs.u8, rs.u8]): undefined => { @@ -3483,12 +3426,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBox(z21), _1246); } else if (_1239 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z21), (_2923: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2923[0] as rs.u32, _2923[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z21), (_2907: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2907[0] as rs.u32, _2907[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1239 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z21), (_2922: [rs.u8, rs.u8]): rs.u8 => { - return _2922[0] ^ _2922[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z21), (_2906: [rs.u8, rs.u8]): rs.u8 => { + return _2906[0] ^ _2906[1]; }), "next")), undefined, true); } else if (_1239 === 5) { const _1254: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc19: rs.u8, p44: [rs.u8, rs.u8]): rs.u8 => { @@ -3496,48 +3439,51 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBox(z21), 0, _1254)); } else if (_1239 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z21), (_2921: [rs.u8, rs.u8]): rs.u8 => { - return _2921[0] ^ _2921[1]; - }), (x362: rs.u8): boolean => { - return x362 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z21), (_2905: [rs.u8, rs.u8]): rs.u8 => { + return _2905[0] ^ _2905[1]; + }), (x346: rs.u8): boolean => { + return x346 === 0; }) ? 1 : 0); } else { const z22: rs.Iter<[rs.u8, rs.u8]> = z21; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z22), (_2916: [rs.u8, rs.u8]): boolean => { - return _2916[0] > _2916[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z22), (_2900: [rs.u8, rs.u8]): boolean => { + return _2900[0] > _2900[1]; }), 238, (i23: rs.usize): rs.u8 => { return i23 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z22), (_2917: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2917[0], 3) === 0; - }), 238, (_2918: [rs.u8, rs.u8]): rs.u8 => { - return _2918[0] ^ _2918[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z22), (_2901: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2901[0], 3) === 0; + }), 238, (_2902: [rs.u8, rs.u8]): rs.u8 => { + return _2902[0] ^ _2902[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z22), n), 238, (_2919: [rs.u8, rs.u8]): rs.u8 => { - return _2919[0] ^ _2919[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z22), n), 238, (_2903: [rs.u8, rs.u8]): rs.u8 => { + return _2903[0] ^ _2903[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z22.next()), 238, (_2920: [rs.u8, rs.u8]): rs.u8 => { - return _2920[0] ^ _2920[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z22.next()), 238, (_2904: [rs.u8, rs.u8]): rs.u8 => { + return _2904[0] ^ _2904[1]; })); } } else if (_1171 === 2) { - const z23: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x342: rs.u8): rs.u8 => { + const z23: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x324: rs.u8): rs.u8 => { const _6239: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6239.value, x342 ^ 7); + rs.byteVecPush(_6239.value, x324 ^ 7); rs.refMutRelease(_6239); - return x342; - }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x343: rs.u8): rs.u8 => { + return x324; + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x325: rs.u8): rs.u8 => { const _6240: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6240.value, x343 ^ 8); + rs.byteVecPush(_6240.value, x325 ^ 8); rs.refMutRelease(_6240); - return x343; + return x325; }), "index"), n); + const _1290: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2889: [rs.u8, rs.u8]): rs.u8 => { + return _2889[0] ^ _2889[1]; + }; const _1291: rs.usize = rs.usizeRem(data.length, 8); if (_1291 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBox(z23)) & 0xff); } else if (_1291 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z23)), 238, (_2915: [rs.u8, rs.u8]): rs.u8 => { - return _2915[0] ^ _2915[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z23)), 238, (_2898: [rs.u8, rs.u8]): rs.u8 => { + return _2898[0] ^ _2898[1]; })); } else if (_1291 === 2) { const _1298: (a0: [rs.u8, rs.u8]) => undefined = (p43: [rs.u8, rs.u8]): undefined => { @@ -3545,12 +3491,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBox(z23), _1298); } else if (_1291 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z23), (_2914: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2914[0] as rs.u32, _2914[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z23), (_2897: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2897[0] as rs.u32, _2897[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1291 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z23), (_2913: [rs.u8, rs.u8]): rs.u8 => { - return _2913[0] ^ _2913[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z23), (_2896: [rs.u8, rs.u8]): rs.u8 => { + return _2896[0] ^ _2896[1]; }), "next")), undefined, true); } else if (_1291 === 5) { const _1306: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc18: rs.u8, p42: [rs.u8, rs.u8]): rs.u8 => { @@ -3558,48 +3504,51 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBox(z23), 0, _1306)); } else if (_1291 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z23), (_2912: [rs.u8, rs.u8]): rs.u8 => { - return _2912[0] ^ _2912[1]; - }), (x350: rs.u8): boolean => { - return x350 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z23), (_2895: [rs.u8, rs.u8]): rs.u8 => { + return _2895[0] ^ _2895[1]; + }), (x333: rs.u8): boolean => { + return x333 === 0; }) ? 1 : 0); } else { const z24: rs.Iter<[rs.u8, rs.u8]> = z23; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z24), (_2907: [rs.u8, rs.u8]): boolean => { - return _2907[0] > _2907[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z24), (_2890: [rs.u8, rs.u8]): boolean => { + return _2890[0] > _2890[1]; }), 238, (i22: rs.usize): rs.u8 => { return i22 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z24), (_2908: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2908[0], 3) === 0; - }), 238, (_2909: [rs.u8, rs.u8]): rs.u8 => { - return _2909[0] ^ _2909[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z24), (_2891: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2891[0], 3) === 0; + }), 238, (_2892: [rs.u8, rs.u8]): rs.u8 => { + return _2892[0] ^ _2892[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z24), n), 238, (_2910: [rs.u8, rs.u8]): rs.u8 => { - return _2910[0] ^ _2910[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z24), n), 238, (_2893: [rs.u8, rs.u8]): rs.u8 => { + return _2893[0] ^ _2893[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z24.next()), 238, (_2911: [rs.u8, rs.u8]): rs.u8 => { - return _2911[0] ^ _2911[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z24.next()), 238, (_2894: [rs.u8, rs.u8]): rs.u8 => { + return _2894[0] ^ _2894[1]; })); } } else if (_1171 === 3) { - const _1330: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x330: rs.u8): rs.u8 => { + const _1330: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x311: rs.u8): rs.u8 => { const _6235: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6235.value, x330 ^ 7); + rs.byteVecPush(_6235.value, x311 ^ 7); rs.refMutRelease(_6235); - return x330; - }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x331: rs.u8): rs.u8 => { + return x311; + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x312: rs.u8): rs.u8 => { const _6236: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6236.value, x331 ^ 8); + rs.byteVecPush(_6236.value, x312 ^ 8); rs.refMutRelease(_6236); - return x331; + return x312; }), "index"); + const _1342: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2879: [rs.u8, rs.u8]): rs.u8 => { + return _2879[0] ^ _2879[1]; + }; const _1343: rs.usize = rs.usizeRem(data.length, 8); if (_1343 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1330)))) & 0xff); } else if (_1343 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1330)))), 238, (_2906: [rs.u8, rs.u8]): rs.u8 => { - return _2906[0] ^ _2906[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1330)))), 238, (_2888: [rs.u8, rs.u8]): rs.u8 => { + return _2888[0] ^ _2888[1]; })); } else if (_1343 === 2) { const _1350: (a0: [rs.u8, rs.u8]) => undefined = (p41: [rs.u8, rs.u8]): undefined => { @@ -3607,12 +3556,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1330))), _1350); } else if (_1343 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1330))), (_2905: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2905[0] as rs.u32, _2905[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1330))), (_2887: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2887[0] as rs.u32, _2887[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1343 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1330))), (_2904: [rs.u8, rs.u8]): rs.u8 => { - return _2904[0] ^ _2904[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1330))), (_2886: [rs.u8, rs.u8]): rs.u8 => { + return _2886[0] ^ _2886[1]; }), "next")), undefined, true); } else if (_1343 === 5) { const _1358: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc17: rs.u8, p40: [rs.u8, rs.u8]): rs.u8 => { @@ -3620,47 +3569,50 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1330))), 0, _1358)); } else if (_1343 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1330))), (_2903: [rs.u8, rs.u8]): rs.u8 => { - return _2903[0] ^ _2903[1]; - }), (x338: rs.u8): boolean => { - return x338 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1330))), (_2885: [rs.u8, rs.u8]): rs.u8 => { + return _2885[0] ^ _2885[1]; + }), (x320: rs.u8): boolean => { + return x320 === 0; }) ? 1 : 0); } else { - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_1330), (_2898: [rs.u8, rs.u8]): boolean => { - return _2898[0] > _2898[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_1330), (_2880: [rs.u8, rs.u8]): boolean => { + return _2880[0] > _2880[1]; }), 238, (i21: rs.usize): rs.u8 => { return i21 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_1330), (_2899: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2899[0], 3) === 0; - }), 238, (_2900: [rs.u8, rs.u8]): rs.u8 => { - return _2900[0] ^ _2900[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_1330), (_2881: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2881[0], 3) === 0; + }), 238, (_2882: [rs.u8, rs.u8]): rs.u8 => { + return _2882[0] ^ _2882[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_1330), n), 238, (_2901: [rs.u8, rs.u8]): rs.u8 => { - return _2901[0] ^ _2901[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_1330), n), 238, (_2883: [rs.u8, rs.u8]): rs.u8 => { + return _2883[0] ^ _2883[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_1330.next()), 238, (_2902: [rs.u8, rs.u8]): rs.u8 => { - return _2902[0] ^ _2902[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_1330.next()), 238, (_2884: [rs.u8, rs.u8]): rs.u8 => { + return _2884[0] ^ _2884[1]; })); } } else { - const _1377: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x318: rs.u8): rs.u8 => { + const _1377: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x298: rs.u8): rs.u8 => { const _6231: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6231.value, x318 ^ 7); + rs.byteVecPush(_6231.value, x298 ^ 7); rs.refMutRelease(_6231); - return x318; - }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x319: rs.u8): rs.u8 => { + return x298; + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x299: rs.u8): rs.u8 => { const _6232: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6232.value, x319 ^ 8); + rs.byteVecPush(_6232.value, x299 ^ 8); rs.refMutRelease(_6232); - return x319; + return x299; }), "index"), n); + const _1390: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2869: [rs.u8, rs.u8]): rs.u8 => { + return _2869[0] ^ _2869[1]; + }; const _1391: rs.usize = rs.usizeRem(data.length, 8); if (_1391 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1377)))) & 0xff); } else if (_1391 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1377)))), 238, (_2897: [rs.u8, rs.u8]): rs.u8 => { - return _2897[0] ^ _2897[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1377)))), 238, (_2878: [rs.u8, rs.u8]): rs.u8 => { + return _2878[0] ^ _2878[1]; })); } else if (_1391 === 2) { const _1398: (a0: [rs.u8, rs.u8]) => undefined = (p39: [rs.u8, rs.u8]): undefined => { @@ -3668,12 +3620,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1377))), _1398); } else if (_1391 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1377))), (_2896: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2896[0] as rs.u32, _2896[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1377))), (_2877: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2877[0] as rs.u32, _2877[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1391 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1377))), (_2895: [rs.u8, rs.u8]): rs.u8 => { - return _2895[0] ^ _2895[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1377))), (_2876: [rs.u8, rs.u8]): rs.u8 => { + return _2876[0] ^ _2876[1]; }), "next")), undefined, true); } else if (_1391 === 5) { const _1406: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc16: rs.u8, p38: [rs.u8, rs.u8]): rs.u8 => { @@ -3681,135 +3633,135 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1377))), 0, _1406)); } else if (_1391 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1377))), (_2894: [rs.u8, rs.u8]): rs.u8 => { - return _2894[0] ^ _2894[1]; - }), (x326: rs.u8): boolean => { - return x326 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1377))), (_2875: [rs.u8, rs.u8]): rs.u8 => { + return _2875[0] ^ _2875[1]; + }), (x307: rs.u8): boolean => { + return x307 === 0; }) ? 1 : 0); } else { - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_1377), (_2889: [rs.u8, rs.u8]): boolean => { - return _2889[0] > _2889[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_1377), (_2870: [rs.u8, rs.u8]): boolean => { + return _2870[0] > _2870[1]; }), 238, (i20: rs.usize): rs.u8 => { return i20 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_1377), (_2890: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2890[0], 3) === 0; - }), 238, (_2891: [rs.u8, rs.u8]): rs.u8 => { - return _2891[0] ^ _2891[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_1377), (_2871: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2871[0], 3) === 0; + }), 238, (_2872: [rs.u8, rs.u8]): rs.u8 => { + return _2872[0] ^ _2872[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_1377), n), 238, (_2892: [rs.u8, rs.u8]): rs.u8 => { - return _2892[0] ^ _2892[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_1377), n), 238, (_2873: [rs.u8, rs.u8]): rs.u8 => { + return _2873[0] ^ _2873[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_1377.next()), 238, (_2893: [rs.u8, rs.u8]): rs.u8 => { - return _2893[0] ^ _2893[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_1377.next()), 238, (_2874: [rs.u8, rs.u8]): rs.u8 => { + return _2874[0] ^ _2874[1]; })); } } } else { const _1424: rs.usize = rs.usizeRem(data.length, 8); if (_1424 === 0) { - rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x315: rs.u8): rs.u8 => { + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x295: rs.u8): rs.u8 => { const _6229: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6229.value, x315 ^ 7); + rs.byteVecPush(_6229.value, x295 ^ 7); rs.refMutRelease(_6229); - return x315; - }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x316: rs.u8): rs.u8 => { + return x295; + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x296: rs.u8): rs.u8 => { const _6230: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6230.value, x316 ^ 8); + rs.byteVecPush(_6230.value, x296 ^ 8); rs.refMutRelease(_6230); - return x316; - }), "index"), (_2888: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2888[0], 2) === 0; + return x296; + }), "index"), (_2868: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2868[0], 2) === 0; })) & 0xff); } else if (_1424 === 1) { - rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x312: rs.u8): rs.u8 => { + rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x292: rs.u8): rs.u8 => { const _6227: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6227.value, x312 ^ 7); + rs.byteVecPush(_6227.value, x292 ^ 7); rs.refMutRelease(_6227); - return x312; - }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x313: rs.u8): rs.u8 => { + return x292; + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x293: rs.u8): rs.u8 => { const _6228: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6228.value, x313 ^ 8); + rs.byteVecPush(_6228.value, x293 ^ 8); rs.refMutRelease(_6228); - return x313; - }), "index"), (_2887: [rs.u8, rs.u8]): rs.u8 | undefined => { - return rs.u8CheckedSub(_2887[0], _2887[1]); + return x293; + }), "index"), (_2867: [rs.u8, rs.u8]): rs.u8 | undefined => { + return rs.u8CheckedSub(_2867[0], _2867[1]); })) & 0xff); } else if (_1424 === 2) { - rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x309: rs.u8): rs.u8 => { + rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x289: rs.u8): rs.u8 => { const _6225: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6225.value, x309 ^ 7); + rs.byteVecPush(_6225.value, x289 ^ 7); rs.refMutRelease(_6225); - return x309; - }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x310: rs.u8): rs.u8 => { + return x289; + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x290: rs.u8): rs.u8 => { const _6226: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6226.value, x310 ^ 8); + rs.byteVecPush(_6226.value, x290 ^ 8); rs.refMutRelease(_6226); - return x310; - }), "index"), (_2886: [rs.u8, rs.u8]): boolean => { - return _2886[0] < 128; + return x290; + }), "index"), (_2866: [rs.u8, rs.u8]): boolean => { + return _2866[0] < 128; })) & 0xff); } else if (_1424 === 3) { - rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x307: rs.u8): rs.u8 => { + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x287: rs.u8): rs.u8 => { const _6223: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6223.value, x307 ^ 7); + rs.byteVecPush(_6223.value, x287 ^ 7); rs.refMutRelease(_6223); - return x307; - }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x308: rs.u8): rs.u8 => { + return x287; + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x288: rs.u8): rs.u8 => { const _6224: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6224.value, x308 ^ 8); + rs.byteVecPush(_6224.value, x288 ^ 8); rs.refMutRelease(_6224); - return x308; - }), "index")), (_2885: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { - return _2885[0] & 0xff; + return x288; + }), "index")), (_2865: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { + return _2865[0] & 0xff; })), 238)); } else if (_1424 === 4) { - rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x305: rs.u8): rs.u8 => { + rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x285: rs.u8): rs.u8 => { const _6221: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6221.value, x305 ^ 7); + rs.byteVecPush(_6221.value, x285 ^ 7); rs.refMutRelease(_6221); - return x305; - }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x306: rs.u8): rs.u8 => { + return x285; + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x286: rs.u8): rs.u8 => { const _6222: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6222.value, x306 ^ 8); + rs.byteVecPush(_6222.value, x286 ^ 8); rs.refMutRelease(_6222); - return x306; + return x286; }), "index"), rs.iterSlice([[1, 2] as [rs.u8, rs.u8]]))) & 0xff); } else if (_1424 === 5) { - rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x303: rs.u8): rs.u8 => { + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x283: rs.u8): rs.u8 => { const _6219: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6219.value, x303 ^ 7); + rs.byteVecPush(_6219.value, x283 ^ 7); rs.refMutRelease(_6219); - return x303; - }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x304: rs.u8): rs.u8 => { + return x283; + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x284: rs.u8): rs.u8 => { const _6220: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6220.value, x304 ^ 8); + rs.byteVecPush(_6220.value, x284 ^ 8); rs.refMutRelease(_6220); - return x304; + return x284; }), "index"), n)) & 0xff); } else if (_1424 === 6) { - rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x301: rs.u8): rs.u8 => { + rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x281: rs.u8): rs.u8 => { const _6217: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6217.value, x301 ^ 7); + rs.byteVecPush(_6217.value, x281 ^ 7); rs.refMutRelease(_6217); - return x301; - }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x302: rs.u8): rs.u8 => { + return x281; + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x282: rs.u8): rs.u8 => { const _6218: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6218.value, x302 ^ 8); + rs.byteVecPush(_6218.value, x282 ^ 8); rs.refMutRelease(_6218); - return x302; + return x282; }), "index"), n)) & 0xff); } else { - const p4: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x299: rs.u8): rs.u8 => { + const p4: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x279: rs.u8): rs.u8 => { const _6215: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6215.value, x299 ^ 7); + rs.byteVecPush(_6215.value, x279 ^ 7); rs.refMutRelease(_6215); - return x299; - }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x300: rs.u8): rs.u8 => { + return x279; + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x280: rs.u8): rs.u8 => { const _6216: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6216.value, x300 ^ 8); + rs.byteVecPush(_6216.value, x280 ^ 8); rs.refMutRelease(_6216); - return x300; + return x280; }), "index")); rs.byteVecPush(out, (rs.peekablePeek(p4) !== undefined ? 1 : 0) ^ (rs.iterCount(p4) & 0xff)); } @@ -3817,85 +3769,91 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else if ((kind & 16) === 0) { const _1551: rs.usize = rs.usizeRem(rs.usizeDiv(data.length, 8), 5); if (_1551 === 0) { - const z25: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x287: rs.u8): rs.u8 => { + const z25: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x266: rs.u8): rs.u8 => { const _6211: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6211.value, x287 ^ 9); + rs.byteVecPush(_6211.value, x266 ^ 9); rs.refMutRelease(_6211); - return x287; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2875: rs.u8): rs.u8 => { - const x288: rs.u8 = _2875; + return x266; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2854: rs.u8): rs.u8 => { + const x267: rs.u8 = _2854; const _6212: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6212.value, x288 ^ 10); + rs.byteVecPush(_6212.value, x267 ^ 10); rs.refMutRelease(_6212); - return x288; + return x267; }), "index"); + const _1567: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2855: [rs.u8, rs.u8]): rs.u8 => { + return _2855[0] ^ _2855[1]; + }; const _1568: rs.usize = rs.usizeRem(data.length, 8); if (_1568 === 0) { rs.byteVecPush(out, rs.iterCount(z25) & 0xff); } else if (_1568 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(z25), 238, (_2884: [rs.u8, rs.u8]): rs.u8 => { - return _2884[0] ^ _2884[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(z25), 238, (_2864: [rs.u8, rs.u8]): rs.u8 => { + return _2864[0] ^ _2864[1]; })); } else if (_1568 === 2) { rs.iterForEach(z25, (p37: [rs.u8, rs.u8]): undefined => { rs.byteVecPush(out, _1567(p37)); }); } else if (_1568 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(z25, (_2883: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2883[0] as rs.u32, _2883[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(z25, (_2863: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2863[0] as rs.u32, _2863[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1568 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(z25, (_2882: [rs.u8, rs.u8]): rs.u8 => { - return _2882[0] ^ _2882[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(z25, (_2862: [rs.u8, rs.u8]): rs.u8 => { + return _2862[0] ^ _2862[1]; }), "index", true, 1)), undefined, true); } else if (_1568 === 5) { rs.byteVecPush(out, rs.iterFold(z25, 0, (acc15: rs.u8, p36: [rs.u8, rs.u8]): rs.u8 => { return rs.u8WrappingMul(acc15, 3) ^ _1567(p36); })); } else if (_1568 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(z25, (_2881: [rs.u8, rs.u8]): rs.u8 => { - return _2881[0] ^ _2881[1]; - }), (x295: rs.u8): boolean => { - return x295 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(z25, (_2861: [rs.u8, rs.u8]): rs.u8 => { + return _2861[0] ^ _2861[1]; + }), (x275: rs.u8): boolean => { + return x275 === 0; }) ? 1 : 0); } else { const z26: rs.Iter<[rs.u8, rs.u8]> = z25; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(z26, (_2876: [rs.u8, rs.u8]): boolean => { - return _2876[0] > _2876[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(z26, (_2856: [rs.u8, rs.u8]): boolean => { + return _2856[0] > _2856[1]; }), 238, (i18: rs.usize): rs.u8 => { return i18 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(z26, (_2877: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2877[0], 3) === 0; - }), 238, (_2878: [rs.u8, rs.u8]): rs.u8 => { - return _2878[0] ^ _2878[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(z26, (_2857: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2857[0], 3) === 0; + }), 238, (_2858: [rs.u8, rs.u8]): rs.u8 => { + return _2858[0] ^ _2858[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z26, n), 238, (_2879: [rs.u8, rs.u8]): rs.u8 => { - return _2879[0] ^ _2879[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z26, n), 238, (_2859: [rs.u8, rs.u8]): rs.u8 => { + return _2859[0] ^ _2859[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z26.next()), 238, (_2880: [rs.u8, rs.u8]): rs.u8 => { - return _2880[0] ^ _2880[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z26.next()), 238, (_2860: [rs.u8, rs.u8]): rs.u8 => { + return _2860[0] ^ _2860[1]; })); } } else if (_1551 === 1) { - const z27: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x275: rs.u8): rs.u8 => { + const z27: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x253: rs.u8): rs.u8 => { const _6207: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6207.value, x275 ^ 9); + rs.byteVecPush(_6207.value, x253 ^ 9); rs.refMutRelease(_6207); - return x275; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2865: rs.u8): rs.u8 => { - const x276: rs.u8 = _2865; + return x253; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2843: rs.u8): rs.u8 => { + const x254: rs.u8 = _2843; const _6208: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6208.value, x276 ^ 10); + rs.byteVecPush(_6208.value, x254 ^ 10); rs.refMutRelease(_6208); - return x276; + return x254; }), "index"); + const _1618: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2844: [rs.u8, rs.u8]): rs.u8 => { + return _2844[0] ^ _2844[1]; + }; const _1619: rs.usize = rs.usizeRem(data.length, 8); if (_1619 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBox(z27)) & 0xff); } else if (_1619 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z27)), 238, (_2874: [rs.u8, rs.u8]): rs.u8 => { - return _2874[0] ^ _2874[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z27)), 238, (_2853: [rs.u8, rs.u8]): rs.u8 => { + return _2853[0] ^ _2853[1]; })); } else if (_1619 === 2) { const _1626: (a0: [rs.u8, rs.u8]) => undefined = (p35: [rs.u8, rs.u8]): undefined => { @@ -3903,12 +3861,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBox(z27), _1626); } else if (_1619 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z27), (_2873: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2873[0] as rs.u32, _2873[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z27), (_2852: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2852[0] as rs.u32, _2852[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1619 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z27), (_2872: [rs.u8, rs.u8]): rs.u8 => { - return _2872[0] ^ _2872[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z27), (_2851: [rs.u8, rs.u8]): rs.u8 => { + return _2851[0] ^ _2851[1]; }), "next")), undefined, true); } else if (_1619 === 5) { const _1634: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc14: rs.u8, p34: [rs.u8, rs.u8]): rs.u8 => { @@ -3916,49 +3874,52 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBox(z27), 0, _1634)); } else if (_1619 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z27), (_2871: [rs.u8, rs.u8]): rs.u8 => { - return _2871[0] ^ _2871[1]; - }), (x283: rs.u8): boolean => { - return x283 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z27), (_2850: [rs.u8, rs.u8]): rs.u8 => { + return _2850[0] ^ _2850[1]; + }), (x262: rs.u8): boolean => { + return x262 === 0; }) ? 1 : 0); } else { const z28: rs.Iter<[rs.u8, rs.u8]> = z27; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z28), (_2866: [rs.u8, rs.u8]): boolean => { - return _2866[0] > _2866[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z28), (_2845: [rs.u8, rs.u8]): boolean => { + return _2845[0] > _2845[1]; }), 238, (i17: rs.usize): rs.u8 => { return i17 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z28), (_2867: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2867[0], 3) === 0; - }), 238, (_2868: [rs.u8, rs.u8]): rs.u8 => { - return _2868[0] ^ _2868[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z28), (_2846: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2846[0], 3) === 0; + }), 238, (_2847: [rs.u8, rs.u8]): rs.u8 => { + return _2847[0] ^ _2847[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z28), n), 238, (_2869: [rs.u8, rs.u8]): rs.u8 => { - return _2869[0] ^ _2869[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z28), n), 238, (_2848: [rs.u8, rs.u8]): rs.u8 => { + return _2848[0] ^ _2848[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z28.next()), 238, (_2870: [rs.u8, rs.u8]): rs.u8 => { - return _2870[0] ^ _2870[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z28.next()), 238, (_2849: [rs.u8, rs.u8]): rs.u8 => { + return _2849[0] ^ _2849[1]; })); } } else if (_1551 === 2) { - const z29: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x263: rs.u8): rs.u8 => { + const z29: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x240: rs.u8): rs.u8 => { const _6203: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6203.value, x263 ^ 9); + rs.byteVecPush(_6203.value, x240 ^ 9); rs.refMutRelease(_6203); - return x263; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2855: rs.u8): rs.u8 => { - const x264: rs.u8 = _2855; + return x240; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2832: rs.u8): rs.u8 => { + const x241: rs.u8 = _2832; const _6204: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6204.value, x264 ^ 10); + rs.byteVecPush(_6204.value, x241 ^ 10); rs.refMutRelease(_6204); - return x264; + return x241; }), "index"), n); + const _1670: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2833: [rs.u8, rs.u8]): rs.u8 => { + return _2833[0] ^ _2833[1]; + }; const _1671: rs.usize = rs.usizeRem(data.length, 8); if (_1671 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBox(z29)) & 0xff); } else if (_1671 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z29)), 238, (_2864: [rs.u8, rs.u8]): rs.u8 => { - return _2864[0] ^ _2864[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z29)), 238, (_2842: [rs.u8, rs.u8]): rs.u8 => { + return _2842[0] ^ _2842[1]; })); } else if (_1671 === 2) { const _1678: (a0: [rs.u8, rs.u8]) => undefined = (p33: [rs.u8, rs.u8]): undefined => { @@ -3966,12 +3927,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBox(z29), _1678); } else if (_1671 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z29), (_2863: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2863[0] as rs.u32, _2863[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z29), (_2841: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2841[0] as rs.u32, _2841[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1671 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z29), (_2862: [rs.u8, rs.u8]): rs.u8 => { - return _2862[0] ^ _2862[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z29), (_2840: [rs.u8, rs.u8]): rs.u8 => { + return _2840[0] ^ _2840[1]; }), "next")), undefined, true); } else if (_1671 === 5) { const _1686: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc13: rs.u8, p32: [rs.u8, rs.u8]): rs.u8 => { @@ -3979,49 +3940,52 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBox(z29), 0, _1686)); } else if (_1671 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z29), (_2861: [rs.u8, rs.u8]): rs.u8 => { - return _2861[0] ^ _2861[1]; - }), (x271: rs.u8): boolean => { - return x271 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z29), (_2839: [rs.u8, rs.u8]): rs.u8 => { + return _2839[0] ^ _2839[1]; + }), (x249: rs.u8): boolean => { + return x249 === 0; }) ? 1 : 0); } else { const z30: rs.Iter<[rs.u8, rs.u8]> = z29; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z30), (_2856: [rs.u8, rs.u8]): boolean => { - return _2856[0] > _2856[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z30), (_2834: [rs.u8, rs.u8]): boolean => { + return _2834[0] > _2834[1]; }), 238, (i16: rs.usize): rs.u8 => { return i16 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z30), (_2857: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2857[0], 3) === 0; - }), 238, (_2858: [rs.u8, rs.u8]): rs.u8 => { - return _2858[0] ^ _2858[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z30), (_2835: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2835[0], 3) === 0; + }), 238, (_2836: [rs.u8, rs.u8]): rs.u8 => { + return _2836[0] ^ _2836[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z30), n), 238, (_2859: [rs.u8, rs.u8]): rs.u8 => { - return _2859[0] ^ _2859[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z30), n), 238, (_2837: [rs.u8, rs.u8]): rs.u8 => { + return _2837[0] ^ _2837[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z30.next()), 238, (_2860: [rs.u8, rs.u8]): rs.u8 => { - return _2860[0] ^ _2860[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z30.next()), 238, (_2838: [rs.u8, rs.u8]): rs.u8 => { + return _2838[0] ^ _2838[1]; })); } } else if (_1551 === 3) { - const _1710: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x251: rs.u8): rs.u8 => { + const _1710: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x227: rs.u8): rs.u8 => { const _6199: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6199.value, x251 ^ 9); + rs.byteVecPush(_6199.value, x227 ^ 9); rs.refMutRelease(_6199); - return x251; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2845: rs.u8): rs.u8 => { - const x252: rs.u8 = _2845; + return x227; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2821: rs.u8): rs.u8 => { + const x228: rs.u8 = _2821; const _6200: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6200.value, x252 ^ 10); + rs.byteVecPush(_6200.value, x228 ^ 10); rs.refMutRelease(_6200); - return x252; + return x228; }), "index"); + const _1722: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2822: [rs.u8, rs.u8]): rs.u8 => { + return _2822[0] ^ _2822[1]; + }; const _1723: rs.usize = rs.usizeRem(data.length, 8); if (_1723 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1710)))) & 0xff); } else if (_1723 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1710)))), 238, (_2854: [rs.u8, rs.u8]): rs.u8 => { - return _2854[0] ^ _2854[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1710)))), 238, (_2831: [rs.u8, rs.u8]): rs.u8 => { + return _2831[0] ^ _2831[1]; })); } else if (_1723 === 2) { const _1730: (a0: [rs.u8, rs.u8]) => undefined = (p31: [rs.u8, rs.u8]): undefined => { @@ -4029,12 +3993,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1710))), _1730); } else if (_1723 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1710))), (_2853: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2853[0] as rs.u32, _2853[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1710))), (_2830: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2830[0] as rs.u32, _2830[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1723 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1710))), (_2852: [rs.u8, rs.u8]): rs.u8 => { - return _2852[0] ^ _2852[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1710))), (_2829: [rs.u8, rs.u8]): rs.u8 => { + return _2829[0] ^ _2829[1]; }), "next")), undefined, true); } else if (_1723 === 5) { const _1738: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc12: rs.u8, p30: [rs.u8, rs.u8]): rs.u8 => { @@ -4042,48 +4006,51 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1710))), 0, _1738)); } else if (_1723 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1710))), (_2851: [rs.u8, rs.u8]): rs.u8 => { - return _2851[0] ^ _2851[1]; - }), (x259: rs.u8): boolean => { - return x259 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1710))), (_2828: [rs.u8, rs.u8]): rs.u8 => { + return _2828[0] ^ _2828[1]; + }), (x236: rs.u8): boolean => { + return x236 === 0; }) ? 1 : 0); } else { - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_1710), (_2846: [rs.u8, rs.u8]): boolean => { - return _2846[0] > _2846[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_1710), (_2823: [rs.u8, rs.u8]): boolean => { + return _2823[0] > _2823[1]; }), 238, (i15: rs.usize): rs.u8 => { return i15 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_1710), (_2847: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2847[0], 3) === 0; - }), 238, (_2848: [rs.u8, rs.u8]): rs.u8 => { - return _2848[0] ^ _2848[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_1710), (_2824: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2824[0], 3) === 0; + }), 238, (_2825: [rs.u8, rs.u8]): rs.u8 => { + return _2825[0] ^ _2825[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_1710), n), 238, (_2849: [rs.u8, rs.u8]): rs.u8 => { - return _2849[0] ^ _2849[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_1710), n), 238, (_2826: [rs.u8, rs.u8]): rs.u8 => { + return _2826[0] ^ _2826[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_1710.next()), 238, (_2850: [rs.u8, rs.u8]): rs.u8 => { - return _2850[0] ^ _2850[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_1710.next()), 238, (_2827: [rs.u8, rs.u8]): rs.u8 => { + return _2827[0] ^ _2827[1]; })); } } else { - const _1757: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x239: rs.u8): rs.u8 => { + const _1757: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x214: rs.u8): rs.u8 => { const _6195: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6195.value, x239 ^ 9); + rs.byteVecPush(_6195.value, x214 ^ 9); rs.refMutRelease(_6195); - return x239; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2835: rs.u8): rs.u8 => { - const x240: rs.u8 = _2835; + return x214; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2810: rs.u8): rs.u8 => { + const x215: rs.u8 = _2810; const _6196: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6196.value, x240 ^ 10); + rs.byteVecPush(_6196.value, x215 ^ 10); rs.refMutRelease(_6196); - return x240; + return x215; }), "index"), n); + const _1770: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2811: [rs.u8, rs.u8]): rs.u8 => { + return _2811[0] ^ _2811[1]; + }; const _1771: rs.usize = rs.usizeRem(data.length, 8); if (_1771 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1757)))) & 0xff); } else if (_1771 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1757)))), 238, (_2844: [rs.u8, rs.u8]): rs.u8 => { - return _2844[0] ^ _2844[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1757)))), 238, (_2820: [rs.u8, rs.u8]): rs.u8 => { + return _2820[0] ^ _2820[1]; })); } else if (_1771 === 2) { const _1778: (a0: [rs.u8, rs.u8]) => undefined = (p29: [rs.u8, rs.u8]): undefined => { @@ -4091,12 +4058,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1757))), _1778); } else if (_1771 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1757))), (_2843: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2843[0] as rs.u32, _2843[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1757))), (_2819: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2819[0] as rs.u32, _2819[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1771 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1757))), (_2842: [rs.u8, rs.u8]): rs.u8 => { - return _2842[0] ^ _2842[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1757))), (_2818: [rs.u8, rs.u8]): rs.u8 => { + return _2818[0] ^ _2818[1]; }), "next")), undefined, true); } else if (_1771 === 5) { const _1786: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc11: rs.u8, p28: [rs.u8, rs.u8]): rs.u8 => { @@ -4104,143 +4071,143 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1757))), 0, _1786)); } else if (_1771 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1757))), (_2841: [rs.u8, rs.u8]): rs.u8 => { - return _2841[0] ^ _2841[1]; - }), (x247: rs.u8): boolean => { - return x247 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1757))), (_2817: [rs.u8, rs.u8]): rs.u8 => { + return _2817[0] ^ _2817[1]; + }), (x223: rs.u8): boolean => { + return x223 === 0; }) ? 1 : 0); } else { - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_1757), (_2836: [rs.u8, rs.u8]): boolean => { - return _2836[0] > _2836[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_1757), (_2812: [rs.u8, rs.u8]): boolean => { + return _2812[0] > _2812[1]; }), 238, (i14: rs.usize): rs.u8 => { return i14 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_1757), (_2837: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2837[0], 3) === 0; - }), 238, (_2838: [rs.u8, rs.u8]): rs.u8 => { - return _2838[0] ^ _2838[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_1757), (_2813: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2813[0], 3) === 0; + }), 238, (_2814: [rs.u8, rs.u8]): rs.u8 => { + return _2814[0] ^ _2814[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_1757), n), 238, (_2839: [rs.u8, rs.u8]): rs.u8 => { - return _2839[0] ^ _2839[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_1757), n), 238, (_2815: [rs.u8, rs.u8]): rs.u8 => { + return _2815[0] ^ _2815[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_1757.next()), 238, (_2840: [rs.u8, rs.u8]): rs.u8 => { - return _2840[0] ^ _2840[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_1757.next()), 238, (_2816: [rs.u8, rs.u8]): rs.u8 => { + return _2816[0] ^ _2816[1]; })); } } } else { const _1804: rs.usize = rs.usizeRem(data.length, 8); if (_1804 === 0) { - rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x236: rs.u8): rs.u8 => { + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x211: rs.u8): rs.u8 => { const _6193: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6193.value, x236 ^ 9); + rs.byteVecPush(_6193.value, x211 ^ 9); rs.refMutRelease(_6193); - return x236; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2833: rs.u8): rs.u8 => { - const x237: rs.u8 = _2833; + return x211; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2808: rs.u8): rs.u8 => { + const x212: rs.u8 = _2808; const _6194: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6194.value, x237 ^ 10); + rs.byteVecPush(_6194.value, x212 ^ 10); rs.refMutRelease(_6194); - return x237; - }), "index"), (_2834: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2834[0], 2) === 0; + return x212; + }), "index"), (_2809: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2809[0], 2) === 0; })) & 0xff); } else if (_1804 === 1) { - rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x233: rs.u8): rs.u8 => { + rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x208: rs.u8): rs.u8 => { const _6191: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6191.value, x233 ^ 9); + rs.byteVecPush(_6191.value, x208 ^ 9); rs.refMutRelease(_6191); - return x233; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2831: rs.u8): rs.u8 => { - const x234: rs.u8 = _2831; + return x208; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2806: rs.u8): rs.u8 => { + const x209: rs.u8 = _2806; const _6192: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6192.value, x234 ^ 10); + rs.byteVecPush(_6192.value, x209 ^ 10); rs.refMutRelease(_6192); - return x234; - }), "index"), (_2832: [rs.u8, rs.u8]): rs.u8 | undefined => { - return rs.u8CheckedSub(_2832[0], _2832[1]); + return x209; + }), "index"), (_2807: [rs.u8, rs.u8]): rs.u8 | undefined => { + return rs.u8CheckedSub(_2807[0], _2807[1]); })) & 0xff); } else if (_1804 === 2) { - rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x230: rs.u8): rs.u8 => { + rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x205: rs.u8): rs.u8 => { const _6189: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6189.value, x230 ^ 9); + rs.byteVecPush(_6189.value, x205 ^ 9); rs.refMutRelease(_6189); - return x230; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2829: rs.u8): rs.u8 => { - const x231: rs.u8 = _2829; + return x205; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2804: rs.u8): rs.u8 => { + const x206: rs.u8 = _2804; const _6190: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6190.value, x231 ^ 10); + rs.byteVecPush(_6190.value, x206 ^ 10); rs.refMutRelease(_6190); - return x231; - }), "index"), (_2830: [rs.u8, rs.u8]): boolean => { - return _2830[0] < 128; + return x206; + }), "index"), (_2805: [rs.u8, rs.u8]): boolean => { + return _2805[0] < 128; })) & 0xff); } else if (_1804 === 3) { - rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x228: rs.u8): rs.u8 => { + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x203: rs.u8): rs.u8 => { const _6187: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6187.value, x228 ^ 9); + rs.byteVecPush(_6187.value, x203 ^ 9); rs.refMutRelease(_6187); - return x228; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2827: rs.u8): rs.u8 => { - const x229: rs.u8 = _2827; + return x203; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2802: rs.u8): rs.u8 => { + const x204: rs.u8 = _2802; const _6188: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6188.value, x229 ^ 10); + rs.byteVecPush(_6188.value, x204 ^ 10); rs.refMutRelease(_6188); - return x229; - }), "index")), (_2828: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { - return _2828[0] & 0xff; + return x204; + }), "index")), (_2803: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { + return _2803[0] & 0xff; })), 238)); } else if (_1804 === 4) { - rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x226: rs.u8): rs.u8 => { + rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x201: rs.u8): rs.u8 => { const _6185: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6185.value, x226 ^ 9); + rs.byteVecPush(_6185.value, x201 ^ 9); rs.refMutRelease(_6185); - return x226; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2826: rs.u8): rs.u8 => { - const x227: rs.u8 = _2826; + return x201; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2801: rs.u8): rs.u8 => { + const x202: rs.u8 = _2801; const _6186: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6186.value, x227 ^ 10); + rs.byteVecPush(_6186.value, x202 ^ 10); rs.refMutRelease(_6186); - return x227; + return x202; }), "index"), rs.iterSlice([[1, 2] as [rs.u8, rs.u8]]))) & 0xff); } else if (_1804 === 5) { - rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x224: rs.u8): rs.u8 => { + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x199: rs.u8): rs.u8 => { const _6183: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6183.value, x224 ^ 9); + rs.byteVecPush(_6183.value, x199 ^ 9); rs.refMutRelease(_6183); - return x224; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2825: rs.u8): rs.u8 => { - const x225: rs.u8 = _2825; + return x199; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2800: rs.u8): rs.u8 => { + const x200: rs.u8 = _2800; const _6184: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6184.value, x225 ^ 10); + rs.byteVecPush(_6184.value, x200 ^ 10); rs.refMutRelease(_6184); - return x225; + return x200; }), "index"), n)) & 0xff); } else if (_1804 === 6) { - rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x222: rs.u8): rs.u8 => { + rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x197: rs.u8): rs.u8 => { const _6181: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6181.value, x222 ^ 9); + rs.byteVecPush(_6181.value, x197 ^ 9); rs.refMutRelease(_6181); - return x222; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2824: rs.u8): rs.u8 => { - const x223: rs.u8 = _2824; + return x197; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2799: rs.u8): rs.u8 => { + const x198: rs.u8 = _2799; const _6182: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6182.value, x223 ^ 10); + rs.byteVecPush(_6182.value, x198 ^ 10); rs.refMutRelease(_6182); - return x223; + return x198; }), "index"), n)) & 0xff); } else { - const p5: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x220: rs.u8): rs.u8 => { + const p5: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x195: rs.u8): rs.u8 => { const _6179: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6179.value, x220 ^ 9); + rs.byteVecPush(_6179.value, x195 ^ 9); rs.refMutRelease(_6179); - return x220; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2823: rs.u8): rs.u8 => { - const x221: rs.u8 = _2823; + return x195; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2798: rs.u8): rs.u8 => { + const x196: rs.u8 = _2798; const _6180: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6180.value, x221 ^ 10); + rs.byteVecPush(_6180.value, x196 ^ 10); rs.refMutRelease(_6180); - return x221; + return x196; }), "index")); rs.byteVecPush(out, (rs.peekablePeek(p5) !== undefined ? 1 : 0) ^ (rs.iterCount(p5) & 0xff)); } @@ -4249,91 +4216,97 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if ((kind & 16) === 0) { const _1931: rs.usize = rs.usizeRem(rs.usizeDiv(data.length, 8), 5); if (_1931 === 0) { - const z31: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2811: rs.u8): rs.u8 => { - const x208: rs.u8 = _2811; + const z31: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2785: rs.u8): rs.u8 => { + const x182: rs.u8 = _2785; const _6175: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6175.value, x208 ^ 11); + rs.byteVecPush(_6175.value, x182 ^ 11); rs.refMutRelease(_6175); - return x208; - }), (_2812: rs.u8): boolean => { + return x182; + }), (_2786: rs.u8): boolean => { return true; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2813: rs.u8): rs.u8 => { - const x209: rs.u8 = _2813; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2787: rs.u8): rs.u8 => { + const x183: rs.u8 = _2787; const _6176: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6176.value, x209 ^ 12); + rs.byteVecPush(_6176.value, x183 ^ 12); rs.refMutRelease(_6176); - return x209; + return x183; })); + const _1946: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2788: [rs.u8, rs.u8]): rs.u8 => { + return _2788[0] ^ _2788[1]; + }; const _1947: rs.usize = rs.usizeRem(data.length, 8); if (_1947 === 0) { rs.byteVecPush(out, rs.iterCount(z31) & 0xff); } else if (_1947 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(z31), 238, (_2822: [rs.u8, rs.u8]): rs.u8 => { - return _2822[0] ^ _2822[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(z31), 238, (_2797: [rs.u8, rs.u8]): rs.u8 => { + return _2797[0] ^ _2797[1]; })); } else if (_1947 === 2) { rs.iterForEach(z31, (p27: [rs.u8, rs.u8]): undefined => { rs.byteVecPush(out, _1946(p27)); }); } else if (_1947 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(z31, (_2821: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2821[0] as rs.u32, _2821[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(z31, (_2796: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2796[0] as rs.u32, _2796[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1947 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(z31, (_2820: [rs.u8, rs.u8]): rs.u8 => { - return _2820[0] ^ _2820[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(z31, (_2795: [rs.u8, rs.u8]): rs.u8 => { + return _2795[0] ^ _2795[1]; }), "next")), undefined, true); } else if (_1947 === 5) { rs.byteVecPush(out, rs.iterFold(z31, 0, (acc10: rs.u8, p26: [rs.u8, rs.u8]): rs.u8 => { return rs.u8WrappingMul(acc10, 3) ^ _1946(p26); })); } else if (_1947 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(z31, (_2819: [rs.u8, rs.u8]): rs.u8 => { - return _2819[0] ^ _2819[1]; - }), (x216: rs.u8): boolean => { - return x216 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(z31, (_2794: [rs.u8, rs.u8]): rs.u8 => { + return _2794[0] ^ _2794[1]; + }), (x191: rs.u8): boolean => { + return x191 === 0; }) ? 1 : 0); } else { const z32: rs.Iter<[rs.u8, rs.u8]> = z31; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(z32, (_2814: [rs.u8, rs.u8]): boolean => { - return _2814[0] > _2814[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(z32, (_2789: [rs.u8, rs.u8]): boolean => { + return _2789[0] > _2789[1]; }), 238, (i12: rs.usize): rs.u8 => { return i12 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(z32, (_2815: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2815[0], 3) === 0; - }), 238, (_2816: [rs.u8, rs.u8]): rs.u8 => { - return _2816[0] ^ _2816[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(z32, (_2790: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2790[0], 3) === 0; + }), 238, (_2791: [rs.u8, rs.u8]): rs.u8 => { + return _2791[0] ^ _2791[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z32, n), 238, (_2817: [rs.u8, rs.u8]): rs.u8 => { - return _2817[0] ^ _2817[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z32, n), 238, (_2792: [rs.u8, rs.u8]): rs.u8 => { + return _2792[0] ^ _2792[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z32.next()), 238, (_2818: [rs.u8, rs.u8]): rs.u8 => { - return _2818[0] ^ _2818[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z32.next()), 238, (_2793: [rs.u8, rs.u8]): rs.u8 => { + return _2793[0] ^ _2793[1]; })); } } else if (_1931 === 1) { - const z33: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2799: rs.u8): rs.u8 => { - const x196: rs.u8 = _2799; + const z33: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2772: rs.u8): rs.u8 => { + const x169: rs.u8 = _2772; const _6171: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6171.value, x196 ^ 11); + rs.byteVecPush(_6171.value, x169 ^ 11); rs.refMutRelease(_6171); - return x196; - }), (_2800: rs.u8): boolean => { + return x169; + }), (_2773: rs.u8): boolean => { return true; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2801: rs.u8): rs.u8 => { - const x197: rs.u8 = _2801; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2774: rs.u8): rs.u8 => { + const x170: rs.u8 = _2774; const _6172: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6172.value, x197 ^ 12); + rs.byteVecPush(_6172.value, x170 ^ 12); rs.refMutRelease(_6172); - return x197; + return x170; })); + const _1996: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2775: [rs.u8, rs.u8]): rs.u8 => { + return _2775[0] ^ _2775[1]; + }; const _1997: rs.usize = rs.usizeRem(data.length, 8); if (_1997 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBox(z33)) & 0xff); } else if (_1997 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z33)), 238, (_2810: [rs.u8, rs.u8]): rs.u8 => { - return _2810[0] ^ _2810[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z33)), 238, (_2784: [rs.u8, rs.u8]): rs.u8 => { + return _2784[0] ^ _2784[1]; })); } else if (_1997 === 2) { const _2004: (a0: [rs.u8, rs.u8]) => undefined = (p25: [rs.u8, rs.u8]): undefined => { @@ -4341,12 +4314,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBox(z33), _2004); } else if (_1997 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z33), (_2809: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2809[0] as rs.u32, _2809[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z33), (_2783: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2783[0] as rs.u32, _2783[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1997 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z33), (_2808: [rs.u8, rs.u8]): rs.u8 => { - return _2808[0] ^ _2808[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z33), (_2782: [rs.u8, rs.u8]): rs.u8 => { + return _2782[0] ^ _2782[1]; }), "next")), undefined, true); } else if (_1997 === 5) { const _2012: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc9: rs.u8, p24: [rs.u8, rs.u8]): rs.u8 => { @@ -4354,52 +4327,55 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBox(z33), 0, _2012)); } else if (_1997 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z33), (_2807: [rs.u8, rs.u8]): rs.u8 => { - return _2807[0] ^ _2807[1]; - }), (x204: rs.u8): boolean => { - return x204 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z33), (_2781: [rs.u8, rs.u8]): rs.u8 => { + return _2781[0] ^ _2781[1]; + }), (x178: rs.u8): boolean => { + return x178 === 0; }) ? 1 : 0); } else { const z34: rs.Iter<[rs.u8, rs.u8]> = z33; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z34), (_2802: [rs.u8, rs.u8]): boolean => { - return _2802[0] > _2802[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z34), (_2776: [rs.u8, rs.u8]): boolean => { + return _2776[0] > _2776[1]; }), 238, (i11: rs.usize): rs.u8 => { return i11 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z34), (_2803: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2803[0], 3) === 0; - }), 238, (_2804: [rs.u8, rs.u8]): rs.u8 => { - return _2804[0] ^ _2804[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z34), (_2777: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2777[0], 3) === 0; + }), 238, (_2778: [rs.u8, rs.u8]): rs.u8 => { + return _2778[0] ^ _2778[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z34), n), 238, (_2805: [rs.u8, rs.u8]): rs.u8 => { - return _2805[0] ^ _2805[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z34), n), 238, (_2779: [rs.u8, rs.u8]): rs.u8 => { + return _2779[0] ^ _2779[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z34.next()), 238, (_2806: [rs.u8, rs.u8]): rs.u8 => { - return _2806[0] ^ _2806[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z34.next()), 238, (_2780: [rs.u8, rs.u8]): rs.u8 => { + return _2780[0] ^ _2780[1]; })); } } else if (_1931 === 2) { - const z35: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2787: rs.u8): rs.u8 => { - const x184: rs.u8 = _2787; + const z35: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2758: rs.u8): rs.u8 => { + const x156: rs.u8 = _2758; const _6167: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6167.value, x184 ^ 11); + rs.byteVecPush(_6167.value, x156 ^ 11); rs.refMutRelease(_6167); - return x184; - }), (_2788: rs.u8): boolean => { + return x156; + }), (_2760: rs.u8): boolean => { return true; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2789: rs.u8): rs.u8 => { - const x185: rs.u8 = _2789; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2761: rs.u8): rs.u8 => { + const x157: rs.u8 = _2761; const _6168: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6168.value, x185 ^ 12); + rs.byteVecPush(_6168.value, x157 ^ 12); rs.refMutRelease(_6168); - return x185; + return x157; })), n); + const _2047: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2762: [rs.u8, rs.u8]): rs.u8 => { + return _2762[0] ^ _2762[1]; + }; const _2048: rs.usize = rs.usizeRem(data.length, 8); if (_2048 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBox(z35)) & 0xff); } else if (_2048 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z35)), 238, (_2798: [rs.u8, rs.u8]): rs.u8 => { - return _2798[0] ^ _2798[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z35)), 238, (_2771: [rs.u8, rs.u8]): rs.u8 => { + return _2771[0] ^ _2771[1]; })); } else if (_2048 === 2) { const _2055: (a0: [rs.u8, rs.u8]) => undefined = (p23: [rs.u8, rs.u8]): undefined => { @@ -4407,12 +4383,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBox(z35), _2055); } else if (_2048 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z35), (_2797: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2797[0] as rs.u32, _2797[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z35), (_2770: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2770[0] as rs.u32, _2770[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_2048 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z35), (_2796: [rs.u8, rs.u8]): rs.u8 => { - return _2796[0] ^ _2796[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z35), (_2769: [rs.u8, rs.u8]): rs.u8 => { + return _2769[0] ^ _2769[1]; }), "next")), undefined, true); } else if (_2048 === 5) { const _2063: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc8: rs.u8, p22: [rs.u8, rs.u8]): rs.u8 => { @@ -4420,52 +4396,55 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBox(z35), 0, _2063)); } else if (_2048 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z35), (_2795: [rs.u8, rs.u8]): rs.u8 => { - return _2795[0] ^ _2795[1]; - }), (x192: rs.u8): boolean => { - return x192 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z35), (_2768: [rs.u8, rs.u8]): rs.u8 => { + return _2768[0] ^ _2768[1]; + }), (x165: rs.u8): boolean => { + return x165 === 0; }) ? 1 : 0); } else { const z36: rs.Iter<[rs.u8, rs.u8]> = z35; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z36), (_2790: [rs.u8, rs.u8]): boolean => { - return _2790[0] > _2790[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z36), (_2763: [rs.u8, rs.u8]): boolean => { + return _2763[0] > _2763[1]; }), 238, (i10: rs.usize): rs.u8 => { return i10 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z36), (_2791: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2791[0], 3) === 0; - }), 238, (_2792: [rs.u8, rs.u8]): rs.u8 => { - return _2792[0] ^ _2792[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z36), (_2764: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2764[0], 3) === 0; + }), 238, (_2765: [rs.u8, rs.u8]): rs.u8 => { + return _2765[0] ^ _2765[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z36), n), 238, (_2793: [rs.u8, rs.u8]): rs.u8 => { - return _2793[0] ^ _2793[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z36), n), 238, (_2766: [rs.u8, rs.u8]): rs.u8 => { + return _2766[0] ^ _2766[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z36.next()), 238, (_2794: [rs.u8, rs.u8]): rs.u8 => { - return _2794[0] ^ _2794[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z36.next()), 238, (_2767: [rs.u8, rs.u8]): rs.u8 => { + return _2767[0] ^ _2767[1]; })); } } else if (_1931 === 3) { - const _2087: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2775: rs.u8): rs.u8 => { - const x172: rs.u8 = _2775; + const _2087: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2706: rs.u8): rs.u8 => { + const x143: rs.u8 = _2706; const _6163: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6163.value, x172 ^ 11); + rs.byteVecPush(_6163.value, x143 ^ 11); rs.refMutRelease(_6163); - return x172; - }), (_2776: rs.u8): boolean => { + return x143; + }), (_2716: rs.u8): boolean => { return true; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2777: rs.u8): rs.u8 => { - const x173: rs.u8 = _2777; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2721: rs.u8): rs.u8 => { + const x144: rs.u8 = _2721; const _6164: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6164.value, x173 ^ 12); + rs.byteVecPush(_6164.value, x144 ^ 12); rs.refMutRelease(_6164); - return x173; + return x144; })); + const _2098: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2726: [rs.u8, rs.u8]): rs.u8 => { + return _2726[0] ^ _2726[1]; + }; const _2099: rs.usize = rs.usizeRem(data.length, 8); if (_2099 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2087)))) & 0xff); } else if (_2099 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2087)))), 238, (_2786: [rs.u8, rs.u8]): rs.u8 => { - return _2786[0] ^ _2786[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2087)))), 238, (_2755: [rs.u8, rs.u8]): rs.u8 => { + return _2755[0] ^ _2755[1]; })); } else if (_2099 === 2) { const _2106: (a0: [rs.u8, rs.u8]) => undefined = (p21: [rs.u8, rs.u8]): undefined => { @@ -4473,12 +4452,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2087))), _2106); } else if (_2099 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2087))), (_2785: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2785[0] as rs.u32, _2785[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2087))), (_2750: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2750[0] as rs.u32, _2750[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_2099 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2087))), (_2784: [rs.u8, rs.u8]): rs.u8 => { - return _2784[0] ^ _2784[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2087))), (_2749: [rs.u8, rs.u8]): rs.u8 => { + return _2749[0] ^ _2749[1]; }), "next")), undefined, true); } else if (_2099 === 5) { const _2114: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc7: rs.u8, p20: [rs.u8, rs.u8]): rs.u8 => { @@ -4486,51 +4465,54 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2087))), 0, _2114)); } else if (_2099 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2087))), (_2783: [rs.u8, rs.u8]): rs.u8 => { - return _2783[0] ^ _2783[1]; - }), (x180: rs.u8): boolean => { - return x180 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2087))), (_2747: [rs.u8, rs.u8]): rs.u8 => { + return _2747[0] ^ _2747[1]; + }), (x152: rs.u8): boolean => { + return x152 === 0; }) ? 1 : 0); } else { - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_2087), (_2778: [rs.u8, rs.u8]): boolean => { - return _2778[0] > _2778[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_2087), (_2727: [rs.u8, rs.u8]): boolean => { + return _2727[0] > _2727[1]; }), 238, (i9: rs.usize): rs.u8 => { return i9 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_2087), (_2779: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2779[0], 3) === 0; - }), 238, (_2780: [rs.u8, rs.u8]): rs.u8 => { - return _2780[0] ^ _2780[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_2087), (_2734: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2734[0], 3) === 0; + }), 238, (_2739: [rs.u8, rs.u8]): rs.u8 => { + return _2739[0] ^ _2739[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_2087), n), 238, (_2781: [rs.u8, rs.u8]): rs.u8 => { - return _2781[0] ^ _2781[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_2087), n), 238, (_2744: [rs.u8, rs.u8]): rs.u8 => { + return _2744[0] ^ _2744[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_2087.next()), 238, (_2782: [rs.u8, rs.u8]): rs.u8 => { - return _2782[0] ^ _2782[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_2087.next()), 238, (_2745: [rs.u8, rs.u8]): rs.u8 => { + return _2745[0] ^ _2745[1]; })); } } else { - const _2133: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2763: rs.u8): rs.u8 => { - const x160: rs.u8 = _2763; + const _2133: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2618: rs.u8): rs.u8 => { + const x130: rs.u8 = _2618; const _6159: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6159.value, x160 ^ 11); + rs.byteVecPush(_6159.value, x130 ^ 11); rs.refMutRelease(_6159); - return x160; - }), (_2764: rs.u8): boolean => { + return x130; + }), (_2623: rs.u8): boolean => { return true; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2765: rs.u8): rs.u8 => { - const x161: rs.u8 = _2765; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2633: rs.u8): rs.u8 => { + const x131: rs.u8 = _2633; const _6160: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6160.value, x161 ^ 12); + rs.byteVecPush(_6160.value, x131 ^ 12); rs.refMutRelease(_6160); - return x161; + return x131; })), n); + const _2145: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2638: [rs.u8, rs.u8]): rs.u8 => { + return _2638[0] ^ _2638[1]; + }; const _2146: rs.usize = rs.usizeRem(data.length, 8); if (_2146 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2133)))) & 0xff); } else if (_2146 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2133)))), 238, (_2774: [rs.u8, rs.u8]): rs.u8 => { - return _2774[0] ^ _2774[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2133)))), 238, (_2701: [rs.u8, rs.u8]): rs.u8 => { + return _2701[0] ^ _2701[1]; })); } else if (_2146 === 2) { const _2153: (a0: [rs.u8, rs.u8]) => undefined = (p19: [rs.u8, rs.u8]): undefined => { @@ -4538,12 +4520,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2133))), _2153); } else if (_2146 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2133))), (_2773: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2773[0] as rs.u32, _2773[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2133))), (_2696: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2696[0] as rs.u32, _2696[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_2146 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2133))), (_2772: [rs.u8, rs.u8]): rs.u8 => { - return _2772[0] ^ _2772[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2133))), (_2684: [rs.u8, rs.u8]): rs.u8 => { + return _2684[0] ^ _2684[1]; }), "next")), undefined, true); } else if (_2146 === 5) { const _2161: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc6: rs.u8, p18: [rs.u8, rs.u8]): rs.u8 => { @@ -4551,167 +4533,167 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2133))), 0, _2161)); } else if (_2146 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2133))), (_2771: [rs.u8, rs.u8]): rs.u8 => { - return _2771[0] ^ _2771[1]; - }), (x168: rs.u8): boolean => { - return x168 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2133))), (_2679: [rs.u8, rs.u8]): rs.u8 => { + return _2679[0] ^ _2679[1]; + }), (x139: rs.u8): boolean => { + return x139 === 0; }) ? 1 : 0); } else { - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_2133), (_2766: [rs.u8, rs.u8]): boolean => { - return _2766[0] > _2766[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_2133), (_2643: [rs.u8, rs.u8]): boolean => { + return _2643[0] > _2643[1]; }), 238, (i8: rs.usize): rs.u8 => { return i8 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_2133), (_2767: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2767[0], 3) === 0; - }), 238, (_2768: [rs.u8, rs.u8]): rs.u8 => { - return _2768[0] ^ _2768[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_2133), (_2654: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2654[0], 3) === 0; + }), 238, (_2659: [rs.u8, rs.u8]): rs.u8 => { + return _2659[0] ^ _2659[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_2133), n), 238, (_2769: [rs.u8, rs.u8]): rs.u8 => { - return _2769[0] ^ _2769[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_2133), n), 238, (_2664: [rs.u8, rs.u8]): rs.u8 => { + return _2664[0] ^ _2664[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_2133.next()), 238, (_2770: [rs.u8, rs.u8]): rs.u8 => { - return _2770[0] ^ _2770[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_2133.next()), 238, (_2674: [rs.u8, rs.u8]): rs.u8 => { + return _2674[0] ^ _2674[1]; })); } } } else { const _2179: rs.usize = rs.usizeRem(data.length, 8); if (_2179 === 0) { - rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2758: rs.u8): rs.u8 => { - const x157: rs.u8 = _2758; + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2593: rs.u8): rs.u8 => { + const x127: rs.u8 = _2593; const _6157: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6157.value, x157 ^ 11); + rs.byteVecPush(_6157.value, x127 ^ 11); rs.refMutRelease(_6157); - return x157; - }), (_2760: rs.u8): boolean => { + return x127; + }), (_2598: rs.u8): boolean => { return true; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2761: rs.u8): rs.u8 => { - const x158: rs.u8 = _2761; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2603: rs.u8): rs.u8 => { + const x128: rs.u8 = _2603; const _6158: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6158.value, x158 ^ 12); + rs.byteVecPush(_6158.value, x128 ^ 12); rs.refMutRelease(_6158); - return x158; - })), (_2762: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2762[0], 2) === 0; + return x128; + })), (_2613: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2613[0], 2) === 0; })) & 0xff); } else if (_2179 === 1) { - rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2747: rs.u8): rs.u8 => { - const x154: rs.u8 = _2747; + rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2569: rs.u8): rs.u8 => { + const x124: rs.u8 = _2569; const _6155: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6155.value, x154 ^ 11); + rs.byteVecPush(_6155.value, x124 ^ 11); rs.refMutRelease(_6155); - return x154; - }), (_2749: rs.u8): boolean => { + return x124; + }), (_2572: rs.u8): boolean => { return true; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2750: rs.u8): rs.u8 => { - const x155: rs.u8 = _2750; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2575: rs.u8): rs.u8 => { + const x125: rs.u8 = _2575; const _6156: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6156.value, x155 ^ 12); + rs.byteVecPush(_6156.value, x125 ^ 12); rs.refMutRelease(_6156); - return x155; - })), (_2755: [rs.u8, rs.u8]): rs.u8 | undefined => { - return rs.u8CheckedSub(_2755[0], _2755[1]); + return x125; + })), (_2578: [rs.u8, rs.u8]): rs.u8 | undefined => { + return rs.u8CheckedSub(_2578[0], _2578[1]); })) & 0xff); } else if (_2179 === 2) { - rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2734: rs.u8): rs.u8 => { - const x151: rs.u8 = _2734; + rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2546: rs.u8): rs.u8 => { + const x121: rs.u8 = _2546; const _6153: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6153.value, x151 ^ 11); + rs.byteVecPush(_6153.value, x121 ^ 11); rs.refMutRelease(_6153); - return x151; - }), (_2739: rs.u8): boolean => { + return x121; + }), (_2556: rs.u8): boolean => { return true; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2744: rs.u8): rs.u8 => { - const x152: rs.u8 = _2744; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2564: rs.u8): rs.u8 => { + const x122: rs.u8 = _2564; const _6154: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6154.value, x152 ^ 12); + rs.byteVecPush(_6154.value, x122 ^ 12); rs.refMutRelease(_6154); - return x152; - })), (_2745: [rs.u8, rs.u8]): boolean => { - return _2745[0] < 128; + return x122; + })), (_2567: [rs.u8, rs.u8]): boolean => { + return _2567[0] < 128; })) & 0xff); } else if (_2179 === 3) { - rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2716: rs.u8): rs.u8 => { - const x149: rs.u8 = _2716; + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2524: rs.u8): rs.u8 => { + const x119: rs.u8 = _2524; const _6151: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6151.value, x149 ^ 11); + rs.byteVecPush(_6151.value, x119 ^ 11); rs.refMutRelease(_6151); - return x149; - }), (_2721: rs.u8): boolean => { + return x119; + }), (_2527: rs.u8): boolean => { return true; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2726: rs.u8): rs.u8 => { - const x150: rs.u8 = _2726; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2536: rs.u8): rs.u8 => { + const x120: rs.u8 = _2536; const _6152: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6152.value, x150 ^ 12); + rs.byteVecPush(_6152.value, x120 ^ 12); rs.refMutRelease(_6152); - return x150; - }))), (_2727: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { - return _2727[0] & 0xff; + return x120; + }))), (_2541: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { + return _2541[0] & 0xff; })), 238)); } else if (_2179 === 4) { - rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2696: rs.u8): rs.u8 => { - const x147: rs.u8 = _2696; + rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2515: rs.u8): rs.u8 => { + const x117: rs.u8 = _2515; const _6149: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6149.value, x147 ^ 11); + rs.byteVecPush(_6149.value, x117 ^ 11); rs.refMutRelease(_6149); - return x147; - }), (_2701: rs.u8): boolean => { + return x117; + }), (_2518: rs.u8): boolean => { return true; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2706: rs.u8): rs.u8 => { - const x148: rs.u8 = _2706; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2521: rs.u8): rs.u8 => { + const x118: rs.u8 = _2521; const _6150: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6150.value, x148 ^ 12); + rs.byteVecPush(_6150.value, x118 ^ 12); rs.refMutRelease(_6150); - return x148; + return x118; })), rs.iterSlice([[1, 2] as [rs.u8, rs.u8]]))) & 0xff); } else if (_2179 === 5) { - rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2674: rs.u8): rs.u8 => { - const x145: rs.u8 = _2674; + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2502: rs.u8): rs.u8 => { + const x115: rs.u8 = _2502; const _6147: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6147.value, x145 ^ 11); + rs.byteVecPush(_6147.value, x115 ^ 11); rs.refMutRelease(_6147); - return x145; - }), (_2679: rs.u8): boolean => { + return x115; + }), (_2510: rs.u8): boolean => { return true; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2684: rs.u8): rs.u8 => { - const x146: rs.u8 = _2684; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2513: rs.u8): rs.u8 => { + const x116: rs.u8 = _2513; const _6148: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6148.value, x146 ^ 12); + rs.byteVecPush(_6148.value, x116 ^ 12); rs.refMutRelease(_6148); - return x146; + return x116; })), n)) & 0xff); } else if (_2179 === 6) { - rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2654: rs.u8): rs.u8 => { - const x143: rs.u8 = _2654; + rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2482: rs.u8): rs.u8 => { + const x113: rs.u8 = _2482; const _6145: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6145.value, x143 ^ 11); + rs.byteVecPush(_6145.value, x113 ^ 11); rs.refMutRelease(_6145); - return x143; - }), (_2659: rs.u8): boolean => { + return x113; + }), (_2487: rs.u8): boolean => { return true; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2664: rs.u8): rs.u8 => { - const x144: rs.u8 = _2664; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2492: rs.u8): rs.u8 => { + const x114: rs.u8 = _2492; const _6146: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6146.value, x144 ^ 12); + rs.byteVecPush(_6146.value, x114 ^ 12); rs.refMutRelease(_6146); - return x144; + return x114; })), n)) & 0xff); } else { - const p6: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2633: rs.u8): rs.u8 => { - const x141: rs.u8 = _2633; + const p6: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2470: rs.u8): rs.u8 => { + const x111: rs.u8 = _2470; const _6143: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6143.value, x141 ^ 11); + rs.byteVecPush(_6143.value, x111 ^ 11); rs.refMutRelease(_6143); - return x141; - }), (_2638: rs.u8): boolean => { + return x111; + }), (_2473: rs.u8): boolean => { return true; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2643: rs.u8): rs.u8 => { - const x142: rs.u8 = _2643; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2474: rs.u8): rs.u8 => { + const x112: rs.u8 = _2474; const _6144: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6144.value, x142 ^ 12); + rs.byteVecPush(_6144.value, x112 ^ 12); rs.refMutRelease(_6144); - return x142; + return x112; }))); rs.byteVecPush(out, (rs.peekablePeek(p6) !== undefined ? 1 : 0) ^ (rs.iterCount(p6) & 0xff)); } @@ -4719,103 +4701,109 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else if ((kind & 16) === 0) { const _2298: rs.usize = rs.usizeRem(rs.usizeDiv(data.length, 8), 5); if (_2298 === 0) { - const z37: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2556: rs.u8): rs.u8 => { - const x127: rs.u8 = _2556; + const z37: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2416: rs.u8): rs.u8 => { + const x96: rs.u8 = _2416; const _6137: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6137.value, x127 ^ 13); + rs.byteVecPush(_6137.value, x96 ^ 13); rs.refMutRelease(_6137); - return x127; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2564: rs.u8): rs.u8 => { - const x128: rs.u8 = _2564; + return x96; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2424: rs.u8): rs.u8 => { + const x97: rs.u8 = _2424; const _6138: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6138.value, x128 ^ 14); + rs.byteVecPush(_6138.value, x97 ^ 14); rs.refMutRelease(_6138); - return x128; - }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2567: rs.u8): rs.u8 => { - const x129: rs.u8 = _2567; + return x97; + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2429: rs.u8): rs.u8 => { + const x98: rs.u8 = _2429; const _6139: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6139.value, x129 ^ 15); + rs.byteVecPush(_6139.value, x98 ^ 15); rs.refMutRelease(_6139); - return x129; - }), "len"), (_2569: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { - return [_2569[0][0] ^ _2569[1], _2569[0][1]] as [rs.u8, rs.u8]; + return x98; + }), "len"), (_2434: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2434[0][0] ^ _2434[1], _2434[0][1]] as [rs.u8, rs.u8]; }); + const _2320: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2444: [rs.u8, rs.u8]): rs.u8 => { + return _2444[0] ^ _2444[1]; + }; const _2321: rs.usize = rs.usizeRem(data.length, 8); if (_2321 === 0) { rs.byteVecPush(out, rs.iterCount(z37) & 0xff); } else if (_2321 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(z37), 238, (_2623: [rs.u8, rs.u8]): rs.u8 => { - return _2623[0] ^ _2623[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(z37), 238, (_2469: [rs.u8, rs.u8]): rs.u8 => { + return _2469[0] ^ _2469[1]; })); } else if (_2321 === 2) { rs.iterForEach(z37, (p17: [rs.u8, rs.u8]): undefined => { rs.byteVecPush(out, _2320(p17)); }); } else if (_2321 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(z37, (_2618: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2618[0] as rs.u32, _2618[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(z37, (_2466: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2466[0] as rs.u32, _2466[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_2321 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(z37, (_2613: [rs.u8, rs.u8]): rs.u8 => { - return _2613[0] ^ _2613[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(z37, (_2465: [rs.u8, rs.u8]): rs.u8 => { + return _2465[0] ^ _2465[1]; }), undefined, true)), undefined, true); } else if (_2321 === 5) { rs.byteVecPush(out, rs.iterFold(z37, 0, (acc5: rs.u8, p16: [rs.u8, rs.u8]): rs.u8 => { return rs.u8WrappingMul(acc5, 3) ^ _2320(p16); })); } else if (_2321 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(z37, (_2603: [rs.u8, rs.u8]): rs.u8 => { - return _2603[0] ^ _2603[1]; - }), (x137: rs.u8): boolean => { - return x137 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(z37, (_2462: [rs.u8, rs.u8]): rs.u8 => { + return _2462[0] ^ _2462[1]; + }), (x107: rs.u8): boolean => { + return x107 === 0; }) ? 1 : 0); } else { const z38: rs.Iter<[rs.u8, rs.u8]> = z37; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(z38, (_2572: [rs.u8, rs.u8]): boolean => { - return _2572[0] > _2572[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(z38, (_2452: [rs.u8, rs.u8]): boolean => { + return _2452[0] > _2452[1]; }), 238, (i6: rs.usize): rs.u8 => { return i6 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(z38, (_2575: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2575[0], 3) === 0; - }), 238, (_2578: [rs.u8, rs.u8]): rs.u8 => { - return _2578[0] ^ _2578[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(z38, (_2455: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2455[0], 3) === 0; + }), 238, (_2457: [rs.u8, rs.u8]): rs.u8 => { + return _2457[0] ^ _2457[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z38, n), 238, (_2593: [rs.u8, rs.u8]): rs.u8 => { - return _2593[0] ^ _2593[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z38, n), 238, (_2458: [rs.u8, rs.u8]): rs.u8 => { + return _2458[0] ^ _2458[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z38.next()), 238, (_2598: [rs.u8, rs.u8]): rs.u8 => { - return _2598[0] ^ _2598[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z38.next()), 238, (_2461: [rs.u8, rs.u8]): rs.u8 => { + return _2461[0] ^ _2461[1]; })); } } else if (_2298 === 1) { - const z39: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2487: rs.u8): rs.u8 => { - const x113: rs.u8 = _2487; + const z39: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2371: rs.u8): rs.u8 => { + const x81: rs.u8 = _2371; const _6131: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6131.value, x113 ^ 13); + rs.byteVecPush(_6131.value, x81 ^ 13); rs.refMutRelease(_6131); - return x113; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2492: rs.u8): rs.u8 => { - const x114: rs.u8 = _2492; + return x81; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2376: rs.u8): rs.u8 => { + const x82: rs.u8 = _2376; const _6132: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6132.value, x114 ^ 14); + rs.byteVecPush(_6132.value, x82 ^ 14); rs.refMutRelease(_6132); - return x114; - }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2502: rs.u8): rs.u8 => { - const x115: rs.u8 = _2502; + return x82; + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2386: rs.u8): rs.u8 => { + const x83: rs.u8 = _2386; const _6133: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6133.value, x115 ^ 15); + rs.byteVecPush(_6133.value, x83 ^ 15); rs.refMutRelease(_6133); - return x115; - }), "len"), (_2510: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { - return [_2510[0][0] ^ _2510[1], _2510[0][1]] as [rs.u8, rs.u8]; + return x83; + }), "len"), (_2394: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2394[0][0] ^ _2394[1], _2394[0][1]] as [rs.u8, rs.u8]; }); + const _2377: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2397: [rs.u8, rs.u8]): rs.u8 => { + return _2397[0] ^ _2397[1]; + }; const _2378: rs.usize = rs.usizeRem(data.length, 8); if (_2378 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBox(z39)) & 0xff); } else if (_2378 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z39)), 238, (_2546: [rs.u8, rs.u8]): rs.u8 => { - return _2546[0] ^ _2546[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z39)), 238, (_2415: [rs.u8, rs.u8]): rs.u8 => { + return _2415[0] ^ _2415[1]; })); } else if (_2378 === 2) { const _2385: (a0: [rs.u8, rs.u8]) => undefined = (p15: [rs.u8, rs.u8]): undefined => { @@ -4823,12 +4811,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBox(z39), _2385); } else if (_2378 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z39), (_2541: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2541[0] as rs.u32, _2541[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z39), (_2412: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2412[0] as rs.u32, _2412[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_2378 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z39), (_2536: [rs.u8, rs.u8]): rs.u8 => { - return _2536[0] ^ _2536[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z39), (_2411: [rs.u8, rs.u8]): rs.u8 => { + return _2411[0] ^ _2411[1]; }), "next")), undefined, true); } else if (_2378 === 5) { const _2393: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc4: rs.u8, p14: [rs.u8, rs.u8]): rs.u8 => { @@ -4836,58 +4824,61 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBox(z39), 0, _2393)); } else if (_2378 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z39), (_2527: [rs.u8, rs.u8]): rs.u8 => { - return _2527[0] ^ _2527[1]; - }), (x123: rs.u8): boolean => { - return x123 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z39), (_2408: [rs.u8, rs.u8]): rs.u8 => { + return _2408[0] ^ _2408[1]; + }), (x92: rs.u8): boolean => { + return x92 === 0; }) ? 1 : 0); } else { const z40: rs.Iter<[rs.u8, rs.u8]> = z39; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z40), (_2513: [rs.u8, rs.u8]): boolean => { - return _2513[0] > _2513[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z40), (_2399: [rs.u8, rs.u8]): boolean => { + return _2399[0] > _2399[1]; }), 238, (i5: rs.usize): rs.u8 => { return i5 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z40), (_2515: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2515[0], 3) === 0; - }), 238, (_2518: [rs.u8, rs.u8]): rs.u8 => { - return _2518[0] ^ _2518[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z40), (_2400: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2400[0], 3) === 0; + }), 238, (_2403: [rs.u8, rs.u8]): rs.u8 => { + return _2403[0] ^ _2403[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z40), n), 238, (_2521: [rs.u8, rs.u8]): rs.u8 => { - return _2521[0] ^ _2521[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z40), n), 238, (_2404: [rs.u8, rs.u8]): rs.u8 => { + return _2404[0] ^ _2404[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z40.next()), 238, (_2524: [rs.u8, rs.u8]): rs.u8 => { - return _2524[0] ^ _2524[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z40.next()), 238, (_2407: [rs.u8, rs.u8]): rs.u8 => { + return _2407[0] ^ _2407[1]; })); } } else if (_2298 === 2) { - const z41: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2452: rs.u8): rs.u8 => { - const x99: rs.u8 = _2452; + const z41: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2329: rs.u8): rs.u8 => { + const x66: rs.u8 = _2329; const _6125: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6125.value, x99 ^ 13); + rs.byteVecPush(_6125.value, x66 ^ 13); rs.refMutRelease(_6125); - return x99; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2455: rs.u8): rs.u8 => { - const x100: rs.u8 = _2455; + return x66; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2337: rs.u8): rs.u8 => { + const x67: rs.u8 = _2337; const _6126: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6126.value, x100 ^ 14); + rs.byteVecPush(_6126.value, x67 ^ 14); rs.refMutRelease(_6126); - return x100; - }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2457: rs.u8): rs.u8 => { - const x101: rs.u8 = _2457; + return x67; + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2340: rs.u8): rs.u8 => { + const x68: rs.u8 = _2340; const _6127: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6127.value, x101 ^ 15); + rs.byteVecPush(_6127.value, x68 ^ 15); rs.refMutRelease(_6127); - return x101; - }), "len"), (_2458: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { - return [_2458[0][0] ^ _2458[1], _2458[0][1]] as [rs.u8, rs.u8]; + return x68; + }), "len"), (_2342: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2342[0][0] ^ _2342[1], _2342[0][1]] as [rs.u8, rs.u8]; }), n); + const _2435: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2343: [rs.u8, rs.u8]): rs.u8 => { + return _2343[0] ^ _2343[1]; + }; const _2436: rs.usize = rs.usizeRem(data.length, 8); if (_2436 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBox(z41)) & 0xff); } else if (_2436 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z41)), 238, (_2482: [rs.u8, rs.u8]): rs.u8 => { - return _2482[0] ^ _2482[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z41)), 238, (_2366: [rs.u8, rs.u8]): rs.u8 => { + return _2366[0] ^ _2366[1]; })); } else if (_2436 === 2) { const _2443: (a0: [rs.u8, rs.u8]) => undefined = (p13: [rs.u8, rs.u8]): undefined => { @@ -4895,12 +4886,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBox(z41), _2443); } else if (_2436 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z41), (_2474: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2474[0] as rs.u32, _2474[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z41), (_2359: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2359[0] as rs.u32, _2359[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_2436 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z41), (_2473: [rs.u8, rs.u8]): rs.u8 => { - return _2473[0] ^ _2473[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z41), (_2358: [rs.u8, rs.u8]): rs.u8 => { + return _2358[0] ^ _2358[1]; }), "next")), undefined, true); } else if (_2436 === 5) { const _2451: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc3: rs.u8, p12: [rs.u8, rs.u8]): rs.u8 => { @@ -4908,58 +4899,61 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBox(z41), 0, _2451)); } else if (_2436 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z41), (_2470: [rs.u8, rs.u8]): rs.u8 => { - return _2470[0] ^ _2470[1]; - }), (x109: rs.u8): boolean => { - return x109 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z41), (_2355: [rs.u8, rs.u8]): rs.u8 => { + return _2355[0] ^ _2355[1]; + }), (x77: rs.u8): boolean => { + return x77 === 0; }) ? 1 : 0); } else { const z42: rs.Iter<[rs.u8, rs.u8]> = z41; - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z42), (_2461: [rs.u8, rs.u8]): boolean => { - return _2461[0] > _2461[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z42), (_2346: [rs.u8, rs.u8]): boolean => { + return _2346[0] > _2346[1]; }), 238, (i4: rs.usize): rs.u8 => { return i4 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z42), (_2462: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2462[0], 3) === 0; - }), 238, (_2465: [rs.u8, rs.u8]): rs.u8 => { - return _2465[0] ^ _2465[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z42), (_2347: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2347[0], 3) === 0; + }), 238, (_2350: [rs.u8, rs.u8]): rs.u8 => { + return _2350[0] ^ _2350[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z42), n), 238, (_2466: [rs.u8, rs.u8]): rs.u8 => { - return _2466[0] ^ _2466[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z42), n), 238, (_2351: [rs.u8, rs.u8]): rs.u8 => { + return _2351[0] ^ _2351[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z42.next()), 238, (_2469: [rs.u8, rs.u8]): rs.u8 => { - return _2469[0] ^ _2469[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z42.next()), 238, (_2354: [rs.u8, rs.u8]): rs.u8 => { + return _2354[0] ^ _2354[1]; })); } } else if (_2298 === 3) { - const _2475: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2400: rs.u8): rs.u8 => { - const x85: rs.u8 = _2400; + const _2475: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2262: rs.u8): rs.u8 => { + const x51: rs.u8 = _2262; const _6119: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6119.value, x85 ^ 13); + rs.byteVecPush(_6119.value, x51 ^ 13); rs.refMutRelease(_6119); - return x85; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2403: rs.u8): rs.u8 => { - const x86: rs.u8 = _2403; + return x51; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2271: rs.u8): rs.u8 => { + const x52: rs.u8 = _2271; const _6120: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6120.value, x86 ^ 14); + rs.byteVecPush(_6120.value, x52 ^ 14); rs.refMutRelease(_6120); - return x86; - }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2404: rs.u8): rs.u8 => { - const x87: rs.u8 = _2404; + return x52; + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2275: rs.u8): rs.u8 => { + const x53: rs.u8 = _2275; const _6121: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6121.value, x87 ^ 15); + rs.byteVecPush(_6121.value, x53 ^ 15); rs.refMutRelease(_6121); - return x87; - }), "len"), (_2407: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { - return [_2407[0][0] ^ _2407[1], _2407[0][1]] as [rs.u8, rs.u8]; + return x53; + }), "len"), (_2276: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2276[0][0] ^ _2276[1], _2276[0][1]] as [rs.u8, rs.u8]; }); + const _2493: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2282: [rs.u8, rs.u8]): rs.u8 => { + return _2282[0] ^ _2282[1]; + }; const _2494: rs.usize = rs.usizeRem(data.length, 8); if (_2494 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2475)))) & 0xff); } else if (_2494 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2475)))), 238, (_2444: [rs.u8, rs.u8]): rs.u8 => { - return _2444[0] ^ _2444[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2475)))), 238, (_2319: [rs.u8, rs.u8]): rs.u8 => { + return _2319[0] ^ _2319[1]; })); } else if (_2494 === 2) { const _2501: (a0: [rs.u8, rs.u8]) => undefined = (p11: [rs.u8, rs.u8]): undefined => { @@ -4967,12 +4961,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2475))), _2501); } else if (_2494 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2475))), (_2434: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2434[0] as rs.u32, _2434[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2475))), (_2314: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2314[0] as rs.u32, _2314[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_2494 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2475))), (_2429: [rs.u8, rs.u8]): rs.u8 => { - return _2429[0] ^ _2429[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2475))), (_2309: [rs.u8, rs.u8]): rs.u8 => { + return _2309[0] ^ _2309[1]; }), "next")), undefined, true); } else if (_2494 === 5) { const _2509: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc2: rs.u8, p10: [rs.u8, rs.u8]): rs.u8 => { @@ -4980,57 +4974,60 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2475))), 0, _2509)); } else if (_2494 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2475))), (_2424: [rs.u8, rs.u8]): rs.u8 => { - return _2424[0] ^ _2424[1]; - }), (x95: rs.u8): boolean => { - return x95 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2475))), (_2303: [rs.u8, rs.u8]): rs.u8 => { + return _2303[0] ^ _2303[1]; + }), (x62: rs.u8): boolean => { + return x62 === 0; }) ? 1 : 0); } else { - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_2475), (_2408: [rs.u8, rs.u8]): boolean => { - return _2408[0] > _2408[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_2475), (_2286: [rs.u8, rs.u8]): boolean => { + return _2286[0] > _2286[1]; }), 238, (i3: rs.usize): rs.u8 => { return i3 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_2475), (_2411: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2411[0], 3) === 0; - }), 238, (_2412: [rs.u8, rs.u8]): rs.u8 => { - return _2412[0] ^ _2412[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_2475), (_2287: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2287[0], 3) === 0; + }), 238, (_2289: [rs.u8, rs.u8]): rs.u8 => { + return _2289[0] ^ _2289[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_2475), n), 238, (_2415: [rs.u8, rs.u8]): rs.u8 => { - return _2415[0] ^ _2415[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_2475), n), 238, (_2291: [rs.u8, rs.u8]): rs.u8 => { + return _2291[0] ^ _2291[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_2475.next()), 238, (_2416: [rs.u8, rs.u8]): rs.u8 => { - return _2416[0] ^ _2416[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_2475.next()), 238, (_2292: [rs.u8, rs.u8]): rs.u8 => { + return _2292[0] ^ _2292[1]; })); } } else { - const _2528: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2350: rs.u8): rs.u8 => { - const x71: rs.u8 = _2350; + const _2528: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2170: rs.u8): rs.u8 => { + const x36: rs.u8 = _2170; const _6113: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6113.value, x71 ^ 13); + rs.byteVecPush(_6113.value, x36 ^ 13); rs.refMutRelease(_6113); - return x71; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2351: rs.u8): rs.u8 => { - const x72: rs.u8 = _2351; + return x36; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2173: rs.u8): rs.u8 => { + const x37: rs.u8 = _2173; const _6114: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6114.value, x72 ^ 14); + rs.byteVecPush(_6114.value, x37 ^ 14); rs.refMutRelease(_6114); - return x72; - }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2354: rs.u8): rs.u8 => { - const x73: rs.u8 = _2354; + return x37; + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2176: rs.u8): rs.u8 => { + const x38: rs.u8 = _2176; const _6115: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6115.value, x73 ^ 15); + rs.byteVecPush(_6115.value, x38 ^ 15); rs.refMutRelease(_6115); - return x73; - }), "len"), (_2355: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { - return [_2355[0][0] ^ _2355[1], _2355[0][1]] as [rs.u8, rs.u8]; + return x38; + }), "len"), (_2190: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2190[0][0] ^ _2190[1], _2190[0][1]] as [rs.u8, rs.u8]; }), n); + const _2547: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2194: [rs.u8, rs.u8]): rs.u8 => { + return _2194[0] ^ _2194[1]; + }; const _2548: rs.usize = rs.usizeRem(data.length, 8); if (_2548 === 0) { rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2528)))) & 0xff); } else if (_2548 === 1) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2528)))), 238, (_2399: [rs.u8, rs.u8]): rs.u8 => { - return _2399[0] ^ _2399[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2528)))), 238, (_2258: [rs.u8, rs.u8]): rs.u8 => { + return _2258[0] ^ _2258[1]; })); } else if (_2548 === 2) { const _2555: (a0: [rs.u8, rs.u8]) => undefined = (p9: [rs.u8, rs.u8]): undefined => { @@ -5038,12 +5035,12 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2528))), _2555); } else if (_2548 === 3) { - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2528))), (_2397: [rs.u8, rs.u8]): rs.u32 => { - return rs.u32Add(_2397[0] as rs.u32, _2397[1] as rs.u32); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2528))), (_2247: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2247[0] as rs.u32, _2247[1] as rs.u32); }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_2548 === 4) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2528))), (_2394: [rs.u8, rs.u8]): rs.u8 => { - return _2394[0] ^ _2394[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2528))), (_2243: [rs.u8, rs.u8]): rs.u8 => { + return _2243[0] ^ _2243[1]; }), "next")), undefined, true); } else if (_2548 === 5) { const _2563: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc: rs.u8, p8: [rs.u8, rs.u8]): rs.u8 => { @@ -5051,215 +5048,215 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2528))), 0, _2563)); } else if (_2548 === 6) { - rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2528))), (_2386: [rs.u8, rs.u8]): rs.u8 => { - return _2386[0] ^ _2386[1]; - }), (x81: rs.u8): boolean => { - return x81 === 0; + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2528))), (_2234: [rs.u8, rs.u8]): rs.u8 => { + return _2234[0] ^ _2234[1]; + }), (x47: rs.u8): boolean => { + return x47 === 0; }) ? 1 : 0); } else { - rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_2528), (_2358: [rs.u8, rs.u8]): boolean => { - return _2358[0] > _2358[1]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_2528), (_2203: [rs.u8, rs.u8]): boolean => { + return _2203[0] > _2203[1]; }), 238, (i2: rs.usize): rs.u8 => { return i2 & 0xff; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_2528), (_2359: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2359[0], 3) === 0; - }), 238, (_2366: [rs.u8, rs.u8]): rs.u8 => { - return _2366[0] ^ _2366[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_2528), (_2207: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2207[0], 3) === 0; + }), 238, (_2216: [rs.u8, rs.u8]): rs.u8 => { + return _2216[0] ^ _2216[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_2528), n), 238, (_2371: [rs.u8, rs.u8]): rs.u8 => { - return _2371[0] ^ _2371[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_2528), n), 238, (_2220: [rs.u8, rs.u8]): rs.u8 => { + return _2220[0] ^ _2220[1]; })); - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_2528.next()), 238, (_2376: [rs.u8, rs.u8]): rs.u8 => { - return _2376[0] ^ _2376[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_2528.next()), 238, (_2230: [rs.u8, rs.u8]): rs.u8 => { + return _2230[0] ^ _2230[1]; })); } } } else { const _2581: rs.usize = rs.usizeRem(data.length, 8); if (_2581 === 0) { - rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2340: rs.u8): rs.u8 => { - const x66: rs.u8 = _2340; + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2144: rs.u8): rs.u8 => { + const x31: rs.u8 = _2144; const _6109: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6109.value, x66 ^ 13); + rs.byteVecPush(_6109.value, x31 ^ 13); rs.refMutRelease(_6109); - return x66; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2342: rs.u8): rs.u8 => { - const x67: rs.u8 = _2342; + return x31; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2154: rs.u8): rs.u8 => { + const x32: rs.u8 = _2154; const _6110: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6110.value, x67 ^ 14); + rs.byteVecPush(_6110.value, x32 ^ 14); rs.refMutRelease(_6110); - return x67; - }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2343: rs.u8): rs.u8 => { - const x68: rs.u8 = _2343; + return x32; + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2162: rs.u8): rs.u8 => { + const x33: rs.u8 = _2162; const _6111: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6111.value, x68 ^ 15); + rs.byteVecPush(_6111.value, x33 ^ 15); rs.refMutRelease(_6111); - return x68; - }), "len"), (_2346: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { - return [_2346[0][0] ^ _2346[1], _2346[0][1]] as [rs.u8, rs.u8]; - }), (_2347: [rs.u8, rs.u8]): boolean => { - return rs.u8Rem(_2347[0], 2) === 0; + return x33; + }), "len"), (_2165: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2165[0][0] ^ _2165[1], _2165[0][1]] as [rs.u8, rs.u8]; + }), (_2167: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2167[0], 2) === 0; })) & 0xff); } else if (_2581 === 1) { - rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2309: rs.u8): rs.u8 => { - const x61: rs.u8 = _2309; + rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2123: rs.u8): rs.u8 => { + const x26: rs.u8 = _2123; const _6105: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6105.value, x61 ^ 13); + rs.byteVecPush(_6105.value, x26 ^ 13); rs.refMutRelease(_6105); - return x61; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2314: rs.u8): rs.u8 => { - const x62: rs.u8 = _2314; + return x26; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2126: rs.u8): rs.u8 => { + const x27: rs.u8 = _2126; const _6106: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6106.value, x62 ^ 14); + rs.byteVecPush(_6106.value, x27 ^ 14); rs.refMutRelease(_6106); - return x62; - }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2319: rs.u8): rs.u8 => { - const x63: rs.u8 = _2319; + return x27; + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2129: rs.u8): rs.u8 => { + const x28: rs.u8 = _2129; const _6107: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6107.value, x63 ^ 15); + rs.byteVecPush(_6107.value, x28 ^ 15); rs.refMutRelease(_6107); - return x63; - }), "len"), (_2329: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { - return [_2329[0][0] ^ _2329[1], _2329[0][1]] as [rs.u8, rs.u8]; - }), (_2337: [rs.u8, rs.u8]): rs.u8 | undefined => { - return rs.u8CheckedSub(_2337[0], _2337[1]); + return x28; + }), "len"), (_2132: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2132[0][0] ^ _2132[1], _2132[0][1]] as [rs.u8, rs.u8]; + }), (_2140: [rs.u8, rs.u8]): rs.u8 | undefined => { + return rs.u8CheckedSub(_2140[0], _2140[1]); })) & 0xff); } else if (_2581 === 2) { - rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2287: rs.u8): rs.u8 => { - const x56: rs.u8 = _2287; + rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_296: rs.u8): rs.u8 => { + const x21: rs.u8 = _296; const _6101: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6101.value, x56 ^ 13); + rs.byteVecPush(_6101.value, x21 ^ 13); rs.refMutRelease(_6101); - return x56; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2289: rs.u8): rs.u8 => { - const x57: rs.u8 = _2289; + return x21; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2107: rs.u8): rs.u8 => { + const x22: rs.u8 = _2107; const _6102: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6102.value, x57 ^ 14); + rs.byteVecPush(_6102.value, x22 ^ 14); rs.refMutRelease(_6102); - return x57; - }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2291: rs.u8): rs.u8 => { - const x58: rs.u8 = _2291; + return x22; + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2115: rs.u8): rs.u8 => { + const x23: rs.u8 = _2115; const _6103: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_6103.value, x58 ^ 15); + rs.byteVecPush(_6103.value, x23 ^ 15); rs.refMutRelease(_6103); - return x58; - }), "len"), (_2292: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { - return [_2292[0][0] ^ _2292[1], _2292[0][1]] as [rs.u8, rs.u8]; - }), (_2303: [rs.u8, rs.u8]): boolean => { - return _2303[0] < 128; + return x23; + }), "len"), (_2118: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2118[0][0] ^ _2118[1], _2118[0][1]] as [rs.u8, rs.u8]; + }), (_2120: [rs.u8, rs.u8]): boolean => { + return _2120[0] < 128; })) & 0xff); } else if (_2581 === 3) { - rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2271: rs.u8): rs.u8 => { - const x52: rs.u8 = _2271; + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_265: rs.u8): rs.u8 => { + const x17: rs.u8 = _265; const _682: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_682.value, x52 ^ 13); + rs.byteVecPush(_682.value, x17 ^ 13); rs.refMutRelease(_682); - return x52; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2275: rs.u8): rs.u8 => { - const x53: rs.u8 = _2275; + return x17; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_268: rs.u8): rs.u8 => { + const x18: rs.u8 = _268; const _692: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_692.value, x53 ^ 14); + rs.byteVecPush(_692.value, x18 ^ 14); rs.refMutRelease(_692); - return x53; - }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2276: rs.u8): rs.u8 => { - const x54: rs.u8 = _2276; + return x18; + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_271: rs.u8): rs.u8 => { + const x19: rs.u8 = _271; const _697: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_697.value, x54 ^ 15); + rs.byteVecPush(_697.value, x19 ^ 15); rs.refMutRelease(_697); - return x54; - }), "len"), (_2282: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { - return [_2282[0][0] ^ _2282[1], _2282[0][1]] as [rs.u8, rs.u8]; - })), (_2286: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { - return _2286[0] & 0xff; + return x19; + }), "len"), (_284: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_284[0][0] ^ _284[1], _284[0][1]] as [rs.u8, rs.u8]; + })), (_288: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { + return _288[0] & 0xff; })), 238)); } else if (_2581 === 4) { - rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2243: rs.u8): rs.u8 => { - const x48: rs.u8 = _2243; + rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_249: rs.u8): rs.u8 => { + const x13: rs.u8 = _249; const _654: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_654.value, x48 ^ 13); + rs.byteVecPush(_654.value, x13 ^ 13); rs.refMutRelease(_654); - return x48; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2247: rs.u8): rs.u8 => { - const x49: rs.u8 = _2247; + return x13; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_257: rs.u8): rs.u8 => { + const x14: rs.u8 = _257; const _663: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_663.value, x49 ^ 14); + rs.byteVecPush(_663.value, x14 ^ 14); rs.refMutRelease(_663); - return x49; - }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2258: rs.u8): rs.u8 => { - const x50: rs.u8 = _2258; + return x14; + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_260: rs.u8): rs.u8 => { + const x15: rs.u8 = _260; const _668: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_668.value, x50 ^ 15); + rs.byteVecPush(_668.value, x15 ^ 15); rs.refMutRelease(_668); - return x50; - }), "len"), (_2262: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { - return [_2262[0][0] ^ _2262[1], _2262[0][1]] as [rs.u8, rs.u8]; + return x15; + }), "len"), (_262: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_262[0][0] ^ _262[1], _262[0][1]] as [rs.u8, rs.u8]; }), rs.iterSlice([[1, 2] as [rs.u8, rs.u8]]))) & 0xff); } else if (_2581 === 5) { - rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2216: rs.u8): rs.u8 => { - const x44: rs.u8 = _2216; + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_225: rs.u8): rs.u8 => { + const x9: rs.u8 = _225; const _629: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_629.value, x44 ^ 13); + rs.byteVecPush(_629.value, x9 ^ 13); rs.refMutRelease(_629); - return x44; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2220: rs.u8): rs.u8 => { - const x45: rs.u8 = _2220; + return x9; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_228: rs.u8): rs.u8 => { + const x10: rs.u8 = _228; const _632: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_632.value, x45 ^ 14); + rs.byteVecPush(_632.value, x10 ^ 14); rs.refMutRelease(_632); - return x45; - }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2230: rs.u8): rs.u8 => { - const x46: rs.u8 = _2230; + return x10; + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_235: rs.u8): rs.u8 => { + const x11: rs.u8 = _235; const _635: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_635.value, x46 ^ 15); + rs.byteVecPush(_635.value, x11 ^ 15); rs.refMutRelease(_635); - return x46; - }), "len"), (_2234: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { - return [_2234[0][0] ^ _2234[1], _2234[0][1]] as [rs.u8, rs.u8]; + return x11; + }), "len"), (_239: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_239[0][0] ^ _239[1], _239[0][1]] as [rs.u8, rs.u8]; }), n)) & 0xff); } else if (_2581 === 6) { - rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2190: rs.u8): rs.u8 => { - const x40: rs.u8 = _2190; + rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_214: rs.u8): rs.u8 => { + const x5: rs.u8 = _214; const _613: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_613.value, x40 ^ 13); + rs.byteVecPush(_613.value, x5 ^ 13); rs.refMutRelease(_613); - return x40; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2194: rs.u8): rs.u8 => { - const x41: rs.u8 = _2194; + return x5; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_216: rs.u8): rs.u8 => { + const x6: rs.u8 = _216; const _621: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_621.value, x41 ^ 14); + rs.byteVecPush(_621.value, x6 ^ 14); rs.refMutRelease(_621); - return x41; - }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2203: rs.u8): rs.u8 => { - const x42: rs.u8 = _2203; + return x6; + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_219: rs.u8): rs.u8 => { + const x7: rs.u8 = _219; const _624: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_624.value, x42 ^ 15); + rs.byteVecPush(_624.value, x7 ^ 15); rs.refMutRelease(_624); - return x42; - }), "len"), (_2207: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { - return [_2207[0][0] ^ _2207[1], _2207[0][1]] as [rs.u8, rs.u8]; + return x7; + }), "len"), (_222: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_222[0][0] ^ _222[1], _222[0][1]] as [rs.u8, rs.u8]; }), n)) & 0xff); } else { - const p7: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2167: rs.u8): rs.u8 => { - const x36: rs.u8 = _2167; + const p7: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_23: rs.u8): rs.u8 => { + const x: rs.u8 = _23; const _62: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_62.value, x36 ^ 13); + rs.byteVecPush(_62.value, x ^ 13); rs.refMutRelease(_62); - return x36; - }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2170: rs.u8): rs.u8 => { - const x37: rs.u8 = _2170; + return x; + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_25: rs.u8): rs.u8 => { + const x2: rs.u8 = _25; const _65: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_65.value, x37 ^ 14); + rs.byteVecPush(_65.value, x2 ^ 14); rs.refMutRelease(_65); - return x37; - }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2173: rs.u8): rs.u8 => { - const x38: rs.u8 = _2173; + return x2; + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_27: rs.u8): rs.u8 => { + const x3: rs.u8 = _27; const _67: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_67.value, x38 ^ 15); + rs.byteVecPush(_67.value, x3 ^ 15); rs.refMutRelease(_67); - return x38; - }), "len"), (_2176: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { - return [_2176[0][0] ^ _2176[1], _2176[0][1]] as [rs.u8, rs.u8]; + return x3; + }), "len"), (_211: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_211[0][0] ^ _211[1], _211[0][1]] as [rs.u8, rs.u8]; })); rs.byteVecPush(out, (rs.peekablePeek(p7) !== undefined ? 1 : 0) ^ (rs.iterCount(p7) & 0xff)); } @@ -5276,38 +5273,29 @@ export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { * reads no item it never yields from a side that does not log, nor through `nth` it skips. */ export function zipsBack(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _20: (a0: rs.ByteSlice) => rs.u8 = (c: rs.ByteSlice): rs.u8 => { - return c.length & 0xff; - }; - const _30: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2: [rs.u8, rs.u8]): rs.u8 => { - return _2[0] ^ _2[1]; - }; - const _79: (a0: [rs.u8, [rs.u8, rs.usize]]) => rs.u8 = (_23: [rs.u8, [rs.u8, rs.usize]]): rs.u8 => { - return _23[0] ^ _23[1][0] ^ (_23[1][1] & 0xff); - }; - const _127: (a0: [rs.u8, rs.u8]) => rs.u8 = (_27: [rs.u8, rs.u8]): rs.u8 => { - return _27[0] ^ _27[1]; - }; - const _176: (a0: [rs.u8, rs.u8]) => rs.u8 = (_210: [rs.u8, rs.u8]): rs.u8 => { - return _210[0] ^ _210[1]; - }; - const split: rs.usize = rs.usizeRem(option_mapOr$1d4bp7c(rs.byteSliceFirst(data), 0, (_211: rs.u8): rs.usize => { - return _211 as rs.usize; + const split: rs.usize = rs.usizeRem(option_mapOr$1d4bp7c(rs.byteSliceFirst(data), 0, (_2: rs.u8): rs.usize => { + return _2 as rs.usize; }), rs.usizeAdd(data.length, 1)); if (split > data.length) { rs.panic("mid > len"); } const n: rs.usize = kind >> 5 as rs.usize; const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const _20: (a0: rs.ByteSlice) => rs.u8 = (c: rs.ByteSlice): rs.u8 => { + return c.length & 0xff; + }; const _21: rs.u8 = rs.u8Rem(kind, 8); if (_21 === 0) { - const z: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start, split))), (_262: rs.u8): rs.u8 => { - const x25: rs.u8 = _262; + const z: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start, split))), (_261: rs.u8): rs.u8 => { + const x24: rs.u8 = _261; const _621: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_621.value, x25 ^ 1); + rs.byteVecPush(_621.value, x24 ^ 1); rs.refMutRelease(_621); - return x25; + return x24; }), rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start + split, data.length - split))), [true, false]); + const _30: (a0: [rs.u8, rs.u8]) => rs.u8 = (_262: [rs.u8, rs.u8]): rs.u8 => { + return _262[0] ^ _262[1]; + }; if ((kind & 8) !== 0) { rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z.next()), 238, (_263: [rs.u8, rs.u8]): rs.u8 => { return _263[0] ^ _263[1]; @@ -5339,21 +5327,24 @@ export function zipsBack(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return _271[0] ^ _271[1]; })); } else if (_21 === 1) { - const z2: rs.Iter<[rs.u8, [rs.u8, rs.usize]]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start, split))), rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start + split, data.length - split))), (_248: rs.u8): rs.u8 => { - const x20: rs.u8 = _248; - const _616: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_616.value, x20 ^ 2); - rs.refMutRelease(_616); - return x20; + const z2: rs.Iter<[rs.u8, [rs.u8, rs.usize]]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start, split))), rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start + split, data.length - split))), (_245: rs.u8): rs.u8 => { + const x18: rs.u8 = _245; + const _615: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_615.value, x18 ^ 2); + rs.refMutRelease(_615); + return x18; }), new rs.Range(0, data.length), [true, false]), [false, true]); + const _79: (a0: [rs.u8, [rs.u8, rs.usize]]) => rs.u8 = (_247: [rs.u8, [rs.u8, rs.usize]]): rs.u8 => { + return _247[0] ^ _247[1][0] ^ (_247[1][1] & 0xff); + }; if ((kind & 8) !== 0) { - rs.byteVecPush(out, option_mapOr$1r07vli(rs.iterToOption(z2.next()), 238, (_254: [rs.u8, [rs.u8, rs.usize]]): rs.u8 => { - return _254[0] ^ _254[1][0] ^ (_254[1][1] & 0xff); + rs.byteVecPush(out, option_mapOr$1r07vli(rs.iterToOption(z2.next()), 238, (_248: [rs.u8, [rs.u8, rs.usize]]): rs.u8 => { + return _248[0] ^ _248[1][0] ^ (_248[1][1] & 0xff); })); } if ((kind & 16) !== 0) { - rs.byteVecPush(out, option_mapOr$1r07vli(rs.iterNth(z2, n), 238, (_257: [rs.u8, [rs.u8, rs.usize]]): rs.u8 => { - return _257[0] ^ _257[1][0] ^ (_257[1][1] & 0xff); + rs.byteVecPush(out, option_mapOr$1r07vli(rs.iterNth(z2, n), 238, (_254: [rs.u8, [rs.u8, rs.usize]]): rs.u8 => { + return _254[0] ^ _254[1][0] ^ (_254[1][1] & 0xff); })); } while (true) { @@ -5365,39 +5356,42 @@ export function zipsBack(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return u7 & 0xff; }))), undefined, true); if ((kind & 24) === 24) { - rs.byteVecPush(out, option_mapOr$1r07vli(rs.iterToOption(z2.next()), 238, (_258: [rs.u8, [rs.u8, rs.usize]]): rs.u8 => { - return _258[0] ^ _258[1][0] ^ (_258[1][1] & 0xff); + rs.byteVecPush(out, option_mapOr$1r07vli(rs.iterToOption(z2.next()), 238, (_257: [rs.u8, [rs.u8, rs.usize]]): rs.u8 => { + return _257[0] ^ _257[1][0] ^ (_257[1][1] & 0xff); })); } } else { break; } } - rs.byteVecPush(out, option_mapOr$1r07vli(rs.iterToOption(z2.next()), 238, (_261: [rs.u8, [rs.u8, rs.usize]]): rs.u8 => { - return _261[0] ^ _261[1][0] ^ (_261[1][1] & 0xff); + rs.byteVecPush(out, option_mapOr$1r07vli(rs.iterToOption(z2.next()), 238, (_258: [rs.u8, [rs.u8, rs.usize]]): rs.u8 => { + return _258[0] ^ _258[1][0] ^ (_258[1][1] & 0xff); })); } else if (_21 === 2) { - const z3: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start, split))), (_239: rs.u8): rs.u8 => { - const x14: rs.u8 = _239; + const z3: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start, split))), (_235: rs.u8): rs.u8 => { + const x11: rs.u8 = _235; + const _613: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_613.value, x11 ^ 3); + rs.refMutRelease(_613); + return x11; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start + split, data.length - split))), (_237: rs.u8): rs.u8 => { + const x12: rs.u8 = _237; const _614: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_614.value, x14 ^ 3); + rs.byteVecPush(_614.value, x12 ^ 4); rs.refMutRelease(_614); - return x14; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start + split, data.length - split))), (_240: rs.u8): rs.u8 => { - const x15: rs.u8 = _240; - const _615: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_615.value, x15 ^ 4); - rs.refMutRelease(_615); - return x15; + return x12; }), [true, true]); + const _127: (a0: [rs.u8, rs.u8]) => rs.u8 = (_238: [rs.u8, rs.u8]): rs.u8 => { + return _238[0] ^ _238[1]; + }; if ((kind & 8) !== 0) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z3.next()), 238, (_242: [rs.u8, rs.u8]): rs.u8 => { - return _242[0] ^ _242[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z3.next()), 238, (_239: [rs.u8, rs.u8]): rs.u8 => { + return _239[0] ^ _239[1]; })); } if ((kind & 16) !== 0) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z3, n), 238, (_244: [rs.u8, rs.u8]): rs.u8 => { - return _244[0] ^ _244[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z3, n), 238, (_240: [rs.u8, rs.u8]): rs.u8 => { + return _240[0] ^ _240[1]; })); } while (true) { @@ -5409,39 +5403,42 @@ export function zipsBack(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return u6 & 0xff; }))), undefined, true); if ((kind & 24) === 24) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z3.next()), 238, (_245: [rs.u8, rs.u8]): rs.u8 => { - return _245[0] ^ _245[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z3.next()), 238, (_242: [rs.u8, rs.u8]): rs.u8 => { + return _242[0] ^ _242[1]; })); } } else { break; } } - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z3.next()), 238, (_247: [rs.u8, rs.u8]): rs.u8 => { - return _247[0] ^ _247[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z3.next()), 238, (_244: [rs.u8, rs.u8]): rs.u8 => { + return _244[0] ^ _244[1]; })); } else if (_21 === 3) { - const z4: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start, split)))), (_226: rs.u8): rs.u8 => { - const x8: rs.u8 = _226; + const z4: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start, split)))), (_215: rs.u8): rs.u8 => { + const x4: rs.u8 = _215; + const _611: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_611.value, x4 ^ 5); + rs.refMutRelease(_611); + return x4; + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start + split, data.length - split))), (_216: rs.u8): rs.u8 => { + const x5: rs.u8 = _216; const _612: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_612.value, x8 ^ 5); + rs.byteVecPush(_612.value, x5 ^ 6); rs.refMutRelease(_612); - return x8; - }), rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start + split, data.length - split))), (_229: rs.u8): rs.u8 => { - const x9: rs.u8 = _229; - const _613: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_613.value, x9 ^ 6); - rs.refMutRelease(_613); - return x9; + return x5; }), "len"); + const _176: (a0: [rs.u8, rs.u8]) => rs.u8 = (_217: [rs.u8, rs.u8]): rs.u8 => { + return _217[0] ^ _217[1]; + }; if ((kind & 8) !== 0) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z4.next()), 238, (_232: [rs.u8, rs.u8]): rs.u8 => { - return _232[0] ^ _232[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z4.next()), 238, (_223: [rs.u8, rs.u8]): rs.u8 => { + return _223[0] ^ _223[1]; })); } if ((kind & 16) !== 0) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z4, n), 238, (_235: [rs.u8, rs.u8]): rs.u8 => { - return _235[0] ^ _235[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z4, n), 238, (_226: [rs.u8, rs.u8]): rs.u8 => { + return _226[0] ^ _226[1]; })); } while (true) { @@ -5453,20 +5450,20 @@ export function zipsBack(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return u5 & 0xff; }))), undefined, true); if ((kind & 24) === 24) { - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z4.next()), 238, (_237: [rs.u8, rs.u8]): rs.u8 => { - return _237[0] ^ _237[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z4.next()), 238, (_229: [rs.u8, rs.u8]): rs.u8 => { + return _229[0] ^ _229[1]; })); } } else { break; } } - rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z4.next()), 238, (_238: [rs.u8, rs.u8]): rs.u8 => { - return _238[0] ^ _238[1]; + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z4.next()), 238, (_232: [rs.u8, rs.u8]): rs.u8 => { + return _232[0] ^ _232[1]; })); } else if (_21 === 4) { - const at: (a0: [rs.usize, [rs.u8, rs.ByteSlice]]) => rs.u8 = (_223: [rs.usize, [rs.u8, rs.ByteSlice]]): rs.u8 => { - return (_223[0] & 0xff) ^ _223[1][0] ^ _20(_223[1][1]); + const at: (a0: [rs.usize, [rs.u8, rs.ByteSlice]]) => rs.u8 = (_214: [rs.usize, [rs.u8, rs.ByteSlice]]): rs.u8 => { + return (_214[0] & 0xff) ^ _214[1][0] ^ _20(_214[1][1]); }; const z5: rs.Iter<[rs.usize, [rs.u8, rs.ByteSlice]]> = rs.iterZip(new rs.Range(0, split), rs.iterZip(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start + split, data.length - split))), rs.byteSliceChunks(data, 2), [false, false]), [false, false]); const at2: (a0: [rs.usize, [rs.u8, rs.ByteSlice]]) => rs.u8 = at; @@ -5493,10 +5490,10 @@ export function zipsBack(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } rs.byteVecPush(out, option_mapOr$17ts8jj(rs.iterToOption(z5.next()), 238, at2)); } else if (_21 === 5) { - const at3: (a0: [rs.ByteSlice, [rs.usize, rs.u8]]) => rs.u8 = (_217: [rs.ByteSlice, [rs.usize, rs.u8]]): rs.u8 => { - const i4: rs.usize = _217[1][0]; - const y5: rs.u8 = _217[1][1]; - return _20(_217[0]) ^ (i4 & 0xff) ^ y5; + const at3: (a0: [rs.ByteSlice, [rs.usize, rs.u8]]) => rs.u8 = (_211: [rs.ByteSlice, [rs.usize, rs.u8]]): rs.u8 => { + const i3: rs.usize = _211[1][0]; + const y: rs.u8 = _211[1][1]; + return _20(_211[0]) ^ (i3 & 0xff) ^ y; }; const z6: rs.Iter<[rs.ByteSlice, [rs.usize, rs.u8]]> = rs.iterZip(rs.byteSliceChunks(new rs.ByteSlice(data.data, data.start, split), 2), rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start + split, data.length - split)))), [false, false]); const at4: (a0: [rs.ByteSlice, [rs.usize, rs.u8]]) => rs.u8 = at3; @@ -5524,14 +5521,14 @@ export function zipsBack(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.byteVecPush(out, option_mapOr$0llggqq(rs.iterToOption(z6.next()), 238, at4)); } else if (_21 === 6) { const logged: (a0: rs.ByteSlice) => rs.ByteSlice = (c2: rs.ByteSlice): rs.ByteSlice => { - const _68: rs.RefCell = rs.refCellBorrowMut(log); - const _712: rs.u8 = _20(c2); - rs.byteVecPush(_68.value, _712); - rs.refMutRelease(_68); + const _65: rs.RefCell = rs.refCellBorrowMut(log); + const _711: rs.u8 = _20(c2); + rs.byteVecPush(_65.value, _711); + rs.refMutRelease(_65); return c2; }; - const at5: (a0: [rs.u8, rs.ByteSlice]) => rs.u8 = (_216: [rs.u8, rs.ByteSlice]): rs.u8 => { - return _216[0] ^ _20(_216[1]); + const at5: (a0: [rs.u8, rs.ByteSlice]) => rs.u8 = (_210: [rs.u8, rs.ByteSlice]): rs.u8 => { + return _210[0] ^ _20(_210[1]); }; const z7: rs.Iter<[rs.u8, rs.ByteSlice]> = rs.iterZip(new rs.Range(split & 0xff, data.length & 0xff), rs.iterMap(rs.byteSliceChunks(new rs.ByteSlice(data.data, data.start, split), 3), logged), [false, true]); const at6: (a0: [rs.u8, rs.ByteSlice]) => rs.u8 = at5; @@ -5558,16 +5555,16 @@ export function zipsBack(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } rs.byteVecPush(out, option_mapOr$1ifh11y(rs.iterToOption(z7.next()), 238, at6)); } else { - const logged2: (a0: [rs.usize, rs.u8]) => rs.u8 = (_214: [rs.usize, rs.u8]): rs.u8 => { - const i2: rs.usize = _214[0]; - const x5: rs.u8 = _214[1]; - const _710: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_710.value, i2 & 0xff); - rs.refMutRelease(_710); - return x5; + const logged2: (a0: [rs.usize, rs.u8]) => rs.u8 = (_23: [rs.usize, rs.u8]): rs.u8 => { + const i: rs.usize = _23[0]; + const x: rs.u8 = _23[1]; + const _76: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_76.value, i & 0xff); + rs.refMutRelease(_76); + return x; }; - const at7: (a0: [rs.u8, [rs.usize, rs.ByteSlice]]) => rs.u8 = (_215: [rs.u8, [rs.usize, rs.ByteSlice]]): rs.u8 => { - return _215[0] ^ (_215[1][0] & 0xff) ^ _20(_215[1][1]); + const at7: (a0: [rs.u8, [rs.usize, rs.ByteSlice]]) => rs.u8 = (_27: [rs.u8, [rs.usize, rs.ByteSlice]]): rs.u8 => { + return _27[0] ^ (_27[1][0] & 0xff) ^ _20(_27[1][1]); }; const z8: rs.Iter<[rs.u8, [rs.usize, rs.ByteSlice]]> = rs.iterZip(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start, split)))), logged2), rs.iterEnumerate(rs.byteSliceChunks(new rs.ByteSlice(data.data, data.start + split, data.length - split), 2)), [true, false]); const at8: (a0: [rs.u8, [rs.usize, rs.ByteSlice]]) => rs.u8 = at7; @@ -5681,49 +5678,45 @@ export function rangeFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo * of two `TrustedLen` iterators reads only as many pairs as the data has. */ export function fromTop$char_iters_chars_closure0(start: rs.char, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.char, a1: rs.ByteVec) => undefined): void { - b0: { - const _6: rs.u8 = rs.u8Rem(how, 4); - if (_6 === 0) { - const iter: rs.Iter<[rs.u8, rs.char]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.charStep), "len"); - while (true) { - const _13: [rs.u8, rs.char] | rs.Done = iter.next(); - if (_13 === rs.DONE) { - break b0; - } - const b: rs.u8 = _13[0]; - const x: rs.char = _13[1]; - rs.byteVecPush(out, b); - put(x, out); + const _6: rs.u8 = rs.u8Rem(how, 4); + if (_6 === 0) { + const iter: rs.Iter<[rs.u8, rs.char]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.charStep), "len"); + while (true) { + const _13: [rs.u8, rs.char] | rs.Done = iter.next(); + if (_13 === rs.DONE) { + break; } - } - if (_6 === 1) { - rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.charStep), "len"), (_26: [rs.u8, rs.char]): undefined => { - const b4: rs.u8 = _26[0]; - const x4: rs.char = _26[1]; - rs.byteVecPush(out, b4); - put(x4, out); - }); - } else { - if (_6 === 2) { - const iter2: rs.Iter<[rs.char, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.charStep), rs.iterSlice(rs.byteSliceView(data)), "len"); - while (true) { - const _31: [rs.char, rs.u8] | rs.Done = iter2.next(); - if (_31 === rs.DONE) { - break b0; - } - const x2: rs.char = _31[0]; - const b2: rs.u8 = _31[1]; - put(x2, out); - rs.byteVecPush(out, b2); - } + const b: rs.u8 = _13[0]; + const x: rs.char = _13[1]; + rs.byteVecPush(out, b); + put(x, out); + } + } else if (_6 === 1) { + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.charStep), "len"), (_26: [rs.u8, rs.char]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.char = _26[1]; + rs.byteVecPush(out, b4); + put(x4, out); + }); + } else if (_6 === 2) { + const iter2: rs.Iter<[rs.char, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.charStep), rs.iterSlice(rs.byteSliceView(data)), "len"); + while (true) { + const _31: [rs.char, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { + break; } - rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.charStep), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.char, rs.u8]): undefined => { - const x3: rs.char = _2[0]; - const b3: rs.u8 = _2[1]; - put(x3, out); - rs.byteVecPush(out, b3); - }); + const x2: rs.char = _31[0]; + const b2: rs.u8 = _31[1]; + put(x2, out); + rs.byteVecPush(out, b2); } + } else { + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.charStep), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.char, rs.u8]): undefined => { + const x3: rs.char = _2[0]; + const b3: rs.u8 = _2[1]; + put(x3, out); + rs.byteVecPush(out, b3); + }); } } @@ -5734,49 +5727,45 @@ export function fromTop$char_iters_chars_closure0(start: rs.char, data: rs.ByteS * of two `TrustedLen` iterators reads only as many pairs as the data has. */ export function fromTop$i128_iters_range_froms_closure10(start: rs.i128, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.i128, a1: rs.ByteVec) => undefined): void { - b0: { - const _6: rs.u8 = rs.u8Rem(how, 4); - if (_6 === 0) { - const iter: rs.Iter<[rs.u8, rs.i128]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i128Step), "len"); - while (true) { - const _13: [rs.u8, rs.i128] | rs.Done = iter.next(); - if (_13 === rs.DONE) { - break b0; - } - const b: rs.u8 = _13[0]; - const x: rs.i128 = _13[1]; - rs.byteVecPush(out, b); - put(x, out); + const _6: rs.u8 = rs.u8Rem(how, 4); + if (_6 === 0) { + const iter: rs.Iter<[rs.u8, rs.i128]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i128Step), "len"); + while (true) { + const _13: [rs.u8, rs.i128] | rs.Done = iter.next(); + if (_13 === rs.DONE) { + break; } - } - if (_6 === 1) { - rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i128Step), "len"), (_26: [rs.u8, rs.i128]): undefined => { - const b4: rs.u8 = _26[0]; - const x4: rs.i128 = _26[1]; - rs.byteVecPush(out, b4); - put(x4, out); - }); - } else { - if (_6 === 2) { - const iter2: rs.Iter<[rs.i128, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.i128Step), rs.iterSlice(rs.byteSliceView(data)), "len"); - while (true) { - const _31: [rs.i128, rs.u8] | rs.Done = iter2.next(); - if (_31 === rs.DONE) { - break b0; - } - const x2: rs.i128 = _31[0]; - const b2: rs.u8 = _31[1]; - put(x2, out); - rs.byteVecPush(out, b2); - } + const b: rs.u8 = _13[0]; + const x: rs.i128 = _13[1]; + rs.byteVecPush(out, b); + put(x, out); + } + } else if (_6 === 1) { + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i128Step), "len"), (_26: [rs.u8, rs.i128]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.i128 = _26[1]; + rs.byteVecPush(out, b4); + put(x4, out); + }); + } else if (_6 === 2) { + const iter2: rs.Iter<[rs.i128, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.i128Step), rs.iterSlice(rs.byteSliceView(data)), "len"); + while (true) { + const _31: [rs.i128, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { + break; } - rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.i128Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.i128, rs.u8]): undefined => { - const x3: rs.i128 = _2[0]; - const b3: rs.u8 = _2[1]; - put(x3, out); - rs.byteVecPush(out, b3); - }); + const x2: rs.i128 = _31[0]; + const b2: rs.u8 = _31[1]; + put(x2, out); + rs.byteVecPush(out, b2); } + } else { + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.i128Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.i128, rs.u8]): undefined => { + const x3: rs.i128 = _2[0]; + const b3: rs.u8 = _2[1]; + put(x3, out); + rs.byteVecPush(out, b3); + }); } } @@ -5787,49 +5776,45 @@ export function fromTop$i128_iters_range_froms_closure10(start: rs.i128, data: r * of two `TrustedLen` iterators reads only as many pairs as the data has. */ export function fromTop$i16_iters_range_froms_closure7(start: rs.i16, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.i16, a1: rs.ByteVec) => undefined): void { - b0: { - const _6: rs.u8 = rs.u8Rem(how, 4); - if (_6 === 0) { - const iter: rs.Iter<[rs.u8, rs.i16]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i16Step), "len"); - while (true) { - const _13: [rs.u8, rs.i16] | rs.Done = iter.next(); - if (_13 === rs.DONE) { - break b0; - } - const b: rs.u8 = _13[0]; - const x: rs.i16 = _13[1]; - rs.byteVecPush(out, b); - put(x, out); + const _6: rs.u8 = rs.u8Rem(how, 4); + if (_6 === 0) { + const iter: rs.Iter<[rs.u8, rs.i16]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i16Step), "len"); + while (true) { + const _13: [rs.u8, rs.i16] | rs.Done = iter.next(); + if (_13 === rs.DONE) { + break; } - } - if (_6 === 1) { - rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i16Step), "len"), (_26: [rs.u8, rs.i16]): undefined => { - const b4: rs.u8 = _26[0]; - const x4: rs.i16 = _26[1]; - rs.byteVecPush(out, b4); - put(x4, out); - }); - } else { - if (_6 === 2) { - const iter2: rs.Iter<[rs.i16, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.i16Step), rs.iterSlice(rs.byteSliceView(data)), "len"); - while (true) { - const _31: [rs.i16, rs.u8] | rs.Done = iter2.next(); - if (_31 === rs.DONE) { - break b0; - } - const x2: rs.i16 = _31[0]; - const b2: rs.u8 = _31[1]; - put(x2, out); - rs.byteVecPush(out, b2); - } + const b: rs.u8 = _13[0]; + const x: rs.i16 = _13[1]; + rs.byteVecPush(out, b); + put(x, out); + } + } else if (_6 === 1) { + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i16Step), "len"), (_26: [rs.u8, rs.i16]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.i16 = _26[1]; + rs.byteVecPush(out, b4); + put(x4, out); + }); + } else if (_6 === 2) { + const iter2: rs.Iter<[rs.i16, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.i16Step), rs.iterSlice(rs.byteSliceView(data)), "len"); + while (true) { + const _31: [rs.i16, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { + break; } - rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.i16Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.i16, rs.u8]): undefined => { - const x3: rs.i16 = _2[0]; - const b3: rs.u8 = _2[1]; - put(x3, out); - rs.byteVecPush(out, b3); - }); + const x2: rs.i16 = _31[0]; + const b2: rs.u8 = _31[1]; + put(x2, out); + rs.byteVecPush(out, b2); } + } else { + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.i16Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.i16, rs.u8]): undefined => { + const x3: rs.i16 = _2[0]; + const b3: rs.u8 = _2[1]; + put(x3, out); + rs.byteVecPush(out, b3); + }); } } @@ -5840,49 +5825,45 @@ export function fromTop$i16_iters_range_froms_closure7(start: rs.i16, data: rs.B * of two `TrustedLen` iterators reads only as many pairs as the data has. */ export function fromTop$i32_iters_range_froms_closure8(start: rs.i32, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.i32, a1: rs.ByteVec) => undefined): void { - b0: { - const _6: rs.u8 = rs.u8Rem(how, 4); - if (_6 === 0) { - const iter: rs.Iter<[rs.u8, rs.i32]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i32Step), "len"); - while (true) { - const _13: [rs.u8, rs.i32] | rs.Done = iter.next(); - if (_13 === rs.DONE) { - break b0; - } - const b: rs.u8 = _13[0]; - const x: rs.i32 = _13[1]; - rs.byteVecPush(out, b); - put(x, out); + const _6: rs.u8 = rs.u8Rem(how, 4); + if (_6 === 0) { + const iter: rs.Iter<[rs.u8, rs.i32]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i32Step), "len"); + while (true) { + const _13: [rs.u8, rs.i32] | rs.Done = iter.next(); + if (_13 === rs.DONE) { + break; } - } - if (_6 === 1) { - rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i32Step), "len"), (_26: [rs.u8, rs.i32]): undefined => { - const b4: rs.u8 = _26[0]; - const x4: rs.i32 = _26[1]; - rs.byteVecPush(out, b4); - put(x4, out); - }); - } else { - if (_6 === 2) { - const iter2: rs.Iter<[rs.i32, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.i32Step), rs.iterSlice(rs.byteSliceView(data)), "len"); - while (true) { - const _31: [rs.i32, rs.u8] | rs.Done = iter2.next(); - if (_31 === rs.DONE) { - break b0; - } - const x2: rs.i32 = _31[0]; - const b2: rs.u8 = _31[1]; - put(x2, out); - rs.byteVecPush(out, b2); - } + const b: rs.u8 = _13[0]; + const x: rs.i32 = _13[1]; + rs.byteVecPush(out, b); + put(x, out); + } + } else if (_6 === 1) { + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i32Step), "len"), (_26: [rs.u8, rs.i32]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.i32 = _26[1]; + rs.byteVecPush(out, b4); + put(x4, out); + }); + } else if (_6 === 2) { + const iter2: rs.Iter<[rs.i32, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.i32Step), rs.iterSlice(rs.byteSliceView(data)), "len"); + while (true) { + const _31: [rs.i32, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { + break; } - rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.i32Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.i32, rs.u8]): undefined => { - const x3: rs.i32 = _2[0]; - const b3: rs.u8 = _2[1]; - put(x3, out); - rs.byteVecPush(out, b3); - }); + const x2: rs.i32 = _31[0]; + const b2: rs.u8 = _31[1]; + put(x2, out); + rs.byteVecPush(out, b2); } + } else { + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.i32Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.i32, rs.u8]): undefined => { + const x3: rs.i32 = _2[0]; + const b3: rs.u8 = _2[1]; + put(x3, out); + rs.byteVecPush(out, b3); + }); } } @@ -5893,49 +5874,45 @@ export function fromTop$i32_iters_range_froms_closure8(start: rs.i32, data: rs.B * of two `TrustedLen` iterators reads only as many pairs as the data has. */ export function fromTop$i64_iters_range_froms_closure9(start: rs.i64, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.i64, a1: rs.ByteVec) => undefined): void { - b0: { - const _6: rs.u8 = rs.u8Rem(how, 4); - if (_6 === 0) { - const iter: rs.Iter<[rs.u8, rs.i64]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i64Step), "len"); - while (true) { - const _13: [rs.u8, rs.i64] | rs.Done = iter.next(); - if (_13 === rs.DONE) { - break b0; - } - const b: rs.u8 = _13[0]; - const x: rs.i64 = _13[1]; - rs.byteVecPush(out, b); - put(x, out); + const _6: rs.u8 = rs.u8Rem(how, 4); + if (_6 === 0) { + const iter: rs.Iter<[rs.u8, rs.i64]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i64Step), "len"); + while (true) { + const _13: [rs.u8, rs.i64] | rs.Done = iter.next(); + if (_13 === rs.DONE) { + break; } - } - if (_6 === 1) { - rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i64Step), "len"), (_26: [rs.u8, rs.i64]): undefined => { - const b4: rs.u8 = _26[0]; - const x4: rs.i64 = _26[1]; - rs.byteVecPush(out, b4); - put(x4, out); - }); - } else { - if (_6 === 2) { - const iter2: rs.Iter<[rs.i64, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.i64Step), rs.iterSlice(rs.byteSliceView(data)), "len"); - while (true) { - const _31: [rs.i64, rs.u8] | rs.Done = iter2.next(); - if (_31 === rs.DONE) { - break b0; - } - const x2: rs.i64 = _31[0]; - const b2: rs.u8 = _31[1]; - put(x2, out); - rs.byteVecPush(out, b2); - } + const b: rs.u8 = _13[0]; + const x: rs.i64 = _13[1]; + rs.byteVecPush(out, b); + put(x, out); + } + } else if (_6 === 1) { + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i64Step), "len"), (_26: [rs.u8, rs.i64]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.i64 = _26[1]; + rs.byteVecPush(out, b4); + put(x4, out); + }); + } else if (_6 === 2) { + const iter2: rs.Iter<[rs.i64, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.i64Step), rs.iterSlice(rs.byteSliceView(data)), "len"); + while (true) { + const _31: [rs.i64, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { + break; } - rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.i64Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.i64, rs.u8]): undefined => { - const x3: rs.i64 = _2[0]; - const b3: rs.u8 = _2[1]; - put(x3, out); - rs.byteVecPush(out, b3); - }); + const x2: rs.i64 = _31[0]; + const b2: rs.u8 = _31[1]; + put(x2, out); + rs.byteVecPush(out, b2); } + } else { + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.i64Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.i64, rs.u8]): undefined => { + const x3: rs.i64 = _2[0]; + const b3: rs.u8 = _2[1]; + put(x3, out); + rs.byteVecPush(out, b3); + }); } } @@ -5946,49 +5923,45 @@ export function fromTop$i64_iters_range_froms_closure9(start: rs.i64, data: rs.B * of two `TrustedLen` iterators reads only as many pairs as the data has. */ export function fromTop$i8_iters_range_froms_closure6(start: rs.i8, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.i8, a1: rs.ByteVec) => undefined): void { - b0: { - const _6: rs.u8 = rs.u8Rem(how, 4); - if (_6 === 0) { - const iter: rs.Iter<[rs.u8, rs.i8]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i8Step), "len"); - while (true) { - const _13: [rs.u8, rs.i8] | rs.Done = iter.next(); - if (_13 === rs.DONE) { - break b0; - } - const b: rs.u8 = _13[0]; - const x: rs.i8 = _13[1]; - rs.byteVecPush(out, b); - put(x, out); + const _6: rs.u8 = rs.u8Rem(how, 4); + if (_6 === 0) { + const iter: rs.Iter<[rs.u8, rs.i8]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i8Step), "len"); + while (true) { + const _13: [rs.u8, rs.i8] | rs.Done = iter.next(); + if (_13 === rs.DONE) { + break; } - } - if (_6 === 1) { - rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i8Step), "len"), (_26: [rs.u8, rs.i8]): undefined => { - const b4: rs.u8 = _26[0]; - const x4: rs.i8 = _26[1]; - rs.byteVecPush(out, b4); - put(x4, out); - }); - } else { - if (_6 === 2) { - const iter2: rs.Iter<[rs.i8, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.i8Step), rs.iterSlice(rs.byteSliceView(data)), "len"); - while (true) { - const _31: [rs.i8, rs.u8] | rs.Done = iter2.next(); - if (_31 === rs.DONE) { - break b0; - } - const x2: rs.i8 = _31[0]; - const b2: rs.u8 = _31[1]; - put(x2, out); - rs.byteVecPush(out, b2); - } + const b: rs.u8 = _13[0]; + const x: rs.i8 = _13[1]; + rs.byteVecPush(out, b); + put(x, out); + } + } else if (_6 === 1) { + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i8Step), "len"), (_26: [rs.u8, rs.i8]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.i8 = _26[1]; + rs.byteVecPush(out, b4); + put(x4, out); + }); + } else if (_6 === 2) { + const iter2: rs.Iter<[rs.i8, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.i8Step), rs.iterSlice(rs.byteSliceView(data)), "len"); + while (true) { + const _31: [rs.i8, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { + break; } - rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.i8Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.i8, rs.u8]): undefined => { - const x3: rs.i8 = _2[0]; - const b3: rs.u8 = _2[1]; - put(x3, out); - rs.byteVecPush(out, b3); - }); + const x2: rs.i8 = _31[0]; + const b2: rs.u8 = _31[1]; + put(x2, out); + rs.byteVecPush(out, b2); } + } else { + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.i8Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.i8, rs.u8]): undefined => { + const x3: rs.i8 = _2[0]; + const b3: rs.u8 = _2[1]; + put(x3, out); + rs.byteVecPush(out, b3); + }); } } @@ -5999,49 +5972,45 @@ export function fromTop$i8_iters_range_froms_closure6(start: rs.i8, data: rs.Byt * of two `TrustedLen` iterators reads only as many pairs as the data has. */ export function fromTop$isize_iters_range_froms_closure11(start: rs.isize, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.isize, a1: rs.ByteVec) => undefined): void { - b0: { - const _6: rs.u8 = rs.u8Rem(how, 4); - if (_6 === 0) { - const iter: rs.Iter<[rs.u8, rs.isize]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.isizeStep), "len"); - while (true) { - const _13: [rs.u8, rs.isize] | rs.Done = iter.next(); - if (_13 === rs.DONE) { - break b0; - } - const b: rs.u8 = _13[0]; - const x: rs.isize = _13[1]; - rs.byteVecPush(out, b); - put(x, out); + const _6: rs.u8 = rs.u8Rem(how, 4); + if (_6 === 0) { + const iter: rs.Iter<[rs.u8, rs.isize]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.isizeStep), "len"); + while (true) { + const _13: [rs.u8, rs.isize] | rs.Done = iter.next(); + if (_13 === rs.DONE) { + break; } - } - if (_6 === 1) { - rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.isizeStep), "len"), (_26: [rs.u8, rs.isize]): undefined => { - const b4: rs.u8 = _26[0]; - const x4: rs.isize = _26[1]; - rs.byteVecPush(out, b4); - put(x4, out); - }); - } else { - if (_6 === 2) { - const iter2: rs.Iter<[rs.isize, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.isizeStep), rs.iterSlice(rs.byteSliceView(data)), "len"); - while (true) { - const _31: [rs.isize, rs.u8] | rs.Done = iter2.next(); - if (_31 === rs.DONE) { - break b0; - } - const x2: rs.isize = _31[0]; - const b2: rs.u8 = _31[1]; - put(x2, out); - rs.byteVecPush(out, b2); - } + const b: rs.u8 = _13[0]; + const x: rs.isize = _13[1]; + rs.byteVecPush(out, b); + put(x, out); + } + } else if (_6 === 1) { + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.isizeStep), "len"), (_26: [rs.u8, rs.isize]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.isize = _26[1]; + rs.byteVecPush(out, b4); + put(x4, out); + }); + } else if (_6 === 2) { + const iter2: rs.Iter<[rs.isize, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.isizeStep), rs.iterSlice(rs.byteSliceView(data)), "len"); + while (true) { + const _31: [rs.isize, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { + break; } - rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.isizeStep), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.isize, rs.u8]): undefined => { - const x3: rs.isize = _2[0]; - const b3: rs.u8 = _2[1]; - put(x3, out); - rs.byteVecPush(out, b3); - }); + const x2: rs.isize = _31[0]; + const b2: rs.u8 = _31[1]; + put(x2, out); + rs.byteVecPush(out, b2); } + } else { + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.isizeStep), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.isize, rs.u8]): undefined => { + const x3: rs.isize = _2[0]; + const b3: rs.u8 = _2[1]; + put(x3, out); + rs.byteVecPush(out, b3); + }); } } @@ -6052,49 +6021,45 @@ export function fromTop$isize_iters_range_froms_closure11(start: rs.isize, data: * of two `TrustedLen` iterators reads only as many pairs as the data has. */ export function fromTop$u128_iters_range_froms_closure13(start: rs.u128, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.u128, a1: rs.ByteVec) => undefined): void { - b0: { - const _6: rs.u8 = rs.u8Rem(how, 4); - if (_6 === 0) { - const iter: rs.Iter<[rs.u8, rs.u128]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u128Step), "len"); - while (true) { - const _13: [rs.u8, rs.u128] | rs.Done = iter.next(); - if (_13 === rs.DONE) { - break b0; - } - const b: rs.u8 = _13[0]; - const x: rs.u128 = _13[1]; - rs.byteVecPush(out, b); - put(x, out); - } - } - if (_6 === 1) { - rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u128Step), "len"), (_26: [rs.u8, rs.u128]): undefined => { - const b4: rs.u8 = _26[0]; - const x4: rs.u128 = _26[1]; - rs.byteVecPush(out, b4); - put(x4, out); - }); - } else { - if (_6 === 2) { - const iter2: rs.Iter<[rs.u128, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u128Step), rs.iterSlice(rs.byteSliceView(data)), "len"); - while (true) { - const _31: [rs.u128, rs.u8] | rs.Done = iter2.next(); - if (_31 === rs.DONE) { - break b0; - } - const x2: rs.u128 = _31[0]; - const b2: rs.u8 = _31[1]; - put(x2, out); - rs.byteVecPush(out, b2); - } + const _6: rs.u8 = rs.u8Rem(how, 4); + if (_6 === 0) { + const iter: rs.Iter<[rs.u8, rs.u128]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u128Step), "len"); + while (true) { + const _13: [rs.u8, rs.u128] | rs.Done = iter.next(); + if (_13 === rs.DONE) { + break; } - rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u128Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u128, rs.u8]): undefined => { - const x3: rs.u128 = _2[0]; - const b3: rs.u8 = _2[1]; - put(x3, out); - rs.byteVecPush(out, b3); - }); + const b: rs.u8 = _13[0]; + const x: rs.u128 = _13[1]; + rs.byteVecPush(out, b); + put(x, out); + } + } else if (_6 === 1) { + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u128Step), "len"), (_26: [rs.u8, rs.u128]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.u128 = _26[1]; + rs.byteVecPush(out, b4); + put(x4, out); + }); + } else if (_6 === 2) { + const iter2: rs.Iter<[rs.u128, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u128Step), rs.iterSlice(rs.byteSliceView(data)), "len"); + while (true) { + const _31: [rs.u128, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { + break; + } + const x2: rs.u128 = _31[0]; + const b2: rs.u8 = _31[1]; + put(x2, out); + rs.byteVecPush(out, b2); } + } else { + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u128Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u128, rs.u8]): undefined => { + const x3: rs.u128 = _2[0]; + const b3: rs.u8 = _2[1]; + put(x3, out); + rs.byteVecPush(out, b3); + }); } } @@ -6105,49 +6070,45 @@ export function fromTop$u128_iters_range_froms_closure13(start: rs.u128, data: r * of two `TrustedLen` iterators reads only as many pairs as the data has. */ export function fromTop$u128_iters_range_froms_closure4(start: rs.u128, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.u128, a1: rs.ByteVec) => undefined): void { - b0: { - const _6: rs.u8 = rs.u8Rem(how, 4); - if (_6 === 0) { - const iter: rs.Iter<[rs.u8, rs.u128]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u128Step), "len"); - while (true) { - const _13: [rs.u8, rs.u128] | rs.Done = iter.next(); - if (_13 === rs.DONE) { - break b0; - } - const b: rs.u8 = _13[0]; - const x: rs.u128 = _13[1]; - rs.byteVecPush(out, b); - put(x, out); + const _6: rs.u8 = rs.u8Rem(how, 4); + if (_6 === 0) { + const iter: rs.Iter<[rs.u8, rs.u128]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u128Step), "len"); + while (true) { + const _13: [rs.u8, rs.u128] | rs.Done = iter.next(); + if (_13 === rs.DONE) { + break; } - } - if (_6 === 1) { - rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u128Step), "len"), (_26: [rs.u8, rs.u128]): undefined => { - const b4: rs.u8 = _26[0]; - const x4: rs.u128 = _26[1]; - rs.byteVecPush(out, b4); - put(x4, out); - }); - } else { - if (_6 === 2) { - const iter2: rs.Iter<[rs.u128, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u128Step), rs.iterSlice(rs.byteSliceView(data)), "len"); - while (true) { - const _31: [rs.u128, rs.u8] | rs.Done = iter2.next(); - if (_31 === rs.DONE) { - break b0; - } - const x2: rs.u128 = _31[0]; - const b2: rs.u8 = _31[1]; - put(x2, out); - rs.byteVecPush(out, b2); - } + const b: rs.u8 = _13[0]; + const x: rs.u128 = _13[1]; + rs.byteVecPush(out, b); + put(x, out); + } + } else if (_6 === 1) { + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u128Step), "len"), (_26: [rs.u8, rs.u128]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.u128 = _26[1]; + rs.byteVecPush(out, b4); + put(x4, out); + }); + } else if (_6 === 2) { + const iter2: rs.Iter<[rs.u128, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u128Step), rs.iterSlice(rs.byteSliceView(data)), "len"); + while (true) { + const _31: [rs.u128, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { + break; } - rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u128Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u128, rs.u8]): undefined => { - const x3: rs.u128 = _2[0]; - const b3: rs.u8 = _2[1]; - put(x3, out); - rs.byteVecPush(out, b3); - }); + const x2: rs.u128 = _31[0]; + const b2: rs.u8 = _31[1]; + put(x2, out); + rs.byteVecPush(out, b2); } + } else { + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u128Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u128, rs.u8]): undefined => { + const x3: rs.u128 = _2[0]; + const b3: rs.u8 = _2[1]; + put(x3, out); + rs.byteVecPush(out, b3); + }); } } @@ -6158,49 +6119,45 @@ export function fromTop$u128_iters_range_froms_closure4(start: rs.u128, data: rs * of two `TrustedLen` iterators reads only as many pairs as the data has. */ export function fromTop$u16_iters_range_froms_closure1(start: rs.u16, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.u16, a1: rs.ByteVec) => undefined): void { - b0: { - const _6: rs.u8 = rs.u8Rem(how, 4); - if (_6 === 0) { - const iter: rs.Iter<[rs.u8, rs.u16]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u16Step), "len"); - while (true) { - const _13: [rs.u8, rs.u16] | rs.Done = iter.next(); - if (_13 === rs.DONE) { - break b0; - } - const b: rs.u8 = _13[0]; - const x: rs.u16 = _13[1]; - rs.byteVecPush(out, b); - put(x, out); + const _6: rs.u8 = rs.u8Rem(how, 4); + if (_6 === 0) { + const iter: rs.Iter<[rs.u8, rs.u16]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u16Step), "len"); + while (true) { + const _13: [rs.u8, rs.u16] | rs.Done = iter.next(); + if (_13 === rs.DONE) { + break; } - } - if (_6 === 1) { - rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u16Step), "len"), (_26: [rs.u8, rs.u16]): undefined => { - const b4: rs.u8 = _26[0]; - const x4: rs.u16 = _26[1]; - rs.byteVecPush(out, b4); - put(x4, out); - }); - } else { - if (_6 === 2) { - const iter2: rs.Iter<[rs.u16, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u16Step), rs.iterSlice(rs.byteSliceView(data)), "len"); - while (true) { - const _31: [rs.u16, rs.u8] | rs.Done = iter2.next(); - if (_31 === rs.DONE) { - break b0; - } - const x2: rs.u16 = _31[0]; - const b2: rs.u8 = _31[1]; - put(x2, out); - rs.byteVecPush(out, b2); - } + const b: rs.u8 = _13[0]; + const x: rs.u16 = _13[1]; + rs.byteVecPush(out, b); + put(x, out); + } + } else if (_6 === 1) { + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u16Step), "len"), (_26: [rs.u8, rs.u16]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.u16 = _26[1]; + rs.byteVecPush(out, b4); + put(x4, out); + }); + } else if (_6 === 2) { + const iter2: rs.Iter<[rs.u16, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u16Step), rs.iterSlice(rs.byteSliceView(data)), "len"); + while (true) { + const _31: [rs.u16, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { + break; } - rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u16Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u16, rs.u8]): undefined => { - const x3: rs.u16 = _2[0]; - const b3: rs.u8 = _2[1]; - put(x3, out); - rs.byteVecPush(out, b3); - }); + const x2: rs.u16 = _31[0]; + const b2: rs.u8 = _31[1]; + put(x2, out); + rs.byteVecPush(out, b2); } + } else { + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u16Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u16, rs.u8]): undefined => { + const x3: rs.u16 = _2[0]; + const b3: rs.u8 = _2[1]; + put(x3, out); + rs.byteVecPush(out, b3); + }); } } @@ -6211,49 +6168,45 @@ export function fromTop$u16_iters_range_froms_closure1(start: rs.u16, data: rs.B * of two `TrustedLen` iterators reads only as many pairs as the data has. */ export function fromTop$u32_iters_range_froms_closure2(start: rs.u32, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.u32, a1: rs.ByteVec) => undefined): void { - b0: { - const _6: rs.u8 = rs.u8Rem(how, 4); - if (_6 === 0) { - const iter: rs.Iter<[rs.u8, rs.u32]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u32Step), "len"); - while (true) { - const _13: [rs.u8, rs.u32] | rs.Done = iter.next(); - if (_13 === rs.DONE) { - break b0; - } - const b: rs.u8 = _13[0]; - const x: rs.u32 = _13[1]; - rs.byteVecPush(out, b); - put(x, out); + const _6: rs.u8 = rs.u8Rem(how, 4); + if (_6 === 0) { + const iter: rs.Iter<[rs.u8, rs.u32]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u32Step), "len"); + while (true) { + const _13: [rs.u8, rs.u32] | rs.Done = iter.next(); + if (_13 === rs.DONE) { + break; } - } - if (_6 === 1) { - rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u32Step), "len"), (_26: [rs.u8, rs.u32]): undefined => { - const b4: rs.u8 = _26[0]; - const x4: rs.u32 = _26[1]; - rs.byteVecPush(out, b4); - put(x4, out); - }); - } else { - if (_6 === 2) { - const iter2: rs.Iter<[rs.u32, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u32Step), rs.iterSlice(rs.byteSliceView(data)), "len"); - while (true) { - const _31: [rs.u32, rs.u8] | rs.Done = iter2.next(); - if (_31 === rs.DONE) { - break b0; - } - const x2: rs.u32 = _31[0]; - const b2: rs.u8 = _31[1]; - put(x2, out); - rs.byteVecPush(out, b2); - } + const b: rs.u8 = _13[0]; + const x: rs.u32 = _13[1]; + rs.byteVecPush(out, b); + put(x, out); + } + } else if (_6 === 1) { + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u32Step), "len"), (_26: [rs.u8, rs.u32]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.u32 = _26[1]; + rs.byteVecPush(out, b4); + put(x4, out); + }); + } else if (_6 === 2) { + const iter2: rs.Iter<[rs.u32, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u32Step), rs.iterSlice(rs.byteSliceView(data)), "len"); + while (true) { + const _31: [rs.u32, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { + break; } - rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u32Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u32, rs.u8]): undefined => { - const x3: rs.u32 = _2[0]; - const b3: rs.u8 = _2[1]; - put(x3, out); - rs.byteVecPush(out, b3); - }); + const x2: rs.u32 = _31[0]; + const b2: rs.u8 = _31[1]; + put(x2, out); + rs.byteVecPush(out, b2); } + } else { + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u32Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u32, rs.u8]): undefined => { + const x3: rs.u32 = _2[0]; + const b3: rs.u8 = _2[1]; + put(x3, out); + rs.byteVecPush(out, b3); + }); } } @@ -6264,49 +6217,45 @@ export function fromTop$u32_iters_range_froms_closure2(start: rs.u32, data: rs.B * of two `TrustedLen` iterators reads only as many pairs as the data has. */ export function fromTop$u64_iters_range_froms_closure12(start: rs.u64, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.u64, a1: rs.ByteVec) => undefined): void { - b0: { - const _6: rs.u8 = rs.u8Rem(how, 4); - if (_6 === 0) { - const iter: rs.Iter<[rs.u8, rs.u64]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u64Step), "len"); - while (true) { - const _13: [rs.u8, rs.u64] | rs.Done = iter.next(); - if (_13 === rs.DONE) { - break b0; - } - const b: rs.u8 = _13[0]; - const x: rs.u64 = _13[1]; - rs.byteVecPush(out, b); - put(x, out); + const _6: rs.u8 = rs.u8Rem(how, 4); + if (_6 === 0) { + const iter: rs.Iter<[rs.u8, rs.u64]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u64Step), "len"); + while (true) { + const _13: [rs.u8, rs.u64] | rs.Done = iter.next(); + if (_13 === rs.DONE) { + break; } - } - if (_6 === 1) { - rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u64Step), "len"), (_26: [rs.u8, rs.u64]): undefined => { - const b4: rs.u8 = _26[0]; - const x4: rs.u64 = _26[1]; - rs.byteVecPush(out, b4); - put(x4, out); - }); - } else { - if (_6 === 2) { - const iter2: rs.Iter<[rs.u64, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u64Step), rs.iterSlice(rs.byteSliceView(data)), "len"); - while (true) { - const _31: [rs.u64, rs.u8] | rs.Done = iter2.next(); - if (_31 === rs.DONE) { - break b0; - } - const x2: rs.u64 = _31[0]; - const b2: rs.u8 = _31[1]; - put(x2, out); - rs.byteVecPush(out, b2); - } + const b: rs.u8 = _13[0]; + const x: rs.u64 = _13[1]; + rs.byteVecPush(out, b); + put(x, out); + } + } else if (_6 === 1) { + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u64Step), "len"), (_26: [rs.u8, rs.u64]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.u64 = _26[1]; + rs.byteVecPush(out, b4); + put(x4, out); + }); + } else if (_6 === 2) { + const iter2: rs.Iter<[rs.u64, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u64Step), rs.iterSlice(rs.byteSliceView(data)), "len"); + while (true) { + const _31: [rs.u64, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { + break; } - rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u64Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u64, rs.u8]): undefined => { - const x3: rs.u64 = _2[0]; - const b3: rs.u8 = _2[1]; - put(x3, out); - rs.byteVecPush(out, b3); - }); + const x2: rs.u64 = _31[0]; + const b2: rs.u8 = _31[1]; + put(x2, out); + rs.byteVecPush(out, b2); } + } else { + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u64Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u64, rs.u8]): undefined => { + const x3: rs.u64 = _2[0]; + const b3: rs.u8 = _2[1]; + put(x3, out); + rs.byteVecPush(out, b3); + }); } } @@ -6317,49 +6266,45 @@ export function fromTop$u64_iters_range_froms_closure12(start: rs.u64, data: rs. * of two `TrustedLen` iterators reads only as many pairs as the data has. */ export function fromTop$u64_iters_range_froms_closure3(start: rs.u64, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.u64, a1: rs.ByteVec) => undefined): void { - b0: { - const _6: rs.u8 = rs.u8Rem(how, 4); - if (_6 === 0) { - const iter: rs.Iter<[rs.u8, rs.u64]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u64Step), "len"); - while (true) { - const _13: [rs.u8, rs.u64] | rs.Done = iter.next(); - if (_13 === rs.DONE) { - break b0; - } - const b: rs.u8 = _13[0]; - const x: rs.u64 = _13[1]; - rs.byteVecPush(out, b); - put(x, out); + const _6: rs.u8 = rs.u8Rem(how, 4); + if (_6 === 0) { + const iter: rs.Iter<[rs.u8, rs.u64]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u64Step), "len"); + while (true) { + const _13: [rs.u8, rs.u64] | rs.Done = iter.next(); + if (_13 === rs.DONE) { + break; } - } - if (_6 === 1) { - rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u64Step), "len"), (_26: [rs.u8, rs.u64]): undefined => { - const b4: rs.u8 = _26[0]; - const x4: rs.u64 = _26[1]; - rs.byteVecPush(out, b4); - put(x4, out); - }); - } else { - if (_6 === 2) { - const iter2: rs.Iter<[rs.u64, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u64Step), rs.iterSlice(rs.byteSliceView(data)), "len"); - while (true) { - const _31: [rs.u64, rs.u8] | rs.Done = iter2.next(); - if (_31 === rs.DONE) { - break b0; - } - const x2: rs.u64 = _31[0]; - const b2: rs.u8 = _31[1]; - put(x2, out); - rs.byteVecPush(out, b2); - } + const b: rs.u8 = _13[0]; + const x: rs.u64 = _13[1]; + rs.byteVecPush(out, b); + put(x, out); + } + } else if (_6 === 1) { + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u64Step), "len"), (_26: [rs.u8, rs.u64]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.u64 = _26[1]; + rs.byteVecPush(out, b4); + put(x4, out); + }); + } else if (_6 === 2) { + const iter2: rs.Iter<[rs.u64, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u64Step), rs.iterSlice(rs.byteSliceView(data)), "len"); + while (true) { + const _31: [rs.u64, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { + break; } - rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u64Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u64, rs.u8]): undefined => { - const x3: rs.u64 = _2[0]; - const b3: rs.u8 = _2[1]; - put(x3, out); - rs.byteVecPush(out, b3); - }); + const x2: rs.u64 = _31[0]; + const b2: rs.u8 = _31[1]; + put(x2, out); + rs.byteVecPush(out, b2); } + } else { + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u64Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u64, rs.u8]): undefined => { + const x3: rs.u64 = _2[0]; + const b3: rs.u8 = _2[1]; + put(x3, out); + rs.byteVecPush(out, b3); + }); } } @@ -6370,49 +6315,45 @@ export function fromTop$u64_iters_range_froms_closure3(start: rs.u64, data: rs.B * of two `TrustedLen` iterators reads only as many pairs as the data has. */ export function fromTop$u8_iters_range_froms_closure0(start: rs.u8, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.u8, a1: rs.ByteVec) => undefined): void { - b0: { - const _6: rs.u8 = rs.u8Rem(how, 4); - if (_6 === 0) { - const iter: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u8Step), "len"); - while (true) { - const _13: [rs.u8, rs.u8] | rs.Done = iter.next(); - if (_13 === rs.DONE) { - break b0; - } - const b: rs.u8 = _13[0]; - const x: rs.u8 = _13[1]; - rs.byteVecPush(out, b); - put(x, out); + const _6: rs.u8 = rs.u8Rem(how, 4); + if (_6 === 0) { + const iter: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u8Step), "len"); + while (true) { + const _13: [rs.u8, rs.u8] | rs.Done = iter.next(); + if (_13 === rs.DONE) { + break; } - } - if (_6 === 1) { - rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u8Step), "len"), (_26: [rs.u8, rs.u8]): undefined => { - const b4: rs.u8 = _26[0]; - const x4: rs.u8 = _26[1]; - rs.byteVecPush(out, b4); - put(x4, out); - }); - } else { - if (_6 === 2) { - const iter2: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u8Step), rs.iterSlice(rs.byteSliceView(data)), "len"); - while (true) { - const _31: [rs.u8, rs.u8] | rs.Done = iter2.next(); - if (_31 === rs.DONE) { - break b0; - } - const x2: rs.u8 = _31[0]; - const b2: rs.u8 = _31[1]; - put(x2, out); - rs.byteVecPush(out, b2); - } + const b: rs.u8 = _13[0]; + const x: rs.u8 = _13[1]; + rs.byteVecPush(out, b); + put(x, out); + } + } else if (_6 === 1) { + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u8Step), "len"), (_26: [rs.u8, rs.u8]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.u8 = _26[1]; + rs.byteVecPush(out, b4); + put(x4, out); + }); + } else if (_6 === 2) { + const iter2: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u8Step), rs.iterSlice(rs.byteSliceView(data)), "len"); + while (true) { + const _31: [rs.u8, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { + break; } - rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u8Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u8, rs.u8]): undefined => { - const x3: rs.u8 = _2[0]; - const b3: rs.u8 = _2[1]; - put(x3, out); - rs.byteVecPush(out, b3); - }); + const x2: rs.u8 = _31[0]; + const b2: rs.u8 = _31[1]; + put(x2, out); + rs.byteVecPush(out, b2); } + } else { + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u8Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u8, rs.u8]): undefined => { + const x3: rs.u8 = _2[0]; + const b3: rs.u8 = _2[1]; + put(x3, out); + rs.byteVecPush(out, b3); + }); } } @@ -6423,49 +6364,45 @@ export function fromTop$u8_iters_range_froms_closure0(start: rs.u8, data: rs.Byt * of two `TrustedLen` iterators reads only as many pairs as the data has. */ export function fromTop$usize_iters_range_froms_closure5(start: rs.usize, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.usize, a1: rs.ByteVec) => undefined): void { - b0: { - const _6: rs.u8 = rs.u8Rem(how, 4); - if (_6 === 0) { - const iter: rs.Iter<[rs.u8, rs.usize]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.usizeStep), "len"); - while (true) { - const _13: [rs.u8, rs.usize] | rs.Done = iter.next(); - if (_13 === rs.DONE) { - break b0; - } - const b: rs.u8 = _13[0]; - const x: rs.usize = _13[1]; - rs.byteVecPush(out, b); - put(x, out); + const _6: rs.u8 = rs.u8Rem(how, 4); + if (_6 === 0) { + const iter: rs.Iter<[rs.u8, rs.usize]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.usizeStep), "len"); + while (true) { + const _13: [rs.u8, rs.usize] | rs.Done = iter.next(); + if (_13 === rs.DONE) { + break; } - } - if (_6 === 1) { - rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.usizeStep), "len"), (_26: [rs.u8, rs.usize]): undefined => { - const b4: rs.u8 = _26[0]; - const x4: rs.usize = _26[1]; - rs.byteVecPush(out, b4); - put(x4, out); - }); - } else { - if (_6 === 2) { - const iter2: rs.Iter<[rs.usize, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.usizeStep), rs.iterSlice(rs.byteSliceView(data)), "len"); - while (true) { - const _31: [rs.usize, rs.u8] | rs.Done = iter2.next(); - if (_31 === rs.DONE) { - break b0; - } - const x2: rs.usize = _31[0]; - const b2: rs.u8 = _31[1]; - put(x2, out); - rs.byteVecPush(out, b2); - } + const b: rs.u8 = _13[0]; + const x: rs.usize = _13[1]; + rs.byteVecPush(out, b); + put(x, out); + } + } else if (_6 === 1) { + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.usizeStep), "len"), (_26: [rs.u8, rs.usize]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.usize = _26[1]; + rs.byteVecPush(out, b4); + put(x4, out); + }); + } else if (_6 === 2) { + const iter2: rs.Iter<[rs.usize, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.usizeStep), rs.iterSlice(rs.byteSliceView(data)), "len"); + while (true) { + const _31: [rs.usize, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { + break; } - rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.usizeStep), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.usize, rs.u8]): undefined => { - const x3: rs.usize = _2[0]; - const b3: rs.u8 = _2[1]; - put(x3, out); - rs.byteVecPush(out, b3); - }); + const x2: rs.usize = _31[0]; + const b2: rs.u8 = _31[1]; + put(x2, out); + rs.byteVecPush(out, b2); } + } else { + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.usizeStep), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.usize, rs.u8]): undefined => { + const x3: rs.usize = _2[0]; + const b3: rs.u8 = _2[1]; + put(x3, out); + rs.byteVecPush(out, b3); + }); } } @@ -6474,10 +6411,10 @@ export function fromTop$usize_iters_range_froms_closure5(start: rs.usize, data: * `char::MAX`, past which `start..` panics. */ export function chars(a: rs.u8, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec): void { + const near: rs.u32 = rs.u8Rem(a, 4) as rs.u32; const _8: (a0: rs.char, a1: rs.ByteVec) => undefined = (c2: rs.char, out2: rs.ByteVec): undefined => { rs.iterExtendBytes(out2, rs.iterSlice(rs.u32ToBeBytes(c2 as rs.u32).reverse()), undefined, true); }; - const near: rs.u32 = rs.u8Rem(a, 4) as rs.u32; const gap: rs.char = rs.optionUnwrap(rs.charFromU32(rs.u32Add(55293, near))); fromTop$char_iters_chars_closure0(gap, data, how, out, (c3: rs.char, out3: rs.ByteVec): undefined => { rs.iterExtendBytes(out3, rs.iterSlice(rs.u32ToBeBytes(c3 as rs.u32).reverse()), undefined, true); @@ -6553,8 +6490,7 @@ export function adapted(a: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return _24[0] ^ (_24[1] & 0xff); }), undefined, true); rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterTake(rs.iterStepBy(new rs.RangeFrom(lo, rs.u8Step), 3), 4), "next")), undefined, true); - const _71: rs.Iter = rs.iterTake(new rs.RangeFrom(97, rs.charStep), rs.usizeRem(n, 6)); - rs.iterExtendBytes(out, rs.strBytes(rs.stringExtendChars(rs.stringNew(), _71).v), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.stringFromChars(rs.iterTake(new rs.RangeFrom(97, rs.charStep), rs.usizeRem(n, 6))).v), undefined, true); const _77: [rs.usize, rs.usize | undefined] = rs.iterZip(it(), new rs.RangeFrom(lo, rs.u8Step), "len").sizeHint(); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_77[0] & 0xff, option_mapOr$188iunt(_77[1], 238, (h: rs.usize): rs.u8 => { return h & 0xff; @@ -8583,14 +8519,14 @@ export function boundsContain$usize_ops_Range_usize(r: rs.Range, x: rs export function stepped$char(table: rs.Slice, at: rs.usize[], out: rs.ByteVec): void { let _20!: rs.i32; let read!: rs.char | undefined; + const _6: [rs.char, rs.char] = bounded$char(table, at, out); + const a: rs.char = _6[0]; + const b: rs.char = _6[1]; const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { const h: rs.Hasher = rs.hasher(); value(h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rs.char, rs.char] = bounded$char(table, at, out); - const a: rs.char = _6[0]; - const b: rs.char = _6[1]; const part2 = (h2: rs.Hasher): undefined => { const _52: rs.Range = new rs.Range(a, b, rs.charStep); rs.rangeHash(rs.hash32)(_52, h2); @@ -8677,14 +8613,14 @@ export function stepped$char(table: rs.Slice, at: rs.usize[], out: rs.B export function stepped$i128(table: rs.Slice, at: rs.usize[], out: rs.ByteVec): void { let _20!: rs.i32; let read!: rs.i128 | undefined; + const _6: [rs.i128, rs.i128] = bounded$i128(table, at, out); + const a: rs.i128 = _6[0]; + const b: rs.i128 = _6[1]; const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { const h: rs.Hasher = rs.hasher(); value(h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rs.i128, rs.i128] = bounded$i128(table, at, out); - const a: rs.i128 = _6[0]; - const b: rs.i128 = _6[1]; const part2 = (h2: rs.Hasher): undefined => { const _52: rs.Range = new rs.Range(a, b, rs.i128Step); rs.rangeHash(rs.hashI128)(_52, h2); @@ -8771,14 +8707,14 @@ export function stepped$i128(table: rs.Slice, at: rs.usize[], out: rs.B export function stepped$i16(table: rs.Slice, at: rs.usize[], out: rs.ByteVec): void { let _20!: rs.i32; let read!: rs.i16 | undefined; + const _6: [rs.i16, rs.i16] = bounded$i16(table, at, out); + const a: rs.i16 = _6[0]; + const b: rs.i16 = _6[1]; const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { const h: rs.Hasher = rs.hasher(); value(h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rs.i16, rs.i16] = bounded$i16(table, at, out); - const a: rs.i16 = _6[0]; - const b: rs.i16 = _6[1]; const part2 = (h2: rs.Hasher): undefined => { const _52: rs.Range = new rs.Range(a, b); rs.rangeHash(rs.hashI16)(_52, h2); @@ -8865,14 +8801,14 @@ export function stepped$i16(table: rs.Slice, at: rs.usize[], out: rs.Byt export function stepped$i32(table: rs.Slice, at: rs.usize[], out: rs.ByteVec): void { let _20!: rs.i32; let read!: rs.i32 | undefined; + const _6: [rs.i32, rs.i32] = bounded$i32(table, at, out); + const a: rs.i32 = _6[0]; + const b: rs.i32 = _6[1]; const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { const h: rs.Hasher = rs.hasher(); value(h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rs.i32, rs.i32] = bounded$i32(table, at, out); - const a: rs.i32 = _6[0]; - const b: rs.i32 = _6[1]; const part2 = (h2: rs.Hasher): undefined => { const _52: rs.Range = new rs.Range(a, b); rs.rangeHash(rs.hashI32)(_52, h2); @@ -8959,14 +8895,14 @@ export function stepped$i32(table: rs.Slice, at: rs.usize[], out: rs.Byt export function stepped$i64(table: rs.Slice, at: rs.usize[], out: rs.ByteVec): void { let _20!: rs.i32; let read!: rs.i64 | undefined; + const _6: [rs.i64, rs.i64] = bounded$i64(table, at, out); + const a: rs.i64 = _6[0]; + const b: rs.i64 = _6[1]; const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { const h: rs.Hasher = rs.hasher(); value(h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rs.i64, rs.i64] = bounded$i64(table, at, out); - const a: rs.i64 = _6[0]; - const b: rs.i64 = _6[1]; const part2 = (h2: rs.Hasher): undefined => { const _52: rs.Range = new rs.Range(a, b, rs.i64Step); rs.rangeHash(rs.hashI64)(_52, h2); @@ -9053,14 +8989,14 @@ export function stepped$i64(table: rs.Slice, at: rs.usize[], out: rs.Byt export function stepped$i8(table: rs.Slice, at: rs.usize[], out: rs.ByteVec): void { let _20!: rs.i32; let read!: rs.i8 | undefined; + const _6: [rs.i8, rs.i8] = bounded$i8(table, at, out); + const a: rs.i8 = _6[0]; + const b: rs.i8 = _6[1]; const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { const h: rs.Hasher = rs.hasher(); value(h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rs.i8, rs.i8] = bounded$i8(table, at, out); - const a: rs.i8 = _6[0]; - const b: rs.i8 = _6[1]; const part2 = (h2: rs.Hasher): undefined => { const _52: rs.Range = new rs.Range(a, b); rs.rangeHash(rs.hashI8)(_52, h2); @@ -9147,14 +9083,14 @@ export function stepped$i8(table: rs.Slice, at: rs.usize[], out: rs.ByteV export function stepped$isize(table: rs.Slice, at: rs.usize[], out: rs.ByteVec): void { let _20!: rs.i32; let read!: rs.isize | undefined; + const _6: [rs.isize, rs.isize] = bounded$isize(table, at, out); + const a: rs.isize = _6[0]; + const b: rs.isize = _6[1]; const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { const h: rs.Hasher = rs.hasher(); value(h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rs.isize, rs.isize] = bounded$isize(table, at, out); - const a: rs.isize = _6[0]; - const b: rs.isize = _6[1]; const part2 = (h2: rs.Hasher): undefined => { const _52: rs.Range = new rs.Range(a, b); rs.rangeHash(rs.hashIsize)(_52, h2); @@ -9241,14 +9177,14 @@ export function stepped$isize(table: rs.Slice, at: rs.usize[], out: rs export function stepped$num_NonZero_u128(table: rs.Slice, at: rs.usize[], out: rs.ByteVec): void { let _20!: rs.i32; let read!: rs.u128 | undefined; + const _6: [rs.u128, rs.u128] = bounded$num_NonZero_u128(table, at, out); + const a: rs.u128 = _6[0]; + const b: rs.u128 = _6[1]; const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { const h: rs.Hasher = rs.hasher(); value(h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rs.u128, rs.u128] = bounded$num_NonZero_u128(table, at, out); - const a: rs.u128 = _6[0]; - const b: rs.u128 = _6[1]; const part2 = (h2: rs.Hasher): undefined => { const _52: rs.Range = new rs.Range(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); rs.rangeHash(rs.hash128)(_52, h2); @@ -9335,14 +9271,14 @@ export function stepped$num_NonZero_u128(table: rs.Slice, at: rs.usize[ export function stepped$num_NonZero_u64(table: rs.Slice, at: rs.usize[], out: rs.ByteVec): void { let _20!: rs.i32; let read!: rs.u64 | undefined; + const _6: [rs.u64, rs.u64] = bounded$num_NonZero_u64(table, at, out); + const a: rs.u64 = _6[0]; + const b: rs.u64 = _6[1]; const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { const h: rs.Hasher = rs.hasher(); value(h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rs.u64, rs.u64] = bounded$num_NonZero_u64(table, at, out); - const a: rs.u64 = _6[0]; - const b: rs.u64 = _6[1]; const part2 = (h2: rs.Hasher): undefined => { const _52: rs.Range = new rs.Range(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); rs.rangeHash(rs.hash64)(_52, h2); @@ -9429,14 +9365,14 @@ export function stepped$num_NonZero_u64(table: rs.Slice, at: rs.usize[], export function stepped$num_NonZero_u8(table: rs.Slice, at: rs.usize[], out: rs.ByteVec): void { let _20!: rs.i32; let read!: rs.u8 | undefined; + const _6: [rs.u8, rs.u8] = bounded$num_NonZero_u8(table, at, out); + const a: rs.u8 = _6[0]; + const b: rs.u8 = _6[1]; const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { const h: rs.Hasher = rs.hasher(); value(h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rs.u8, rs.u8] = bounded$num_NonZero_u8(table, at, out); - const a: rs.u8 = _6[0]; - const b: rs.u8 = _6[1]; const part2 = (h2: rs.Hasher): undefined => { const _52: rs.Range = new rs.Range(a, b); rs.rangeHash(rs.hash8)(_52, h2); @@ -9523,14 +9459,14 @@ export function stepped$num_NonZero_u8(table: rs.Slice, at: rs.usize[], o export function stepped$num_NonZero_usize(table: rs.Slice, at: rs.usize[], out: rs.ByteVec): void { let _20!: rs.i32; let read!: rs.usize | undefined; + const _6: [rs.usize, rs.usize] = bounded$num_NonZero_usize(table, at, out); + const a: rs.usize = _6[0]; + const b: rs.usize = _6[1]; const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { const h: rs.Hasher = rs.hasher(); value(h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rs.usize, rs.usize] = bounded$num_NonZero_usize(table, at, out); - const a: rs.usize = _6[0]; - const b: rs.usize = _6[1]; const part2 = (h2: rs.Hasher): undefined => { const _52: rs.Range = new rs.Range(a, b); rs.rangeHash(rs.hashUsize)(_52, h2); @@ -9617,14 +9553,14 @@ export function stepped$num_NonZero_usize(table: rs.Slice, at: rs.usiz export function stepped$u128(table: rs.Slice, at: rs.usize[], out: rs.ByteVec): void { let _20!: rs.i32; let read!: rs.u128 | undefined; + const _6: [rs.u128, rs.u128] = bounded$u128(table, at, out); + const a: rs.u128 = _6[0]; + const b: rs.u128 = _6[1]; const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { const h: rs.Hasher = rs.hasher(); value(h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rs.u128, rs.u128] = bounded$u128(table, at, out); - const a: rs.u128 = _6[0]; - const b: rs.u128 = _6[1]; const part2 = (h2: rs.Hasher): undefined => { const _52: rs.Range = new rs.Range(a, b, rs.u128Step); rs.rangeHash(rs.hash128)(_52, h2); @@ -9711,14 +9647,14 @@ export function stepped$u128(table: rs.Slice, at: rs.usize[], out: rs.B export function stepped$u16(table: rs.Slice, at: rs.usize[], out: rs.ByteVec): void { let _20!: rs.i32; let read!: rs.u16 | undefined; + const _6: [rs.u16, rs.u16] = bounded$u16(table, at, out); + const a: rs.u16 = _6[0]; + const b: rs.u16 = _6[1]; const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { const h: rs.Hasher = rs.hasher(); value(h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rs.u16, rs.u16] = bounded$u16(table, at, out); - const a: rs.u16 = _6[0]; - const b: rs.u16 = _6[1]; const part2 = (h2: rs.Hasher): undefined => { const _52: rs.Range = new rs.Range(a, b); rs.rangeHash(rs.hash16)(_52, h2); @@ -9805,14 +9741,14 @@ export function stepped$u16(table: rs.Slice, at: rs.usize[], out: rs.Byt export function stepped$u32(table: rs.Slice, at: rs.usize[], out: rs.ByteVec): void { let _20!: rs.i32; let read!: rs.u32 | undefined; + const _6: [rs.u32, rs.u32] = bounded$u32(table, at, out); + const a: rs.u32 = _6[0]; + const b: rs.u32 = _6[1]; const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { const h: rs.Hasher = rs.hasher(); value(h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rs.u32, rs.u32] = bounded$u32(table, at, out); - const a: rs.u32 = _6[0]; - const b: rs.u32 = _6[1]; const part2 = (h2: rs.Hasher): undefined => { const _52: rs.Range = new rs.Range(a, b); rs.rangeHash(rs.hash32)(_52, h2); @@ -9899,14 +9835,14 @@ export function stepped$u32(table: rs.Slice, at: rs.usize[], out: rs.Byt export function stepped$u64(table: rs.Slice, at: rs.usize[], out: rs.ByteVec): void { let _20!: rs.i32; let read!: rs.u64 | undefined; + const _6: [rs.u64, rs.u64] = bounded$u64(table, at, out); + const a: rs.u64 = _6[0]; + const b: rs.u64 = _6[1]; const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { const h: rs.Hasher = rs.hasher(); value(h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rs.u64, rs.u64] = bounded$u64(table, at, out); - const a: rs.u64 = _6[0]; - const b: rs.u64 = _6[1]; const part2 = (h2: rs.Hasher): undefined => { const _52: rs.Range = new rs.Range(a, b, rs.u64Step); rs.rangeHash(rs.hash64)(_52, h2); @@ -9993,14 +9929,14 @@ export function stepped$u64(table: rs.Slice, at: rs.usize[], out: rs.Byt export function stepped$u8(table: rs.ByteSlice, at: rs.usize[], out: rs.ByteVec): void { let _20!: rs.i32; let read!: rs.u8 | undefined; + const _6: [rs.u8, rs.u8] = bounded$u8(table, at, out); + const a: rs.u8 = _6[0]; + const b: rs.u8 = _6[1]; const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { const h: rs.Hasher = rs.hasher(); value(h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rs.u8, rs.u8] = bounded$u8(table, at, out); - const a: rs.u8 = _6[0]; - const b: rs.u8 = _6[1]; const part2 = (h2: rs.Hasher): undefined => { const _52: rs.Range = new rs.Range(a, b); rs.rangeHash(rs.hash8)(_52, h2); @@ -10087,14 +10023,14 @@ export function stepped$u8(table: rs.ByteSlice, at: rs.usize[], out: rs.ByteVec) export function stepped$usize(table: rs.Slice, at: rs.usize[], out: rs.ByteVec): void { let _20!: rs.i32; let read!: rs.usize | undefined; + const _6: [rs.usize, rs.usize] = bounded$usize(table, at, out); + const a: rs.usize = _6[0]; + const b: rs.usize = _6[1]; const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { const h: rs.Hasher = rs.hasher(); value(h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rs.usize, rs.usize] = bounded$usize(table, at, out); - const a: rs.usize = _6[0]; - const b: rs.usize = _6[1]; const part2 = (h2: rs.Hasher): undefined => { const _52: rs.Range = new rs.Range(a, b); rs.rangeHash(rs.hashUsize)(_52, h2); @@ -10189,11 +10125,6 @@ export function compares(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void let r5!: rs.u8; let r6!: rs.u8; let r7!: rs.u8; - const _23: (a0: rs.Ordering | undefined) => rs.u8 = (o: rs.Ordering | undefined): rs.u8 => { - return option_mapOr$14runhi(o, 9, (o2: rs.Ordering): rs.u8 => { - return o2 & 0xff; - }); - }; const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const other: rs.ByteVec = rs.byteSliceToByteVec(data); const _8: rs.u8 = rs.u8Rem(kind >> 4, 4); @@ -10209,6 +10140,11 @@ export function compares(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } } } + const _23: (a0: rs.Ordering | undefined) => rs.u8 = (o: rs.Ordering | undefined): rs.u8 => { + return option_mapOr$14runhi(o, 9, (o2: rs.Ordering): rs.u8 => { + return o2 & 0xff; + }); + }; const _24: rs.u8 = kind >> 6; if (_24 === 0) { let calls: rs.u8 = 0; @@ -11493,147 +11429,142 @@ export function byValue(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const logged: () => Logged.Logged = (): Logged.Logged => { return new Logged.Logged(rs.u8Rem(at(2), 5), log); }; - b0: { - const _18: rs.u8 = rs.u8Rem(kind, 13); - if (_18 === 0) { - rs.iterExtendBytes(out, rs.iterMap(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), (n14: rs.u8): rs.u8 => { - return rs.u8Mul(n14, 3); - }), "next"); - } else if (_18 === 1) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterFilter(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), (n13: rs.u8): boolean => { - return rs.u8Rem(n13, 2) === 0; - }), "next")), undefined, true); - } else if (_18 === 2) { - const _26: Ticks.Ticks = ticks(); - rs.iterExtendBytes(out, rs.iterMap(rs.iterZip(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rs.iterFrom({ v: _26 }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v))), (_215: [rs.u8, rs.u8]): rs.u8 => { - return _215[0] ^ _215[1]; - }), "next"); - } else if (_18 === 3) { - const _30: Ticks.Ticks = ticks(); - const _32: Logged.Logged = logged(); - rs.iterExtendBytes(out, rs.iterMap(rs.iterZip(rs.iterFrom({ v: _30 }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v)), rs.iterFrom(_32, Logged.next$iter_Iterator, rs.drop)), (_214: [rs.u8, rs.u8]): rs.u8 => { - return rs.u8Add(_214[0], _214[1]); - }), "next"); - } else if (_18 === 4) { - const _36: Ticks.Ticks = ticks(); - rs.iterExtendBytes(out, rs.iterChain(rs.iterChain(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rs.iterFrom({ v: _36 }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v))), rs.iterFrom(logged(), Logged.next$iter_Iterator, rs.drop)), "next"); - } else { - if (_18 === 5) { - let iter: Ticks.Ticks = ticks(); - while (true) { - const _44: rs.u8 | rs.Done = Ticks.next$iter_Iterator(rs.place(() => iter, (value11) => iter = value11)); - if (_44 === rs.DONE) { - break; - } - const n: rs.u8 = _44; - const _51: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_51.value, n); - rs.refMutRelease(_51); - } - drop$iters_Ticks(iter); - let iter2: Phase.Phase = phase; - while (true) { - const _55: rs.u8 | rs.Done = Phase.next$iter_Iterator(rs.place(() => iter2, (value12) => iter2 = value12)); - if (_55 === rs.DONE) { - break b0; - } - rs.byteVecPush(out, _55); - } - } - if (_18 === 6) { - rs.byteVecPush(out, Phase.count$iter_Iterator(phase) & 0xff); - rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.ownedLast(rs.iterFrom({ v: Phase.of(at(1)) }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) })), 238)); - rs.byteVecPush(out, rs.iterFold(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), 1, (acc: rs.u8, n12: rs.u8): rs.u8 => { - return acc ^ n12; - }, true)); - rs.byteVecPush(out, Phase.sizeHint$iter_Iterator(phase)[0] & 0xff); - rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(rs.iterRev(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) })).next()), 238)); - } else if (_18 === 7) { - rs.byteVecPush(out, rs.ownedCount(rs.iterFrom({ v: ticks() }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v))) & 0xff); - rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.ownedLast(rs.iterFrom({ v: ticks() }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v))), 238)); - rs.byteVecPush(out, rs.iterSum(rs.iterFrom({ v: ticks() }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v)), rs.u8Add, 0, true)); - let _100: Ticks.Ticks = ticks(); - rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterNth(rs.iterFrom(rs.place(() => _100, (value10) => _100 = value10), Ticks.next$iter_Iterator), 1), 238)); - drop$iters_Ticks(_100); - rs.byteVecPush(out, rs.ownedCount(rs.iterTake(rs.iterFrom(logged(), Logged.next$iter_Iterator, rs.drop), 2)) & 0xff); - } else if (_18 === 8) { - const v2: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(at(3))); - const _115: Ticks.Ticks = ticks(); - rs.iterExtendBytes(v2, rs.iterFrom({ v: _115 }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v)), "next"); - rs.iterExtendBytes(v2, rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), "next"); - rs.iterExtendBytes(out, rs.byteVecIntoIter(v2), undefined, true); - } else if (_18 === 9) { - const bag: Bag.Bag = { _0: at(0), _1: at(1) }; - const iter3: rs.Iter = Bag.intoIter$iter_IntoIterator(bag); - while (true) { - const _130: rs.u8 | rs.Done = iter3.next(); - if (_130 === rs.DONE) { - break; - } - rs.byteVecPush(out, _130); - } - rs.iterExtendBytes(out, rs.iterMap(rs.iterEnumerate(rs.iterMap(Bag.intoIter$iter_IntoIterator(bag), (n10: rs.u8): rs.u8 => { - return rs.u8Add(n10, 1); - })), (_210: [rs.usize, rs.u8]): rs.u8 => { - return (_210[0] & 0xff) ^ _210[1]; - }), "next"); - } else if (_18 === 10) { - it = rs.iterPeekable(rs.iterMap(rs.iterFrom({ v: ticks() }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v)), (n9: rs.u8): rs.u8 => { - return rs.u8Mul(n9, 2); - })); - rs.iterExtendBytes(out, rs.iterOption(rs.iterToOption(it.next())), undefined, true); - rs.iterExtendBytes(out, rs.iterOption(rs.peekablePeek(it)), undefined, true); - rs.drop(it); - const _155: Logged.Logged = logged(); - const _157: Ticks.Ticks = ticks(); - const it2: rs.Iter = rs.iterSkip(rs.iterChain(rs.iterFrom(_155, Logged.next$iter_Iterator, rs.drop), rs.iterFrom({ v: _157 }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v))), 1); - rs.iterExtendBytes(out, rs.iterOption(rs.iterToOption(it2.next())), undefined, true); - const _165: rs.RefCell = rs.refCellBorrowMut(log); - rs.byteVecPush(_165.value, 170); - rs.refMutRelease(_165); - rs.drop(it2); - } else if (_18 === 11) { - const _169: rs.Iter = rs.iterRev(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) })); - for (const _172 of rs.iterToVec(rs.iterZip(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), _169), "next", 2).items) { - rs.byteVecPush(out, rs.u8Add(rs.u8Mul(_172[0], 16), _172[1])); - } - rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterMax(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rs.lt, true), 238)); - const _188: Phase.Phase = Phase.of(at(1)); - rs.byteVecPush(out, rs.iterEq(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rs.iterFrom({ v: _188 }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rs.same, undefined, true, true) ? 1 : 0); - rs.iterExtendBytes(out, rs.iterTake(rs.iterCycle(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), { v: (it: rs.Place) => ({ v: it.v }) }), rs.u8Rem(at(1), 8) as rs.usize), "next"); - } else { - let p: Phase.Phase = phase; - rs.iterExtendBytes(out, rs.iterOption(rs.iterNth(rs.iterFrom(rs.place(() => p, (value) => p = value), Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), 0)), undefined, true); - rs.byteVecPush(out, rs.iterAny(rs.iterFrom(rs.place(() => p, (value2) => p = value2), Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), (n5: rs.u8): boolean => { - return n5 === 1; - }) ? 1 : 0); - rs.iterExtendBytes(out, rs.iterTake(rs.iterMap(rs.iterFrom(rs.place(() => p, (value3) => p = value3), Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), (n6: rs.u8): rs.u8 => { - return rs.u8Add(n6, 16); - }), 1), "next"); - rs.byteVecPush(out, rs.iterFrom(rs.place(() => p, (value4) => p = value4), Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }).sizeHint()[0] & 0xff); - const _224: rs.u8 | rs.Done = Phase.next$iter_Iterator(rs.place(() => p, (value5) => p = value5)); - if (_224 !== rs.DONE) { - rs.byteVecPush(out, _224); - } - const lent: rs.Place = rs.place(() => p, (value6) => p = value6); - rs.iterExtendBytes(out, rs.iterOption(rs.iterNth(rs.iterFrom(lent, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), 0)), undefined, true); - rs.byteVecPush(out, rs.iterFrom(lent, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }).sizeHint()[0] & 0xff); - rs.iterExtendBytes(out, rs.iterFrom({ v: p }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), "next"); - let t: Ticks.Ticks = ticks(); - rs.iterExtendBytes(out, rs.iterOption(rs.iterFind(rs.iterFrom(rs.place(() => t, (value7) => t = value7), Ticks.next$iter_Iterator), (n7: rs.u8): boolean => { - return rs.u8Rem(n7, 2) === 0; - })), undefined, true); - rs.iterExtendBytes(out, rs.iterOption(option_map$14ju55r(rs.iterPosition(rs.iterFrom(rs.place(() => t, (value8) => t = value8), Ticks.next$iter_Iterator), (n8: rs.u8): boolean => { - return n8 === 0; - }), (i2: rs.usize): rs.u8 => { - return i2 & 0xff; - })), undefined, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterZip(rs.iterFrom(rs.place(() => t, (value9) => t = value9), Ticks.next$iter_Iterator), rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) })), (_27: [rs.u8, rs.u8]): rs.u8 => { - return rs.u8Mul(_27[0], _27[1]); - }), "next"); - rs.iterExtendBytes(out, rs.iterFrom({ v: t }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v)), "next"); + const _18: rs.u8 = rs.u8Rem(kind, 13); + if (_18 === 0) { + rs.iterExtendBytes(out, rs.iterMap(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), (n14: rs.u8): rs.u8 => { + return rs.u8Mul(n14, 3); + }), "next"); + } else if (_18 === 1) { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterFilter(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), (n13: rs.u8): boolean => { + return rs.u8Rem(n13, 2) === 0; + }), "next")), undefined, true); + } else if (_18 === 2) { + const _26: Ticks.Ticks = ticks(); + rs.iterExtendBytes(out, rs.iterMap(rs.iterZip(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rs.iterFrom({ v: _26 }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v))), (_215: [rs.u8, rs.u8]): rs.u8 => { + return _215[0] ^ _215[1]; + }), "next"); + } else if (_18 === 3) { + const _30: Ticks.Ticks = ticks(); + const _32: Logged.Logged = logged(); + rs.iterExtendBytes(out, rs.iterMap(rs.iterZip(rs.iterFrom({ v: _30 }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v)), rs.iterFrom(_32, Logged.next$iter_Iterator, rs.drop)), (_214: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8Add(_214[0], _214[1]); + }), "next"); + } else if (_18 === 4) { + const _36: Ticks.Ticks = ticks(); + rs.iterExtendBytes(out, rs.iterChain(rs.iterChain(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rs.iterFrom({ v: _36 }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v))), rs.iterFrom(logged(), Logged.next$iter_Iterator, rs.drop)), "next"); + } else if (_18 === 5) { + let iter: Ticks.Ticks = ticks(); + while (true) { + const _44: rs.u8 | rs.Done = Ticks.next$iter_Iterator(rs.place(() => iter, (value11) => iter = value11)); + if (_44 === rs.DONE) { + break; } + const n: rs.u8 = _44; + const _51: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_51.value, n); + rs.refMutRelease(_51); } + drop$iters_Ticks(iter); + let iter2: Phase.Phase = phase; + while (true) { + const _55: rs.u8 | rs.Done = Phase.next$iter_Iterator(rs.place(() => iter2, (value12) => iter2 = value12)); + if (_55 === rs.DONE) { + break; + } + rs.byteVecPush(out, _55); + } + } else if (_18 === 6) { + rs.byteVecPush(out, Phase.count$iter_Iterator(phase) & 0xff); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.ownedLast(rs.iterFrom({ v: Phase.of(at(1)) }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) })), 238)); + rs.byteVecPush(out, rs.iterFold(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), 1, (acc: rs.u8, n12: rs.u8): rs.u8 => { + return acc ^ n12; + }, true)); + rs.byteVecPush(out, Phase.sizeHint$iter_Iterator(phase)[0] & 0xff); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(rs.iterRev(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) })).next()), 238)); + } else if (_18 === 7) { + rs.byteVecPush(out, rs.ownedCount(rs.iterFrom({ v: ticks() }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v))) & 0xff); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.ownedLast(rs.iterFrom({ v: ticks() }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v))), 238)); + rs.byteVecPush(out, rs.iterSum(rs.iterFrom({ v: ticks() }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v)), rs.u8Add, 0, true)); + let _100: Ticks.Ticks = ticks(); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterNth(rs.iterFrom(rs.place(() => _100, (value10) => _100 = value10), Ticks.next$iter_Iterator), 1), 238)); + drop$iters_Ticks(_100); + rs.byteVecPush(out, rs.ownedCount(rs.iterTake(rs.iterFrom(logged(), Logged.next$iter_Iterator, rs.drop), 2)) & 0xff); + } else if (_18 === 8) { + const v2: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(at(3))); + const _115: Ticks.Ticks = ticks(); + rs.iterExtendBytes(v2, rs.iterFrom({ v: _115 }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v)), "next"); + rs.iterExtendBytes(v2, rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), "next"); + rs.iterExtendBytes(out, rs.byteVecIntoIter(v2), undefined, true); + } else if (_18 === 9) { + const bag: Bag.Bag = { _0: at(0), _1: at(1) }; + const iter3: rs.Iter = Bag.intoIter$iter_IntoIterator(bag); + while (true) { + const _130: rs.u8 | rs.Done = iter3.next(); + if (_130 === rs.DONE) { + break; + } + rs.byteVecPush(out, _130); + } + rs.iterExtendBytes(out, rs.iterMap(rs.iterEnumerate(rs.iterMap(Bag.intoIter$iter_IntoIterator(bag), (n10: rs.u8): rs.u8 => { + return rs.u8Add(n10, 1); + })), (_210: [rs.usize, rs.u8]): rs.u8 => { + return (_210[0] & 0xff) ^ _210[1]; + }), "next"); + } else if (_18 === 10) { + it = rs.iterPeekable(rs.iterMap(rs.iterFrom({ v: ticks() }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v)), (n9: rs.u8): rs.u8 => { + return rs.u8Mul(n9, 2); + })); + rs.iterExtendBytes(out, rs.iterOption(rs.iterToOption(it.next())), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(rs.peekablePeek(it)), undefined, true); + rs.drop(it); + const _155: Logged.Logged = logged(); + const _157: Ticks.Ticks = ticks(); + const it2: rs.Iter = rs.iterSkip(rs.iterChain(rs.iterFrom(_155, Logged.next$iter_Iterator, rs.drop), rs.iterFrom({ v: _157 }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v))), 1); + rs.iterExtendBytes(out, rs.iterOption(rs.iterToOption(it2.next())), undefined, true); + const _165: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_165.value, 170); + rs.refMutRelease(_165); + rs.drop(it2); + } else if (_18 === 11) { + const _169: rs.Iter = rs.iterRev(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) })); + for (const _172 of rs.iterToVec(rs.iterZip(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), _169), "next", 2).items) { + rs.byteVecPush(out, rs.u8Add(rs.u8Mul(_172[0], 16), _172[1])); + } + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterMax(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rs.lt, true), 238)); + const _188: Phase.Phase = Phase.of(at(1)); + rs.byteVecPush(out, rs.iterEq(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rs.iterFrom({ v: _188 }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rs.same, undefined, true, true) ? 1 : 0); + rs.iterExtendBytes(out, rs.iterTake(rs.iterCycle(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), { v: (it: rs.Place) => ({ v: it.v }) }), rs.u8Rem(at(1), 8) as rs.usize), "next"); + } else { + let p: Phase.Phase = phase; + rs.iterExtendBytes(out, rs.iterOption(rs.iterNth(rs.iterFrom(rs.place(() => p, (value) => p = value), Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), 0)), undefined, true); + rs.byteVecPush(out, rs.iterAny(rs.iterFrom(rs.place(() => p, (value2) => p = value2), Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), (n5: rs.u8): boolean => { + return n5 === 1; + }) ? 1 : 0); + rs.iterExtendBytes(out, rs.iterTake(rs.iterMap(rs.iterFrom(rs.place(() => p, (value3) => p = value3), Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), (n6: rs.u8): rs.u8 => { + return rs.u8Add(n6, 16); + }), 1), "next"); + rs.byteVecPush(out, rs.iterFrom(rs.place(() => p, (value4) => p = value4), Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }).sizeHint()[0] & 0xff); + const _224: rs.u8 | rs.Done = Phase.next$iter_Iterator(rs.place(() => p, (value5) => p = value5)); + if (_224 !== rs.DONE) { + rs.byteVecPush(out, _224); + } + const lent: rs.Place = rs.place(() => p, (value6) => p = value6); + rs.iterExtendBytes(out, rs.iterOption(rs.iterNth(rs.iterFrom(lent, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), 0)), undefined, true); + rs.byteVecPush(out, rs.iterFrom(lent, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }).sizeHint()[0] & 0xff); + rs.iterExtendBytes(out, rs.iterFrom({ v: p }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), "next"); + let t: Ticks.Ticks = ticks(); + rs.iterExtendBytes(out, rs.iterOption(rs.iterFind(rs.iterFrom(rs.place(() => t, (value7) => t = value7), Ticks.next$iter_Iterator), (n7: rs.u8): boolean => { + return rs.u8Rem(n7, 2) === 0; + })), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$14ju55r(rs.iterPosition(rs.iterFrom(rs.place(() => t, (value8) => t = value8), Ticks.next$iter_Iterator), (n8: rs.u8): boolean => { + return n8 === 0; + }), (i2: rs.usize): rs.u8 => { + return i2 & 0xff; + })), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterZip(rs.iterFrom(rs.place(() => t, (value9) => t = value9), Ticks.next$iter_Iterator), rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) })), (_27: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8Mul(_27[0], _27[1]); + }), "next"); + rs.iterExtendBytes(out, rs.iterFrom({ v: t }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v)), "next"); } const _258: rs.RefCell = rs.refCellBorrow(log); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_258.value)); diff --git a/ts/fixtures/lang/joins/expected/joins.ts b/ts/fixtures/lang/joins/expected/joins.ts index 5cf590089..009badf17 100644 --- a/ts/fixtures/lang/joins/expected/joins.ts +++ b/ts/fixtures/lang/joins/expected/joins.ts @@ -69,9 +69,10 @@ export function joins(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { bytes(rs.byteSlicesJoin(rs.sliceFrom(boxed.items)), out); bytes(rs.byteSlicesJoin(rs.sliceFrom(boxed.items), rs.byteSliceFrom(Uint8Array.of(sep))), out); bytes(rs.byteSlicesJoin(rs.sliceFrom(boxed.items), seps), out); - bytes(rs.byteSlicesJoin(rs.sliceFrom([])), out); - bytes(rs.byteSlicesJoin(rs.sliceFrom([]), rs.byteSliceFrom(Uint8Array.of(sep))), out); - bytes(rs.byteSlicesJoin(rs.sliceFrom([]), seps), out); + const _71: rs.ByteSlice[] = []; + bytes(rs.byteSlicesJoin(rs.sliceFrom(_71)), out); + bytes(rs.byteSlicesJoin(rs.sliceFrom(_71), rs.byteSliceFrom(Uint8Array.of(sep))), out); + bytes(rs.byteSlicesJoin(rs.sliceFrom(_71), seps), out); } else if (_26 === 1) { const at: (a0: rs.usize) => rs.u8 = (i5: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i5), i5 & 0xff); @@ -98,8 +99,9 @@ export function joins(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { bytes(rs.byteSlicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom(zeros.items, rs.byteSliceFrom)), undefined, rs.byteSliceFrom), out); bytes(rs.byteSlicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom(zeros.items, rs.byteSliceFrom)), rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); bytes(rs.byteSlicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom(zeros.items, rs.byteSliceFrom)), seps, rs.byteSliceFrom), out); - bytes(rs.byteSlicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom([], rs.byteSliceFrom)), undefined, rs.byteSliceFrom), out); - bytes(rs.byteSlicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom([], rs.byteSliceFrom)), rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); + const _138: Uint8Array[] = []; + bytes(rs.byteSlicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom(_138, rs.byteSliceFrom)), undefined, rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom(_138, rs.byteSliceFrom)), rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); } else if (_26 === 2) { const sep2: rs.u16 = (((sep as rs.u16) << 8) & 0xffff) | 1; const wide: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(parts)), (p5: rs.ByteSlice): rs.Vec => { @@ -200,8 +202,9 @@ export function joins(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _428: rs.Slice = rs.sliceFrom(borrowed.items); const _430: string = sep4.v; put(out, rs.strsJoin(rs.sliceItems(_428), _430).v); - put(out, rs.strsJoin([], "").v); - const _443: rs.Slice = rs.sliceFrom([]); + const _432: rs.String[] = []; + put(out, rs.strsJoin(_432, "").v); + const _443: rs.Slice = rs.sliceFrom(_432); const _445: string = sep4.v; put(out, rs.strsJoin(rs.sliceItems(_443), _445).v); } else if (_26 === 5) { diff --git a/ts/fixtures/lang/keys/expected/keys.ts b/ts/fixtures/lang/keys/expected/keys.ts index 42dc0061b..d8b40a57a 100644 --- a/ts/fixtures/lang/keys/expected/keys.ts +++ b/ts/fixtures/lang/keys/expected/keys.ts @@ -536,11 +536,6 @@ export function borrows(dataData: Uint8Array, dataStart: number, dataLen: number /** `Option`s compared, ordered, and hashed, alone and in keys. */ export function options(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let _12!: rs.usize; - const _313: (a0: rs.u8) => Way.Way | undefined | rs.None = (b2: rs.u8): Way.Way | undefined | rs.None => { - return then$05y10ww(rs.u8Rem(b2, 5) !== 0, (): Way.Way | undefined => { - return way(b2); - }); - }; const hashed: rs.HashMap<[rs.u8, Horizon.Horizon], rs.u8> = rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, Horizon.hash$Hash_hash_DefaultHasher as (a0: Horizon.Horizon, a1: rs.Hasher) => undefined]), rs.eqTuple([rs.same, Horizon.eq$cmp_PartialEq]))) as rs.HashMap<[rs.u8, Horizon.Horizon], rs.u8>; const sorted: rs.BTreeMap<[rs.u8, Horizon.Horizon], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, Horizon.Horizon], rs.Ordering>([rs.cmp, Horizon.cmp$cmp_Ord])) as rs.BTreeMap<[rs.u8, Horizon.Horizon], rs.u8>; const ways: rs.HashMap<[Way.Way | undefined, boolean], rs.u8> = rs.hashNew(rs.hashing(rs.hashTuple([rs.hashOption(Way.hash$Hash_hash_DefaultHasher as (a0: Way.Way, a1: rs.Hasher) => undefined), rs.hash8]), rs.eqTuple([rs.eqOption(Way.eq$cmp_PartialEq), rs.same]))) as rs.HashMap<[Way.Way | undefined, boolean], rs.u8>; @@ -620,6 +615,11 @@ export function options(dataData: Uint8Array, dataStart: number, dataLen: number rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(bare, _304, i & 0xff), 204)); const _312: Way.Way | undefined = way(d); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashGet(bare, _312), 221)); + const _313: (a0: rs.u8) => Way.Way | undefined | rs.None = (b2: rs.u8): Way.Way | undefined | rs.None => { + return then$05y10ww(rs.u8Rem(b2, 5) !== 0, (): Way.Way | undefined => { + return way(b2); + }); + }; const _319: Way.Way | undefined | rs.None = _313(c); const _316: rs.u8 = rs.hashAdd(deep, _319) ? 1 : 0; const _327: Way.Way | undefined | rs.None = _313(d); diff --git a/ts/fixtures/lang/lengths/expected/lengths.ts b/ts/fixtures/lang/lengths/expected/lengths.ts index 45832e90a..7b08fc2bc 100644 --- a/ts/fixtures/lang/lengths/expected/lengths.ts +++ b/ts/fixtures/lang/lengths/expected/lengths.ts @@ -1956,47 +1956,38 @@ export function put$lengths_Put_array3_u8(self: rs.ByteSlice, out: rs.ByteVec): */ export function swapped$u32_0(data: rs.ByteSlice, rows: rs.ArraySlice>, out: rs.ByteVec): void { const _6: [rs.Slice, rs.ArraySlice>] | undefined = rs.arraySliceSplitFirst(rows); - b0: { - if (_6 !== undefined) { - const item = copy$array_u32(rs.sliceToArray(_6[0])); - const grid: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { - return copy$array_u32(item); - }); - const _9: rs.Slice | undefined = rs.arraySliceFirst(_6[1]); - if (_9 !== undefined) { - const next: rs.u32[] = rs.sliceToArray(_9); - grid[1] = copy$array_u32(next); + if (_6 !== undefined) { + const item = copy$array_u32(rs.sliceToArray(_6[0])); + const grid: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { + return copy$array_u32(item); + }); + const _9: rs.Slice | undefined = rs.arraySliceFirst(_6[1]); + if (_9 !== undefined) { + const next: rs.u32[] = rs.sliceToArray(_9); + grid[1] = copy$array_u32(next); + } + for (const byte of rs.byteSliceView(data)) { + const row: rs.u32[] = copy$array_u32(grid[0]); + const _23: rs.u32[] = copy$array_u32(grid[1]); + grid[0] = _23; + const _28: rs.u32[] = copy$array_u32(row); + grid[1] = _28; + const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); + if (!(_35 < 2)) { + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); } - const iterS: Uint8Array = rs.byteSliceView(data); - let iterI: number = 0; - while (true) { - const _16: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; - if (_16 === rs.DONE) { - break b0; - } - const byte: rs.u8 = _16; - const row: rs.u32[] = copy$array_u32(grid[0]); - const _23: rs.u32[] = copy$array_u32(grid[1]); - grid[0] = _23; - const _28: rs.u32[] = copy$array_u32(row); - grid[1] = _28; - const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); - if (!(_35 < 2)) { - rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); + const _32: rs.Place | undefined = rs.sliceFirstMut(rs.sliceFrom(grid[_35])); + const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); + rs.idx(rows, _42); + const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rs.arraySliceAt(rows, _42))]; + if (_32 !== undefined) { + if (_31[1] !== undefined) { + _32.v = _31[1]; } - const _32: rs.Place | undefined = rs.sliceFirstMut(rs.sliceFrom(grid[_35])); - const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); - rs.idx(rows, _42); - const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rs.arraySliceAt(rows, _42))]; - if (_32 !== undefined) { - if (_31[1] !== undefined) { - _32.v = _31[1]; - } - } - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.sliceFrom)), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 0)), (_2: rs.u32): rs.u8 => { - return _2 & 0xff; - }), undefined, true); } + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.sliceFrom)), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 0)), (_2: rs.u32): rs.u8 => { + return _2 & 0xff; + }), undefined, true); } } } @@ -2007,47 +1998,38 @@ export function swapped$u32_0(data: rs.ByteSlice, rows: rs.ArraySlice>, out: rs.ByteVec): void { const _6: [rs.Slice, rs.ArraySlice>] | undefined = rs.arraySliceSplitFirst(rows); - b0: { - if (_6 !== undefined) { - const item = copy$array_u32(rs.sliceToArray(_6[0])); - const grid: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { - return copy$array_u32(item); - }); - const _9: rs.Slice | undefined = rs.arraySliceFirst(_6[1]); - if (_9 !== undefined) { - const next: rs.u32[] = rs.sliceToArray(_9); - grid[1] = copy$array_u32(next); + if (_6 !== undefined) { + const item = copy$array_u32(rs.sliceToArray(_6[0])); + const grid: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { + return copy$array_u32(item); + }); + const _9: rs.Slice | undefined = rs.arraySliceFirst(_6[1]); + if (_9 !== undefined) { + const next: rs.u32[] = rs.sliceToArray(_9); + grid[1] = copy$array_u32(next); + } + for (const byte of rs.byteSliceView(data)) { + const row: rs.u32[] = copy$array_u32(grid[0]); + const _23: rs.u32[] = copy$array_u32(grid[1]); + grid[0] = _23; + const _28: rs.u32[] = copy$array_u32(row); + grid[1] = _28; + const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); + if (!(_35 < 2)) { + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); } - const iterS: Uint8Array = rs.byteSliceView(data); - let iterI: number = 0; - while (true) { - const _16: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; - if (_16 === rs.DONE) { - break b0; - } - const byte: rs.u8 = _16; - const row: rs.u32[] = copy$array_u32(grid[0]); - const _23: rs.u32[] = copy$array_u32(grid[1]); - grid[0] = _23; - const _28: rs.u32[] = copy$array_u32(row); - grid[1] = _28; - const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); - if (!(_35 < 2)) { - rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); + const _32: rs.Place | undefined = rs.sliceFirstMut(rs.sliceFrom(grid[_35])); + const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); + rs.idx(rows, _42); + const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rs.arraySliceAt(rows, _42))]; + if (_32 !== undefined) { + if (_31[1] !== undefined) { + _32.v = _31[1]; } - const _32: rs.Place | undefined = rs.sliceFirstMut(rs.sliceFrom(grid[_35])); - const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); - rs.idx(rows, _42); - const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rs.arraySliceAt(rows, _42))]; - if (_32 !== undefined) { - if (_31[1] !== undefined) { - _32.v = _31[1]; - } - } - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.sliceFrom)), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 1)), (_2: rs.u32): rs.u8 => { - return _2 & 0xff; - }), undefined, true); } + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.sliceFrom)), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 1)), (_2: rs.u32): rs.u8 => { + return _2 & 0xff; + }), undefined, true); } } } @@ -2058,47 +2040,38 @@ export function swapped$u32_1(data: rs.ByteSlice, rows: rs.ArraySlice>, out: rs.ByteVec): void { const _6: [rs.Slice, rs.ArraySlice>] | undefined = rs.arraySliceSplitFirst(rows); - b0: { - if (_6 !== undefined) { - const item = copy$array_u32(rs.sliceToArray(_6[0])); - const grid: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { - return copy$array_u32(item); - }); - const _9: rs.Slice | undefined = rs.arraySliceFirst(_6[1]); - if (_9 !== undefined) { - const next: rs.u32[] = rs.sliceToArray(_9); - grid[1] = copy$array_u32(next); + if (_6 !== undefined) { + const item = copy$array_u32(rs.sliceToArray(_6[0])); + const grid: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { + return copy$array_u32(item); + }); + const _9: rs.Slice | undefined = rs.arraySliceFirst(_6[1]); + if (_9 !== undefined) { + const next: rs.u32[] = rs.sliceToArray(_9); + grid[1] = copy$array_u32(next); + } + for (const byte of rs.byteSliceView(data)) { + const row: rs.u32[] = copy$array_u32(grid[0]); + const _23: rs.u32[] = copy$array_u32(grid[1]); + grid[0] = _23; + const _28: rs.u32[] = copy$array_u32(row); + grid[1] = _28; + const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); + if (!(_35 < 2)) { + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); } - const iterS: Uint8Array = rs.byteSliceView(data); - let iterI: number = 0; - while (true) { - const _16: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; - if (_16 === rs.DONE) { - break b0; + const _32: rs.Place | undefined = rs.sliceFirstMut(rs.sliceFrom(grid[_35])); + const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); + rs.idx(rows, _42); + const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rs.arraySliceAt(rows, _42))]; + if (_32 !== undefined) { + if (_31[1] !== undefined) { + _32.v = _31[1]; } - const byte: rs.u8 = _16; - const row: rs.u32[] = copy$array_u32(grid[0]); - const _23: rs.u32[] = copy$array_u32(grid[1]); - grid[0] = _23; - const _28: rs.u32[] = copy$array_u32(row); - grid[1] = _28; - const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); - if (!(_35 < 2)) { - rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); - } - const _32: rs.Place | undefined = rs.sliceFirstMut(rs.sliceFrom(grid[_35])); - const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); - rs.idx(rows, _42); - const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rs.arraySliceAt(rows, _42))]; - if (_32 !== undefined) { - if (_31[1] !== undefined) { - _32.v = _31[1]; - } - } - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.sliceFrom)), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 17)), (_2: rs.u32): rs.u8 => { - return _2 & 0xff; - }), undefined, true); } + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.sliceFrom)), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 17)), (_2: rs.u32): rs.u8 => { + return _2 & 0xff; + }), undefined, true); } } } @@ -2109,47 +2082,38 @@ export function swapped$u32_17(data: rs.ByteSlice, rows: rs.ArraySlice>, out: rs.ByteVec): void { const _6: [rs.Slice, rs.ArraySlice>] | undefined = rs.arraySliceSplitFirst(rows); - b0: { - if (_6 !== undefined) { - const item = copy$array_u32(rs.sliceToArray(_6[0])); - const grid: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { - return copy$array_u32(item); - }); - const _9: rs.Slice | undefined = rs.arraySliceFirst(_6[1]); - if (_9 !== undefined) { - const next: rs.u32[] = rs.sliceToArray(_9); - grid[1] = copy$array_u32(next); + if (_6 !== undefined) { + const item = copy$array_u32(rs.sliceToArray(_6[0])); + const grid: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { + return copy$array_u32(item); + }); + const _9: rs.Slice | undefined = rs.arraySliceFirst(_6[1]); + if (_9 !== undefined) { + const next: rs.u32[] = rs.sliceToArray(_9); + grid[1] = copy$array_u32(next); + } + for (const byte of rs.byteSliceView(data)) { + const row: rs.u32[] = copy$array_u32(grid[0]); + const _23: rs.u32[] = copy$array_u32(grid[1]); + grid[0] = _23; + const _28: rs.u32[] = copy$array_u32(row); + grid[1] = _28; + const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); + if (!(_35 < 2)) { + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); } - const iterS: Uint8Array = rs.byteSliceView(data); - let iterI: number = 0; - while (true) { - const _16: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; - if (_16 === rs.DONE) { - break b0; - } - const byte: rs.u8 = _16; - const row: rs.u32[] = copy$array_u32(grid[0]); - const _23: rs.u32[] = copy$array_u32(grid[1]); - grid[0] = _23; - const _28: rs.u32[] = copy$array_u32(row); - grid[1] = _28; - const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); - if (!(_35 < 2)) { - rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); - } - const _32: rs.Place | undefined = rs.sliceFirstMut(rs.sliceFrom(grid[_35])); - const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); - rs.idx(rows, _42); - const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rs.arraySliceAt(rows, _42))]; - if (_32 !== undefined) { - if (_31[1] !== undefined) { - _32.v = _31[1]; - } + const _32: rs.Place | undefined = rs.sliceFirstMut(rs.sliceFrom(grid[_35])); + const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); + rs.idx(rows, _42); + const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rs.arraySliceAt(rows, _42))]; + if (_32 !== undefined) { + if (_31[1] !== undefined) { + _32.v = _31[1]; } - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.sliceFrom)), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 3)), (_2: rs.u32): rs.u8 => { - return _2 & 0xff; - }), undefined, true); } + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.sliceFrom)), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 3)), (_2: rs.u32): rs.u8 => { + return _2 & 0xff; + }), undefined, true); } } } @@ -2160,47 +2124,38 @@ export function swapped$u32_3(data: rs.ByteSlice, rows: rs.ArraySlice, out: rs.ByteVec): void { const _6: [rs.ByteSlice, rs.ArraySlice] | undefined = rs.arraySliceSplitFirst(rows); - b0: { - if (_6 !== undefined) { - const item = copy$array_u8(rs.byteSliceToArray(_6[0])); - const grid: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { - return copy$array_u8(item); - }); - const _9: rs.ByteSlice | undefined = rs.arraySliceFirst(_6[1]); - if (_9 !== undefined) { - const next: Uint8Array = rs.byteSliceToArray(_9); - grid[1] = copy$array_u8(next); + if (_6 !== undefined) { + const item = copy$array_u8(rs.byteSliceToArray(_6[0])); + const grid: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { + return copy$array_u8(item); + }); + const _9: rs.ByteSlice | undefined = rs.arraySliceFirst(_6[1]); + if (_9 !== undefined) { + const next: Uint8Array = rs.byteSliceToArray(_9); + grid[1] = copy$array_u8(next); + } + for (const byte of rs.byteSliceView(data)) { + const row: Uint8Array = copy$array_u8(grid[0]); + const _23: Uint8Array = copy$array_u8(grid[1]); + grid[0] = _23; + const _28: Uint8Array = copy$array_u8(row); + grid[1] = _28; + const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); + if (!(_35 < 2)) { + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); } - const iterS: Uint8Array = rs.byteSliceView(data); - let iterI: number = 0; - while (true) { - const _16: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; - if (_16 === rs.DONE) { - break b0; - } - const byte: rs.u8 = _16; - const row: Uint8Array = copy$array_u8(grid[0]); - const _23: Uint8Array = copy$array_u8(grid[1]); - grid[0] = _23; - const _28: Uint8Array = copy$array_u8(row); - grid[1] = _28; - const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); - if (!(_35 < 2)) { - rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); - } - const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceFrom(grid[_35])); - const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); - rs.idx(rows, _42); - const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.arraySliceAt(rows, _42))]; - if (_32 !== undefined) { - if (_31[1] !== undefined) { - _32.v = _31[1]; - } + const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceFrom(grid[_35])); + const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); + rs.idx(rows, _42); + const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.arraySliceAt(rows, _42))]; + if (_32 !== undefined) { + if (_31[1] !== undefined) { + _32.v = _31[1]; } - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0)), (_2: rs.u8): rs.u8 => { - return (_2 as rs.u32) & 0xff; - }), undefined, true); } + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0)), (_2: rs.u8): rs.u8 => { + return (_2 as rs.u32) & 0xff; + }), undefined, true); } } } @@ -2211,47 +2166,38 @@ export function swapped$u8_0(data: rs.ByteSlice, rows: rs.ArraySlice, out: rs.ByteVec): void { const _6: [rs.ByteSlice, rs.ArraySlice] | undefined = rs.arraySliceSplitFirst(rows); - b0: { - if (_6 !== undefined) { - const item = copy$array_u8(rs.byteSliceToArray(_6[0])); - const grid: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { - return copy$array_u8(item); - }); - const _9: rs.ByteSlice | undefined = rs.arraySliceFirst(_6[1]); - if (_9 !== undefined) { - const next: Uint8Array = rs.byteSliceToArray(_9); - grid[1] = copy$array_u8(next); + if (_6 !== undefined) { + const item = copy$array_u8(rs.byteSliceToArray(_6[0])); + const grid: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { + return copy$array_u8(item); + }); + const _9: rs.ByteSlice | undefined = rs.arraySliceFirst(_6[1]); + if (_9 !== undefined) { + const next: Uint8Array = rs.byteSliceToArray(_9); + grid[1] = copy$array_u8(next); + } + for (const byte of rs.byteSliceView(data)) { + const row: Uint8Array = copy$array_u8(grid[0]); + const _23: Uint8Array = copy$array_u8(grid[1]); + grid[0] = _23; + const _28: Uint8Array = copy$array_u8(row); + grid[1] = _28; + const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); + if (!(_35 < 2)) { + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); } - const iterS: Uint8Array = rs.byteSliceView(data); - let iterI: number = 0; - while (true) { - const _16: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; - if (_16 === rs.DONE) { - break b0; - } - const byte: rs.u8 = _16; - const row: Uint8Array = copy$array_u8(grid[0]); - const _23: Uint8Array = copy$array_u8(grid[1]); - grid[0] = _23; - const _28: Uint8Array = copy$array_u8(row); - grid[1] = _28; - const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); - if (!(_35 < 2)) { - rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); - } - const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceFrom(grid[_35])); - const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); - rs.idx(rows, _42); - const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.arraySliceAt(rows, _42))]; - if (_32 !== undefined) { - if (_31[1] !== undefined) { - _32.v = _31[1]; - } + const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceFrom(grid[_35])); + const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); + rs.idx(rows, _42); + const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.arraySliceAt(rows, _42))]; + if (_32 !== undefined) { + if (_31[1] !== undefined) { + _32.v = _31[1]; } - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 1)), (_2: rs.u8): rs.u8 => { - return (_2 as rs.u32) & 0xff; - }), undefined, true); } + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 1)), (_2: rs.u8): rs.u8 => { + return (_2 as rs.u32) & 0xff; + }), undefined, true); } } } @@ -2262,47 +2208,38 @@ export function swapped$u8_1(data: rs.ByteSlice, rows: rs.ArraySlice, out: rs.ByteVec): void { const _6: [rs.ByteSlice, rs.ArraySlice] | undefined = rs.arraySliceSplitFirst(rows); - b0: { - if (_6 !== undefined) { - const item = copy$array_u8(rs.byteSliceToArray(_6[0])); - const grid: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { - return copy$array_u8(item); - }); - const _9: rs.ByteSlice | undefined = rs.arraySliceFirst(_6[1]); - if (_9 !== undefined) { - const next: Uint8Array = rs.byteSliceToArray(_9); - grid[1] = copy$array_u8(next); + if (_6 !== undefined) { + const item = copy$array_u8(rs.byteSliceToArray(_6[0])); + const grid: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { + return copy$array_u8(item); + }); + const _9: rs.ByteSlice | undefined = rs.arraySliceFirst(_6[1]); + if (_9 !== undefined) { + const next: Uint8Array = rs.byteSliceToArray(_9); + grid[1] = copy$array_u8(next); + } + for (const byte of rs.byteSliceView(data)) { + const row: Uint8Array = copy$array_u8(grid[0]); + const _23: Uint8Array = copy$array_u8(grid[1]); + grid[0] = _23; + const _28: Uint8Array = copy$array_u8(row); + grid[1] = _28; + const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); + if (!(_35 < 2)) { + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); } - const iterS: Uint8Array = rs.byteSliceView(data); - let iterI: number = 0; - while (true) { - const _16: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; - if (_16 === rs.DONE) { - break b0; + const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceFrom(grid[_35])); + const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); + rs.idx(rows, _42); + const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.arraySliceAt(rows, _42))]; + if (_32 !== undefined) { + if (_31[1] !== undefined) { + _32.v = _31[1]; } - const byte: rs.u8 = _16; - const row: Uint8Array = copy$array_u8(grid[0]); - const _23: Uint8Array = copy$array_u8(grid[1]); - grid[0] = _23; - const _28: Uint8Array = copy$array_u8(row); - grid[1] = _28; - const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); - if (!(_35 < 2)) { - rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); - } - const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceFrom(grid[_35])); - const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); - rs.idx(rows, _42); - const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.arraySliceAt(rows, _42))]; - if (_32 !== undefined) { - if (_31[1] !== undefined) { - _32.v = _31[1]; - } - } - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 17)), (_2: rs.u8): rs.u8 => { - return (_2 as rs.u32) & 0xff; - }), undefined, true); } + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 17)), (_2: rs.u8): rs.u8 => { + return (_2 as rs.u32) & 0xff; + }), undefined, true); } } } @@ -2313,47 +2250,38 @@ export function swapped$u8_17(data: rs.ByteSlice, rows: rs.ArraySlice, out: rs.ByteVec): void { const _6: [rs.ByteSlice, rs.ArraySlice] | undefined = rs.arraySliceSplitFirst(rows); - b0: { - if (_6 !== undefined) { - const item = copy$array_u8(rs.byteSliceToArray(_6[0])); - const grid: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { - return copy$array_u8(item); - }); - const _9: rs.ByteSlice | undefined = rs.arraySliceFirst(_6[1]); - if (_9 !== undefined) { - const next: Uint8Array = rs.byteSliceToArray(_9); - grid[1] = copy$array_u8(next); + if (_6 !== undefined) { + const item = copy$array_u8(rs.byteSliceToArray(_6[0])); + const grid: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { + return copy$array_u8(item); + }); + const _9: rs.ByteSlice | undefined = rs.arraySliceFirst(_6[1]); + if (_9 !== undefined) { + const next: Uint8Array = rs.byteSliceToArray(_9); + grid[1] = copy$array_u8(next); + } + for (const byte of rs.byteSliceView(data)) { + const row: Uint8Array = copy$array_u8(grid[0]); + const _23: Uint8Array = copy$array_u8(grid[1]); + grid[0] = _23; + const _28: Uint8Array = copy$array_u8(row); + grid[1] = _28; + const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); + if (!(_35 < 2)) { + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); } - const iterS: Uint8Array = rs.byteSliceView(data); - let iterI: number = 0; - while (true) { - const _16: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; - if (_16 === rs.DONE) { - break b0; - } - const byte: rs.u8 = _16; - const row: Uint8Array = copy$array_u8(grid[0]); - const _23: Uint8Array = copy$array_u8(grid[1]); - grid[0] = _23; - const _28: Uint8Array = copy$array_u8(row); - grid[1] = _28; - const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); - if (!(_35 < 2)) { - rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); + const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceFrom(grid[_35])); + const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); + rs.idx(rows, _42); + const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.arraySliceAt(rows, _42))]; + if (_32 !== undefined) { + if (_31[1] !== undefined) { + _32.v = _31[1]; } - const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceFrom(grid[_35])); - const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); - rs.idx(rows, _42); - const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.arraySliceAt(rows, _42))]; - if (_32 !== undefined) { - if (_31[1] !== undefined) { - _32.v = _31[1]; - } - } - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 3)), (_2: rs.u8): rs.u8 => { - return (_2 as rs.u32) & 0xff; - }), undefined, true); } + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 3)), (_2: rs.u8): rs.u8 => { + return (_2 as rs.u32) & 0xff; + }), undefined, true); } } } diff --git a/ts/fixtures/lang/lists/expected/lists.Tally.ts b/ts/fixtures/lang/lists/expected/lists.Tally.ts index 43371170f..563ae0470 100644 --- a/ts/fixtures/lang/lists/expected/lists.Tally.ts +++ b/ts/fixtures/lang/lists/expected/lists.Tally.ts @@ -7,10 +7,7 @@ export function clone$Clone(self: Tally): Tally { } export function fmt$fmt_Debug(self: Tally, f: rs.Formatter): rs.Result { - const _3: string = "Tally"; - const _4: string = "n"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.u16Debug(self.n, f); - return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5)); + return rs.fmtDebugFields(f, "Tally n", [(f: rs.Formatter) => rs.u16Debug(self.n, f)]); } export function default$Default(): Tally { diff --git a/ts/fixtures/lang/lists/expected/lists.ts b/ts/fixtures/lang/lists/expected/lists.ts index 049e0bc0b..aa337d522 100644 --- a/ts/fixtures/lang/lists/expected/lists.ts +++ b/ts/fixtures/lang/lists/expected/lists.ts @@ -105,10 +105,11 @@ export function lists(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { while (true) { const _144: rs.Place | rs.Done = iter3.next(); if (_144 === rs.DONE) { - continue l1; + break; } _144.v = rs.intRotateLeft(_144.v, 1, 8, false); } + continue l1; } } } diff --git a/ts/fixtures/lang/methods/expected/methods.ts b/ts/fixtures/lang/methods/expected/methods.ts index a8e5dd701..c27b65e84 100644 --- a/ts/fixtures/lang/methods/expected/methods.ts +++ b/ts/fixtures/lang/methods/expected/methods.ts @@ -5,13 +5,6 @@ import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1ocvprc as option_map$ /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _22: (a0: rs.ByteVec, a1: rs.u8) => undefined = (out2: rs.ByteVec, v4: rs.u8): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u8ToBeBytes(v4))); - rs.byteVecPush(out2, rs.u8FromBeBytes(rs.u8ToBeBytes(v4)) === v4 ? 1 : 0); - }; - const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v5: rs.u32): undefined => { - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v5))); - }; const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; @@ -26,20 +19,27 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { })); const o: rs.i8 = (b << 24) >> 24; const k: rs.u32 = rs.u32Rem(n, 3 * 8); - const putOpt: (a0: rs.ByteVec, a1: rs.u8 | undefined) => undefined = (out4: rs.ByteVec, v6: rs.u8 | undefined): undefined => { - if (v6 === undefined) { - rs.byteVecPush(out4, 0); + const _22: (a0: rs.ByteVec, a1: rs.u8) => undefined = (out2: rs.ByteVec, v4: rs.u8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u8ToBeBytes(v4))); + rs.byteVecPush(out2, rs.u8FromBeBytes(rs.u8ToBeBytes(v4)) === v4 ? 1 : 0); + }; + const putOpt: (a0: rs.ByteVec, a1: rs.u8 | undefined) => undefined = (out3: rs.ByteVec, v5: rs.u8 | undefined): undefined => { + if (v5 === undefined) { + rs.byteVecPush(out3, 0); } else { - const v7: rs.u8 = v6; - rs.byteVecPush(out4, 1); - _22(out4, v7); + const v6: rs.u8 = v5; + rs.byteVecPush(out3, 1); + _22(out3, v6); } }; - const putPair: (a0: rs.ByteVec, a1: [rs.u8, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.u8, boolean]): undefined => { - const v8: rs.u8 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.u8, boolean]) => undefined = (out4: rs.ByteVec, _37: [rs.u8, boolean]): undefined => { + const v7: rs.u8 = _37[0]; const over: boolean = _37[1]; - _22(out5, v8); - rs.byteVecPush(out5, over ? 1 : 0); + _22(out4, v7); + rs.byteVecPush(out4, over ? 1 : 0); + }; + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out5: rs.ByteVec, v8: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out5, rs.byteSliceFrom(rs.u32ToBeBytes(v8))); }; const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v9: rs.u32 | undefined): undefined => { if (v9 === undefined) { @@ -475,13 +475,6 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _22: (a0: rs.ByteVec, a1: rs.u16) => undefined = (out2: rs.ByteVec, v4: rs.u16): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u16ToBeBytes(v4))); - rs.byteVecPush(out2, rs.u16FromBeBytes(rs.u16ToBeBytes(v4)) === v4 ? 1 : 0); - }; - const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v5: rs.u32): undefined => { - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v5))); - }; const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; @@ -496,20 +489,27 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { })); const o: rs.i16 = (b << 16) >> 16; const k: rs.u32 = rs.u32Rem(n, 3 * 16); - const putOpt: (a0: rs.ByteVec, a1: rs.u16 | undefined) => undefined = (out4: rs.ByteVec, v6: rs.u16 | undefined): undefined => { - if (v6 === undefined) { - rs.byteVecPush(out4, 0); + const _22: (a0: rs.ByteVec, a1: rs.u16) => undefined = (out2: rs.ByteVec, v4: rs.u16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u16ToBeBytes(v4))); + rs.byteVecPush(out2, rs.u16FromBeBytes(rs.u16ToBeBytes(v4)) === v4 ? 1 : 0); + }; + const putOpt: (a0: rs.ByteVec, a1: rs.u16 | undefined) => undefined = (out3: rs.ByteVec, v5: rs.u16 | undefined): undefined => { + if (v5 === undefined) { + rs.byteVecPush(out3, 0); } else { - const v7: rs.u16 = v6; - rs.byteVecPush(out4, 1); - _22(out4, v7); + const v6: rs.u16 = v5; + rs.byteVecPush(out3, 1); + _22(out3, v6); } }; - const putPair: (a0: rs.ByteVec, a1: [rs.u16, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.u16, boolean]): undefined => { - const v8: rs.u16 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.u16, boolean]) => undefined = (out4: rs.ByteVec, _37: [rs.u16, boolean]): undefined => { + const v7: rs.u16 = _37[0]; const over: boolean = _37[1]; - _22(out5, v8); - rs.byteVecPush(out5, over ? 1 : 0); + _22(out4, v7); + rs.byteVecPush(out4, over ? 1 : 0); + }; + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out5: rs.ByteVec, v8: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out5, rs.byteSliceFrom(rs.u32ToBeBytes(v8))); }; const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v9: rs.u32 | undefined): undefined => { if (v9 === undefined) { @@ -945,13 +945,6 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _22: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out2: rs.ByteVec, v4: rs.u32): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u32ToBeBytes(v4))); - rs.byteVecPush(out2, rs.u32FromBeBytes(rs.u32ToBeBytes(v4)) === v4 ? 1 : 0); - }; - const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v5: rs.u32): undefined => { - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v5))); - }; const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; @@ -966,20 +959,27 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { })); const o: rs.i32 = b | 0; const k: rs.u32 = rs.u32Rem(n, 3 * 32); - const putOpt: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out4: rs.ByteVec, v6: rs.u32 | undefined): undefined => { - if (v6 === undefined) { - rs.byteVecPush(out4, 0); + const _22: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out2: rs.ByteVec, v4: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u32ToBeBytes(v4))); + rs.byteVecPush(out2, rs.u32FromBeBytes(rs.u32ToBeBytes(v4)) === v4 ? 1 : 0); + }; + const putOpt: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out3: rs.ByteVec, v5: rs.u32 | undefined): undefined => { + if (v5 === undefined) { + rs.byteVecPush(out3, 0); } else { - const v7: rs.u32 = v6; - rs.byteVecPush(out4, 1); - _22(out4, v7); + const v6: rs.u32 = v5; + rs.byteVecPush(out3, 1); + _22(out3, v6); } }; - const putPair: (a0: rs.ByteVec, a1: [rs.u32, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.u32, boolean]): undefined => { - const v8: rs.u32 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.u32, boolean]) => undefined = (out4: rs.ByteVec, _37: [rs.u32, boolean]): undefined => { + const v7: rs.u32 = _37[0]; const over: boolean = _37[1]; - _22(out5, v8); - rs.byteVecPush(out5, over ? 1 : 0); + _22(out4, v7); + rs.byteVecPush(out4, over ? 1 : 0); + }; + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out5: rs.ByteVec, v8: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out5, rs.byteSliceFrom(rs.u32ToBeBytes(v8))); }; const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v9: rs.u32 | undefined): undefined => { if (v9 === undefined) { @@ -1415,13 +1415,6 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _22: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, v4: rs.u64): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u64ToBeBytes(v4))); - rs.byteVecPush(out2, rs.u64Eq(rs.u64FromBeBytes(rs.u64ToBeBytes(v4)), v4) ? 1 : 0); - }; - const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v5: rs.u32): undefined => { - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v5))); - }; const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; @@ -1436,20 +1429,27 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { })); const o: rs.i64 = rs.i64Cast(b); const k: rs.u32 = rs.u32Rem(n, 3 * 64); - const putOpt: (a0: rs.ByteVec, a1: rs.u64 | undefined) => undefined = (out4: rs.ByteVec, v6: rs.u64 | undefined): undefined => { - if (v6 === undefined) { - rs.byteVecPush(out4, 0); + const _22: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, v4: rs.u64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u64ToBeBytes(v4))); + rs.byteVecPush(out2, rs.u64Eq(rs.u64FromBeBytes(rs.u64ToBeBytes(v4)), v4) ? 1 : 0); + }; + const putOpt: (a0: rs.ByteVec, a1: rs.u64 | undefined) => undefined = (out3: rs.ByteVec, v5: rs.u64 | undefined): undefined => { + if (v5 === undefined) { + rs.byteVecPush(out3, 0); } else { - const v7: rs.u64 = v6; - rs.byteVecPush(out4, 1); - _22(out4, v7); + const v6: rs.u64 = v5; + rs.byteVecPush(out3, 1); + _22(out3, v6); } }; - const putPair: (a0: rs.ByteVec, a1: [rs.u64, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.u64, boolean]): undefined => { - const v8: rs.u64 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.u64, boolean]) => undefined = (out4: rs.ByteVec, _37: [rs.u64, boolean]): undefined => { + const v7: rs.u64 = _37[0]; const over: boolean = _37[1]; - _22(out5, v8); - rs.byteVecPush(out5, over ? 1 : 0); + _22(out4, v7); + rs.byteVecPush(out4, over ? 1 : 0); + }; + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out5: rs.ByteVec, v8: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out5, rs.byteSliceFrom(rs.u32ToBeBytes(v8))); }; const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v9: rs.u32 | undefined): undefined => { if (v9 === undefined) { @@ -1885,13 +1885,6 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _22: (a0: rs.ByteVec, a1: rs.u128) => undefined = (out2: rs.ByteVec, v4: rs.u128): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v4))); - rs.byteVecPush(out2, rs.u128Eq(rs.u128FromBeBytes(rs.u128ToBeBytes(v4)), v4) ? 1 : 0); - }; - const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v5: rs.u32): undefined => { - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v5))); - }; const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; @@ -1906,20 +1899,27 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { })); const o: rs.i128 = rs.i128Cast(b); const k: rs.u32 = rs.u32Rem(n, 3 * 128); - const putOpt: (a0: rs.ByteVec, a1: rs.u128 | undefined) => undefined = (out4: rs.ByteVec, v6: rs.u128 | undefined): undefined => { - if (v6 === undefined) { - rs.byteVecPush(out4, 0); + const _22: (a0: rs.ByteVec, a1: rs.u128) => undefined = (out2: rs.ByteVec, v4: rs.u128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v4))); + rs.byteVecPush(out2, rs.u128Eq(rs.u128FromBeBytes(rs.u128ToBeBytes(v4)), v4) ? 1 : 0); + }; + const putOpt: (a0: rs.ByteVec, a1: rs.u128 | undefined) => undefined = (out3: rs.ByteVec, v5: rs.u128 | undefined): undefined => { + if (v5 === undefined) { + rs.byteVecPush(out3, 0); } else { - const v7: rs.u128 = v6; - rs.byteVecPush(out4, 1); - _22(out4, v7); + const v6: rs.u128 = v5; + rs.byteVecPush(out3, 1); + _22(out3, v6); } }; - const putPair: (a0: rs.ByteVec, a1: [rs.u128, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.u128, boolean]): undefined => { - const v8: rs.u128 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.u128, boolean]) => undefined = (out4: rs.ByteVec, _37: [rs.u128, boolean]): undefined => { + const v7: rs.u128 = _37[0]; const over: boolean = _37[1]; - _22(out5, v8); - rs.byteVecPush(out5, over ? 1 : 0); + _22(out4, v7); + rs.byteVecPush(out4, over ? 1 : 0); + }; + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out5: rs.ByteVec, v8: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out5, rs.byteSliceFrom(rs.u32ToBeBytes(v8))); }; const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v9: rs.u32 | undefined): undefined => { if (v9 === undefined) { @@ -2355,13 +2355,6 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _22: (a0: rs.ByteVec, a1: rs.usize) => undefined = (out2: rs.ByteVec, v4: rs.usize): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.usizeToBeBytes(v4))); - rs.byteVecPush(out2, rs.usizeFromBeBytes(rs.usizeToBeBytes(v4)) === v4 ? 1 : 0); - }; - const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v5: rs.u32): undefined => { - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v5))); - }; const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; @@ -2376,20 +2369,27 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { })); const o: rs.isize = b | 0; const k: rs.u32 = rs.u32Rem(n, 3 * 32); - const putOpt: (a0: rs.ByteVec, a1: rs.usize | undefined) => undefined = (out4: rs.ByteVec, v6: rs.usize | undefined): undefined => { - if (v6 === undefined) { - rs.byteVecPush(out4, 0); + const _22: (a0: rs.ByteVec, a1: rs.usize) => undefined = (out2: rs.ByteVec, v4: rs.usize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.usizeToBeBytes(v4))); + rs.byteVecPush(out2, rs.usizeFromBeBytes(rs.usizeToBeBytes(v4)) === v4 ? 1 : 0); + }; + const putOpt: (a0: rs.ByteVec, a1: rs.usize | undefined) => undefined = (out3: rs.ByteVec, v5: rs.usize | undefined): undefined => { + if (v5 === undefined) { + rs.byteVecPush(out3, 0); } else { - const v7: rs.usize = v6; - rs.byteVecPush(out4, 1); - _22(out4, v7); + const v6: rs.usize = v5; + rs.byteVecPush(out3, 1); + _22(out3, v6); } }; - const putPair: (a0: rs.ByteVec, a1: [rs.usize, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.usize, boolean]): undefined => { - const v8: rs.usize = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.usize, boolean]) => undefined = (out4: rs.ByteVec, _37: [rs.usize, boolean]): undefined => { + const v7: rs.usize = _37[0]; const over: boolean = _37[1]; - _22(out5, v8); - rs.byteVecPush(out5, over ? 1 : 0); + _22(out4, v7); + rs.byteVecPush(out4, over ? 1 : 0); + }; + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out5: rs.ByteVec, v8: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out5, rs.byteSliceFrom(rs.u32ToBeBytes(v8))); }; const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v9: rs.u32 | undefined): undefined => { if (v9 === undefined) { @@ -2825,13 +2825,6 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _22: (a0: rs.ByteVec, a1: rs.i8) => undefined = (out2: rs.ByteVec, v8: rs.i8): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i8ToBeBytes(v8))); - rs.byteVecPush(out2, rs.i8FromBeBytes(rs.i8ToBeBytes(v8)) === v8 ? 1 : 0); - }; - const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v9: rs.u32): undefined => { - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v9))); - }; const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; @@ -2846,20 +2839,27 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { })); const o: rs.u8 = b & 0xff; const k: rs.u32 = rs.u32Rem(n, 3 * 8); - const putOpt: (a0: rs.ByteVec, a1: rs.i8 | undefined) => undefined = (out4: rs.ByteVec, v10: rs.i8 | undefined): undefined => { - if (v10 === undefined) { - rs.byteVecPush(out4, 0); + const _22: (a0: rs.ByteVec, a1: rs.i8) => undefined = (out2: rs.ByteVec, v8: rs.i8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i8ToBeBytes(v8))); + rs.byteVecPush(out2, rs.i8FromBeBytes(rs.i8ToBeBytes(v8)) === v8 ? 1 : 0); + }; + const putOpt: (a0: rs.ByteVec, a1: rs.i8 | undefined) => undefined = (out3: rs.ByteVec, v9: rs.i8 | undefined): undefined => { + if (v9 === undefined) { + rs.byteVecPush(out3, 0); } else { - const v11: rs.i8 = v10; - rs.byteVecPush(out4, 1); - _22(out4, v11); + const v10: rs.i8 = v9; + rs.byteVecPush(out3, 1); + _22(out3, v10); } }; - const putPair: (a0: rs.ByteVec, a1: [rs.i8, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.i8, boolean]): undefined => { - const v12: rs.i8 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.i8, boolean]) => undefined = (out4: rs.ByteVec, _37: [rs.i8, boolean]): undefined => { + const v11: rs.i8 = _37[0]; const over3: boolean = _37[1]; - _22(out5, v12); - rs.byteVecPush(out5, over3 ? 1 : 0); + _22(out4, v11); + rs.byteVecPush(out4, over3 ? 1 : 0); + }; + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out5: rs.ByteVec, v12: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out5, rs.byteSliceFrom(rs.u32ToBeBytes(v12))); }; const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v13: rs.u32 | undefined): undefined => { if (v13 === undefined) { @@ -3281,13 +3281,6 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _22: (a0: rs.ByteVec, a1: rs.i16) => undefined = (out2: rs.ByteVec, v8: rs.i16): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i16ToBeBytes(v8))); - rs.byteVecPush(out2, rs.i16FromBeBytes(rs.i16ToBeBytes(v8)) === v8 ? 1 : 0); - }; - const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v9: rs.u32): undefined => { - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v9))); - }; const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; @@ -3302,20 +3295,27 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { })); const o: rs.u16 = b & 0xffff; const k: rs.u32 = rs.u32Rem(n, 3 * 16); - const putOpt: (a0: rs.ByteVec, a1: rs.i16 | undefined) => undefined = (out4: rs.ByteVec, v10: rs.i16 | undefined): undefined => { - if (v10 === undefined) { - rs.byteVecPush(out4, 0); + const _22: (a0: rs.ByteVec, a1: rs.i16) => undefined = (out2: rs.ByteVec, v8: rs.i16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i16ToBeBytes(v8))); + rs.byteVecPush(out2, rs.i16FromBeBytes(rs.i16ToBeBytes(v8)) === v8 ? 1 : 0); + }; + const putOpt: (a0: rs.ByteVec, a1: rs.i16 | undefined) => undefined = (out3: rs.ByteVec, v9: rs.i16 | undefined): undefined => { + if (v9 === undefined) { + rs.byteVecPush(out3, 0); } else { - const v11: rs.i16 = v10; - rs.byteVecPush(out4, 1); - _22(out4, v11); + const v10: rs.i16 = v9; + rs.byteVecPush(out3, 1); + _22(out3, v10); } }; - const putPair: (a0: rs.ByteVec, a1: [rs.i16, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.i16, boolean]): undefined => { - const v12: rs.i16 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.i16, boolean]) => undefined = (out4: rs.ByteVec, _37: [rs.i16, boolean]): undefined => { + const v11: rs.i16 = _37[0]; const over3: boolean = _37[1]; - _22(out5, v12); - rs.byteVecPush(out5, over3 ? 1 : 0); + _22(out4, v11); + rs.byteVecPush(out4, over3 ? 1 : 0); + }; + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out5: rs.ByteVec, v12: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out5, rs.byteSliceFrom(rs.u32ToBeBytes(v12))); }; const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v13: rs.u32 | undefined): undefined => { if (v13 === undefined) { @@ -3737,13 +3737,6 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _22: (a0: rs.ByteVec, a1: rs.i32) => undefined = (out2: rs.ByteVec, v8: rs.i32): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i32ToBeBytes(v8))); - rs.byteVecPush(out2, rs.i32FromBeBytes(rs.i32ToBeBytes(v8)) === v8 ? 1 : 0); - }; - const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v9: rs.u32): undefined => { - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v9))); - }; const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; @@ -3758,20 +3751,27 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { })); const o: rs.u32 = b >>> 0; const k: rs.u32 = rs.u32Rem(n, 3 * 32); - const putOpt: (a0: rs.ByteVec, a1: rs.i32 | undefined) => undefined = (out4: rs.ByteVec, v10: rs.i32 | undefined): undefined => { - if (v10 === undefined) { - rs.byteVecPush(out4, 0); + const _22: (a0: rs.ByteVec, a1: rs.i32) => undefined = (out2: rs.ByteVec, v8: rs.i32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i32ToBeBytes(v8))); + rs.byteVecPush(out2, rs.i32FromBeBytes(rs.i32ToBeBytes(v8)) === v8 ? 1 : 0); + }; + const putOpt: (a0: rs.ByteVec, a1: rs.i32 | undefined) => undefined = (out3: rs.ByteVec, v9: rs.i32 | undefined): undefined => { + if (v9 === undefined) { + rs.byteVecPush(out3, 0); } else { - const v11: rs.i32 = v10; - rs.byteVecPush(out4, 1); - _22(out4, v11); + const v10: rs.i32 = v9; + rs.byteVecPush(out3, 1); + _22(out3, v10); } }; - const putPair: (a0: rs.ByteVec, a1: [rs.i32, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.i32, boolean]): undefined => { - const v12: rs.i32 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.i32, boolean]) => undefined = (out4: rs.ByteVec, _37: [rs.i32, boolean]): undefined => { + const v11: rs.i32 = _37[0]; const over3: boolean = _37[1]; - _22(out5, v12); - rs.byteVecPush(out5, over3 ? 1 : 0); + _22(out4, v11); + rs.byteVecPush(out4, over3 ? 1 : 0); + }; + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out5: rs.ByteVec, v12: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out5, rs.byteSliceFrom(rs.u32ToBeBytes(v12))); }; const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v13: rs.u32 | undefined): undefined => { if (v13 === undefined) { @@ -4193,13 +4193,6 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _22: (a0: rs.ByteVec, a1: rs.i64) => undefined = (out2: rs.ByteVec, v8: rs.i64): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i64ToBeBytes(v8))); - rs.byteVecPush(out2, rs.i64Eq(rs.i64FromBeBytes(rs.i64ToBeBytes(v8)), v8) ? 1 : 0); - }; - const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v9: rs.u32): undefined => { - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v9))); - }; const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; @@ -4214,20 +4207,27 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { })); const o: rs.u64 = rs.u64Cast(b); const k: rs.u32 = rs.u32Rem(n, 3 * 64); - const putOpt: (a0: rs.ByteVec, a1: rs.i64 | undefined) => undefined = (out4: rs.ByteVec, v10: rs.i64 | undefined): undefined => { - if (v10 === undefined) { - rs.byteVecPush(out4, 0); + const _22: (a0: rs.ByteVec, a1: rs.i64) => undefined = (out2: rs.ByteVec, v8: rs.i64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i64ToBeBytes(v8))); + rs.byteVecPush(out2, rs.i64Eq(rs.i64FromBeBytes(rs.i64ToBeBytes(v8)), v8) ? 1 : 0); + }; + const putOpt: (a0: rs.ByteVec, a1: rs.i64 | undefined) => undefined = (out3: rs.ByteVec, v9: rs.i64 | undefined): undefined => { + if (v9 === undefined) { + rs.byteVecPush(out3, 0); } else { - const v11: rs.i64 = v10; - rs.byteVecPush(out4, 1); - _22(out4, v11); + const v10: rs.i64 = v9; + rs.byteVecPush(out3, 1); + _22(out3, v10); } }; - const putPair: (a0: rs.ByteVec, a1: [rs.i64, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.i64, boolean]): undefined => { - const v12: rs.i64 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.i64, boolean]) => undefined = (out4: rs.ByteVec, _37: [rs.i64, boolean]): undefined => { + const v11: rs.i64 = _37[0]; const over3: boolean = _37[1]; - _22(out5, v12); - rs.byteVecPush(out5, over3 ? 1 : 0); + _22(out4, v11); + rs.byteVecPush(out4, over3 ? 1 : 0); + }; + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out5: rs.ByteVec, v12: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out5, rs.byteSliceFrom(rs.u32ToBeBytes(v12))); }; const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v13: rs.u32 | undefined): undefined => { if (v13 === undefined) { @@ -4649,13 +4649,6 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _22: (a0: rs.ByteVec, a1: rs.i128) => undefined = (out2: rs.ByteVec, v8: rs.i128): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v8))); - rs.byteVecPush(out2, rs.i128Eq(rs.i128FromBeBytes(rs.i128ToBeBytes(v8)), v8) ? 1 : 0); - }; - const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v9: rs.u32): undefined => { - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v9))); - }; const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; @@ -4670,20 +4663,27 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { })); const o: rs.u128 = rs.u128Cast(b); const k: rs.u32 = rs.u32Rem(n, 3 * 128); - const putOpt: (a0: rs.ByteVec, a1: rs.i128 | undefined) => undefined = (out4: rs.ByteVec, v10: rs.i128 | undefined): undefined => { - if (v10 === undefined) { - rs.byteVecPush(out4, 0); + const _22: (a0: rs.ByteVec, a1: rs.i128) => undefined = (out2: rs.ByteVec, v8: rs.i128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v8))); + rs.byteVecPush(out2, rs.i128Eq(rs.i128FromBeBytes(rs.i128ToBeBytes(v8)), v8) ? 1 : 0); + }; + const putOpt: (a0: rs.ByteVec, a1: rs.i128 | undefined) => undefined = (out3: rs.ByteVec, v9: rs.i128 | undefined): undefined => { + if (v9 === undefined) { + rs.byteVecPush(out3, 0); } else { - const v11: rs.i128 = v10; - rs.byteVecPush(out4, 1); - _22(out4, v11); + const v10: rs.i128 = v9; + rs.byteVecPush(out3, 1); + _22(out3, v10); } }; - const putPair: (a0: rs.ByteVec, a1: [rs.i128, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.i128, boolean]): undefined => { - const v12: rs.i128 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.i128, boolean]) => undefined = (out4: rs.ByteVec, _37: [rs.i128, boolean]): undefined => { + const v11: rs.i128 = _37[0]; const over3: boolean = _37[1]; - _22(out5, v12); - rs.byteVecPush(out5, over3 ? 1 : 0); + _22(out4, v11); + rs.byteVecPush(out4, over3 ? 1 : 0); + }; + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out5: rs.ByteVec, v12: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out5, rs.byteSliceFrom(rs.u32ToBeBytes(v12))); }; const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v13: rs.u32 | undefined): undefined => { if (v13 === undefined) { @@ -5105,13 +5105,6 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _22: (a0: rs.ByteVec, a1: rs.isize) => undefined = (out2: rs.ByteVec, v8: rs.isize): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.isizeToBeBytes(v8))); - rs.byteVecPush(out2, rs.isizeFromBeBytes(rs.isizeToBeBytes(v8)) === v8 ? 1 : 0); - }; - const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v9: rs.u32): undefined => { - rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v9))); - }; const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; @@ -5126,20 +5119,27 @@ export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { })); const o: rs.usize = b >>> 0; const k: rs.u32 = rs.u32Rem(n, 3 * 32); - const putOpt: (a0: rs.ByteVec, a1: rs.isize | undefined) => undefined = (out4: rs.ByteVec, v10: rs.isize | undefined): undefined => { - if (v10 === undefined) { - rs.byteVecPush(out4, 0); + const _22: (a0: rs.ByteVec, a1: rs.isize) => undefined = (out2: rs.ByteVec, v8: rs.isize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.isizeToBeBytes(v8))); + rs.byteVecPush(out2, rs.isizeFromBeBytes(rs.isizeToBeBytes(v8)) === v8 ? 1 : 0); + }; + const putOpt: (a0: rs.ByteVec, a1: rs.isize | undefined) => undefined = (out3: rs.ByteVec, v9: rs.isize | undefined): undefined => { + if (v9 === undefined) { + rs.byteVecPush(out3, 0); } else { - const v11: rs.isize = v10; - rs.byteVecPush(out4, 1); - _22(out4, v11); + const v10: rs.isize = v9; + rs.byteVecPush(out3, 1); + _22(out3, v10); } }; - const putPair: (a0: rs.ByteVec, a1: [rs.isize, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.isize, boolean]): undefined => { - const v12: rs.isize = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.isize, boolean]) => undefined = (out4: rs.ByteVec, _37: [rs.isize, boolean]): undefined => { + const v11: rs.isize = _37[0]; const over3: boolean = _37[1]; - _22(out5, v12); - rs.byteVecPush(out5, over3 ? 1 : 0); + _22(out4, v11); + rs.byteVecPush(out4, over3 ? 1 : 0); + }; + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out5: rs.ByteVec, v12: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out5, rs.byteSliceFrom(rs.u32ToBeBytes(v12))); }; const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v13: rs.u32 | undefined): undefined => { if (v13 === undefined) { diff --git a/ts/fixtures/lang/nested/expected/nested.ts b/ts/fixtures/lang/nested/expected/nested.ts index e1e300287..2122773e9 100644 --- a/ts/fixtures/lang/nested/expected/nested.ts +++ b/ts/fixtures/lang/nested/expected/nested.ts @@ -482,13 +482,8 @@ export function closures(data: rs.ByteSlice, out: rs.ByteVec): void { * `Some(None)`. The first byte is also the index. */ export function elements(data: rs.ByteSlice, out: rs.ByteVec): void { - const _8: (a0: rs.Place) => undefined = (o8: rs.Place): undefined => { - o8.v = option_mapOr$19a4gco(o8.v, 66, (_2: rs.u8): rs.u8 | undefined => { - return undefined; - }); - }; - const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): rs.u8 | undefined => { - const b: rs.u8 = _22; + const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u8 | undefined => { + const b: rs.u8 = _2; return thenSome$0quywni(rs.u8Rem(b, 2) === 0, b); }), undefined, 2, true); const at: rs.usize = option_mapOr$1d4bp7c(rs.byteSliceFirst(data), 0, (b2: rs.u8): rs.usize => { @@ -496,6 +491,11 @@ export function elements(data: rs.ByteSlice, out: rs.ByteVec): void { }); const v: rs.Vec = rs.vecFrom(items.items.slice()); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.sliceFirst(rs.sliceFrom(v.items), rs.None)), code(rs.sliceLast(rs.sliceFrom(v.items), rs.None)), code(rs.sliceGet(rs.sliceFrom(v.items), at, rs.None)))), undefined, true); + const _8: (a0: rs.Place) => undefined = (o8: rs.Place): undefined => { + o8.v = option_mapOr$19a4gco(o8.v, 66, (_22: rs.u8): rs.u8 | undefined => { + return undefined; + }); + }; rs.byteVecPush(out, code(option_andThen$0q72czq(rs.sliceGetRange(rs.sliceFrom(v.items), at), (s: rs.Slice): rs.u8 | undefined | rs.None => { return rs.sliceFirst(s, rs.None); }))); diff --git a/ts/fixtures/lang/operators/expected/operators.ts b/ts/fixtures/lang/operators/expected/operators.ts index 141752a06..a0f64877d 100644 --- a/ts/fixtures/lang/operators/expected/operators.ts +++ b/ts/fixtures/lang/operators/expected/operators.ts @@ -2487,9 +2487,6 @@ export function two$usize_usize_usize_ops_Sub_sub_usize_usize(_: (a0: rs.usize, */ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let v!: rs.u8; - const _28: (a0: rs.ByteVec, a1: rs.u8) => undefined = (out2: rs.ByteVec, v3: rs.u8): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); - }; const take: (a0: rs.usize) => rs.u8 = (at: rs.usize): rs.u8 => { const buf: Uint8Array = Uint8Array.of(0); const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -2512,6 +2509,9 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { const _30: rs.u8 = rs.u8Rem(kind, 32); + const _28: (a0: rs.ByteVec, a1: rs.u8) => undefined = (out2: rs.ByteVec, v3: rs.u8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); + }; if (_30 === 0) { const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { @@ -2959,9 +2959,6 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { */ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let v!: rs.u16; - const _28: (a0: rs.ByteVec, a1: rs.u16) => undefined = (out2: rs.ByteVec, v3: rs.u16): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); - }; const take: (a0: rs.usize) => rs.u16 = (at: rs.usize): rs.u16 => { const buf: Uint8Array = rs.bytes(2); const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -2984,6 +2981,9 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { const _30: rs.u8 = rs.u8Rem(kind, 32); + const _28: (a0: rs.ByteVec, a1: rs.u16) => undefined = (out2: rs.ByteVec, v3: rs.u16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); + }; if (_30 === 0) { const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { @@ -3431,9 +3431,6 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { */ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let v!: rs.u32; - const _28: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out2: rs.ByteVec, v3: rs.u32): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); - }; const take: (a0: rs.usize) => rs.u32 = (at: rs.usize): rs.u32 => { const buf: Uint8Array = rs.bytes(4); const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -3456,6 +3453,9 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { const _30: rs.u8 = rs.u8Rem(kind, 32); + const _28: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out2: rs.ByteVec, v3: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); + }; if (_30 === 0) { const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { @@ -3903,9 +3903,6 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { */ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let v!: rs.u64; - const _28: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, v3: rs.u64): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(rs.u128Cast(v3)))); - }; const take: (a0: rs.usize) => rs.u64 = (at: rs.usize): rs.u64 => { const buf: Uint8Array = rs.bytes(8); const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -3928,6 +3925,9 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { const _30: rs.u8 = rs.u8Rem(kind, 32); + const _28: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, v3: rs.u64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(rs.u128Cast(v3)))); + }; if (_30 === 0) { const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { @@ -4375,9 +4375,6 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { */ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let v!: rs.u128; - const _28: (a0: rs.ByteVec, a1: rs.u128) => undefined = (out2: rs.ByteVec, v3: rs.u128): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3))); - }; const take: (a0: rs.usize) => rs.u128 = (at: rs.usize): rs.u128 => { const buf: Uint8Array = rs.bytes(16); const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -4400,6 +4397,9 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { const _30: rs.u8 = rs.u8Rem(kind, 32); + const _28: (a0: rs.ByteVec, a1: rs.u128) => undefined = (out2: rs.ByteVec, v3: rs.u128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3))); + }; if (_30 === 0) { const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { @@ -4847,9 +4847,6 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { */ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let v!: rs.usize; - const _28: (a0: rs.ByteVec, a1: rs.usize) => undefined = (out2: rs.ByteVec, v3: rs.usize): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); - }; const take: (a0: rs.usize) => rs.usize = (at: rs.usize): rs.usize => { const buf: Uint8Array = rs.bytes(4); const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -4872,6 +4869,9 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { const _30: rs.u8 = rs.u8Rem(kind, 32); + const _28: (a0: rs.ByteVec, a1: rs.usize) => undefined = (out2: rs.ByteVec, v3: rs.usize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); + }; if (_30 === 0) { const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { @@ -5320,9 +5320,6 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let v!: rs.i8; let _87!: rs.i8; - const _28: (a0: rs.ByteVec, a1: rs.i8) => undefined = (out2: rs.ByteVec, v3: rs.i8): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); - }; const take: (a0: rs.usize) => rs.i8 = (at: rs.usize): rs.i8 => { const buf: Uint8Array = Uint8Array.of(0); const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -5345,6 +5342,9 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { const _30: rs.u8 = rs.u8Rem(kind, 32); + const _28: (a0: rs.ByteVec, a1: rs.i8) => undefined = (out2: rs.ByteVec, v3: rs.i8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); + }; if (_30 === 0) { const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { @@ -5820,9 +5820,6 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let v!: rs.i16; let _87!: rs.i16; - const _28: (a0: rs.ByteVec, a1: rs.i16) => undefined = (out2: rs.ByteVec, v3: rs.i16): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); - }; const take: (a0: rs.usize) => rs.i16 = (at: rs.usize): rs.i16 => { const buf: Uint8Array = rs.bytes(2); const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -5845,6 +5842,9 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { const _30: rs.u8 = rs.u8Rem(kind, 32); + const _28: (a0: rs.ByteVec, a1: rs.i16) => undefined = (out2: rs.ByteVec, v3: rs.i16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); + }; if (_30 === 0) { const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { @@ -6320,9 +6320,6 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let v!: rs.i32; let _87!: rs.i32; - const _28: (a0: rs.ByteVec, a1: rs.i32) => undefined = (out2: rs.ByteVec, v3: rs.i32): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); - }; const take: (a0: rs.usize) => rs.i32 = (at: rs.usize): rs.i32 => { const buf: Uint8Array = rs.bytes(4); const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -6345,6 +6342,9 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { const _30: rs.u8 = rs.u8Rem(kind, 32); + const _28: (a0: rs.ByteVec, a1: rs.i32) => undefined = (out2: rs.ByteVec, v3: rs.i32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); + }; if (_30 === 0) { const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { @@ -6820,9 +6820,6 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let v!: rs.i64; let _87!: rs.i64; - const _28: (a0: rs.ByteVec, a1: rs.i64) => undefined = (out2: rs.ByteVec, v3: rs.i64): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i128Cast(v3)))); - }; const take: (a0: rs.usize) => rs.i64 = (at: rs.usize): rs.i64 => { const buf: Uint8Array = rs.bytes(8); const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -6845,6 +6842,9 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { const _30: rs.u8 = rs.u8Rem(kind, 32); + const _28: (a0: rs.ByteVec, a1: rs.i64) => undefined = (out2: rs.ByteVec, v3: rs.i64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i128Cast(v3)))); + }; if (_30 === 0) { const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { @@ -7320,9 +7320,6 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let v!: rs.i128; let _87!: rs.i128; - const _28: (a0: rs.ByteVec, a1: rs.i128) => undefined = (out2: rs.ByteVec, v3: rs.i128): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3))); - }; const take: (a0: rs.usize) => rs.i128 = (at: rs.usize): rs.i128 => { const buf: Uint8Array = rs.bytes(16); const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -7345,6 +7342,9 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { const _30: rs.u8 = rs.u8Rem(kind, 32); + const _28: (a0: rs.ByteVec, a1: rs.i128) => undefined = (out2: rs.ByteVec, v3: rs.i128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3))); + }; if (_30 === 0) { const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { @@ -7820,9 +7820,6 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let v!: rs.isize; let _87!: rs.isize; - const _28: (a0: rs.ByteVec, a1: rs.isize) => undefined = (out2: rs.ByteVec, v3: rs.isize): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); - }; const take: (a0: rs.usize) => rs.isize = (at: rs.usize): rs.isize => { const buf: Uint8Array = rs.bytes(4); const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -7845,6 +7842,9 @@ export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { const _30: rs.u8 = rs.u8Rem(kind, 32); + const _28: (a0: rs.ByteVec, a1: rs.isize) => undefined = (out2: rs.ByteVec, v3: rs.isize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); + }; if (_30 === 0) { const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { diff --git a/ts/fixtures/lang/orders/expected/orders.ts b/ts/fixtures/lang/orders/expected/orders.ts index 5758896ac..e313c1d5c 100644 --- a/ts/fixtures/lang/orders/expected/orders.ts +++ b/ts/fixtures/lang/orders/expected/orders.ts @@ -127,9 +127,6 @@ export function cmps(dataData: Uint8Array, dataStart: number, dataLen: number, o * and sorted: each test std makes, and each item or key it drops. */ export function sorted(data: rs.ByteSlice, out: rs.ByteVec): void { - const _77: () => Item.Item = (): Item.Item => { - return item(200, 0); - }; const ascending: rs.ByteVec = rs.byteSliceToByteVec(data); rs.sliceSort(rs.byteVecSlice(ascending), rs.keyLt((b: rs.u8): rs.u8 => { return rs.u8Rem(b, 8); @@ -168,12 +165,15 @@ export function sorted(data: rs.ByteSlice, out: rs.ByteVec): void { return true; }, undefined, rs.drop) ? 1 : 0); rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterMap(items(), (x3: Item.Item): rs.u8 => { - const _09: rs.u8 = x3.key; + const _08: rs.u8 = x3.key; x3[Symbol.dispose](); - return _09; + return _08; }), rs.cmpLe(rs.cmpReverse(rs.cmp))) ? 1 : 0); rs.byteVecPush(out, rs.iterIsSortedBy(rs.vecIntoIter(rs.iterToVec(items(), undefined, 2, true), rs.drop), Item.le$cmp_PartialOrd, true, rs.drop) ? 1 : 0); flush(out); + const _77: () => Item.Item = (): Item.Item => { + return item(200, 0); + }; const _82: [Item.Item, Item.Item, Item.Item, Item.Item] = [_77(), _77(), _77(), _77()]; const g: Item.Item = _82[0]; const h: Item.Item = _82[1]; @@ -887,14 +887,6 @@ export function held(data: rs.ByteSlice, out: rs.ByteVec): void { } return rs.Pending; }; - const _296: (a0: rs.VecDeque) => rs.VecDeque = (d3: rs.VecDeque): rs.VecDeque => { - return rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.dequeIter(d3), (p2: Part.Part): rs.f64 => { - if (!(p2.key === 7)) { - return p2.key as rs.f64; - } - return NaN; - }), undefined, 8, true), 8) as rs.VecDeque; - }; const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.byteSliceWindows(data, 2)); while (true) { const _10: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); @@ -1011,6 +1003,14 @@ export function held(data: rs.ByteSlice, out: rs.ByteVec): void { const _288: rs.Vec> = rs.vecFrom([e]); const _292: rs.Vec> = rs.vecFrom([d]); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_277, rs.cmpSlice(rs.cmpDeque(Part.cmp$cmp_Ord))(_288, _292) & 0xff)), undefined, true); + const _296: (a0: rs.VecDeque) => rs.VecDeque = (d3: rs.VecDeque): rs.VecDeque => { + return rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.dequeIter(d3), (p2: Part.Part): rs.f64 => { + if (!(p2.key === 7)) { + return p2.key as rs.f64; + } + return NaN; + }), undefined, 8, true), 8) as rs.VecDeque; + }; const _301: rs.VecDeque = _296(d); const _306: rs.VecDeque = _296(e); rs.byteVecPush(out, order(rs.cmpDeque(rs.f64PartialCmp)(_301, _306))); diff --git a/ts/fixtures/lang/panics/expected/located.Held$read.ts b/ts/fixtures/lang/panics/expected/located.Held$read.ts index cc96f2732..40fa5dc4c 100644 --- a/ts/fixtures/lang/panics/expected/located.Held$read.ts +++ b/ts/fixtures/lang/panics/expected/located.Held$read.ts @@ -3,12 +3,7 @@ import * as rs from "./rs.ts"; export function fmt$read_fmt_Debug(self: Held, f: rs.Formatter): rs.Result { - const _3: string = "Held"; - const _4: string = "at"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtLocationDebug(self.at, f); - const _7: string = "maybe"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(self.maybe, f, rs.fmtLocationDebug); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Held at maybe", [(f: rs.Formatter) => rs.fmtLocationDebug(self.at, f), (f: rs.Formatter) => rs.fmtOption(self.maybe, f, rs.fmtLocationDebug)]); } export function eq$read_cmp_PartialEq(self: Held, other: Held): boolean { diff --git a/ts/fixtures/lang/panics/expected/located.ts b/ts/fixtures/lang/panics/expected/located.ts index 65667c8d0..b3bb11ec2 100644 --- a/ts/fixtures/lang/panics/expected/located.ts +++ b/ts/fixtures/lang/panics/expected/located.ts @@ -43,13 +43,12 @@ export function picked(first: rs.u8, caller: rs.Location): rs.Location { /** A closure is no `#[track_caller]` function, so it gives its own calls'. */ export function inClosure(_caller: rs.Location): [rs.Location, rs.Location] { - const _1: () => rs.Location = (): rs.Location => { - return { file: "fixtures/lang/panics/src/located.rs", line: 47, col: 18 }; - }; const _2: () => rs.Location = (): rs.Location => { return here({ file: "fixtures/lang/panics/src/located.rs", line: 48, col: 21 }); }; - return [_1(), _2()] as [rs.Location, rs.Location]; + return [((): rs.Location => { + return { file: "fixtures/lang/panics/src/located.rs", line: 47, col: 18 }; + })(), _2()] as [rs.Location, rs.Location]; } /** A default, untracked, of the tracked method. */ @@ -78,12 +77,6 @@ export function lines(out: rs.ByteVec, at: rs.Slice): void { /** Calls of `#[track_caller]` functions, and `Location::caller` itself. */ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _24: (a0: rs.u8) => rs.Location = (n: rs.u8): rs.Location => { - if (!(rs.u8Rem(n, 2) === 0)) { - return outer({ file: "fixtures/lang/panics/src/located.rs", line: 139, col: 61 }); - } - return here({ file: "fixtures/lang/panics/src/located.rs", line: 139, col: 45 }); - }; const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); const _7: rs.u8 = rs.u8Rem(kind, 6); if (_7 === 0) { @@ -91,7 +84,12 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { lines(out, rs.sliceFrom([{ file: "fixtures/lang/panics/src/located.rs", line: 134, col: 19 }, here({ file: "fixtures/lang/panics/src/located.rs", line: 134, col: 39 }), outer({ file: "fixtures/lang/panics/src/located.rs", line: 134, col: 47 }), _11[0], _11[1], plain(), picked(first, { file: "fixtures/lang/panics/src/located.rs", line: 134, col: 71 })])); } else if (_7 === 1) { const _23: [rs.Location, rs.Location] = inClosure({ file: "fixtures/lang/panics/src/located.rs", line: 138, col: 33 }); - lines(out, rs.sliceFrom([_23[0], _23[1], _24(first), ((): rs.Location => { + lines(out, rs.sliceFrom([_23[0], _23[1], ((n: rs.u8): rs.Location => { + if (!(rs.u8Rem(n, 2) === 0)) { + return outer({ file: "fixtures/lang/panics/src/located.rs", line: 139, col: 61 }); + } + return here({ file: "fixtures/lang/panics/src/located.rs", line: 139, col: 45 }); + })(first), ((): rs.Location => { return { file: "fixtures/lang/panics/src/located.rs", line: 140, col: 53 }; })()])); } else if (_7 === 2) { diff --git a/ts/fixtures/lang/panics/expected/panics.Point.ts b/ts/fixtures/lang/panics/expected/panics.Point.ts index c5f7e0f38..b79454859 100644 --- a/ts/fixtures/lang/panics/expected/panics.Point.ts +++ b/ts/fixtures/lang/panics/expected/panics.Point.ts @@ -3,12 +3,7 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug(self: Point, f: rs.Formatter): rs.Result { - const _3: string = "Point"; - const _4: string = "x"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.x, f); - const _7: string = "y"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.y, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Point x y", [(f: rs.Formatter) => rs.u8Debug(self.x, f), (f: rs.Formatter) => rs.u8Debug(self.y, f)]); } export function default$Default(): Point { diff --git a/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts b/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts index 50c8393ba..c65470a9a 100644 --- a/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts +++ b/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts @@ -16,7 +16,7 @@ export function fmt$fmt_Display(self: Shown, f: rs.Formatter): rs.Result rs.fmtBool(part, f), "\n"]); rs.localKeyWithBorrowMut(NOTE, (note: rs.String): undefined => { rs.stringPushStr(note, line.v); - }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); + }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/std/src/thread/local.rs", line: 721, col: 38 }); if (!self.again) { return rs.fmtWriteStr(f, "shown"); } diff --git a/ts/fixtures/lang/panics/hook/expected/hooked.ts b/ts/fixtures/lang/panics/hook/expected/hooked.ts index 881cf3e9f..b0604c8b6 100644 --- a/ts/fixtures/lang/panics/hook/expected/hooked.ts +++ b/ts/fixtures/lang/panics/hook/expected/hooked.ts @@ -13,7 +13,7 @@ import * as Failing from "./hooked.Failing.ts"; import * as Lying from "./hooked.Lying.ts"; import * as Short from "./hooked.Short.ts"; import * as Shown from "./hooked.Shown.ts"; -import { withBorrow$097wfl1 } from "./std/thread/local.ts"; +import { withBorrow$08fexrm } from "./std/thread/local.ts"; import type * as oneshot_error_RecvError from "./tokio/sync/oneshot/error.RecvError.ts"; /** @@ -54,7 +54,7 @@ export function record(info: rs.PanicHookInfo): void { const line: rs.String = rs.fmtFormat([args12[0], "\n", args12[1], " ", args12[2], " ", args12[3], " ", args12[4], " ", args12[5], " ", args12[6], "\n"]); rs.localKeyWithBorrowMut(NOTE, (note: rs.String): undefined => { rs.stringPushStr(note, line.v); - }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); + }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/std/src/thread/local.rs", line: 721, col: 38 }); } /** @@ -87,7 +87,7 @@ export function hook(): void { captured(info); }, (): void => { rs.drop(captured); - }), { capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/raw_vec/mod.rs", line: 29, col: 5 }, trusted_capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/spec_from_iter_nested.rs", line: 57, col: 18 }, swap_remove: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2178, col: 13 }, vec_set_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2138, col: 9 }, into_flattened: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3667, col: 36 }, rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3902, col: 9 }, rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3948, col: 9 }, ord_violation: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/sort/shared/smallsort.rs", line: 854, col: 5 }, ord_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cmp.rs", line: 1166, col: 9 }, f32_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f32.rs", line: 1665, col: 9 }, f64_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f64.rs", line: 1643, col: 9 }, encode_utf8: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2507, col: 9 }, encode_utf16: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2601, col: 13 }, format: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/fmt.rs", line: 657, col: 14 }, to_string: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/string.rs", line: 2997, col: 14 }, debug_struct_fields: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/fmt/mod.rs", line: 2572, col: 9 }, exact_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/exact_size.rs", line: 122, col: 9 }, join_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/str.rs", line: 177, col: 10 }, int_sum: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }, int_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 554, col: 1 }, char_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 119, col: 45 }, hash_capacity: { file: "/cargo/registry/25cdd57fae9f0462/hashbrown-0.17.1/src/raw.rs", line: 36, col: 40 }, btree_range_equal_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 110, col: 21 }, btree_range_equal_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 112, col: 21 }, btree_range_order_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 119, col: 21 }, btree_range_order_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 121, col: 21 }, deque_insert: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2612, col: 9 }, deque_swap_i: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1062, col: 9 }, deque_swap_j: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1063, col: 9 }, deque_rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3198, col: 9 }, deque_rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3243, col: 9 }, deque_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2724, col: 9 }, list_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/linked_list.rs", line: 1015, col: 9 }, mutex_lock: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sys/sync/mutex/no_threads.rs", line: 28, col: 9 }, once_force: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sync/once.rs", line: 227, col: 20 }, reentrant_init: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/once.rs", line: 325, col: 66 }, lazy_poisoned: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/lazy.rs", line: 386, col: 5 }, ready_poll: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 23, col: 35 }, ready_into_inner: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 46, col: 16 }, duration_new: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 281, col: 18 }, duration_from_mins: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 540, col: 13 }, duration_from_hours: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 510, col: 13 }, duration_add: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1345, col: 31 }, duration_sub: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1365, col: 31 }, duration_mul: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1385, col: 31 }, zip_next_back: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/adapters/zip.rs", line: 213, col: 5 }, bytes_advance: { file: "bytes/source/lib.rs", line: 207, col: 5 }, bytes_does_not_fit: { file: "bytes/source/lib.rs", line: 215, col: 5 }, bytes_slice: { file: "bytes/source/bytes.rs", line: 374, col: 28 }, bytes_slice_ref_start: { file: "bytes/source/bytes.rs", line: 426, col: 9 }, bytes_slice_ref_end: { file: "bytes/source/bytes.rs", line: 432, col: 9 }, bytes_split_off: { file: "bytes/source/bytes.rs", line: 481, col: 9 }, bytes_split_to: { file: "bytes/source/bytes.rs", line: 533, col: 9 }, bytes_buf_advance: { file: "bytes/source/bytes.rs", line: 694, col: 9 }, bytes_mut_split_off: { file: "bytes/source/bytes_mut.rs", line: 329, col: 9 }, bytes_mut_split_to: { file: "bytes/source/bytes_mut.rs", line: 408, col: 9 }, bytes_mut_set_len: { file: "bytes/source/bytes_mut.rs", line: 545, col: 9 }, bytes_mut_overflow: { file: "bytes/source/bytes_mut.rs", line: 700, col: 21 }, bytes_mut_overflow_offset: { file: "bytes/source/bytes_mut.rs", line: 720, col: 29 }, bytes_mut_buf_advance: { file: "bytes/source/bytes_mut.rs", line: 1246, col: 9 } }); + }), { capacity: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/raw_vec/mod.rs", line: 29, col: 5 }, trusted_capacity: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/spec_from_iter_nested.rs", line: 57, col: 18 }, swap_remove: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 2180, col: 13 }, vec_set_len: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 2140, col: 9 }, into_flattened: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 3757, col: 36 }, rotate_left: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/slice/mod.rs", line: 3900, col: 9 }, rotate_right: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/slice/mod.rs", line: 3946, col: 9 }, ord_violation: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/slice/sort/shared/smallsort.rs", line: 854, col: 5 }, ord_clamp: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cmp.rs", line: 1166, col: 9 }, f32_clamp: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/num/f32.rs", line: 1441, col: 9 }, f64_clamp: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/num/f64.rs", line: 1420, col: 9 }, encode_utf8: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/char/methods.rs", line: 2581, col: 9 }, encode_utf16: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/char/methods.rs", line: 2675, col: 13 }, format: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/fmt.rs", line: 657, col: 14 }, to_string: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/string.rs", line: 3049, col: 14 }, debug_struct_fields: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/fmt/mod.rs", line: 2589, col: 41 }, debug_enum: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/fmt/mod.rs", line: 2606, col: 26 }, exact_len: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/traits/exact_size.rs", line: 122, col: 9 }, join_len: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/str.rs", line: 177, col: 10 }, int_sum: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }, int_forward: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/range.rs", line: 554, col: 1 }, char_forward: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/range.rs", line: 119, col: 45 }, hash_capacity: { file: "/cargo/registry/25cdd57fae9f0462/hashbrown-0.17.1/src/raw.rs", line: 36, col: 40 }, btree_range_equal_BTreeSet: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 110, col: 21 }, btree_range_equal_BTreeMap: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 112, col: 21 }, btree_range_order_BTreeSet: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 119, col: 21 }, btree_range_order_BTreeMap: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 121, col: 21 }, deque_insert: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 2614, col: 9 }, deque_swap_i: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 1062, col: 9 }, deque_swap_j: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 1063, col: 9 }, deque_rotate_left: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 3200, col: 9 }, deque_rotate_right: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 3245, col: 9 }, deque_split_off: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 2726, col: 9 }, list_split_off: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/linked_list.rs", line: 1067, col: 9 }, mutex_lock: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/std/src/sys/sync/mutex/no_threads.rs", line: 31, col: 9 }, once_force: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/std/src/sync/once.rs", line: 227, col: 20 }, reentrant_init: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell/once.rs", line: 325, col: 66 }, lazy_poisoned: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell/lazy.rs", line: 386, col: 5 }, ready_poll: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/future/ready.rs", line: 23, col: 35 }, ready_into_inner: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/future/ready.rs", line: 46, col: 16 }, duration_new: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 283, col: 18 }, duration_from_mins: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 542, col: 13 }, duration_from_hours: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 512, col: 13 }, duration_add: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1397, col: 31 }, duration_sub: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1417, col: 31 }, duration_mul: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1437, col: 31 }, zip_next_back: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/adapters/zip.rs", line: 213, col: 5 }, bytes_advance: { file: "bytes/source/lib.rs", line: 207, col: 5 }, bytes_does_not_fit: { file: "bytes/source/lib.rs", line: 215, col: 5 }, bytes_slice: { file: "bytes/source/bytes.rs", line: 374, col: 28 }, bytes_slice_ref_start: { file: "bytes/source/bytes.rs", line: 426, col: 9 }, bytes_slice_ref_end: { file: "bytes/source/bytes.rs", line: 432, col: 9 }, bytes_split_off: { file: "bytes/source/bytes.rs", line: 481, col: 9 }, bytes_split_to: { file: "bytes/source/bytes.rs", line: 533, col: 9 }, bytes_buf_advance: { file: "bytes/source/bytes.rs", line: 694, col: 9 }, bytes_mut_split_off: { file: "bytes/source/bytes_mut.rs", line: 329, col: 9 }, bytes_mut_split_to: { file: "bytes/source/bytes_mut.rs", line: 408, col: 9 }, bytes_mut_set_len: { file: "bytes/source/bytes_mut.rs", line: 545, col: 9 }, bytes_mut_overflow: { file: "bytes/source/bytes_mut.rs", line: 700, col: 21 }, bytes_mut_overflow_offset: { file: "bytes/source/bytes_mut.rs", line: 720, col: 29 }, bytes_mut_buf_advance: { file: "bytes/source/bytes_mut.rs", line: 1246, col: 9 } }); } export function tracked(n: rs.u8, caller: rs.Location): rs.u8 { @@ -129,7 +129,7 @@ export function panicked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.refMutRelease(_56); rs.refMutRelease(_held); } else if (_10 === 9) { - rs.byteVecPush(out, rs.intPow(rs.max(n, 2), 9, 8, false, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/mod.rs", line: 590, col: 5 })); + rs.byteVecPush(out, rs.intPow(rs.max(n, 2), 9, 8, false, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/num/mod.rs", line: 594, col: 5 })); } else if (_10 === 10) { rs.byteVecPush(out, rs.u8Div(100, rs.u8WrappingMul(n, 0), { file: "fixtures/lang/panics/src/hooked.rs", line: 102, col: 24 })); } else if (_10 === 11) { @@ -159,15 +159,15 @@ export function panicked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } else if (_10 === 21) { rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.strSlice("éé", 0, rs.usizeAdd(rs.usizeMul(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 113, col: 56 }) as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 113, col: 44 }), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 113, col: 44 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 113, col: 41 }))); } else if (_10 === 22) { - rs.iterExtendBytes(out, rs.iterStepBy(new rs.Range(0, n), rs.usizeMul(n as rs.usize, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 114, col: 41 }), undefined, 255, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/adapters/step_by.rs", line: 36, col: 9 }), undefined, true); + rs.iterExtendBytes(out, rs.iterStepBy(new rs.Range(0, n), rs.usizeMul(n as rs.usize, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 114, col: 41 }), undefined, 255, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/adapters/step_by.rs", line: 36, col: 9 }), undefined, true); } else if (_10 === 23) { const _150: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); const _152: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(n as rs.usize, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 115, col: 42 }), rs.usizeStep); - rs.iterExtendBytes(out, rs.byteVecDrain(_150, _152, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3007, col: 36 }), "fold", true); + rs.iterExtendBytes(out, rs.byteVecDrain(_150, _152, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 3095, col: 36 }), "fold", true); } else if (_10 === 24) { rs.panic("any", { file: "fixtures/lang/panics/src/hooked.rs", line: 116, col: 15 }); } else if (_10 === 25) { - rs.iterExtendBytes(out, rs.iterStepBy(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(v))), rs.usizeMul(n as rs.usize, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 117, col: 43 }), undefined, undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/adapters/step_by.rs", line: 36, col: 9 }), undefined, true); + rs.iterExtendBytes(out, rs.iterStepBy(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(v))), rs.usizeMul(n as rs.usize, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 117, col: 43 }), undefined, undefined, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/adapters/step_by.rs", line: 36, col: 9 }), undefined, true); } else if (_10 === 26) { const _165: rs.u8 = rs.u8WrappingAdd(n, 1); if (!(n === _165)) { @@ -190,10 +190,10 @@ export function panicked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } else if (_10 === 33) { rs.byteVecPush(out, rs.precondition(rs.nonZero(rs.u8WrappingMul(n, 0)), "NonZero::new_unchecked requires the argument to be non-zero", { file: "fixtures/lang/panics/src/hooked.rs", line: 127, col: 33 })); } else if (_10 === 34) { - rs.byteVecPush(out, rs.precondition(rs.u8CheckedAdd(rs.optionUnwrap(rs.nonZero(rs.max(n, 200)), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 130, col: 68 }), rs.max(n, 100)), "u8::unchecked_add cannot overflow", { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/nonzero.rs", line: 2662, col: 1 })); + rs.byteVecPush(out, rs.precondition(rs.u8CheckedAdd(rs.optionUnwrap(rs.nonZero(rs.max(n, 200)), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 130, col: 68 }), rs.max(n, 100)), "u8::unchecked_add cannot overflow", { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/num/nonzero.rs", line: 2895, col: 1 })); } else if (_10 === 35) { const x: rs.i16 = rs.optionUnwrap(rs.nonZero(rs.max(n, 200) as rs.i16), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 133, col: 67 }); - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(rs.precondition(rs.i16CheckedMul(x, x), "i16::unchecked_mul cannot overflow", { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/nonzero.rs", line: 2773, col: 1 })))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(rs.precondition(rs.i16CheckedMul(x, x), "i16::unchecked_mul cannot overflow", { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/num/nonzero.rs", line: 3006, col: 1 })))); } else { rs.byteVecPush(out, rs.hashLen(rs.hashWithCapacity(4294967295, 469762048) as rs.HashMap) & 0xff); } @@ -220,7 +220,7 @@ export function aborted(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } }, (): void => { rs.drop(captured2); - }), { capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/raw_vec/mod.rs", line: 29, col: 5 }, trusted_capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/spec_from_iter_nested.rs", line: 57, col: 18 }, swap_remove: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2178, col: 13 }, vec_set_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2138, col: 9 }, into_flattened: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3667, col: 36 }, rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3902, col: 9 }, rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3948, col: 9 }, ord_violation: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/sort/shared/smallsort.rs", line: 854, col: 5 }, ord_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cmp.rs", line: 1166, col: 9 }, f32_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f32.rs", line: 1665, col: 9 }, f64_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f64.rs", line: 1643, col: 9 }, encode_utf8: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2507, col: 9 }, encode_utf16: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2601, col: 13 }, format: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/fmt.rs", line: 657, col: 14 }, to_string: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/string.rs", line: 2997, col: 14 }, debug_struct_fields: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/fmt/mod.rs", line: 2572, col: 9 }, exact_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/exact_size.rs", line: 122, col: 9 }, join_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/str.rs", line: 177, col: 10 }, int_sum: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }, int_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 554, col: 1 }, char_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 119, col: 45 }, hash_capacity: { file: "/cargo/registry/25cdd57fae9f0462/hashbrown-0.17.1/src/raw.rs", line: 36, col: 40 }, btree_range_equal_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 110, col: 21 }, btree_range_equal_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 112, col: 21 }, btree_range_order_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 119, col: 21 }, btree_range_order_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 121, col: 21 }, deque_insert: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2612, col: 9 }, deque_swap_i: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1062, col: 9 }, deque_swap_j: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1063, col: 9 }, deque_rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3198, col: 9 }, deque_rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3243, col: 9 }, deque_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2724, col: 9 }, list_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/linked_list.rs", line: 1015, col: 9 }, mutex_lock: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sys/sync/mutex/no_threads.rs", line: 28, col: 9 }, once_force: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sync/once.rs", line: 227, col: 20 }, reentrant_init: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/once.rs", line: 325, col: 66 }, lazy_poisoned: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/lazy.rs", line: 386, col: 5 }, ready_poll: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 23, col: 35 }, ready_into_inner: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 46, col: 16 }, duration_new: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 281, col: 18 }, duration_from_mins: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 540, col: 13 }, duration_from_hours: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 510, col: 13 }, duration_add: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1345, col: 31 }, duration_sub: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1365, col: 31 }, duration_mul: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1385, col: 31 }, zip_next_back: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/adapters/zip.rs", line: 213, col: 5 }, bytes_advance: { file: "bytes/source/lib.rs", line: 207, col: 5 }, bytes_does_not_fit: { file: "bytes/source/lib.rs", line: 215, col: 5 }, bytes_slice: { file: "bytes/source/bytes.rs", line: 374, col: 28 }, bytes_slice_ref_start: { file: "bytes/source/bytes.rs", line: 426, col: 9 }, bytes_slice_ref_end: { file: "bytes/source/bytes.rs", line: 432, col: 9 }, bytes_split_off: { file: "bytes/source/bytes.rs", line: 481, col: 9 }, bytes_split_to: { file: "bytes/source/bytes.rs", line: 533, col: 9 }, bytes_buf_advance: { file: "bytes/source/bytes.rs", line: 694, col: 9 }, bytes_mut_split_off: { file: "bytes/source/bytes_mut.rs", line: 329, col: 9 }, bytes_mut_split_to: { file: "bytes/source/bytes_mut.rs", line: 408, col: 9 }, bytes_mut_set_len: { file: "bytes/source/bytes_mut.rs", line: 545, col: 9 }, bytes_mut_overflow: { file: "bytes/source/bytes_mut.rs", line: 700, col: 21 }, bytes_mut_overflow_offset: { file: "bytes/source/bytes_mut.rs", line: 720, col: 29 }, bytes_mut_buf_advance: { file: "bytes/source/bytes_mut.rs", line: 1246, col: 9 } }); + }), { capacity: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/raw_vec/mod.rs", line: 29, col: 5 }, trusted_capacity: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/spec_from_iter_nested.rs", line: 57, col: 18 }, swap_remove: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 2180, col: 13 }, vec_set_len: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 2140, col: 9 }, into_flattened: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 3757, col: 36 }, rotate_left: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/slice/mod.rs", line: 3900, col: 9 }, rotate_right: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/slice/mod.rs", line: 3946, col: 9 }, ord_violation: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/slice/sort/shared/smallsort.rs", line: 854, col: 5 }, ord_clamp: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cmp.rs", line: 1166, col: 9 }, f32_clamp: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/num/f32.rs", line: 1441, col: 9 }, f64_clamp: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/num/f64.rs", line: 1420, col: 9 }, encode_utf8: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/char/methods.rs", line: 2581, col: 9 }, encode_utf16: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/char/methods.rs", line: 2675, col: 13 }, format: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/fmt.rs", line: 657, col: 14 }, to_string: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/string.rs", line: 3049, col: 14 }, debug_struct_fields: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/fmt/mod.rs", line: 2589, col: 41 }, debug_enum: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/fmt/mod.rs", line: 2606, col: 26 }, exact_len: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/traits/exact_size.rs", line: 122, col: 9 }, join_len: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/str.rs", line: 177, col: 10 }, int_sum: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }, int_forward: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/range.rs", line: 554, col: 1 }, char_forward: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/range.rs", line: 119, col: 45 }, hash_capacity: { file: "/cargo/registry/25cdd57fae9f0462/hashbrown-0.17.1/src/raw.rs", line: 36, col: 40 }, btree_range_equal_BTreeSet: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 110, col: 21 }, btree_range_equal_BTreeMap: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 112, col: 21 }, btree_range_order_BTreeSet: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 119, col: 21 }, btree_range_order_BTreeMap: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 121, col: 21 }, deque_insert: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 2614, col: 9 }, deque_swap_i: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 1062, col: 9 }, deque_swap_j: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 1063, col: 9 }, deque_rotate_left: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 3200, col: 9 }, deque_rotate_right: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 3245, col: 9 }, deque_split_off: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 2726, col: 9 }, list_split_off: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/linked_list.rs", line: 1067, col: 9 }, mutex_lock: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/std/src/sys/sync/mutex/no_threads.rs", line: 31, col: 9 }, once_force: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/std/src/sync/once.rs", line: 227, col: 20 }, reentrant_init: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell/once.rs", line: 325, col: 66 }, lazy_poisoned: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell/lazy.rs", line: 386, col: 5 }, ready_poll: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/future/ready.rs", line: 23, col: 35 }, ready_into_inner: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/future/ready.rs", line: 46, col: 16 }, duration_new: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 283, col: 18 }, duration_from_mins: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 542, col: 13 }, duration_from_hours: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 512, col: 13 }, duration_add: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1397, col: 31 }, duration_sub: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1417, col: 31 }, duration_mul: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1437, col: 31 }, zip_next_back: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/adapters/zip.rs", line: 213, col: 5 }, bytes_advance: { file: "bytes/source/lib.rs", line: 207, col: 5 }, bytes_does_not_fit: { file: "bytes/source/lib.rs", line: 215, col: 5 }, bytes_slice: { file: "bytes/source/bytes.rs", line: 374, col: 28 }, bytes_slice_ref_start: { file: "bytes/source/bytes.rs", line: 426, col: 9 }, bytes_slice_ref_end: { file: "bytes/source/bytes.rs", line: 432, col: 9 }, bytes_split_off: { file: "bytes/source/bytes.rs", line: 481, col: 9 }, bytes_split_to: { file: "bytes/source/bytes.rs", line: 533, col: 9 }, bytes_buf_advance: { file: "bytes/source/bytes.rs", line: 694, col: 9 }, bytes_mut_split_off: { file: "bytes/source/bytes_mut.rs", line: 329, col: 9 }, bytes_mut_split_to: { file: "bytes/source/bytes_mut.rs", line: 408, col: 9 }, bytes_mut_set_len: { file: "bytes/source/bytes_mut.rs", line: 545, col: 9 }, bytes_mut_overflow: { file: "bytes/source/bytes_mut.rs", line: 700, col: 21 }, bytes_mut_overflow_offset: { file: "bytes/source/bytes_mut.rs", line: 720, col: 29 }, bytes_mut_buf_advance: { file: "bytes/source/bytes_mut.rs", line: 1246, col: 9 } }); rs.byteVecPush(out, n); const _13: rs.u8 = rs.u8Rem(kind, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 174, col: 11 }); if (_13 === 3 || _13 === 4) { @@ -332,227 +332,221 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return n; }); })); - } else { - if (k === 21) { - const ready: rs.Ready = new rs.Ready(n); - const cx: rs.Context = rs.NOOP_WAKER; - let iterStart: rs.i32 = 0; - const iterEnd: rs.i32 = 2; - while (true) { - if (!(iterStart++ < iterEnd)) { - break b0; - } - const _174: rs.Poll = ready.poll(cx); - if (_174 !== rs.Pending) { - rs.byteVecPush(out, _174); - } + } else if (k === 21) { + const ready: rs.Ready = new rs.Ready(n); + const cx: rs.Context = rs.NOOP_WAKER; + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 2; + while (iterStart++ < iterEnd) { + const _174: rs.Poll = ready.poll(cx); + if (_174 !== rs.Pending) { + rs.byteVecPush(out, _174); } } - if (k === 22) { - const ready2: rs.Ready = new rs.Ready(n); - const _184: rs.Poll = ready2.poll(rs.NOOP_WAKER); - if (_184 !== rs.Pending) { - rs.byteVecPush(out, _184); - } - rs.byteVecPush(out, ready2.intoInner()); - } else if (k === 23) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationNew({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u32Add(1000000000, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 258, col: 48 }))) & 0xff); - } else if (k === 24) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromMins(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 259, col: 44 }))) & 0xff); - } else if (k === 25) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromHours(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 260, col: 45 }))) & 0xff); - } else if (k === 26) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationSub({ secs: 0, nanos: 0 }, rs.durationFromSecs(rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 261, col: 62 })))) & 0xff); - } else if (k === 27) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationMul({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.u32Add(n as rs.u32, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 262, col: 41 }))) & 0xff); - } else if (k === 28) { - const _231: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); - const _233: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 263, col: 44 }), rs.usizeStep); - rs.byteVecExtendFromWithin(_231, _233, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3614, col: 21 }); - } else if (k === 29) { - const _238: rs.VecDeque = rs.dequeClone(deque); - const _240: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 264, col: 46 }), rs.usizeStep); - rs.iterExtendBytes(out, rs.dequeDrain(_238, _240, undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1998, col: 36 }), "next"); - } else if (k === 30) { - const _245: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 265, col: 38 }), rs.usizeStep); - rs.iterExtendBytes(out, rs.dequeRange(deque, _245, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1845, col: 36 }), undefined, true); - } else if (k === 31) { - const _251: rs.VecDeque = rs.dequeClone(deque); - const _253: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 266, col: 50 }), rs.usizeStep); - rs.iterExtendBytes(out, rs.iterMap(rs.dequeRangeMut(_251, _253, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1845, col: 36 }), (v6: rs.Place): rs.u8 => { - return v6.v; - }), undefined, true); - } else if (k === 32) { - const cell2: rs.RefCell = new rs.RefCell(rs.byteVecFrom(Uint8Array.of(n))); - const _held2: rs.RefCell = rs.refCellBorrow(cell2, { file: "fixtures/lang/panics/src/hooked.rs", line: 269, col: 30 }); - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.refCellReplace(cell2, new rs.ByteVec(), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1434, col: 14 })), undefined, true); - rs.refRelease(_held2); - } else if (k === 33) { - ((cell4: rs.RefCell): undefined => { - rs.refCellBorrow(cell4, { file: "fixtures/lang/panics/src/hooked.rs", line: 273, col: 54 }); - })(SHARED.get()); - rs.localKeyWithBorrowMutPlace(SHARED, (v5: rs.Place): undefined => { - v5.v = n; - }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); - } else if (k === 34) { - ((cell3: rs.RefCell): undefined => { - result_unwrapOrDefault$0t7trfe(result_map$1hfd4x1(rs.refCellTryBorrowMut(cell3), (_a03: rs.RefCell): undefined => { - undefined; - })); - })(EXCLUSIVE.get()); - withBorrow$097wfl1(EXCLUSIVE, (_225: rs.u8): undefined => { - rs.byteVecPush(out, _225); + } else if (k === 22) { + const ready2: rs.Ready = new rs.Ready(n); + const _184: rs.Poll = ready2.poll(rs.NOOP_WAKER); + if (_184 !== rs.Pending) { + rs.byteVecPush(out, _184); + } + rs.byteVecPush(out, ready2.intoInner()); + } else if (k === 23) { + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationNew({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u32Add(1000000000, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 258, col: 48 }))) & 0xff); + } else if (k === 24) { + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromMins(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 259, col: 44 }))) & 0xff); + } else if (k === 25) { + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromHours(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 260, col: 45 }))) & 0xff); + } else if (k === 26) { + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationSub({ secs: 0, nanos: 0 }, rs.durationFromSecs(rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 261, col: 62 })))) & 0xff); + } else if (k === 27) { + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationMul({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.u32Add(n as rs.u32, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 262, col: 41 }))) & 0xff); + } else if (k === 28) { + const _231: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); + const _233: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 263, col: 44 }), rs.usizeStep); + rs.byteVecExtendFromWithin(_231, _233, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 3704, col: 21 }); + } else if (k === 29) { + const _238: rs.VecDeque = rs.dequeClone(deque); + const _240: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 264, col: 46 }), rs.usizeStep); + rs.iterExtendBytes(out, rs.dequeDrain(_238, _240, undefined, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 2000, col: 36 }), "next"); + } else if (k === 30) { + const _245: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 265, col: 38 }), rs.usizeStep); + rs.iterExtendBytes(out, rs.dequeRange(deque, _245, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 1847, col: 36 }), undefined, true); + } else if (k === 31) { + const _251: rs.VecDeque = rs.dequeClone(deque); + const _253: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 266, col: 50 }), rs.usizeStep); + rs.iterExtendBytes(out, rs.iterMap(rs.dequeRangeMut(_251, _253, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 1847, col: 36 }), (v6: rs.Place): rs.u8 => { + return v6.v; + }), undefined, true); + } else if (k === 32) { + const cell2: rs.RefCell = new rs.RefCell(rs.byteVecFrom(Uint8Array.of(n))); + const _held2: rs.RefCell = rs.refCellBorrow(cell2, { file: "fixtures/lang/panics/src/hooked.rs", line: 269, col: 30 }); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.refCellReplace(cell2, new rs.ByteVec(), { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1436, col: 14 })), undefined, true); + rs.refRelease(_held2); + } else if (k === 33) { + ((cell4: rs.RefCell): undefined => { + rs.refCellBorrow(cell4, { file: "fixtures/lang/panics/src/hooked.rs", line: 273, col: 54 }); + })(SHARED.get()); + rs.localKeyWithBorrowMutPlace(SHARED, (v5: rs.Place): undefined => { + v5.v = n; + }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/std/src/thread/local.rs", line: 721, col: 38 }); + } else if (k === 34) { + ((cell3: rs.RefCell): undefined => { + result_unwrapOrDefault$0t7trfe(result_map$1hfd4x1(rs.refCellTryBorrowMut(cell3), (_a03: rs.RefCell): undefined => { + undefined; + })); + })(EXCLUSIVE.get()); + withBorrow$08fexrm(EXCLUSIVE, (_225: rs.u8): undefined => { + rs.byteVecPush(out, _225); + }); + } else if (k === 35) { + const _277: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); + const _279: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 280, col: 43 }), rs.usizeStep); + const _282: Uint8Array = Uint8Array.of(n); + rs.iterExtendBytes(out, rs.spliceFrom(rs.byteVecSplice(_277, _279, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 3095, col: 36 }), rs.iterSlice(_282), true), "next"); + } else if (k === 36) { + rs.iterExtendBytes(out, rs.iterOption(option_map$04ry0e1(option_map$18ftgyp(rs.charFromDigit(n as rs.u32, rs.u32Add(37, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 282, col: 44 }), { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/char/convert.rs", line: 332, col: 9 }), (a02: rs.char): rs.u32 => { + return a02 as rs.u32; + }), (c2: rs.u32): rs.u8 => { + return c2 & 0xff; + })), undefined, true); + } else if (k === 37) { + const _294: rs.usize = rs.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 286, col: 59 }); + if (!(_294 < 2)) { + rs.panicSizes(["index out of bounds: the len is ", 2, " but the index is ", _294], { file: "fixtures/lang/panics/src/hooked.rs", line: 286, col: 21 }); + } + rs.fence([0, 4][_294], { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/sync/atomic.rs", line: 4822, col: 24 }); + } else if (k === 38) { + const _301: rs.usize = rs.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 287, col: 68 }); + if (!(_301 < 2)) { + rs.panicSizes(["index out of bounds: the len is ", 2, " but the index is ", _301], { file: "fixtures/lang/panics/src/hooked.rs", line: 287, col: 30 }); + } + rs.fence([0, 4][_301], { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/sync/atomic.rs", line: 4907, col: 24 }); + } else if (k === 39) { + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromSecsF64(-1.0 - (n as rs.f64), { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1052, col: 23 })) & 0xff); + } else if (k === 40) { + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromSecsF32(Math.fround(-1.0 - Math.fround(n)), { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1089, col: 23 })) & 0xff); + } else if (k === 41) { + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationMulF64(rs.durationFromSecs(1), -1.0 - (n as rs.f64), { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1052, col: 23 })) & 0xff); + } else if (k === 42) { + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationDivF32(rs.durationFromSecs(1), Math.fround(-1.0 - Math.fround(n)), { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1052, col: 23 })) & 0xff); + } else if (k === 43) { + rs.byteVecPush(out, rs.iterSum(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of(rs.max(n, 1), 255)))), (a: rs.u8, b: rs.u8) => rs.u8Add(a, b, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }), 0)); + } else if (k === 44) { + rs.byteVecPush(out, rs.iterProduct(rs.iterSlice([rs.max(n, 2) as rs.u16, 65535]), (a: rs.u16, b: rs.u16) => rs.u16Mul(a, b, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }), 1) & 0xff); + } else if (k === 45) { + rs.byteVecPush(out, rs.u64Low(rs.durationAsSecs(rs.durationSum(rs.iterSlice([{ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.durationFromSecs(rs.max(n, 1) as rs.u64)]), undefined, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1513, col: 9 }))) & 0xff); + } else if (k === 46) { + rs.byteVecPush(out, rs.u64Low(rs.durationAsSecs(rs.durationSum(rs.iterSlice([{ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.durationNew(rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 301, col: 43 }), 0)]), undefined, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1520, col: 9 }))) & 0xff); + } else if (k === 47) { + const _365: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); + const _367: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 306, col: 47 }), rs.usizeStep); + rs.iterExtendBytes(out, rs.byteVecExtractIf(_365, _367, (_217: rs.Place): boolean => { + return true; + }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/extract_if.rs", line: 43, col: 36 }), "next"); + } else if (k === 48) { + const _374: rs.Vec = rs.vecFrom([n as rs.u16]); + const _377: { end: rs.usize } = { end: rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 307, col: 56 }) }; + rs.byteVecPush(out, rs.ownedCount(rs.vecExtractIfMut(_374, _377, (_210: rs.Place): boolean => { + return true; + }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/extract_if.rs", line: 43, col: 36 }), undefined, undefined) & 0xff); + } else if (k === 49) { + rs.iterExtendBytes(out, rs.iterTake(new rs.RangeFrom(rs.u8Sub(255, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 308, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 308, col: 27 }), rs.u8Step), 3), undefined, true); + } else if (k === 50) { + rs.iterExtendBytes(out, rs.iterOption(rs.iterNth(new rs.RangeFrom(rs.u8Sub(255, rs.u8Rem(n, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 309, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 309, col: 27 }), rs.u8Step), rs.usizeAdd(rs.u8Rem(n, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 309, col: 62 }) as rs.usize, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 309, col: 50 }))), undefined, true); + } else if (k === 51) { + rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(new rs.RangeFrom(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 310, col: 48 }) as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 310, col: 27 }), rs.u64Step), 3), (x: rs.u64): rs.u8 => { + return rs.u64Low(x) & 0xff; + }), undefined, true); + } else if (k === 52) { + rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(new rs.RangeFrom(rs.optionUnwrap(rs.charFromU32(rs.u32Sub(1114111, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 312, col: 51 }) as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 312, col: 29 })), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 312, col: 59 }), rs.charStep), 3), (c: rs.char): rs.u8 => { + return c & 0xff; + }), undefined, true); + } else if (k === 68) { + if (!(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 318, col: 15 }) === 0)) { + const v3: rs.Vec = rs.vecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 325, col: 51 }), 4); + const _442: rs.usize = rs.usizeAdd(rs.vecCapacity(v3, 4), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 327, col: 32 }); + rs.vecSetLen(v3, _442, 4, (): rs.u32 => { + return (undefined as unknown) as rs.u32; }); - } else if (k === 35) { - const _277: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); - const _279: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 280, col: 43 }), rs.usizeStep); - const _282: Uint8Array = Uint8Array.of(n); - rs.iterExtendBytes(out, rs.spliceFrom(rs.byteVecSplice(_277, _279, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3007, col: 36 }), rs.iterSlice(_282), true), "next"); - } else if (k === 36) { - rs.iterExtendBytes(out, rs.iterOption(option_map$04ry0e1(option_map$18ftgyp(rs.charFromDigit(n as rs.u32, rs.u32Add(37, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 282, col: 44 }), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/convert.rs", line: 332, col: 9 }), (a02: rs.char): rs.u32 => { - return a02 as rs.u32; - }), (c2: rs.u32): rs.u8 => { - return c2 & 0xff; - })), undefined, true); - } else if (k === 37) { - const _294: rs.usize = rs.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 286, col: 59 }); - if (!(_294 < 2)) { - rs.panicSizes(["index out of bounds: the len is ", 2, " but the index is ", _294], { file: "fixtures/lang/panics/src/hooked.rs", line: 286, col: 21 }); - } - rs.fence([0, 4][_294], { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/sync/atomic.rs", line: 4822, col: 24 }); - } else if (k === 38) { - const _301: rs.usize = rs.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 287, col: 68 }); - if (!(_301 < 2)) { - rs.panicSizes(["index out of bounds: the len is ", 2, " but the index is ", _301], { file: "fixtures/lang/panics/src/hooked.rs", line: 287, col: 30 }); - } - rs.fence([0, 4][_301], { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/sync/atomic.rs", line: 4907, col: 24 }); - } else if (k === 39) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromSecsF64(-1.0 - (n as rs.f64), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1050, col: 23 })) & 0xff); - } else if (k === 40) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromSecsF32(Math.fround(-1.0 - Math.fround(n)), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1087, col: 23 })) & 0xff); - } else if (k === 41) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationMulF64(rs.durationFromSecs(1), -1.0 - (n as rs.f64), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1050, col: 23 })) & 0xff); - } else if (k === 42) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationDivF32(rs.durationFromSecs(1), Math.fround(-1.0 - Math.fround(n)), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1050, col: 23 })) & 0xff); - } else if (k === 43) { - rs.byteVecPush(out, rs.iterSum(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of(rs.max(n, 1), 255)))), (a: rs.u8, b: rs.u8) => rs.u8Add(a, b, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }), 0)); - } else if (k === 44) { - rs.byteVecPush(out, rs.iterProduct(rs.iterSlice([rs.max(n, 2) as rs.u16, 65535]), (a: rs.u16, b: rs.u16) => rs.u16Mul(a, b, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }), 1) & 0xff); - } else if (k === 45) { - rs.byteVecPush(out, rs.u64Low(rs.durationAsSecs(rs.durationSum(rs.iterSlice([{ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.durationFromSecs(rs.max(n, 1) as rs.u64)]), undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1461, col: 9 }))) & 0xff); - } else if (k === 46) { - rs.byteVecPush(out, rs.u64Low(rs.durationAsSecs(rs.durationSum(rs.iterSlice([{ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.durationNew(rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 301, col: 43 }), 0)]), undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1468, col: 9 }))) & 0xff); - } else if (k === 47) { - const _365: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); - const _367: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 306, col: 47 }), rs.usizeStep); - rs.iterExtendBytes(out, rs.byteVecExtractIf(_365, _367, (_217: rs.Place): boolean => { - return true; - }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/extract_if.rs", line: 43, col: 36 }), "next"); - } else if (k === 48) { - const _374: rs.Vec = rs.vecFrom([n as rs.u16]); - const _377: { end: rs.usize } = { end: rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 307, col: 56 }) }; - rs.byteVecPush(out, rs.ownedCount(rs.vecExtractIfMut(_374, _377, (_210: rs.Place): boolean => { - return true; - }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/extract_if.rs", line: 43, col: 36 }), undefined, undefined) & 0xff); - } else if (k === 49) { - rs.iterExtendBytes(out, rs.iterTake(new rs.RangeFrom(rs.u8Sub(255, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 308, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 308, col: 27 }), rs.u8Step), 3), undefined, true); - } else if (k === 50) { - rs.iterExtendBytes(out, rs.iterOption(rs.iterNth(new rs.RangeFrom(rs.u8Sub(255, rs.u8Rem(n, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 309, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 309, col: 27 }), rs.u8Step), rs.usizeAdd(rs.u8Rem(n, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 309, col: 62 }) as rs.usize, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 309, col: 50 }))), undefined, true); - } else if (k === 51) { - rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(new rs.RangeFrom(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 310, col: 48 }) as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 310, col: 27 }), rs.u64Step), 3), (x: rs.u64): rs.u8 => { - return rs.u64Low(x) & 0xff; - }), undefined, true); - } else if (k === 52) { - rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(new rs.RangeFrom(rs.optionUnwrap(rs.charFromU32(rs.u32Sub(1114111, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 312, col: 51 }) as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 312, col: 29 })), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 312, col: 59 }), rs.charStep), 3), (c: rs.char): rs.u8 => { - return c & 0xff; - }), undefined, true); - } else if (k === 68) { - if (!(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 318, col: 15 }) === 0)) { - const v3: rs.Vec = rs.vecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 325, col: 51 }), 4); - const _442: rs.usize = rs.usizeAdd(rs.vecCapacity(v3, 4), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 327, col: 32 }); - rs.vecSetLen(v3, _442, 4, (): rs.u32 => { - return (undefined as unknown) as rs.u32; - }); - rs.byteVecPush(out, v3.items.length & 0xff); - } else { - const v2: rs.ByteVec = rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 319, col: 50 })); - rs.byteVecSetLen(v2, rs.usizeAdd(v2.data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 321, col: 32 })); - rs.byteVecPush(out, v2.length & 0xff); - } - } else if (k === 69) { - const _451: rs.ByteSlice = rs.byteSliceFrom(rs.bytes(2).fill((0 as unknown) as rs.u8)); - const part2 = rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 330, col: 81 }); - rs.byteSliceCopyFromSlice(_451, rs.byteSliceRange(rs.byteVecSlice(v), 0, part2, { file: "fixtures/lang/panics/src/hooked.rs", line: 330, col: 78 }), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/mem/maybe_uninit.rs", line: 1170, col: 14 }); - } else if (k === 70) { - rs.sliceWriteCloneOfSlice(rs.sliceFrom(Array.from({ length: 2 }, (): rs.String => { - return (undefined as unknown) as rs.String; - })), rs.sliceRange(rs.sliceFrom([rs.stringNew()]), 0, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 331, col: 106 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 331, col: 103 }), (a0: rs.String): rs.String => { - return rs.stringClone(a0); - }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/mem/maybe_uninit.rs", line: 1230, col: 9 }); - } else if (k === 71) { - rs.byteVecPush(out, rs.sliceNewUninit(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 332, col: 55 }), 2, (): rs.u16 => { - return (undefined as unknown) as rs.u16; - }).length & 0xff); - } else if (k === 72) { - let lent: rs.ByteSlice = rs.byteVecSlice(v); - const _482: rs.usize = rs.usizeAdd(rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 335, col: 26 }), 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 335, col: 26 }); - rs.ioSliceAdvance(rs.place(() => lent, (value2) => lent = value2), _482, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/io/io_slice/repr_generic.rs", line: 14, col: 25 }); - rs.byteVecExtendFromSlice(out, lent); - } else if (k === 73) { - const lent2: rs.ByteSlice[] = [rs.byteVecSlice(v)]; - let left: rs.Slice = rs.sliceFrom(lent2); - const _498: rs.usize = rs.usizeAdd(rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 341, col: 57 }), 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 341, col: 57 }); - rs.ioSliceAdvanceSlices(rs.place(() => left, (value) => left = value), _498, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/io/io_slice.rs", line: 304, col: 13 }); - rs.byteVecPush(out, left.length & 0xff); - } else if (k === 74) { - rs.byteVecInsert(rs.byteVecFrom(rs.byteVecView(v)), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 344, col: 32 }), n, { file: "fixtures/lang/panics/src/hooked.rs", line: 344, col: 25 }); - } else if (k === 75) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecSplitOff(rs.byteVecFrom(rs.byteVecView(v)), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 345, col: 46 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 345, col: 36 })), undefined, true); - } else if (k === 76) { - rs.byteVecPush(out, rs.vecRemove(rs.vecFrom([n as rs.u16]), rs.usizeAdd(at, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 346, col: 50 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 346, col: 43 }) & 0xff); - } else if (k === 77) { - rs.byteVecPush(out, rs.vecSwapRemove(rs.vecFrom([n as rs.u16]), rs.usizeAdd(at, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 347, col: 55 })) & 0xff); - } else if (k === 78) { - rs.vecInsert(rs.vecFrom([n as rs.u16]), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 348, col: 41 }), 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 348, col: 34 }); - } else if (k === 79) { - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.vecSplitOff(rs.vecFrom([n as rs.u16]), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 349, col: 55 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 349, col: 45 }).items), (_29: rs.u16): rs.u8 => { - return _29 & 0xff; - }), undefined, true); - } else if (k === 80) { - const _550: rs.ByteSlice = rs.byteVecSlice(rs.byteVecFrom(rs.byteVecView(v))); - const _554: rs.Range = new rs.Range(rs.usizeAdd(at, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 350, col: 37 }), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 350, col: 45 })); - rs.byteSliceCopyWithin(_550, _554.start, _554.end, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 350, col: 25 }); - } else if (k === 81) { - rs.byteVecPush(out, rs.u64Low(rs.u64Clamp(n as rs.u64, rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 351, col: 43 }), n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 351, col: 37 })) & 0xff); - } else if (k === 82) { - rs.byteVecPush(out, rs.clamp(rs.i32Neg(n as rs.i32, { file: "fixtures/lang/panics/src/hooked.rs", line: 352, col: 24 }), 0, -1, { file: "fixtures/lang/panics/src/hooked.rs", line: 352, col: 40 }) & 0xff); - } else if (k === 83) { - const arg = {}; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => Failing.fmt$fmt_Display(arg, f)]).v)); - } else if (k === 84) { - const _585: Failing.Failing = {}; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => Failing.fmt$fmt_Display(_585, f)).v)); - } else if (k === 85) { - rs.byteVecPush(out, rs.iterFrom({ _0: n }, Lying.next$iter_Iterator, undefined, { hint: Lying.sizeHint$iter_Iterator }).len() & 0xff); + rs.byteVecPush(out, v3.items.length & 0xff); } else { - if (53 <= k) { - if (k <= 56) { - joined(rs.u8Sub(k, 53, { file: "fixtures/lang/panics/src/hooked.rs", line: 316, col: 31 }), n, out); - break b0; - } + const v2: rs.ByteVec = rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 319, col: 50 })); + rs.byteVecSetLen(v2, rs.usizeAdd(v2.data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 321, col: 32 })); + rs.byteVecPush(out, v2.length & 0xff); + } + } else if (k === 69) { + const _451: rs.ByteSlice = rs.byteSliceFrom(rs.bytes(2).fill((0 as unknown) as rs.u8)); + const part2 = rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 330, col: 81 }); + rs.byteSliceCopyFromSlice(_451, rs.byteSliceRange(rs.byteVecSlice(v), 0, part2, { file: "fixtures/lang/panics/src/hooked.rs", line: 330, col: 78 }), { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/mem/maybe_uninit.rs", line: 1205, col: 14 }); + } else if (k === 70) { + rs.sliceWriteCloneOfSlice(rs.sliceFrom(Array.from({ length: 2 }, (): rs.String => { + return (undefined as unknown) as rs.String; + })), rs.sliceRange(rs.sliceFrom([rs.stringNew()]), 0, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 331, col: 106 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 331, col: 103 }), (a0: rs.String): rs.String => { + return rs.stringClone(a0); + }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/mem/maybe_uninit.rs", line: 1265, col: 9 }); + } else if (k === 71) { + rs.byteVecPush(out, rs.sliceNewUninit(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 332, col: 55 }), 2, (): rs.u16 => { + return (undefined as unknown) as rs.u16; + }).length & 0xff); + } else if (k === 72) { + let lent: rs.ByteSlice = rs.byteVecSlice(v); + const _482: rs.usize = rs.usizeAdd(rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 335, col: 26 }), 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 335, col: 26 }); + rs.ioSliceAdvance(rs.place(() => lent, (value2) => lent = value2), _482, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/io/io_slice/repr_generic.rs", line: 15, col: 37 }); + rs.byteVecExtendFromSlice(out, lent); + } else if (k === 73) { + const lent2: rs.ByteSlice[] = [rs.byteVecSlice(v)]; + let left: rs.Slice = rs.sliceFrom(lent2); + const _498: rs.usize = rs.usizeAdd(rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 341, col: 57 }), 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 341, col: 57 }); + rs.ioSliceAdvanceSlices(rs.place(() => left, (value) => left = value), _498, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/io/io_slice.rs", line: 308, col: 13 }); + rs.byteVecPush(out, left.length & 0xff); + } else if (k === 74) { + rs.byteVecInsert(rs.byteVecFrom(rs.byteVecView(v)), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 344, col: 32 }), n, { file: "fixtures/lang/panics/src/hooked.rs", line: 344, col: 25 }); + } else if (k === 75) { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecSplitOff(rs.byteVecFrom(rs.byteVecView(v)), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 345, col: 46 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 345, col: 36 })), undefined, true); + } else if (k === 76) { + rs.byteVecPush(out, rs.vecRemove(rs.vecFrom([n as rs.u16]), rs.usizeAdd(at, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 346, col: 50 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 346, col: 43 }) & 0xff); + } else if (k === 77) { + rs.byteVecPush(out, rs.vecSwapRemove(rs.vecFrom([n as rs.u16]), rs.usizeAdd(at, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 347, col: 55 })) & 0xff); + } else if (k === 78) { + rs.vecInsert(rs.vecFrom([n as rs.u16]), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 348, col: 41 }), 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 348, col: 34 }); + } else if (k === 79) { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.vecSplitOff(rs.vecFrom([n as rs.u16]), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 349, col: 55 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 349, col: 45 }).items), (_29: rs.u16): rs.u8 => { + return _29 & 0xff; + }), undefined, true); + } else if (k === 80) { + const _550: rs.ByteSlice = rs.byteVecSlice(rs.byteVecFrom(rs.byteVecView(v))); + const _554: rs.Range = new rs.Range(rs.usizeAdd(at, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 350, col: 37 }), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 350, col: 45 })); + rs.byteSliceCopyWithin(_550, _554.start, _554.end, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 350, col: 25 }); + } else if (k === 81) { + rs.byteVecPush(out, rs.u64Low(rs.u64Clamp(n as rs.u64, rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 351, col: 43 }), n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 351, col: 37 })) & 0xff); + } else if (k === 82) { + rs.byteVecPush(out, rs.clamp(rs.i32Neg(n as rs.i32, { file: "fixtures/lang/panics/src/hooked.rs", line: 352, col: 24 }), 0, -1, { file: "fixtures/lang/panics/src/hooked.rs", line: 352, col: 40 }) & 0xff); + } else if (k === 83) { + const arg = {}; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => Failing.fmt$fmt_Display(arg, f)]).v)); + } else if (k === 84) { + const _585: Failing.Failing = {}; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => Failing.fmt$fmt_Display(_585, f)).v)); + } else if (k === 85) { + rs.byteVecPush(out, rs.iterFrom({ _0: n }, Lying.next$iter_Iterator, undefined, { hint: Lying.sizeHint$iter_Iterator }).len() & 0xff); + } else { + if (53 <= k) { + if (k <= 56) { + joined(rs.u8Sub(k, 53, { file: "fixtures/lang/panics/src/hooked.rs", line: 316, col: 31 }), n, out); + break b0; } - if (57 <= k) { - if (k <= 67) { - rs.byteVecPush(out, compared(rs.u8Sub(k, 57, { file: "fixtures/lang/panics/src/hooked.rs", line: 317, col: 42 }), n)); - break b0; - } + } + if (57 <= k) { + if (k <= 67) { + rs.byteVecPush(out, compared(rs.u8Sub(k, 57, { file: "fixtures/lang/panics/src/hooked.rs", line: 317, col: 42 }), n)); + break b0; } - const _593: Short.Short = { _0: rs.u8Rem(n, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 356, col: 31 }) }; - const _596: rs.Range = new rs.Range(0, rs.u8Add(rs.u8Rem(n, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 356, col: 45 }), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 356, col: 45 })); - rs.iterExtendBytes(out, rs.iterMap(rs.iterRev(rs.iterZip(rs.iterFrom(_593, Short.next$iter_Iterator, undefined, { hint: Short.sizeHint$iter_Iterator, back: (it: Short.Short) => rs.iterFromOption(Short.nextBack$iter_DoubleEndedIterator(it)) }), _596)), (_2: [rs.u8, rs.u8]): rs.u8 => { - return _2[0] ^ _2[1]; - }), "next"); } + const _593: Short.Short = { _0: rs.u8Rem(n, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 356, col: 31 }) }; + const _596: rs.Range = new rs.Range(0, rs.u8Add(rs.u8Rem(n, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 356, col: 45 }), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 356, col: 45 })); + rs.iterExtendBytes(out, rs.iterMap(rs.iterRev(rs.iterZip(rs.iterFrom(_593, Short.next$iter_Iterator, undefined, { hint: Short.sizeHint$iter_Iterator, back: (it: Short.Short) => rs.iterFromOption(Short.nextBack$iter_DoubleEndedIterator(it)) }), _596)), (_2: [rs.u8, rs.u8]): rs.u8 => { + return _2[0] ^ _2[1]; + }), "next"); } } } @@ -589,11 +583,6 @@ export function joined(kind: rs.u8, n: rs.u8, out: rs.ByteVec): void { export function compared(kind: rs.u8, n: rs.u8): rs.u8 { let _0!: rs.u8; let _held!: rs.RefCell; - const _15: (a0: rs.Ordering | undefined) => rs.u8 = (o: rs.Ordering | undefined): rs.u8 => { - return option_mapOr$14runhi(o, 9, (o2: rs.Ordering): rs.u8 => { - return o2 & 0xff; - }); - }; const _5: [rs.RefCell, rs.RefCell] = [new rs.RefCell(n), new rs.RefCell(rs.u8WrappingAdd(n, 1))]; const a: rs.RefCell = _5[0]; const b: rs.RefCell = _5[1]; @@ -602,36 +591,41 @@ export function compared(kind: rs.u8, n: rs.u8): rs.u8 { } else { _held = rs.refCellBorrowMut(a, { file: "fixtures/lang/panics/src/hooked.rs", line: 393, col: 35 }); } + const _15: (a0: rs.Ordering | undefined) => rs.u8 = (o: rs.Ordering | undefined): rs.u8 => { + return option_mapOr$14runhi(o, 9, (o2: rs.Ordering): rs.u8 => { + return o2 & 0xff; + }); + }; if (kind === 0) { - _0 = rs.refCellBy(rs.same, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 34 })(a, b) ? 1 : 0; + _0 = rs.refCellBy(rs.same, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1484, col: 15 }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1484, col: 34 })(a, b) ? 1 : 0; } else if (kind === 1) { - _0 = !rs.refCellBy(rs.same, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 34 })(a, b) ? 1 : 0; + _0 = !rs.refCellBy(rs.same, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1484, col: 15 }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1484, col: 34 })(a, b) ? 1 : 0; } else if (kind === 2) { - const part2 = rs.refCellBy(rs.cmp, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1496, col: 14 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1496, col: 43 })(a, b); + const part2 = rs.refCellBy(rs.cmp, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1498, col: 14 }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1498, col: 43 })(a, b); _0 = _15(part2); } else if (kind === 3) { - _0 = rs.refCellBy(rs.lt, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 33 })(a, b) ? 1 : 0; + _0 = rs.refCellBy(rs.lt, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1506, col: 15 }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1506, col: 33 })(a, b) ? 1 : 0; } else if (kind === 4) { - _0 = rs.refCellBy(rs.le, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1512, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1512, col: 34 })(a, b) ? 1 : 0; + _0 = rs.refCellBy(rs.le, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1514, col: 15 }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1514, col: 34 })(a, b) ? 1 : 0; } else if (kind === 5) { - _0 = rs.refCellBy(rs.gt, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1520, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1520, col: 33 })(a, b) ? 1 : 0; + _0 = rs.refCellBy(rs.gt, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1522, col: 15 }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1522, col: 33 })(a, b) ? 1 : 0; } else if (kind === 6) { - _0 = rs.refCellBy(rs.ge, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1528, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1528, col: 34 })(a, b) ? 1 : 0; + _0 = rs.refCellBy(rs.ge, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1530, col: 15 }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1530, col: 34 })(a, b) ? 1 : 0; } else if (kind === 7) { - const part = rs.refCellBy(rs.cmp, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1539, col: 14 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1539, col: 35 })(a, b); + const part = rs.refCellBy(rs.cmp, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1541, col: 14 }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1541, col: 35 })(a, b); _0 = _15(part); } else if (kind === 8) { const _47: [rs.u8, rs.RefCell] = [n, a]; const _50: [rs.u8, rs.RefCell] = [n, b]; - _0 = rs.testTuple([rs.cmp], rs.refCellBy(rs.lt, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 33 }), -1)(_47, _50) ? 1 : 0; + _0 = rs.testTuple([rs.cmp], rs.refCellBy(rs.lt, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1506, col: 15 }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1506, col: 33 }), -1)(_47, _50) ? 1 : 0; } else if (kind === 9) { const _54: rs.RefCell = a; const _57: rs.RefCell = b; - _0 = rs.cmpReverse(rs.refCellBy(rs.lt, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 33 }))(_54, _57) ? 1 : 0; + _0 = rs.cmpReverse(rs.refCellBy(rs.lt, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1506, col: 15 }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1506, col: 33 }))(_54, _57) ? 1 : 0; } else { const _60: rs.Slice> = rs.sliceFrom([a]); const _63: rs.Slice> = rs.sliceFrom([b]); - _0 = rs.eqSlice(rs.refCellBy(rs.same, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 34 }))(_60, _63) ? 1 : 0; + _0 = rs.eqSlice(rs.refCellBy(rs.same, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1484, col: 15 }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1484, col: 34 }))(_60, _63) ? 1 : 0; } rs.refMutRelease(_held); return _0; @@ -659,9 +653,9 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const line: rs.String = rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], "\n"]); rs.localKeyWithBorrowMut(NOTE, (note: rs.String): undefined => { rs.stringPushStr(note, line.v); - }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); + }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/std/src/thread/local.rs", line: 721, col: 38 }); rs.panicFmt(["unread"], { file: "fixtures/lang/panics/src/hooked.rs", line: 466, col: 13 }); - }, { capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/raw_vec/mod.rs", line: 29, col: 5 }, trusted_capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/spec_from_iter_nested.rs", line: 57, col: 18 }, swap_remove: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2178, col: 13 }, vec_set_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2138, col: 9 }, into_flattened: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3667, col: 36 }, rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3902, col: 9 }, rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3948, col: 9 }, ord_violation: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/sort/shared/smallsort.rs", line: 854, col: 5 }, ord_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cmp.rs", line: 1166, col: 9 }, f32_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f32.rs", line: 1665, col: 9 }, f64_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f64.rs", line: 1643, col: 9 }, encode_utf8: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2507, col: 9 }, encode_utf16: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2601, col: 13 }, format: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/fmt.rs", line: 657, col: 14 }, to_string: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/string.rs", line: 2997, col: 14 }, debug_struct_fields: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/fmt/mod.rs", line: 2572, col: 9 }, exact_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/exact_size.rs", line: 122, col: 9 }, join_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/str.rs", line: 177, col: 10 }, int_sum: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }, int_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 554, col: 1 }, char_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 119, col: 45 }, hash_capacity: { file: "/cargo/registry/25cdd57fae9f0462/hashbrown-0.17.1/src/raw.rs", line: 36, col: 40 }, btree_range_equal_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 110, col: 21 }, btree_range_equal_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 112, col: 21 }, btree_range_order_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 119, col: 21 }, btree_range_order_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 121, col: 21 }, deque_insert: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2612, col: 9 }, deque_swap_i: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1062, col: 9 }, deque_swap_j: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1063, col: 9 }, deque_rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3198, col: 9 }, deque_rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3243, col: 9 }, deque_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2724, col: 9 }, list_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/linked_list.rs", line: 1015, col: 9 }, mutex_lock: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sys/sync/mutex/no_threads.rs", line: 28, col: 9 }, once_force: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sync/once.rs", line: 227, col: 20 }, reentrant_init: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/once.rs", line: 325, col: 66 }, lazy_poisoned: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/lazy.rs", line: 386, col: 5 }, ready_poll: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 23, col: 35 }, ready_into_inner: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 46, col: 16 }, duration_new: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 281, col: 18 }, duration_from_mins: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 540, col: 13 }, duration_from_hours: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 510, col: 13 }, duration_add: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1345, col: 31 }, duration_sub: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1365, col: 31 }, duration_mul: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1385, col: 31 }, zip_next_back: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/adapters/zip.rs", line: 213, col: 5 }, bytes_advance: { file: "bytes/source/lib.rs", line: 207, col: 5 }, bytes_does_not_fit: { file: "bytes/source/lib.rs", line: 215, col: 5 }, bytes_slice: { file: "bytes/source/bytes.rs", line: 374, col: 28 }, bytes_slice_ref_start: { file: "bytes/source/bytes.rs", line: 426, col: 9 }, bytes_slice_ref_end: { file: "bytes/source/bytes.rs", line: 432, col: 9 }, bytes_split_off: { file: "bytes/source/bytes.rs", line: 481, col: 9 }, bytes_split_to: { file: "bytes/source/bytes.rs", line: 533, col: 9 }, bytes_buf_advance: { file: "bytes/source/bytes.rs", line: 694, col: 9 }, bytes_mut_split_off: { file: "bytes/source/bytes_mut.rs", line: 329, col: 9 }, bytes_mut_split_to: { file: "bytes/source/bytes_mut.rs", line: 408, col: 9 }, bytes_mut_set_len: { file: "bytes/source/bytes_mut.rs", line: 545, col: 9 }, bytes_mut_overflow: { file: "bytes/source/bytes_mut.rs", line: 700, col: 21 }, bytes_mut_overflow_offset: { file: "bytes/source/bytes_mut.rs", line: 720, col: 29 }, bytes_mut_buf_advance: { file: "bytes/source/bytes_mut.rs", line: 1246, col: 9 } }); + }, { capacity: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/raw_vec/mod.rs", line: 29, col: 5 }, trusted_capacity: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/spec_from_iter_nested.rs", line: 57, col: 18 }, swap_remove: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 2180, col: 13 }, vec_set_len: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 2140, col: 9 }, into_flattened: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 3757, col: 36 }, rotate_left: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/slice/mod.rs", line: 3900, col: 9 }, rotate_right: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/slice/mod.rs", line: 3946, col: 9 }, ord_violation: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/slice/sort/shared/smallsort.rs", line: 854, col: 5 }, ord_clamp: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cmp.rs", line: 1166, col: 9 }, f32_clamp: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/num/f32.rs", line: 1441, col: 9 }, f64_clamp: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/num/f64.rs", line: 1420, col: 9 }, encode_utf8: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/char/methods.rs", line: 2581, col: 9 }, encode_utf16: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/char/methods.rs", line: 2675, col: 13 }, format: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/fmt.rs", line: 657, col: 14 }, to_string: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/string.rs", line: 3049, col: 14 }, debug_struct_fields: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/fmt/mod.rs", line: 2589, col: 41 }, debug_enum: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/fmt/mod.rs", line: 2606, col: 26 }, exact_len: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/traits/exact_size.rs", line: 122, col: 9 }, join_len: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/str.rs", line: 177, col: 10 }, int_sum: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }, int_forward: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/range.rs", line: 554, col: 1 }, char_forward: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/range.rs", line: 119, col: 45 }, hash_capacity: { file: "/cargo/registry/25cdd57fae9f0462/hashbrown-0.17.1/src/raw.rs", line: 36, col: 40 }, btree_range_equal_BTreeSet: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 110, col: 21 }, btree_range_equal_BTreeMap: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 112, col: 21 }, btree_range_order_BTreeSet: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 119, col: 21 }, btree_range_order_BTreeMap: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 121, col: 21 }, deque_insert: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 2614, col: 9 }, deque_swap_i: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 1062, col: 9 }, deque_swap_j: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 1063, col: 9 }, deque_rotate_left: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 3200, col: 9 }, deque_rotate_right: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 3245, col: 9 }, deque_split_off: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 2726, col: 9 }, list_split_off: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/linked_list.rs", line: 1067, col: 9 }, mutex_lock: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/std/src/sys/sync/mutex/no_threads.rs", line: 31, col: 9 }, once_force: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/std/src/sync/once.rs", line: 227, col: 20 }, reentrant_init: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell/once.rs", line: 325, col: 66 }, lazy_poisoned: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell/lazy.rs", line: 386, col: 5 }, ready_poll: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/future/ready.rs", line: 23, col: 35 }, ready_into_inner: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/future/ready.rs", line: 46, col: 16 }, duration_new: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 283, col: 18 }, duration_from_mins: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 542, col: 13 }, duration_from_hours: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 512, col: 13 }, duration_add: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1397, col: 31 }, duration_sub: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1417, col: 31 }, duration_mul: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1437, col: 31 }, zip_next_back: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/adapters/zip.rs", line: 213, col: 5 }, bytes_advance: { file: "bytes/source/lib.rs", line: 207, col: 5 }, bytes_does_not_fit: { file: "bytes/source/lib.rs", line: 215, col: 5 }, bytes_slice: { file: "bytes/source/bytes.rs", line: 374, col: 28 }, bytes_slice_ref_start: { file: "bytes/source/bytes.rs", line: 426, col: 9 }, bytes_slice_ref_end: { file: "bytes/source/bytes.rs", line: 432, col: 9 }, bytes_split_off: { file: "bytes/source/bytes.rs", line: 481, col: 9 }, bytes_split_to: { file: "bytes/source/bytes.rs", line: 533, col: 9 }, bytes_buf_advance: { file: "bytes/source/bytes.rs", line: 694, col: 9 }, bytes_mut_split_off: { file: "bytes/source/bytes_mut.rs", line: 329, col: 9 }, bytes_mut_split_to: { file: "bytes/source/bytes_mut.rs", line: 408, col: 9 }, bytes_mut_set_len: { file: "bytes/source/bytes_mut.rs", line: 545, col: 9 }, bytes_mut_overflow: { file: "bytes/source/bytes_mut.rs", line: 700, col: 21 }, bytes_mut_overflow_offset: { file: "bytes/source/bytes_mut.rs", line: 720, col: 29 }, bytes_mut_buf_advance: { file: "bytes/source/bytes_mut.rs", line: 1246, col: 9 } }); const subset: rs.ByteSlice = rs.bytesSlice(whole, 0, 1); if (k === 0) { const _22: rs.ByteSlice = rs.bytesSlice(whole, rs.usizeAdd(1, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 470, col: 34 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 470, col: 30 })); diff --git a/ts/fixtures/lang/panics/hook/expected/located.Held$read.ts b/ts/fixtures/lang/panics/hook/expected/located.Held$read.ts index cc96f2732..40fa5dc4c 100644 --- a/ts/fixtures/lang/panics/hook/expected/located.Held$read.ts +++ b/ts/fixtures/lang/panics/hook/expected/located.Held$read.ts @@ -3,12 +3,7 @@ import * as rs from "./rs.ts"; export function fmt$read_fmt_Debug(self: Held, f: rs.Formatter): rs.Result { - const _3: string = "Held"; - const _4: string = "at"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtLocationDebug(self.at, f); - const _7: string = "maybe"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(self.maybe, f, rs.fmtLocationDebug); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Held at maybe", [(f: rs.Formatter) => rs.fmtLocationDebug(self.at, f), (f: rs.Formatter) => rs.fmtOption(self.maybe, f, rs.fmtLocationDebug)]); } export function eq$read_cmp_PartialEq(self: Held, other: Held): boolean { diff --git a/ts/fixtures/lang/panics/hook/expected/located.ts b/ts/fixtures/lang/panics/hook/expected/located.ts index a3c44a448..ceccf1317 100644 --- a/ts/fixtures/lang/panics/hook/expected/located.ts +++ b/ts/fixtures/lang/panics/hook/expected/located.ts @@ -43,13 +43,12 @@ export function picked(first: rs.u8, caller: rs.Location): rs.Location { /** A closure is no `#[track_caller]` function, so it gives its own calls'. */ export function inClosure(_caller: rs.Location): [rs.Location, rs.Location] { - const _1: () => rs.Location = (): rs.Location => { - return { file: "fixtures/lang/panics/src/located.rs", line: 47, col: 18 }; - }; const _2: () => rs.Location = (): rs.Location => { return here({ file: "fixtures/lang/panics/src/located.rs", line: 48, col: 21 }); }; - return [_1(), _2()] as [rs.Location, rs.Location]; + return [((): rs.Location => { + return { file: "fixtures/lang/panics/src/located.rs", line: 47, col: 18 }; + })(), _2()] as [rs.Location, rs.Location]; } /** A default, untracked, of the tracked method. */ @@ -78,12 +77,6 @@ export function lines(out: rs.ByteVec, at: rs.Slice): void { /** Calls of `#[track_caller]` functions, and `Location::caller` itself. */ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _24: (a0: rs.u8) => rs.Location = (n: rs.u8): rs.Location => { - if (!(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/located.rs", line: 139, col: 32 }) === 0)) { - return outer({ file: "fixtures/lang/panics/src/located.rs", line: 139, col: 61 }); - } - return here({ file: "fixtures/lang/panics/src/located.rs", line: 139, col: 45 }); - }; const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); const _7: rs.u8 = rs.u8Rem(kind, 6, { file: "fixtures/lang/panics/src/located.rs", line: 129, col: 11 }); if (_7 === 0) { @@ -91,7 +84,12 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { lines(out, rs.sliceFrom([{ file: "fixtures/lang/panics/src/located.rs", line: 134, col: 19 }, here({ file: "fixtures/lang/panics/src/located.rs", line: 134, col: 39 }), outer({ file: "fixtures/lang/panics/src/located.rs", line: 134, col: 47 }), _11[0], _11[1], plain(), picked(first, { file: "fixtures/lang/panics/src/located.rs", line: 134, col: 71 })])); } else if (_7 === 1) { const _23: [rs.Location, rs.Location] = inClosure({ file: "fixtures/lang/panics/src/located.rs", line: 138, col: 33 }); - lines(out, rs.sliceFrom([_23[0], _23[1], _24(first), ((): rs.Location => { + lines(out, rs.sliceFrom([_23[0], _23[1], ((n: rs.u8): rs.Location => { + if (!(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/located.rs", line: 139, col: 32 }) === 0)) { + return outer({ file: "fixtures/lang/panics/src/located.rs", line: 139, col: 61 }); + } + return here({ file: "fixtures/lang/panics/src/located.rs", line: 139, col: 45 }); + })(first), ((): rs.Location => { return { file: "fixtures/lang/panics/src/located.rs", line: 140, col: 53 }; })()])); } else if (_7 === 2) { diff --git a/ts/fixtures/lang/panics/hook/expected/panics.Point.ts b/ts/fixtures/lang/panics/hook/expected/panics.Point.ts index c5f7e0f38..b79454859 100644 --- a/ts/fixtures/lang/panics/hook/expected/panics.Point.ts +++ b/ts/fixtures/lang/panics/hook/expected/panics.Point.ts @@ -3,12 +3,7 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug(self: Point, f: rs.Formatter): rs.Result { - const _3: string = "Point"; - const _4: string = "x"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.x, f); - const _7: string = "y"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.y, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Point x y", [(f: rs.Formatter) => rs.u8Debug(self.x, f), (f: rs.Formatter) => rs.u8Debug(self.y, f)]); } export function default$Default(): Point { diff --git a/ts/fixtures/lang/panics/hook/expected/std/thread/local.ts b/ts/fixtures/lang/panics/hook/expected/std/thread/local.ts index 4606da7f5..8e083c887 100644 --- a/ts/fixtures/lang/panics/hook/expected/std/thread/local.ts +++ b/ts/fixtures/lang/panics/hook/expected/std/thread/local.ts @@ -2,11 +2,11 @@ import * as rs from "../../rs.ts"; -export function withBorrow$097wfl1(self: rs.LocalKey>, f: (a0: rs.u8) => undefined): void { +export function withBorrow$08fexrm(self: rs.LocalKey>, f: (a0: rs.u8) => undefined): void { const captured = f; ((cell: rs.RefCell): undefined => { const _32: (a0: rs.u8) => undefined = captured; - const _7: rs.RefCell = rs.refCellBorrow(cell, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 688, col: 34 }); + const _7: rs.RefCell = rs.refCellBorrow(cell, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/std/src/thread/local.rs", line: 688, col: 34 }); _32(_7.value); rs.refRelease(_7); })(self.get()); diff --git a/ts/fixtures/lang/pointers/expected/pointers.List.ts b/ts/fixtures/lang/pointers/expected/pointers.List.ts index 4bbebb0fb..d6862f2c7 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.List.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.List.ts @@ -192,19 +192,14 @@ export function getMut$Vec_u8(self: List, key: rs.u8): rs.ByteVec | } export function each$Vec_u8(self: List, out: rs.ByteVec): void { - b0: { - if (self.guard !== undefined) { - const guard: Node.Node = self.guard; - let at: Node.Node = guard.link.at0 as Node.Node; - while (true) { - if (!(at !== guard)) { - break b0; - } - const _13: [rs.u8, rs.ByteVec] = at.entry; - rs.byteVecPush(out, _13[0]); - rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_13[1])); - at = at.link.at0 as Node.Node; - } + if (self.guard !== undefined) { + const guard: Node.Node = self.guard; + let at: Node.Node = guard.link.at0 as Node.Node; + while (at !== guard) { + const _13: [rs.u8, rs.ByteVec] = at.entry; + rs.byteVecPush(out, _13[0]); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_13[1])); + at = at.link.at0 as Node.Node; } } } diff --git a/ts/fixtures/lang/pointers/expected/pointers.Waiters.ts b/ts/fixtures/lang/pointers/expected/pointers.Waiters.ts index 4af08be45..b796f6938 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Waiters.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Waiters.ts @@ -13,17 +13,15 @@ export interface Waiters { } export function push(self: Waiters, waiter: Waiter.Waiter): void { - b0: { - if (!rs.atomicSwap(waiter.enqueued, true, 4)) { - let head: Waiter.Waiter = rs.atomicLoad(self.head, 4); - while (true) { - rs.atomicStore(waiter.next, head, 4); - const _14: rs.Result = rs.atomicCompareExchange(self.head, head, waiter, 4, 4); - if (_14.ok) { - break b0; - } - head = _14.error; + if (!rs.atomicSwap(waiter.enqueued, true, 4)) { + let head: Waiter.Waiter = rs.atomicLoad(self.head, 4); + while (true) { + rs.atomicStore(waiter.next, head, 4); + const _14: rs.Result = rs.atomicCompareExchange(self.head, head, waiter, 4, 4); + if (_14.ok) { + break; } + head = _14.error; } } } diff --git a/ts/fixtures/lang/pointers/expected/pointers.ts b/ts/fixtures/lang/pointers/expected/pointers.ts index efc4d3268..4e5c6fcb0 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.ts @@ -1490,21 +1490,6 @@ export function aimed(data: rs.ByteSlice, out: rs.ByteVec): void { let _528!: boolean; let _536!: boolean; let _538!: boolean; - const _322: (a0: rs.Slice) => rs.u8 = (b: rs.Slice): rs.u8 => { - return rs.iterFold(rs.iterSlice(rs.sliceItems(b)), 0, (acc: rs.u8, _33: boolean): rs.u8 => { - return ((acc << 1) & 0xff) | (_33 ? 1 : 0); - }); - }; - const _455: (a0: rs.Slice) => rs.u8 = (b3: rs.Slice): rs.u8 => { - return rs.iterFold(rs.iterSlice(rs.sliceItems(b3)), 0, (acc2: rs.u8, _36: boolean): rs.u8 => { - return ((acc2 << 1) & 0xff) | (_36 ? 1 : 0); - }); - }; - const _588: (a0: rs.Slice) => rs.u8 = (b5: rs.Slice): rs.u8 => { - return rs.iterFold(rs.iterSlice(rs.sliceItems(b5)), 0, (acc3: rs.u8, _38: boolean): rs.u8 => { - return ((acc3 << 1) & 0xff) | (_38 ? 1 : 0); - }); - }; for (const n of rs.byteSliceView(data)) { const pair: Paired.Paired = { _0: n, _1: ~n & 0xff }; const at: Paired.Paired = pair; @@ -1731,10 +1716,12 @@ export function aimed(data: rs.ByteSlice, out: rs.ByteVec): void { const _289: boolean = (nest8.inner.maybe as Paired.Paired | undefined) !== nest8.inner.held as Paired.Paired; const pointer11 = other2; const optional: boolean[] = [_284, _289, (nest8.inner.maybe as Paired.Paired | undefined) === (pointer11 === rs.NULL ? undefined : pointer11), (nest8.inner.maybe as Paired.Paired | undefined) === none, none === undefined, (nest8.inner.seen as Paired.Paired) === nest8.inner.at as Paired.Paired, (nest8.inner.seen as Paired.Paired) !== null_, null_ === rs.NULL]; - const _323: rs.u8 = _322(rs.sliceFrom(same)); - const _328: rs.u8 = _322(rs.sliceFrom(apart)); - const part = rs.sliceFrom(optional); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_323, _328, _322(part))), undefined, true); + const _322: (a0: rs.Slice) => rs.u8 = (b: rs.Slice): rs.u8 => { + return rs.iterFold(rs.iterSlice(rs.sliceItems(b)), 0, (acc: rs.u8, _33: boolean): rs.u8 => { + return ((acc << 1) & 0xff) | (_33 ? 1 : 0); + }); + }; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_322(rs.sliceFrom(same)), _322(rs.sliceFrom(apart)), _322(rs.sliceFrom(optional)))), undefined, true); const other3: rs.ByteSlice = rs.byteSliceFrom(otherBytes); const at10: rs.ByteSlice = rs.byteSliceFrom(bytes); const pointer12 = at10; @@ -1818,10 +1805,12 @@ export function aimed(data: rs.ByteSlice, out: rs.ByteVec): void { const _437: boolean = rs.eqOption(rs.byteSliceSame)(_439, _442); const _447: rs.ByteSlice | undefined = nest9.inner.seen as rs.ByteSlice; const optional2: boolean[] = [_417, _422, _427, _431, _434, _437, !rs.eqOption(rs.byteSliceSame)(_447, null_2), rs.eqOption(rs.byteSliceSame)(null_2, rs.NULL)]; - const _456: rs.u8 = _455(rs.sliceFrom(same2)); - const _461: rs.u8 = _455(rs.sliceFrom(apart2)); - const part2 = rs.sliceFrom(optional2); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_456, _461, _455(part2))), undefined, true); + const _455: (a0: rs.Slice) => rs.u8 = (b3: rs.Slice): rs.u8 => { + return rs.iterFold(rs.iterSlice(rs.sliceItems(b3)), 0, (acc2: rs.u8, _36: boolean): rs.u8 => { + return ((acc2 << 1) & 0xff) | (_36 ? 1 : 0); + }); + }; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_455(rs.sliceFrom(same2)), _455(rs.sliceFrom(apart2)), _455(rs.sliceFrom(optional2)))), undefined, true); const other4: Housed.Housed = otherWrap; const at12: Housed.Housed = wrap; const pointer16 = at12; @@ -1896,10 +1885,12 @@ export function aimed(data: rs.ByteSlice, out: rs.ByteVec): void { const _555: boolean = (nest10.inner.maybe as Housed.Housed | undefined) !== nest10.inner.held as Housed.Housed; const pointer19 = other4; const optional3: boolean[] = [_550, _555, (nest10.inner.maybe as Housed.Housed | undefined) === (pointer19 === rs.NULL ? undefined : pointer19), (nest10.inner.maybe as Housed.Housed | undefined) === none3, none3 === undefined, (nest10.inner.seen as Housed.Housed) === nest10.inner.at as Housed.Housed, (nest10.inner.seen as Housed.Housed) !== null_3, null_3 === rs.NULL]; - const _589: rs.u8 = _588(rs.sliceFrom(same3)); - const _594: rs.u8 = _588(rs.sliceFrom(apart3)); - const part3 = rs.sliceFrom(optional3); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_589, _594, _588(part3))), undefined, true); + const _588: (a0: rs.Slice) => rs.u8 = (b5: rs.Slice): rs.u8 => { + return rs.iterFold(rs.iterSlice(rs.sliceItems(b5)), 0, (acc3: rs.u8, _38: boolean): rs.u8 => { + return ((acc3 << 1) & 0xff) | (_38 ? 1 : 0); + }); + }; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_588(rs.sliceFrom(same3)), _588(rs.sliceFrom(apart3)), _588(rs.sliceFrom(optional3)))), undefined, true); } } @@ -3481,8 +3472,8 @@ export function behindRefs(data: rs.ByteSlice, out: rs.ByteVec): void { let end: rs.Place = rs.NULL; end = rs.ptrAdd(at, 1); rs.byteVecPush(out, rs.ptrOffsetFrom(end, at) & 0xff); - const _296: Nothing.Nothing = {}; - rs.byteVecPush(out, nothingTag(_296, bits)); + const _294: Nothing.Nothing = {}; + rs.byteVecPush(out, nothingTag(_294, bits)); arc2[Symbol.dispose](); arc[Symbol.dispose](); } diff --git a/ts/fixtures/lang/refs/expected/refs.Listing.ts b/ts/fixtures/lang/refs/expected/refs.Listing.ts index 5454dfe64..69a7d1a2c 100644 --- a/ts/fixtures/lang/refs/expected/refs.Listing.ts +++ b/ts/fixtures/lang/refs/expected/refs.Listing.ts @@ -7,14 +7,7 @@ export function default$Default(): Listing { } export function fmt$fmt_Debug(self: Listing, f: rs.Formatter): rs.Result { - const _3: string = "Listing"; - const _4: string = "source"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(self.source, f, rs.u8Debug); - const _7: string = "listed"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.listed), f, rs.u8Debug); - const _10: string = "stale"; - const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.stale), f, rs.u8Debug); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11)); + return rs.fmtDebugFields(f, "Listing source listed stale", [(f: rs.Formatter) => rs.fmtOption(self.source, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.listed), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.stale), f, rs.u8Debug)]); } /** moq-net's listing: a crate type's default, made in place only while there is none. */ diff --git a/ts/fixtures/lang/refs/expected/refs.ts b/ts/fixtures/lang/refs/expected/refs.ts index 978014448..571a5736e 100644 --- a/ts/fixtures/lang/refs/expected/refs.ts +++ b/ts/fixtures/lang/refs/expected/refs.ts @@ -168,14 +168,6 @@ export function fill(seen: rs.Place, s: rs.String, next: rs.u export function refs(data: rs.ByteSlice, out: rs.ByteVec): void { let _170!: rs.u8; - const _117: (a0: rs.u8 | undefined | rs.None) => rs.u8 = (o: rs.u8 | undefined | rs.None): rs.u8 => { - return option_mapOr$1rg5gkk(o, 221, (o2: rs.u8 | undefined): rs.u8 => { - return option_unwrapOr$1fr498u(o2, 238); - }); - }; - const _275: (a0: rs.Place, a1: rs.u8) => undefined = (x3: rs.Place, b8: rs.u8): undefined => { - bump(x3, b8); - }; const by: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 3); let local: rs.u32 = 7; bumpThrice(rs.place(() => local, (value) => local = value), by); @@ -238,6 +230,11 @@ export function refs(data: rs.ByteSlice, out: rs.ByteVec): void { })); } let nested = rs.None as rs.u8 | undefined | rs.None; + const _117: (a0: rs.u8 | undefined | rs.None) => rs.u8 = (o: rs.u8 | undefined | rs.None): rs.u8 => { + return option_mapOr$1rg5gkk(o, 221, (o2: rs.u8 | undefined): rs.u8 => { + return option_unwrapOr$1fr498u(o2, 238); + }); + }; const old2: rs.u8 | undefined | rs.None = nested; nested = by; rs.byteVecPush(out, _117(old2)); @@ -324,8 +321,17 @@ export function refs(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(x))); } let total: rs.u32 = 0; - for (const b7 of rs.byteSliceView(data)) { - _275(rs.place(() => total, (value15) => total = value15), b7); + const iterS4: Uint8Array = rs.byteSliceView(data); + let iterI4: number = 0; + while (true) { + const _278: rs.u8 | rs.Done = iterI4 < iterS4.length ? iterS4[iterI4++] : rs.DONE; + const _275: (a0: rs.Place, a1: rs.u8) => undefined = (x3: rs.Place, b9: rs.u8): undefined => { + bump(x3, b9); + }; + if (_278 === rs.DONE) { + break; + } + _275(rs.place(() => total, (value15) => total = value15), _278); } rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(total))); const _293: [rs.u32, rs.u32] = [by as rs.u32, option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 5) as rs.u32]; diff --git a/ts/fixtures/lang/results/expected/results.ts b/ts/fixtures/lang/results/expected/results.ts index c50920f6e..08ccb863a 100644 --- a/ts/fixtures/lang/results/expected/results.ts +++ b/ts/fixtures/lang/results/expected/results.ts @@ -641,89 +641,78 @@ export function optionSlices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): return rs.u8Rem(b, 3) !== 0; }); }; - b0: { - const _5: rs.u8 = rs.u8Rem(kind, 4); - if (_5 === 0) { - const bytes: Array = [some(0), some(1)]; - for (const _17 of bytes) { - rs.byteVecPush(out, rs.byteOptionAsSlice(_17).length & 0xff); - rs.byteVecExtendFromSlice(out, rs.byteOptionAsSlice(_17)); - } - rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(bytes), (a02: rs.u8 | undefined): rs.ByteSlice => { - return rs.byteOptionAsSlice(a02); - }, (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true), "next"); - } else { - if (_5 === 1) { - let wide: rs.u16 | undefined = option_map$0ydco3f(some(0), (b3: rs.u8): rs.u16 => { - return ((b3 as rs.u16) << 4) & 0xffff; - }); - rs.sliceFill(wide === undefined ? rs.sliceFrom([]) : rs.sliceOfPlace(rs.place(() => wide as rs.u16, (value3) => wide = value3)), 4660, undefined); - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(rs.iterFold(rs.iterSlice(rs.sliceItems(rs.optionAsSlice(wide))), 0, (a: rs.u16, w: rs.u16): rs.u16 => { - return a ^ w; - })))); - const wides: Array = [wide, option_map$0zvojrv(some(1), (a0: rs.u8): rs.u16 => { - return a0 as rs.u16; - }), option_map$0ydco3f(some(2), (b4: rs.u8): rs.u16 => { - return rs.u16Mul(b4 as rs.u16, 257); - })]; - const iterS2: Array = wides; - let iterI2: number = 0; - const iterE: number = wides.length; - while (iterI2 < iterE) { - const _60: number = iterI2++; - const borrowed = iterS2; - const _65: rs.Slice = iterS2[_60] === undefined ? rs.sliceFrom([]) : rs.sliceOfPlace(rs.place(() => borrowed[_60] as rs.u16, (value4) => borrowed[_60] = value4)); - const iterS3: rs.u16[] = _65.data; - let iterI3: number = _65.start; - const iterE2: number = _65.start + _65.length; - while (iterI3 < iterE2) { - const _67: number = iterI3++; - iterS3[_67] = iterS3[_67] ^ 3855; - } - const borrowed2 = iterS2; - const _71: rs.Slice = iterS2[_60] === undefined ? rs.sliceFrom([]) : rs.sliceOfPlace(rs.place(() => borrowed2[_60] as rs.u16, (value5) => borrowed2[_60] = value5)); - if (_71.length === 1) { - const _76: rs.u16 = rs.intRotateLeft(_71.data[_71.start], 3, 16, false); - _71.data[_71.start] = _76; - } - rs.byteVecPush(out, rs.optionAsSlice(iterS2[_60]).length & 0xff); - } - swapHalves(rs.place(() => wides[1], (value6) => wides[1] = value6)); - const iterS4: Array = wides; - let iterI4: number = 0; - while (true) { - const _90: rs.u16 | undefined | rs.Done = iterI4 < iterS4.length ? iterS4[iterI4++] : rs.DONE; - if (_90 === rs.DONE) { - break b0; - } - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(option_unwrapOr$1szdyfq(_90, 61166)))); - } + const _5: rs.u8 = rs.u8Rem(kind, 4); + if (_5 === 0) { + const bytes: Array = [some(0), some(1)]; + for (const _17 of bytes) { + rs.byteVecPush(out, rs.byteOptionAsSlice(_17).length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteOptionAsSlice(_17)); + } + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(bytes), (a02: rs.u8 | undefined): rs.ByteSlice => { + return rs.byteOptionAsSlice(a02); + }, (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true), "next"); + } else if (_5 === 1) { + let wide: rs.u16 | undefined = option_map$0ydco3f(some(0), (b3: rs.u8): rs.u16 => { + return ((b3 as rs.u16) << 4) & 0xffff; + }); + rs.sliceFill(wide === undefined ? rs.sliceFrom([]) : rs.sliceOfPlace(rs.place(() => wide as rs.u16, (value3) => wide = value3)), 4660, undefined); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(rs.iterFold(rs.iterSlice(rs.sliceItems(rs.optionAsSlice(wide))), 0, (a: rs.u16, w: rs.u16): rs.u16 => { + return a ^ w; + })))); + const wides: Array = [wide, option_map$0zvojrv(some(1), (a0: rs.u8): rs.u16 => { + return a0 as rs.u16; + }), option_map$0ydco3f(some(2), (b4: rs.u8): rs.u16 => { + return rs.u16Mul(b4 as rs.u16, 257); + })]; + const iterS2: Array = wides; + let iterI2: number = 0; + const iterE: number = wides.length; + while (iterI2 < iterE) { + const _60: number = iterI2++; + const borrowed = iterS2; + const _65: rs.Slice = iterS2[_60] === undefined ? rs.sliceFrom([]) : rs.sliceOfPlace(rs.place(() => borrowed[_60] as rs.u16, (value4) => borrowed[_60] = value4)); + const iterS3: rs.u16[] = _65.data; + let iterI3: number = _65.start; + const iterE2: number = _65.start + _65.length; + while (iterI3 < iterE2) { + const _67: number = iterI3++; + iterS3[_67] = iterS3[_67] ^ 3855; } - if (_5 === 2) { - const words: rs.ByteVec | undefined = option_map$1px2rk4(some(0), (b2: rs.u8): rs.ByteVec => { - return rs.byteVecOf(b2, rs.u8Rem(b2, 4) as rs.usize); - }); - const other: rs.ByteVec | undefined = option_clone$0e53k5z(words); - for (const _110 of rs.sliceItems(words === undefined ? rs.sliceFrom([]) : rs.sliceIn(words))) { - rs.byteVecPush(_110, 119); - } - const _115: rs.ByteVec | undefined = rs.sliceFirst(words === undefined ? rs.sliceFrom([]) : rs.sliceIn(words)); - if (_115 !== undefined) { - Object.assign(_115, rs.byteVecFrom(Uint8Array.of(102))); - } - const s: rs.Slice = rs.optionAsSlice(words); - rs.byteVecPush(out, s.length & 0xff); - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterSlice(rs.sliceItems(s)), (value: rs.ByteVec) => rs.iterSlice(rs.byteVecView(value)), true), "next"); - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterSlice(rs.sliceItems(rs.optionAsSlice(other))), (value: rs.ByteVec) => rs.iterSlice(rs.byteVecView(value)), true), "next"); - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(words), (value: rs.ByteVec) => rs.byteVecIntoIter(value), true), "next"); - } else { - let units: undefined | rs.None = option_map$057a36e(some(0), (_2: rs.u8): undefined => {}); - rs.byteVecPush(out, rs.optionAsSlice(units, rs.None).length & 0xff); - rs.byteVecPush(out, (units === rs.None ? rs.sliceFrom([]) : rs.sliceOfPlace(rs.place(() => units as undefined, (value) => units = value))).length & 0xff); - rs.sliceFill(units === rs.None ? rs.sliceFrom([]) : rs.sliceOfPlace(rs.place(() => units as undefined, (value2) => units = value2)), undefined, undefined); - rs.byteVecPush(out, units !== rs.None ? 1 : 0); + const borrowed2 = iterS2; + const _71: rs.Slice = iterS2[_60] === undefined ? rs.sliceFrom([]) : rs.sliceOfPlace(rs.place(() => borrowed2[_60] as rs.u16, (value5) => borrowed2[_60] = value5)); + if (_71.length === 1) { + const _76: rs.u16 = rs.intRotateLeft(_71.data[_71.start], 3, 16, false); + _71.data[_71.start] = _76; } + rs.byteVecPush(out, rs.optionAsSlice(iterS2[_60]).length & 0xff); } + swapHalves(rs.place(() => wides[1], (value6) => wides[1] = value6)); + for (const _90 of wides) { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(option_unwrapOr$1szdyfq(_90, 61166)))); + } + } else if (_5 === 2) { + const words: rs.ByteVec | undefined = option_map$1px2rk4(some(0), (b2: rs.u8): rs.ByteVec => { + return rs.byteVecOf(b2, rs.u8Rem(b2, 4) as rs.usize); + }); + const other: rs.ByteVec | undefined = option_clone$0e53k5z(words); + for (const _110 of rs.sliceItems(words === undefined ? rs.sliceFrom([]) : rs.sliceIn(words))) { + rs.byteVecPush(_110, 119); + } + const _115: rs.ByteVec | undefined = rs.sliceFirst(words === undefined ? rs.sliceFrom([]) : rs.sliceIn(words)); + if (_115 !== undefined) { + Object.assign(_115, rs.byteVecFrom(Uint8Array.of(102))); + } + const s: rs.Slice = rs.optionAsSlice(words); + rs.byteVecPush(out, s.length & 0xff); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterSlice(rs.sliceItems(s)), (value: rs.ByteVec) => rs.iterSlice(rs.byteVecView(value)), true), "next"); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterSlice(rs.sliceItems(rs.optionAsSlice(other))), (value: rs.ByteVec) => rs.iterSlice(rs.byteVecView(value)), true), "next"); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(words), (value: rs.ByteVec) => rs.byteVecIntoIter(value), true), "next"); + } else { + let units: undefined | rs.None = option_map$057a36e(some(0), (_2: rs.u8): undefined => {}); + rs.byteVecPush(out, rs.optionAsSlice(units, rs.None).length & 0xff); + rs.byteVecPush(out, (units === rs.None ? rs.sliceFrom([]) : rs.sliceOfPlace(rs.place(() => units as undefined, (value) => units = value))).length & 0xff); + rs.sliceFill(units === rs.None ? rs.sliceFrom([]) : rs.sliceOfPlace(rs.place(() => units as undefined, (value2) => units = value2)), undefined, undefined); + rs.byteVecPush(out, units !== rs.None ? 1 : 0); } } diff --git a/ts/fixtures/lang/saturates/expected/saturates.Gauge.ts b/ts/fixtures/lang/saturates/expected/saturates.Gauge.ts index 8a8eedc3a..86c855563 100644 --- a/ts/fixtures/lang/saturates/expected/saturates.Gauge.ts +++ b/ts/fixtures/lang/saturates/expected/saturates.Gauge.ts @@ -3,75 +3,51 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug_i128(self: Gauge, f: rs.Formatter): rs.Result { - const _3: string = "Gauge"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.i128Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Gauge", [(f: rs.Formatter) => rs.i128Debug(self._0, f)]); } export function fmt$fmt_Debug_i16(self: Gauge, f: rs.Formatter): rs.Result { - const _3: string = "Gauge"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.i16Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Gauge", [(f: rs.Formatter) => rs.i16Debug(self._0, f)]); } export function fmt$fmt_Debug_i32(self: Gauge, f: rs.Formatter): rs.Result { - const _3: string = "Gauge"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.i32Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Gauge", [(f: rs.Formatter) => rs.i32Debug(self._0, f)]); } export function fmt$fmt_Debug_i64(self: Gauge, f: rs.Formatter): rs.Result { - const _3: string = "Gauge"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.i64Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Gauge", [(f: rs.Formatter) => rs.i64Debug(self._0, f)]); } export function fmt$fmt_Debug_i8(self: Gauge, f: rs.Formatter): rs.Result { - const _3: string = "Gauge"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.i8Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Gauge", [(f: rs.Formatter) => rs.i8Debug(self._0, f)]); } export function fmt$fmt_Debug_isize(self: Gauge, f: rs.Formatter): rs.Result { - const _3: string = "Gauge"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.isizeDebug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Gauge", [(f: rs.Formatter) => rs.isizeDebug(self._0, f)]); } export function fmt$fmt_Debug_u128(self: Gauge, f: rs.Formatter): rs.Result { - const _3: string = "Gauge"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.u128Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Gauge", [(f: rs.Formatter) => rs.u128Debug(self._0, f)]); } export function fmt$fmt_Debug_u16(self: Gauge, f: rs.Formatter): rs.Result { - const _3: string = "Gauge"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.u16Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Gauge", [(f: rs.Formatter) => rs.u16Debug(self._0, f)]); } export function fmt$fmt_Debug_u32(self: Gauge, f: rs.Formatter): rs.Result { - const _3: string = "Gauge"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.u32Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Gauge", [(f: rs.Formatter) => rs.u32Debug(self._0, f)]); } export function fmt$fmt_Debug_u64(self: Gauge, f: rs.Formatter): rs.Result { - const _3: string = "Gauge"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.u64Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Gauge", [(f: rs.Formatter) => rs.u64Debug(self._0, f)]); } export function fmt$fmt_Debug_u8(self: Gauge, f: rs.Formatter): rs.Result { - const _3: string = "Gauge"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Gauge", [(f: rs.Formatter) => rs.u8Debug(self._0, f)]); } export function fmt$fmt_Debug_usize(self: Gauge, f: rs.Formatter): rs.Result { - const _3: string = "Gauge"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.usizeDebug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Gauge", [(f: rs.Formatter) => rs.usizeDebug(self._0, f)]); } export function default$Default_i128(): Gauge { diff --git a/ts/fixtures/lang/saturates/expected/saturates.ts b/ts/fixtures/lang/saturates/expected/saturates.ts index f307c7bcf..3b92dc428 100644 --- a/ts/fixtures/lang/saturates/expected/saturates.ts +++ b/ts/fixtures/lang/saturates/expected/saturates.ts @@ -223,9 +223,6 @@ export function hashed$usize(v: rs.usize): rs.u64 { /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _20: (a0: rs.ByteVec, a1: rs.u8) => undefined = (out2: rs.ByteVec, v: rs.u8): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u8ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.u8 = (at: rs.usize): rs.u8 => { const buf: Uint8Array = Uint8Array.of(0); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -242,6 +239,9 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const a: rs.u8 = _8[0]; const b: rs.u8 = _8[1]; const c: rs.u8 = _8[2]; + const _20: (a0: rs.ByteVec, a1: rs.u8) => undefined = (out2: rs.ByteVec, v: rs.u8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u8ToBeBytes(v))); + }; const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { const part47 = rs.u8SaturatingAdd(a, b); @@ -421,9 +421,6 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _20: (a0: rs.ByteVec, a1: rs.u16) => undefined = (out2: rs.ByteVec, v: rs.u16): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u16ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.u16 = (at: rs.usize): rs.u16 => { const buf: Uint8Array = rs.bytes(2); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -440,6 +437,9 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const a: rs.u16 = _8[0]; const b: rs.u16 = _8[1]; const c: rs.u16 = _8[2]; + const _20: (a0: rs.ByteVec, a1: rs.u16) => undefined = (out2: rs.ByteVec, v: rs.u16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u16ToBeBytes(v))); + }; const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { const part47 = rs.u16SaturatingAdd(a, b); @@ -619,9 +619,6 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _20: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out2: rs.ByteVec, v: rs.u32): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u32ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.u32 = (at: rs.usize): rs.u32 => { const buf: Uint8Array = rs.bytes(4); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -638,6 +635,9 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const a: rs.u32 = _8[0]; const b: rs.u32 = _8[1]; const c: rs.u32 = _8[2]; + const _20: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out2: rs.ByteVec, v: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u32ToBeBytes(v))); + }; const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { const part47 = rs.u32SaturatingAdd(a, b); @@ -817,9 +817,6 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _20: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, v: rs.u64): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u64ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.u64 = (at: rs.usize): rs.u64 => { const buf: Uint8Array = rs.bytes(8); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -836,6 +833,9 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const a: rs.u64 = _8[0]; const b: rs.u64 = _8[1]; const c: rs.u64 = _8[2]; + const _20: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, v: rs.u64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u64ToBeBytes(v))); + }; const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { const part47 = rs.u64SaturatingAdd(a, b); @@ -1015,9 +1015,6 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _20: (a0: rs.ByteVec, a1: rs.u128) => undefined = (out2: rs.ByteVec, v: rs.u128): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.u128 = (at: rs.usize): rs.u128 => { const buf: Uint8Array = rs.bytes(16); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -1034,6 +1031,9 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const a: rs.u128 = _8[0]; const b: rs.u128 = _8[1]; const c: rs.u128 = _8[2]; + const _20: (a0: rs.ByteVec, a1: rs.u128) => undefined = (out2: rs.ByteVec, v: rs.u128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v))); + }; const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { const part47 = rs.u128SaturatingAdd(a, b); @@ -1213,9 +1213,6 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _20: (a0: rs.ByteVec, a1: rs.usize) => undefined = (out2: rs.ByteVec, v: rs.usize): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.usizeToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.usize = (at: rs.usize): rs.usize => { const buf: Uint8Array = rs.bytes(4); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -1232,6 +1229,9 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const a: rs.usize = _8[0]; const b: rs.usize = _8[1]; const c: rs.usize = _8[2]; + const _20: (a0: rs.ByteVec, a1: rs.usize) => undefined = (out2: rs.ByteVec, v: rs.usize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.usizeToBeBytes(v))); + }; const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { const part47 = rs.usizeSaturatingAdd(a, b); @@ -1411,9 +1411,6 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _20: (a0: rs.ByteVec, a1: rs.i8) => undefined = (out2: rs.ByteVec, v: rs.i8): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i8ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.i8 = (at: rs.usize): rs.i8 => { const buf: Uint8Array = Uint8Array.of(0); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -1430,6 +1427,9 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const a: rs.i8 = _8[0]; const b: rs.i8 = _8[1]; const c: rs.i8 = _8[2]; + const _20: (a0: rs.ByteVec, a1: rs.i8) => undefined = (out2: rs.ByteVec, v: rs.i8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i8ToBeBytes(v))); + }; const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { const part44 = rs.i8SaturatingAdd(a, b); @@ -1605,9 +1605,6 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _20: (a0: rs.ByteVec, a1: rs.i16) => undefined = (out2: rs.ByteVec, v: rs.i16): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i16ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.i16 = (at: rs.usize): rs.i16 => { const buf: Uint8Array = rs.bytes(2); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -1624,6 +1621,9 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const a: rs.i16 = _8[0]; const b: rs.i16 = _8[1]; const c: rs.i16 = _8[2]; + const _20: (a0: rs.ByteVec, a1: rs.i16) => undefined = (out2: rs.ByteVec, v: rs.i16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i16ToBeBytes(v))); + }; const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { const part44 = rs.i16SaturatingAdd(a, b); @@ -1799,9 +1799,6 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _20: (a0: rs.ByteVec, a1: rs.i32) => undefined = (out2: rs.ByteVec, v: rs.i32): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i32ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.i32 = (at: rs.usize): rs.i32 => { const buf: Uint8Array = rs.bytes(4); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -1818,6 +1815,9 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const a: rs.i32 = _8[0]; const b: rs.i32 = _8[1]; const c: rs.i32 = _8[2]; + const _20: (a0: rs.ByteVec, a1: rs.i32) => undefined = (out2: rs.ByteVec, v: rs.i32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i32ToBeBytes(v))); + }; const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { const part44 = rs.i32SaturatingAdd(a, b); @@ -1993,9 +1993,6 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _20: (a0: rs.ByteVec, a1: rs.i64) => undefined = (out2: rs.ByteVec, v: rs.i64): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i64ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.i64 = (at: rs.usize): rs.i64 => { const buf: Uint8Array = rs.bytes(8); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -2012,6 +2009,9 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const a: rs.i64 = _8[0]; const b: rs.i64 = _8[1]; const c: rs.i64 = _8[2]; + const _20: (a0: rs.ByteVec, a1: rs.i64) => undefined = (out2: rs.ByteVec, v: rs.i64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i64ToBeBytes(v))); + }; const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { const part44 = rs.i64SaturatingAdd(a, b); @@ -2187,9 +2187,6 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _20: (a0: rs.ByteVec, a1: rs.i128) => undefined = (out2: rs.ByteVec, v: rs.i128): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.i128 = (at: rs.usize): rs.i128 => { const buf: Uint8Array = rs.bytes(16); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -2206,6 +2203,9 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const a: rs.i128 = _8[0]; const b: rs.i128 = _8[1]; const c: rs.i128 = _8[2]; + const _20: (a0: rs.ByteVec, a1: rs.i128) => undefined = (out2: rs.ByteVec, v: rs.i128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v))); + }; const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { const part44 = rs.i128SaturatingAdd(a, b); @@ -2381,9 +2381,6 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _20: (a0: rs.ByteVec, a1: rs.isize) => undefined = (out2: rs.ByteVec, v: rs.isize): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.isizeToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.isize = (at: rs.usize): rs.isize => { const buf: Uint8Array = rs.bytes(4); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -2400,6 +2397,9 @@ export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const a: rs.isize = _8[0]; const b: rs.isize = _8[1]; const c: rs.isize = _8[2]; + const _20: (a0: rs.ByteVec, a1: rs.isize) => undefined = (out2: rs.ByteVec, v: rs.isize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.isizeToBeBytes(v))); + }; const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { const part44 = rs.isizeSaturatingAdd(a, b); diff --git a/ts/fixtures/lang/shapes/expected/fmt.Countdown.ts b/ts/fixtures/lang/shapes/expected/fmt.Countdown.ts index d6891dc28..fac11a5a9 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Countdown.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Countdown.ts @@ -3,9 +3,7 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug(self: Countdown, f: rs.Formatter): rs.Result { - const _3: string = "Countdown"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Countdown", [(f: rs.Formatter) => rs.u8Debug(self._0, f)]); } /** diff --git a/ts/fixtures/lang/shapes/expected/fmt.Fault.ts b/ts/fixtures/lang/shapes/expected/fmt.Fault.ts index 0301c3037..bd5394be3 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Fault.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Fault.ts @@ -9,21 +9,12 @@ export function fmt$fmt_Debug(self: Fault, f: rs.Formatter): rs.Result rs.u16Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _6), _7)); + return rs.fmtDebugFields(f, "Code", [(f: rs.Formatter) => rs.u16Debug(self._0, f)]); } if (self.tag === "TooLarge") { - const _11: string = "TooLarge"; - const _12: string = "size"; - const _13: rs.Fmt = (f: rs.Formatter) => rs.usizeDebug(self.size, f); - const _14: string = "max"; - const _15: rs.Fmt = (f: rs.Formatter) => rs.usizeDebug(self.max, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _11), _12, _13), _14, _15)); + return rs.fmtDebugFields(f, "TooLarge size max", [(f: rs.Formatter) => rs.usizeDebug(self.size, f), (f: rs.Formatter) => rs.usizeDebug(self.max, f)]); } - const _18: string = "At"; - const _19: rs.Fmt = (f: rs.Formatter) => Pair.fmt$fmt_Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _18), _19)); + return rs.fmtDebugFields(f, "At", [(f: rs.Formatter) => Pair.fmt$fmt_Debug(self._0, f)]); } /** diff --git a/ts/fixtures/lang/shapes/expected/fmt.Kind.ts b/ts/fixtures/lang/shapes/expected/fmt.Kind.ts index c5ee522fa..27fb775e4 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Kind.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Kind.ts @@ -13,16 +13,9 @@ export function fmt$fmt_Debug(self: Kind, f: rs.Formatter): rs.Result rs.u8Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _8), _9)); + return rs.fmtDebugFields(f, "One", [(f: rs.Formatter) => rs.u8Debug(self._0, f)]); } - const _13: string = "Many"; - const _14: string = "count"; - const _15: rs.Fmt = (f: rs.Formatter) => rs.u32Debug(self.count, f); - const _16: string = "items"; - const _17: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.items), f, rs.u8Debug); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _13), _14, _15), _16, _17)); + return rs.fmtDebugFields(f, "Many count items", [(f: rs.Formatter) => rs.u32Debug(self.count, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.items), f, rs.u8Debug)]); } export type Kind = diff --git a/ts/fixtures/lang/shapes/expected/fmt.Nested.ts b/ts/fixtures/lang/shapes/expected/fmt.Nested.ts index f005b7c64..f9bf58ed1 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Nested.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Nested.ts @@ -7,7 +7,7 @@ import * as Point from "./shapes.Point.ts"; import * as Shape from "./shapes.Shape.ts"; export function fmt$fmt_Debug(self: Nested, f: rs.Formatter): rs.Result { - const names: rs.Slice = rs.sliceFrom(["name", "point", "shape", "tags", "pairs", "maybe", "none", "result", "list", "tuple", "single", "empty", "unit", "boxed"]); + const names: string = "Nested name point shape tags pairs maybe none result list tuple single empty unit boxed"; const _7: rs.Fmt = (f: rs.Formatter) => rs.fmtStr(self.name.v, f); const _9: rs.Fmt = (f: rs.Formatter) => Point.fmt$fmt_Debug(self.point, f); const _11: rs.Fmt = (f: rs.Formatter) => Shape.fmt$fmt_Debug(self.shape, f); @@ -17,8 +17,7 @@ export function fmt$fmt_Debug(self: Nested, f: rs.Formatter): rs.Result rs.fmtOption(self.none, f, rs.u8Debug); const _21: rs.Fmt = (f: rs.Formatter) => rs.fmtResult(self.result, f, rs.u8Debug, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)); const _24: rs.Slice = rs.sliceFrom(self.list); - const values: rs.Slice = rs.sliceFrom([_7, _9, _11, _13, _15, _17, _19, _21, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_24), f, rs.i16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(self.tuple[0], f), (f: rs.Formatter) => rs.fmtBool(self.tuple[1], f), (f: rs.Formatter) => rs.fmtStr(self.tuple[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(self.single[0], f)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.empty), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtUnit(self.unit, f), (f: rs.Formatter) => Kind.fmt$fmt_Debug(self.boxed, f)]); - return rs.fmtDebugStructFields(f, "Nested", rs.sliceItems(names), rs.sliceItems(values)); + return rs.fmtDebugFields(f, names, [_7, _9, _11, _13, _15, _17, _19, _21, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_24), f, rs.i16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(self.tuple[0], f), (f: rs.Formatter) => rs.fmtBool(self.tuple[1], f), (f: rs.Formatter) => rs.fmtStr(self.tuple[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(self.single[0], f)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.empty), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtUnit(self.unit, f), (f: rs.Formatter) => Kind.fmt$fmt_Debug(self.boxed, f)]); } export interface Nested { diff --git a/ts/fixtures/lang/shapes/expected/fmt.Pair.ts b/ts/fixtures/lang/shapes/expected/fmt.Pair.ts index 052303dbb..5e87e2166 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Pair.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Pair.ts @@ -3,10 +3,7 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug(self: Pair, f: rs.Formatter): rs.Result { - const _3: string = "Pair"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); - const _6: rs.Fmt = (f: rs.Formatter) => rs.i64Debug(self._1, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4), _6)); + return rs.fmtDebugFields(f, "Pair", [(f: rs.Formatter) => rs.u8Debug(self._0, f), (f: rs.Formatter) => rs.i64Debug(self._1, f)]); } export function eq$cmp_PartialEq(self: Pair, other: Pair): boolean { diff --git a/ts/fixtures/lang/shapes/expected/fmt.Shared.ts b/ts/fixtures/lang/shapes/expected/fmt.Shared.ts index 189c0aa17..4a0c94015 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Shared.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Shared.ts @@ -4,14 +4,7 @@ import * as rs from "./rs.ts"; import * as Pair from "./fmt.Pair.ts"; export function fmt$fmt_Debug(self: Shared, f: rs.Formatter): rs.Result { - const _3: string = "Shared"; - const _4: string = "arc"; - const _5: rs.Fmt = (f: rs.Formatter) => Pair.fmt$fmt_Debug(self.arc.value, f); - const _7: string = "span"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtRange(self.span, f, rs.u16Debug); - const _10: string = "upto"; - const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtRangeToInclusive(self.upto, f, rs.u8Debug); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11)); + return rs.fmtDebugFields(f, "Shared arc span upto", [(f: rs.Formatter) => Pair.fmt$fmt_Debug(self.arc.value, f), (f: rs.Formatter) => rs.fmtRange(self.span, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(self.upto, f, rs.u8Debug)]); } export class Shared { diff --git a/ts/fixtures/lang/shapes/expected/fmt.Six.ts b/ts/fixtures/lang/shapes/expected/fmt.Six.ts index 00e4eb0eb..32a3bfd0d 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Six.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Six.ts @@ -3,7 +3,7 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug(self: Six, f: rs.Formatter): rs.Result { - return rs.fmtDebugTupleFields(f, "Six", [(f: rs.Formatter) => rs.u8Debug(self._0, f), (f: rs.Formatter) => rs.u8Debug(self._1, f), (f: rs.Formatter) => rs.u8Debug(self._2, f), (f: rs.Formatter) => rs.u8Debug(self._3, f), (f: rs.Formatter) => rs.u8Debug(self._4, f), (f: rs.Formatter) => rs.u8Debug(self._5, f)]); + return rs.fmtDebugFields(f, "Six", [(f: rs.Formatter) => rs.u8Debug(self._0, f), (f: rs.Formatter) => rs.u8Debug(self._1, f), (f: rs.Formatter) => rs.u8Debug(self._2, f), (f: rs.Formatter) => rs.u8Debug(self._3, f), (f: rs.Formatter) => rs.u8Debug(self._4, f), (f: rs.Formatter) => rs.u8Debug(self._5, f)]); } export interface Six { diff --git a/ts/fixtures/lang/shapes/expected/fmt.Wide.ts b/ts/fixtures/lang/shapes/expected/fmt.Wide.ts index e43a876ae..96a0a4d6e 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Wide.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Wide.ts @@ -3,9 +3,7 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug(self: Wide, f: rs.Formatter): rs.Result { - const names: rs.Slice = rs.sliceFrom(["a", "b", "c", "d", "e", "f"]); - const values: rs.Slice = rs.sliceFrom([(f: rs.Formatter) => rs.u8Debug(self.a, f), (f: rs.Formatter) => rs.u16Debug(self.b, f), (f: rs.Formatter) => rs.u32Debug(self.c, f), (f: rs.Formatter) => rs.u64Debug(self.d, f), (f: rs.Formatter) => rs.i8Debug(self.e, f), (f: rs.Formatter) => rs.fmtBool(self.f, f)]); - return rs.fmtDebugStructFields(f, "Wide", rs.sliceItems(names), rs.sliceItems(values)); + return rs.fmtDebugFields(f, "Wide a b c d e f", [(f: rs.Formatter) => rs.u8Debug(self.a, f), (f: rs.Formatter) => rs.u16Debug(self.b, f), (f: rs.Formatter) => rs.u32Debug(self.c, f), (f: rs.Formatter) => rs.u64Debug(self.d, f), (f: rs.Formatter) => rs.i8Debug(self.e, f), (f: rs.Formatter) => rs.fmtBool(self.f, f)]); } /** Past five fields, derived `Debug` takes the fields as slices. */ diff --git a/ts/fixtures/lang/shapes/expected/fmt.ts b/ts/fixtures/lang/shapes/expected/fmt.ts index d949f7f7f..0b7a415fa 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.ts @@ -1040,14 +1040,13 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { }), undefined, 2, true), 2) as rs.VecDeque), front, back); const args93 = [(f: rs.Formatter) => rs.fmtIter(part9, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), ["IntoIter"])]; put(out, rs.fmtFormat([args93[0], "|", rs.fmtSpec({ alternate: true }, args93[0])]).v); - const _253: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_28: rs.u8): rs.char => { + const text: rs.String = rs.stringFromChars(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_28: rs.u8): rs.char => { const _510: rs.usize = rs.u8Rem(_28, 6) as rs.usize; if (!(_510 < 6)) { rs.panic("index out of bounds: the len is " + 6 + " but the index is " + _510); } return [97, 233, 20013, 129408, 10, 39][_510]; - }); - const text: rs.String = rs.stringExtendChars(rs.stringNew(), _253); + })); const part10 = ends$iters_str_Chars(rs.strChars(text.v), front, back); const args94 = [(f: rs.Formatter) => rs.fmtChars(part10, f)]; put(out, rs.fmtFormat([args94[0], "|", rs.fmtSpec({ alternate: true }, args94[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args94[0])]).v); @@ -1952,14 +1951,13 @@ export function adaptors(data: rs.ByteSlice, out: rs.ByteVec): void { put(out, rs.fmtFormat([args166[0], "|", rs.fmtSpec({ alternate: true }, args166[0])]).v); const part22 = ends$adaptors_iter_Zip_slice_Iter_u8_iter_Rev_slice_Iter_u8(rs.iterZip(rs.iterSlice(rs.byteSliceView(bytes)), rs.iterRev(rs.iterSlice(rs.byteSliceView(bytes))), "len"), front, back); put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtZip(part22, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]).v); - const _509: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_213: rs.u8): rs.char => { + const part23 = fronts$adaptors_iter_Zip_str_Chars_slice_Iter_u8(rs.iterZip(rs.strChars(rs.stringFromChars(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_213: rs.u8): rs.char => { const _515: rs.usize = rs.u8Rem(_213, 4) as rs.usize; if (!(_515 < 4)) { rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _515); } return [97, 233, 20013, 129408][_515]; - }); - const part23 = fronts$adaptors_iter_Zip_str_Chars_slice_Iter_u8(rs.iterZip(rs.strChars(rs.stringExtendChars(rs.stringNew(), _509).v), rs.iterSlice(rs.byteSliceView(bytes))), front); + })).v), rs.iterSlice(rs.byteSliceView(bytes))), front); const args168 = [(f: rs.Formatter) => rs.fmtZip(part23, f, rs.fmtChars, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; put(out, rs.fmtFormat([args168[0], "|", rs.fmtSpec({ alternate: true }, args168[0])]).v); const part24 = fronts$adaptors_iter_Cycle_slice_Iter_u8(rs.iterCycle(rs.iterSlice(rs.byteSliceView(bytes))), rs.usizeAdd(front, rs.u8Rem(at(2), 8) as rs.usize)); @@ -2028,14 +2026,13 @@ export function adaptors(data: rs.ByteSlice, out: rs.ByteVec): void { put(out, rs.fmtFormat([args186[0], "|", rs.fmtSpec({ alternate: true }, args186[0]), "|", rs.fmtSpec({ debugHex: "x" }, args186[0])]).v); const part42 = fronts$adaptors_char_DecodeUtf16_vec_IntoIter_u16(rs.charDecodeUtf16(rs.vecIntoIter(rs.vecFrom([55296, 97, 98]))), rs.u8Rem(at(2), 3) as rs.usize); put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtDecodeUtf16(part42, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u16Debug, ["IntoIter"]))]).v); - const _893: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_221: rs.u8): rs.char => { + const quoted: rs.String = rs.stringFromChars(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_221: rs.u8): rs.char => { const _523: rs.usize = rs.u8Rem(_221, 6) as rs.usize; if (!(_523 < 6)) { rs.panic("index out of bounds: the len is " + 6 + " but the index is " + _523); } return [97, 34, 10, 769, 233, 39][_523]; - }); - const quoted: rs.String = rs.stringExtendChars(rs.stringNew(), _893); + })); const part43 = fronts$adaptors_str_EscapeDebug(rs.strEscapeDebug(quoted.v), rs.usizeMul(front, 2)); const args188 = [(f: rs.Formatter) => rs.fmtAround(part43, f, "EscapeDebug", "inner", (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", rs.fmtChars), (value: rs.Iter, f: rs.Formatter) => rs.fmtCharsDebug(value, f, "EscapeDebug")))]; put(out, rs.fmtFormat([args188[0], "|", rs.fmtSpec({ alternate: true }, args188[0])]).v); @@ -3434,14 +3431,13 @@ export function sources(data: rs.ByteSlice, out: rs.ByteVec): void { }), rs.usizeRem(front, 2), rs.usizeRem(back, 2)); const args136 = [(f: rs.Formatter) => rs.fmtOnceWith(part21, f)]; put(out, rs.fmtFormat([args136[0], "|", rs.fmtSpec({ alternate: true }, args136[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args136[0])]).v); - const _503: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_212: rs.u8): rs.char => { + const text: rs.String = rs.stringFromChars(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_212: rs.u8): rs.char => { const _54: rs.usize = rs.u8Rem(_212, 5) as rs.usize; if (!(_54 < 5)) { rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _54); } return [97, 233, 20013, 129408, 10][_54]; - }); - const text: rs.String = rs.stringExtendChars(rs.stringNew(), _503); + })); const part22 = ends$sources_str_CharIndices(rs.strCharIndices(text.v), front, back); const args137 = [(f: rs.Formatter) => rs.fmtCharIndices(part22, f)]; put(out, rs.fmtFormat([args137[0], "|", rs.fmtSpec({ alternate: true }, args137[0]), "|", rs.fmtSpec({ debugHex: "x" }, args137[0])]).v); @@ -4707,14 +4703,13 @@ export function searches(data: rs.ByteSlice, out: rs.ByteVec): void { const front: rs.usize = _6[0]; const back: rs.usize = _6[1]; const rest: rs.ByteSlice = option_unwrapOrDefault$0avqj0t(rs.byteSliceGetRange(data, 4)); - const _23: rs.Iter = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(rest)), 10), (_2: rs.u8): rs.char => { + const text2: string = rs.stringFromChars(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(rest)), 10), (_2: rs.u8): rs.char => { const _5: rs.usize = rs.u8Rem(_2, 9) as rs.usize; if (!(_5 < 9)) { rs.panic("index out of bounds: the len is " + 9 + " but the index is " + _5); } return [97, 98, 233, 129408, 32, 10, 13, 12288, 9][_5]; - }); - const text2: string = rs.stringExtendChars(rs.stringNew(), _23).v; + })).v; const _30: rs.usize = rs.u8Rem(at(2), 4) as rs.usize; if (!(_30 < 4)) { rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _30); @@ -4758,14 +4753,13 @@ export function searches(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.charIsWhitespace(a0); }), front, back); put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtStrSearch(part16, f, "MatchIndices", "CharPredicateSearcher"))]).v); - const _275: rs.Iter = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(rest)), 16), (_22: rs.u8): rs.char => { + const few2: string = rs.stringFromChars(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(rest)), 16), (_22: rs.u8): rs.char => { const _53: rs.usize = rs.u8Rem(_22, 3) as rs.usize; if (!(_53 < 3)) { rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _53); } return [97, 98, 233][_53]; - }); - const few2: string = rs.stringExtendChars(rs.stringNew(), _275).v; + })).v; const _291: rs.usize = rs.u8Rem(at(2), 10) as rs.usize; if (!(_291 < 10)) { rs.panic("index out of bounds: the len is " + 10 + " but the index is " + _291); diff --git a/ts/fixtures/lang/shapes/expected/generics.Either.ts b/ts/fixtures/lang/shapes/expected/generics.Either.ts index 758d4b29a..5f6189ecb 100644 --- a/ts/fixtures/lang/shapes/expected/generics.Either.ts +++ b/ts/fixtures/lang/shapes/expected/generics.Either.ts @@ -6,45 +6,30 @@ import * as Point from "./shapes.Point.ts"; export function fmt$fmt_Debug_shapes_Point_u8(self: Either, f: rs.Formatter): rs.Result { if (self.tag === "Left") { - const _5: string = "Left"; - const _6: rs.Fmt = (f: rs.Formatter) => Point.fmt$fmt_Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _5), _6)); + return rs.fmtDebugFields(f, "Left", [(f: rs.Formatter) => Point.fmt$fmt_Debug(self._0, f)]); } if (self.tag === "Right") { - const _9: string = "Right"; - const _10: string = "value"; - const _11: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.value, f); - return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _9), _10, _11)); + return rs.fmtDebugFields(f, "Right value", [(f: rs.Formatter) => rs.u8Debug(self.value, f)]); } return rs.fmtWriteStr(f, "Neither"); } export function fmt$fmt_Debug_u8_shapes_Point(self: Either, f: rs.Formatter): rs.Result { if (self.tag === "Left") { - const _5: string = "Left"; - const _6: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _5), _6)); + return rs.fmtDebugFields(f, "Left", [(f: rs.Formatter) => rs.u8Debug(self._0, f)]); } if (self.tag === "Right") { - const _9: string = "Right"; - const _10: string = "value"; - const _11: rs.Fmt = (f: rs.Formatter) => Point.fmt$fmt_Debug(self.value, f); - return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _9), _10, _11)); + return rs.fmtDebugFields(f, "Right value", [(f: rs.Formatter) => Point.fmt$fmt_Debug(self.value, f)]); } return rs.fmtWriteStr(f, "Neither"); } export function fmt$fmt_Debug_u8_u16(self: Either, f: rs.Formatter): rs.Result { if (self.tag === "Left") { - const _5: string = "Left"; - const _6: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _5), _6)); + return rs.fmtDebugFields(f, "Left", [(f: rs.Formatter) => rs.u8Debug(self._0, f)]); } if (self.tag === "Right") { - const _9: string = "Right"; - const _10: string = "value"; - const _11: rs.Fmt = (f: rs.Formatter) => rs.u16Debug(self.value, f); - return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _9), _10, _11)); + return rs.fmtDebugFields(f, "Right value", [(f: rs.Formatter) => rs.u16Debug(self.value, f)]); } return rs.fmtWriteStr(f, "Neither"); } diff --git a/ts/fixtures/lang/shapes/expected/generics.Fixed.ts b/ts/fixtures/lang/shapes/expected/generics.Fixed.ts index 2747c29d6..4704121ef 100644 --- a/ts/fixtures/lang/shapes/expected/generics.Fixed.ts +++ b/ts/fixtures/lang/shapes/expected/generics.Fixed.ts @@ -3,23 +3,15 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug_u16(self: Fixed, f: rs.Formatter): rs.Result { - const _3: string = "Fixed"; - const _4: string = "pair"; - const _6: rs.Slice = rs.sliceFrom(self.pair as rs.u16[]); - const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_6), f, rs.u16Debug); - const _7: string = "tag"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.tag, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _3: string = "Fixed pair tag"; + const _5: rs.Slice = rs.sliceFrom(self.pair as rs.u16[]); + return rs.fmtDebugFields(f, _3, [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(_5), f, rs.u16Debug), (f: rs.Formatter) => rs.u8Debug(self.tag, f)]); } export function fmt$fmt_Debug_u8(self: Fixed, f: rs.Formatter): rs.Result { - const _3: string = "Fixed"; - const _4: string = "pair"; - const _6: rs.ByteSlice = rs.byteSliceFrom(self.pair as Uint8Array); - const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_6), f, rs.u8Debug); - const _7: string = "tag"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.tag, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _3: string = "Fixed pair tag"; + const _5: rs.ByteSlice = rs.byteSliceFrom(self.pair as Uint8Array); + return rs.fmtDebugFields(f, _3, [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_5), f, rs.u8Debug), (f: rs.Formatter) => rs.u8Debug(self.tag, f)]); } /** A generic type JS copies, holding an array of its parameter. */ diff --git a/ts/fixtures/lang/shapes/expected/generics.Run.ts b/ts/fixtures/lang/shapes/expected/generics.Run.ts index 99982d68e..5f53927d4 100644 --- a/ts/fixtures/lang/shapes/expected/generics.Run.ts +++ b/ts/fixtures/lang/shapes/expected/generics.Run.ts @@ -5,16 +5,11 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug_u16(self: Run, f: rs.Formatter): rs.Result { if (self.tag === "Listed") { const arg = self._0 as rs.Vec; - const _5: string = "Listed"; - const _6: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg.items, f, rs.u16Debug); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _5), _6)); + return rs.fmtDebugFields(f, "Listed", [(f: rs.Formatter) => rs.fmtList(arg.items, f, rs.u16Debug)]); } if (self.tag === "Fixed") { const __self0: rs.Slice = rs.sliceFrom(self.array as rs.u16[]); - const _9: string = "Fixed"; - const _10: string = "array"; - const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(__self0), f, rs.u16Debug); - return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _9), _10, _11)); + return rs.fmtDebugFields(f, "Fixed array", [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(__self0), f, rs.u16Debug)]); } return rs.fmtWriteStr(f, "Empty"); } @@ -22,16 +17,11 @@ export function fmt$fmt_Debug_u16(self: Run, f: rs.Formatter): rs.Result export function fmt$fmt_Debug_u8(self: Run, f: rs.Formatter): rs.Result { if (self.tag === "Listed") { const arg = self._0 as rs.ByteVec; - const _5: string = "Listed"; - const _6: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteVecView(arg), f, rs.u8Debug); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _5), _6)); + return rs.fmtDebugFields(f, "Listed", [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(arg), f, rs.u8Debug)]); } if (self.tag === "Fixed") { const __self0: rs.ByteSlice = rs.byteSliceFrom(self.array as Uint8Array); - const _9: string = "Fixed"; - const _10: string = "array"; - const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(__self0), f, rs.u8Debug); - return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _9), _10, _11)); + return rs.fmtDebugFields(f, "Fixed array", [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(__self0), f, rs.u8Debug)]); } return rs.fmtWriteStr(f, "Empty"); } diff --git a/ts/fixtures/lang/shapes/expected/generics.Runs.ts b/ts/fixtures/lang/shapes/expected/generics.Runs.ts index 1ed68d69e..82de02c84 100644 --- a/ts/fixtures/lang/shapes/expected/generics.Runs.ts +++ b/ts/fixtures/lang/shapes/expected/generics.Runs.ts @@ -14,7 +14,7 @@ export function clone$Clone_u8(self: Runs): Runs { } export function fmt$fmt_Debug_u16(self: Runs, f: rs.Formatter): rs.Result { - const names: rs.Slice = rs.sliceFrom(["array", "list", "view", "boxed", "cow", "pairs", "maybe"]); + const names: string = "Runs array list view boxed cow pairs maybe"; const _8: rs.Slice = rs.sliceFrom(self.array as rs.u16[]); const arg = self.list as rs.Vec; const _9: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg.items, f, rs.u16Debug); @@ -27,12 +27,11 @@ export function fmt$fmt_Debug_u16(self: Runs, f: rs.Formatter): rs.Resul const arg5 = self.pairs as rs.Vec; const _17: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg5.items, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug)); const arg6 = self.maybe as rs.Vec | undefined; - const values: rs.Slice = rs.sliceFrom([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(_8), f, rs.u16Debug), _9, _11, _13, _15, _17, (f: rs.Formatter) => rs.fmtOption(arg6, f, (value: rs.Vec, f: rs.Formatter) => rs.fmtList(value.items, f, rs.u16Debug))]); - return rs.fmtDebugStructFields(f, "Runs", rs.sliceItems(names), rs.sliceItems(values)); + return rs.fmtDebugFields(f, names, [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(_8), f, rs.u16Debug), _9, _11, _13, _15, _17, (f: rs.Formatter) => rs.fmtOption(arg6, f, (value: rs.Vec, f: rs.Formatter) => rs.fmtList(value.items, f, rs.u16Debug))]); } export function fmt$fmt_Debug_u8(self: Runs, f: rs.Formatter): rs.Result { - const names: rs.Slice = rs.sliceFrom(["array", "list", "view", "boxed", "cow", "pairs", "maybe"]); + const names: string = "Runs array list view boxed cow pairs maybe"; const _8: rs.ByteSlice = rs.byteSliceFrom(self.array as Uint8Array); const arg = self.list as rs.ByteVec; const _9: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteVecView(arg), f, rs.u8Debug); @@ -45,8 +44,7 @@ export function fmt$fmt_Debug_u8(self: Runs, f: rs.Formatter): rs.Result< const arg5 = self.pairs as rs.Vec; const _17: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg5.items, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)); const arg6 = self.maybe as rs.ByteVec | undefined; - const values: rs.Slice = rs.sliceFrom([(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_8), f, rs.u8Debug), _9, _11, _13, _15, _17, (f: rs.Formatter) => rs.fmtOption(arg6, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]); - return rs.fmtDebugStructFields(f, "Runs", rs.sliceItems(names), rs.sliceItems(values)); + return rs.fmtDebugFields(f, names, [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_8), f, rs.u8Debug), _9, _11, _13, _15, _17, (f: rs.Formatter) => rs.fmtOption(arg6, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]); } export function eq$cmp_PartialEq_u16(self: Runs, other: Runs): boolean { diff --git a/ts/fixtures/lang/shapes/expected/generics.Tagged.ts b/ts/fixtures/lang/shapes/expected/generics.Tagged.ts index 9e7385c71..c327cd02d 100644 --- a/ts/fixtures/lang/shapes/expected/generics.Tagged.ts +++ b/ts/fixtures/lang/shapes/expected/generics.Tagged.ts @@ -5,14 +5,7 @@ import * as Either from "./generics.Either.ts"; import * as Wrap from "./generics.Wrap.ts"; export function fmt$fmt_Debug_generics_Either_u8_u16_i16(self: Tagged, rs.i16>, f: rs.Formatter): rs.Result { - const _3: string = "Tagged"; - const _4: string = "key"; - const _5: rs.Fmt = (f: rs.Formatter) => Either.fmt$fmt_Debug_u8_u16(self.key, f); - const _7: string = "inner"; - const _8: rs.Fmt = (f: rs.Formatter) => Wrap.fmt$fmt_Debug_i16(self.inner, f); - const _10: string = "all"; - const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtList(self.all.items, f, (value: Wrap.Wrap, f: rs.Formatter) => Wrap.fmt$fmt_Debug_i16(value, f)); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11)); + return rs.fmtDebugFields(f, "Tagged key inner all", [(f: rs.Formatter) => Either.fmt$fmt_Debug_u8_u16(self.key, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_i16(self.inner, f), (f: rs.Formatter) => rs.fmtList(self.all.items, f, (value: Wrap.Wrap, f: rs.Formatter) => Wrap.fmt$fmt_Debug_i16(value, f))]); } /** Two parameters, one nested in another generic type. */ diff --git a/ts/fixtures/lang/shapes/expected/generics.Wrap.ts b/ts/fixtures/lang/shapes/expected/generics.Wrap.ts index ef804b195..6dc2d0b14 100644 --- a/ts/fixtures/lang/shapes/expected/generics.Wrap.ts +++ b/ts/fixtures/lang/shapes/expected/generics.Wrap.ts @@ -7,84 +7,39 @@ import * as Point from "./shapes.Point.ts"; import * as Shape from "./shapes.Shape.ts"; export function fmt$fmt_Debug_Option_u8(self: Wrap, f: rs.Formatter): rs.Result { - const _3: string = "Wrap"; - const _4: string = "value"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(self.value, f, rs.u8Debug); - const _7: string = "count"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.count, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Wrap value count", [(f: rs.Formatter) => rs.fmtOption(self.value, f, rs.u8Debug), (f: rs.Formatter) => rs.u8Debug(self.count, f)]); } export function fmt$fmt_Debug_Result_u8_shapes_Shape(self: Wrap>, f: rs.Formatter): rs.Result { - const _3: string = "Wrap"; - const _4: string = "value"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtResult(self.value, f, rs.u8Debug, (value: Shape.Shape, f: rs.Formatter) => Shape.fmt$fmt_Debug(value, f)); - const _7: string = "count"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.count, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Wrap value count", [(f: rs.Formatter) => rs.fmtResult(self.value, f, rs.u8Debug, (value: Shape.Shape, f: rs.Formatter) => Shape.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.u8Debug(self.count, f)]); } export function fmt$fmt_Debug_Vec_u16(self: Wrap>, f: rs.Formatter): rs.Result { - const _3: string = "Wrap"; - const _4: string = "value"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtList(self.value.items, f, rs.u16Debug); - const _7: string = "count"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.count, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Wrap value count", [(f: rs.Formatter) => rs.fmtList(self.value.items, f, rs.u16Debug), (f: rs.Formatter) => rs.u8Debug(self.count, f)]); } export function fmt$fmt_Debug_fmt_Pair(self: Wrap, f: rs.Formatter): rs.Result { - const _3: string = "Wrap"; - const _4: string = "value"; - const _5: rs.Fmt = (f: rs.Formatter) => Pair.fmt$fmt_Debug(self.value, f); - const _7: string = "count"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.count, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Wrap value count", [(f: rs.Formatter) => Pair.fmt$fmt_Debug(self.value, f), (f: rs.Formatter) => rs.u8Debug(self.count, f)]); } export function fmt$fmt_Debug_generics_Wrap_fmt_Pair(self: Wrap>, f: rs.Formatter): rs.Result { - const _3: string = "Wrap"; - const _4: string = "value"; - const _5: rs.Fmt = (f: rs.Formatter) => fmt$fmt_Debug_fmt_Pair(self.value, f); - const _7: string = "count"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.count, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Wrap value count", [(f: rs.Formatter) => fmt$fmt_Debug_fmt_Pair(self.value, f), (f: rs.Formatter) => rs.u8Debug(self.count, f)]); } export function fmt$fmt_Debug_i16(self: Wrap, f: rs.Formatter): rs.Result { - const _3: string = "Wrap"; - const _4: string = "value"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.i16Debug(self.value, f); - const _7: string = "count"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.count, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Wrap value count", [(f: rs.Formatter) => rs.i16Debug(self.value, f), (f: rs.Formatter) => rs.u8Debug(self.count, f)]); } export function fmt$fmt_Debug_shapes_Point(self: Wrap, f: rs.Formatter): rs.Result { - const _3: string = "Wrap"; - const _4: string = "value"; - const _5: rs.Fmt = (f: rs.Formatter) => Point.fmt$fmt_Debug(self.value, f); - const _7: string = "count"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.count, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Wrap value count", [(f: rs.Formatter) => Point.fmt$fmt_Debug(self.value, f), (f: rs.Formatter) => rs.u8Debug(self.count, f)]); } export function fmt$fmt_Debug_shapes_Shape(self: Wrap, f: rs.Formatter): rs.Result { - const _3: string = "Wrap"; - const _4: string = "value"; - const _5: rs.Fmt = (f: rs.Formatter) => Shape.fmt$fmt_Debug(self.value, f); - const _7: string = "count"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.count, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Wrap value count", [(f: rs.Formatter) => Shape.fmt$fmt_Debug(self.value, f), (f: rs.Formatter) => rs.u8Debug(self.count, f)]); } export function fmt$fmt_Debug_u8(self: Wrap, f: rs.Formatter): rs.Result { - const _3: string = "Wrap"; - const _4: string = "value"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.value, f); - const _7: string = "count"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.count, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Wrap value count", [(f: rs.Formatter) => rs.u8Debug(self.value, f), (f: rs.Formatter) => rs.u8Debug(self.count, f)]); } export function eq$cmp_PartialEq_fmt_Pair(self: Wrap, other: Wrap): boolean { diff --git a/ts/fixtures/lang/shapes/expected/generics.ts b/ts/fixtures/lang/shapes/expected/generics.ts index 88a59e69b..1d139f6fc 100644 --- a/ts/fixtures/lang/shapes/expected/generics.ts +++ b/ts/fixtures/lang/shapes/expected/generics.ts @@ -321,8 +321,16 @@ export function runs(data: rs.ByteSlice, out: rs.ByteVec): void { */ export function units(data: rs.ByteSlice, out: rs.ByteVec): void { const parked: Parked.Parked = Parked.new$unit(); - for (const b of rs.byteSliceView(data)) { - const _12: rs.usize = rs.usizeRem(b >> 4 as rs.usize, rs.sliceFrom([undefined]).length); + const iterS: Uint8Array = rs.byteSliceView(data); + let iterI: number = 0; + while (true) { + const _8: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + const _3: undefined[] = [undefined]; + if (_8 === rs.DONE) { + break; + } + const b: rs.u8 = _8; + const _12: rs.usize = rs.usizeRem(b >> 4 as rs.usize, rs.sliceFrom(_3).length); if (!(_12 < 1)) { rs.panic("index out of bounds: the len is " + 1 + " but the index is " + _12); } diff --git a/ts/fixtures/lang/shapes/expected/shapes.Moved.ts b/ts/fixtures/lang/shapes/expected/shapes.Moved.ts index 5a6009de7..2d1e4d7d4 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.Moved.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.Moved.ts @@ -3,10 +3,7 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug(self: Moved, f: rs.Formatter): rs.Result { - const _3: string = "Moved"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); - const _6: rs.Fmt = (f: rs.Formatter) => rs.u16Debug(self._1, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4), _6)); + return rs.fmtDebugFields(f, "Moved", [(f: rs.Formatter) => rs.u8Debug(self._0, f), (f: rs.Formatter) => rs.u16Debug(self._1, f)]); } /** A tuple struct that is not `Copy`, so struct update syntax reads its base in place. */ diff --git a/ts/fixtures/lang/shapes/expected/shapes.Point.ts b/ts/fixtures/lang/shapes/expected/shapes.Point.ts index e19009318..a28c70b4e 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.Point.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.Point.ts @@ -4,12 +4,7 @@ import * as rs from "./rs.ts"; import { copy$shapes_Point } from "./lib.ts"; export function fmt$fmt_Debug(self: Point, f: rs.Formatter): rs.Result { - const _3: string = "Point"; - const _4: string = "x"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.i32Debug(self.x, f); - const _7: string = "y"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.i32Debug(self.y, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Point x y", [(f: rs.Formatter) => rs.i32Debug(self.x, f), (f: rs.Formatter) => rs.i32Debug(self.y, f)]); } export function eq$cmp_PartialEq(self: Point, other: Point): boolean { diff --git a/ts/fixtures/lang/shapes/expected/shapes.Shape.ts b/ts/fixtures/lang/shapes/expected/shapes.Shape.ts index c4f3dd839..aec9f0e48 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.Shape.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.Shape.ts @@ -8,19 +8,9 @@ export function fmt$fmt_Debug(self: Shape, f: rs.Formatter): rs.Result Point.fmt$fmt_Debug(self._0, f); - const _9: rs.Fmt = (f: rs.Formatter) => Point.fmt$fmt_Debug(self._1, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.debugTupleField(rs.fmtDebugTuple(f, _7), _8), _9)); + return rs.fmtDebugFields(f, "Line", [(f: rs.Formatter) => Point.fmt$fmt_Debug(self._0, f), (f: rs.Formatter) => Point.fmt$fmt_Debug(self._1, f)]); } - const _14: string = "Rect"; - const _15: string = "corner"; - const _16: rs.Fmt = (f: rs.Formatter) => Point.fmt$fmt_Debug(self.corner, f); - const _17: string = "width"; - const _18: rs.Fmt = (f: rs.Formatter) => rs.u16Debug(self.width, f); - const _19: string = "height"; - const _20: rs.Fmt = (f: rs.Formatter) => rs.u16Debug(self.height, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _14), _15, _16), _17, _18), _19, _20)); + return rs.fmtDebugFields(f, "Rect corner width height", [(f: rs.Formatter) => Point.fmt$fmt_Debug(self.corner, f), (f: rs.Formatter) => rs.u16Debug(self.width, f), (f: rs.Formatter) => rs.u16Debug(self.height, f)]); } export function eq$cmp_PartialEq(self: Shape, other: Shape): boolean { diff --git a/ts/fixtures/lang/shapes/expected/shapes.ts b/ts/fixtures/lang/shapes/expected/shapes.ts index 2ff0e920f..d291b0847 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.ts @@ -751,15 +751,6 @@ export function loops(data: rs.ByteSlice, out: rs.ByteVec): void { let _65!: rs.u64; let _124!: rs.i32; let _136!: rs.i8; - const _158: (a0: rs.u8) => rs.u8 = (x3: rs.u8): rs.u8 => { - while (true) { - if (!(x3 < 10)) { - x3 = rs.u8Div(x3, 3); - } else { - return x3; - } - } - }; const stack: rs.ByteVec = rs.byteSliceToByteVec(data); let popped: rs.u32 = 0; while (true) { @@ -861,7 +852,15 @@ export function loops(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(tailBreak(data)))); rs.byteVecPush(out, armLoop(data)); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(position$u8(data.data, data.start, data.length, 0) as rs.u32))); - rs.byteVecPush(out, _158(rs.u8Mul(data.length & 0xff, 7))); + rs.byteVecPush(out, ((x3: rs.u8): rs.u8 => { + while (true) { + if (!(x3 < 10)) { + x3 = rs.u8Div(x3, 3); + } else { + return x3; + } + } + })(rs.u8Mul(data.length & 0xff, 7))); drain(data.data, data.start, data.length, out); rs.byteVecPush(out, returnedLoop(data)); branchLoops(data, out); @@ -873,17 +872,16 @@ export function loops(data: rs.ByteSlice, out: rs.ByteVec): void { * inputs run every case to its end. */ export function diverging(data: rs.ByteSlice, out: rs.ByteVec): void { - const _15: (a0: rs.u8) => rs.u8 = (b2: rs.u8): rs.u8 => { - if (!(b2 === 253)) { - return rs.u8Div(b2, 3); - } - rs.panicFmt(["closure ", (f: rs.Formatter) => rs.u8Display(b2, f)]); - }; const head: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 2)); const b: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(head), 0); rs.byteVecPush(out, returnedNever(b, data.length)); rs.byteVecPush(out, brokenNever(head.data, head.start, head.length)); - rs.byteVecPush(out, _15(b)); + rs.byteVecPush(out, ((b2: rs.u8): rs.u8 => { + if (!(b2 === 253)) { + return rs.u8Div(b2, 3); + } + rs.panicFmt(["closure ", (f: rs.Formatter) => rs.u8Display(b2, f)]); + })(b)); rs.byteVecPush(out, guardedReturn(head.data, head.start, head.length)); rs.byteVecPush(out, boundNever(head.data, head.start, head.length, out)); rs.byteVecPush(out, closureNever(b)); @@ -1089,14 +1087,11 @@ export function branchLoops(data: rs.ByteSlice, out: rs.ByteVec): void { const b: rs.u8 = w.data[w.start + 1]; if (a > b) { let n: rs.u8 = a; - while (true) { - if (!(n <= b)) { - n = rs.u8Sub(n, 1); - rs.byteVecPush(out, n); - } else { - break b2; - } + while (!(n <= b)) { + n = rs.u8Sub(n, 1); + rs.byteVecPush(out, n); } + break b2; } } if (w.length >= 1) { @@ -1379,7 +1374,8 @@ export function patterns(data: rs.ByteSlice, out: rs.ByteVec): void { v = either.error; } rs.byteVecPush(out, v); - rs.byteVecPush(out, rs.u8Add(rs.byteSliceFrom(Uint8Array.of()).length & 0xff, rs.iterSum(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of()))), rs.u8Add, 0))); + const _113: Uint8Array = Uint8Array.of(); + rs.byteVecPush(out, rs.u8Add(rs.byteSliceFrom(_113).length & 0xff, rs.iterSum(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(_113))), rs.u8Add, 0))); const bytes: Uint8Array = Uint8Array.of(data.length & 0xff, 1, 2); const slice = rs.byteSliceRange(rs.byteSliceFrom(bytes), 1, 3); slice.data[slice.start] = 9; @@ -2248,7 +2244,9 @@ export function apply$shapes_closures_closure1(f: (a0: rs.u32) => rs.u32, v: rs. /** Options, results, `?`, and strings. */ export function library(data: rs.ByteSlice, out: rs.ByteVec): void { let parsed!: rs.Result; - const _3: (a0: rs.u8, a1: rs.u8) => rs.u8 | undefined = (a2: rs.u8, b2: rs.u8): rs.u8 | undefined => { + const a: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const b: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(((a2: rs.u8, b2: rs.u8): rs.u8 | undefined => { const _4: rs.u8 | undefined = rs.u8CheckedAdd(a2, b2); if (_4 !== undefined) { const _83: rs.u8 | undefined = rs.u8CheckedMul(_4, 2); @@ -2258,8 +2256,23 @@ export function library(data: rs.ByteSlice, out: rs.ByteVec): void { return undefined; } return undefined; - }; - const _30: (a0: rs.u8) => rs.Poll> = (a3: rs.u8): rs.Poll> => { + })(a, b), 255)); + if (a === 0) { + parsed = rs.Err("zero"); + } else { + parsed = rs.Ok(a); + } + const mapped: rs.Result = result_mapErr$0hqg57m(result_map$1yblbjf(parsed, (n6: rs.u8): rs.u8 => { + return rs.u8Div(n6, 2); + }), (e4: string): rs.u8 => { + return rs.stringLen(e4) & 0xff; + }); + if (mapped.ok) { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(0, mapped.value))); + } else { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(1, mapped.error))); + } + const _32: rs.Poll> = ((a3: rs.u8): rs.Poll> => { let half2!: rs.Result; const _45: Dir.Dir | undefined = dir(a3); b0: { @@ -2276,26 +2289,7 @@ export function library(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.Ok(_132.value); } return rs.Err(from$convert_From_shapes_Dir_u8((_132 as { ok: false; error: Dir.Dir }).error)); - }; - const a: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); - const b: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0); - rs.byteVecPush(out, option_unwrapOr$1fr498u(_3(a, b), 255)); - if (a === 0) { - parsed = rs.Err("zero"); - } else { - parsed = rs.Ok(a); - } - const mapped: rs.Result = result_mapErr$0hqg57m(result_map$1yblbjf(parsed, (n7: rs.u8): rs.u8 => { - return rs.u8Div(n7, 2); - }), (e4: string): rs.u8 => { - return rs.stringLen(e4) & 0xff; - }); - if (mapped.ok) { - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(0, mapped.value))); - } else { - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(1, mapped.error))); - } - const _32: rs.Poll> = _30(b); + })(b); if (_32 !== rs.Pending) { if (_32.ok) { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(2, _32.value))); diff --git a/ts/fixtures/lang/singles/expected/singles.Reading.ts b/ts/fixtures/lang/singles/expected/singles.Reading.ts index 50a207cdf..a616d695d 100644 --- a/ts/fixtures/lang/singles/expected/singles.Reading.ts +++ b/ts/fixtures/lang/singles/expected/singles.Reading.ts @@ -3,12 +3,7 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug(self: Reading, f: rs.Formatter): rs.Result { - const _3: string = "Reading"; - const _4: string = "level"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.f32Debug(self.level, f); - const _7: string = "history"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtList(self.history.items, f, rs.f32Debug); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Reading level history", [(f: rs.Formatter) => rs.f32Debug(self.level, f), (f: rs.Formatter) => rs.fmtList(self.history.items, f, rs.f32Debug)]); } /** A reading whose derived `Debug` writes each `f32` with the placeholder's options. */ diff --git a/ts/fixtures/lang/singles/expected/singles.ts b/ts/fixtures/lang/singles/expected/singles.ts index 2702ad34c..4590a48ab 100644 --- a/ts/fixtures/lang/singles/expected/singles.ts +++ b/ts/fixtures/lang/singles/expected/singles.ts @@ -307,63 +307,59 @@ export function singles(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void export function mulAdds(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let _53!: [rs.f32, rs.f32, rs.f32]; let _95!: rs.f32; - const _63: (a0: rs.f32) => rs.f32 = (x: rs.f32): rs.f32 => { - return rs.f32FromBits((((rs.f32ToBits(x) & 4294963200) >>> 0) | 2048) >>> 0); - }; - b0: { - if (!(rs.u8Rem(kind, 2) === 0)) { - let state: rs.u32 = (takeBits(data)[0] | 1) >>> 0; - let iterStart: rs.i32 = 0; - const iterEnd: rs.i32 = 32; - while (true) { - if (!(iterStart++ < iterEnd)) { - break b0; - } - const r: rs.u32 = step(rs.place(() => state, (value) => state = value)); - const pick: (a0: rs.u32, a1: rs.u32) => rs.i32 = (shift: rs.u32, n: rs.u32): rs.i32 => { - return rs.u32Rem(rs.u32Shr(r, shift), n) | 0; + if (!(rs.u8Rem(kind, 2) === 0)) { + let state: rs.u32 = (takeBits(data)[0] | 1) >>> 0; + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 32; + while (iterStart++ < iterEnd) { + const r: rs.u32 = step(rs.place(() => state, (value) => state = value)); + const pick: (a0: rs.u32, a1: rs.u32) => rs.i32 = (shift: rs.u32, n: rs.u32): rs.i32 => { + return rs.u32Rem(rs.u32Shr(r, shift), n) | 0; + }; + const ea: rs.i32 = rs.i32Sub(pick(4, 32), 16); + const e: rs.i32 = rs.i32Sub(pick(9, 32), 16); + const a2: rs.f32 = near(step(rs.place(() => state, (value2) => state = value2)), ea); + const b2: rs.f32 = near(step(rs.place(() => state, (value3) => state = value3)), rs.i32Sub(e, ea)); + const c2: rs.u32 = step(rs.place(() => state, (value4) => state = value4)); + const _54: rs.u32 = rs.u32Rem(r, 6); + if (_54 === 0) { + _53 = [rs.f32FromBits(r), rs.f32FromBits(step(rs.place(() => state, (value5) => state = value5))), rs.f32FromBits(c2)] as [rs.f32, rs.f32, rs.f32]; + } else if (_54 === 1) { + _53 = [a2, b2, -Math.fround(a2 * b2)] as [rs.f32, rs.f32, rs.f32]; + } else if (_54 === 2) { + const _63: (a0: rs.f32) => rs.f32 = (x: rs.f32): rs.f32 => { + return rs.f32FromBits((((rs.f32ToBits(x) & 4294963200) >>> 0) | 2048) >>> 0); }; - const ea: rs.i32 = rs.i32Sub(pick(4, 32), 16); - const e: rs.i32 = rs.i32Sub(pick(9, 32), 16); - const a2: rs.f32 = near(step(rs.place(() => state, (value2) => state = value2)), ea); - const b2: rs.f32 = near(step(rs.place(() => state, (value3) => state = value3)), rs.i32Sub(e, ea)); - const c2: rs.u32 = step(rs.place(() => state, (value4) => state = value4)); - const _54: rs.u32 = rs.u32Rem(r, 6); - if (_54 === 0) { - _53 = [rs.f32FromBits(r), rs.f32FromBits(step(rs.place(() => state, (value5) => state = value5))), rs.f32FromBits(c2)] as [rs.f32, rs.f32, rs.f32]; - } else if (_54 === 1) { - _53 = [a2, b2, -Math.fround(a2 * b2)] as [rs.f32, rs.f32, rs.f32]; - } else if (_54 === 2) { - _53 = [_63(a2), _63(b2), near(c2, rs.i32Sub(rs.i32Sub(e, 26), pick(14, 100)))] as [rs.f32, rs.f32, rs.f32]; - } else if (_54 === 3) { - const ea2: rs.i32 = rs.i32Sub(pick(14, 120), 60); - const e2: rs.i32 = rs.i32Sub(-130, pick(21, 30)); - const _90: [rs.f32, rs.f32] = [near(r, ea2), near(c2, rs.i32Sub(e2, ea2))]; - const a4: rs.f32 = _90[0]; - const b4: rs.f32 = _90[1]; - if (!((r >>> 31) === 0)) { - _95 = near(c2 >>> 1, rs.i32Sub(rs.i32Add(e2, pick(26, 30)), 15)); - } else { - _95 = -Math.fround(a4 * b4); - } - _53 = [a4, b4, _95] as [rs.f32, rs.f32, rs.f32]; - } else if (_54 === 4) { - const ea3: rs.i32 = rs.i32Add(100, pick(14, 27)); - const a5: rs.f32 = near(r, ea3); - const b5: rs.f32 = near(c2, rs.i32Sub(rs.i32Add(rs.i32Sub(127, ea3), pick(21, 4)), 1)); - _53 = [a5, b5, rs.f32Copysign(near(c2 >>> 1, rs.i32Add(124, pick(26, 4))), -Math.fround(a5 * b5))] as [rs.f32, rs.f32, rs.f32]; + _53 = [_63(a2), _63(b2), near(c2, rs.i32Sub(rs.i32Sub(e, 26), pick(14, 100)))] as [rs.f32, rs.f32, rs.f32]; + } else if (_54 === 3) { + const ea2: rs.i32 = rs.i32Sub(pick(14, 120), 60); + const e2: rs.i32 = rs.i32Sub(-130, pick(21, 30)); + const _90: [rs.f32, rs.f32] = [near(r, ea2), near(c2, rs.i32Sub(e2, ea2))]; + const a4: rs.f32 = _90[0]; + const b4: rs.f32 = _90[1]; + if (!((r >>> 31) === 0)) { + _95 = near(c2 >>> 1, rs.i32Sub(rs.i32Add(e2, pick(26, 30)), 15)); } else { - const p: rs.f32 = Math.abs(Math.fround(a2 * b2)); - const _143: rs.usize = pick(14, 5) >>> 0; - if (!(_143 < 5)) { - rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _143); - } - const half: rs.f32 = [0.5, -0.5, 0.25, -0.75, 1.5][_143]; - _53 = [a2, b2, Math.fround(Math.fround(rs.f32NextUp(p) - p) * half)] as [rs.f32, rs.f32, rs.f32]; + _95 = -Math.fround(a4 * b4); + } + _53 = [a4, b4, _95] as [rs.f32, rs.f32, rs.f32]; + } else if (_54 === 4) { + const ea3: rs.i32 = rs.i32Add(100, pick(14, 27)); + const a5: rs.f32 = near(r, ea3); + const b5: rs.f32 = near(c2, rs.i32Sub(rs.i32Add(rs.i32Sub(127, ea3), pick(21, 4)), 1)); + _53 = [a5, b5, rs.f32Copysign(near(c2 >>> 1, rs.i32Add(124, pick(26, 4))), -Math.fround(a5 * b5))] as [rs.f32, rs.f32, rs.f32]; + } else { + const p: rs.f32 = Math.abs(Math.fround(a2 * b2)); + const _143: rs.usize = pick(14, 5) >>> 0; + if (!(_143 < 5)) { + rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _143); } - putF32(out, rs.f32MulAdd(_53[0], _53[1], _53[2])); + const half: rs.f32 = [0.5, -0.5, 0.25, -0.75, 1.5][_143]; + _53 = [a2, b2, Math.fround(Math.fround(rs.f32NextUp(p) - p) * half)] as [rs.f32, rs.f32, rs.f32]; } + putF32(out, rs.f32MulAdd(_53[0], _53[1], _53[2])); } + } else { const _9: [rs.f32, rs.ByteSlice] = take(data); const a: rs.f32 = _9[0]; const _12: [rs.f32, rs.ByteSlice] = take(_9[1]); @@ -392,48 +388,43 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _6: [rs.f32, rs.ByteSlice] = take(data); const a: rs.f32 = _6[0]; const p: rs.usize = option_unwrapOr$1fr498u(rs.byteSliceFirst(_6[1]), 0) as rs.usize; - b0: { - const w: rs.usize = rs.usizeDiv(p, 4); - const _13: rs.u8 = rs.u8Rem(kind, 5); - if (_13 === 0) { - const args17 = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32Debug(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32UpperExp(a, f), rs.fmtCount(p)]; - put(out, rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " ", args17[3], " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[0]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[1]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[2]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[3]), " ", rs.fmtSpec({ plus: true }, args17[0]), " ", rs.fmtSpec({ plus: true }, args17[1]), " ", rs.fmtSpec({ plus: true, precision: rs.fmtCountOf(args17[4]) }, args17[2])]).v); - const args18 = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32Debug(a, f), (f: rs.Formatter) => rs.f32UpperExp(a, f), rs.fmtCount(w), rs.fmtCount(p)]; - put(out, rs.fmtFormat([rs.fmtSpec({ zero: true, width: 8, precision: 3 }, args18[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args18[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args18[0]), "|", rs.fmtSpec({ align: "^", width: 12 }, args18[2]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args18[0]), "|", rs.fmtSpec({ alternate: true }, args18[2]), "|", rs.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args18[3]), "|", rs.fmtSpec({ zero: true, width: 10 }, args18[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args18[4]), precision: rs.fmtCountOf(args18[5]) }, args18[0])]).v); - put(out, rs.fmtToString((f: rs.Formatter) => rs.f32Display(a, f)).v); - } else if (_13 === 1) { - const args16 = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32Debug(a, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 160 }, args16[0]), " ", rs.fmtSpec({ precision: 120 }, args16[1]), " ", rs.fmtSpec({ precision: 160 }, args16[2])]).v); - } else if (_13 === 2) { - const _72: [rs.f32, rs.ByteSlice] = take(_6[1]); - const b: rs.f32 = _72[0]; - const c: rs.f32 = take(_72[1])[0]; - putF32(out, rs.f32Clamp(a, b, c)); - } else if (_13 === 3) { - const _78: rs.Vec = rs.vecFrom([Math.fround(a * 0.5), -0.0, 9.999999747378752e-5, 1.0000000272564224e16, NaN]); - const part = { level: a, history: _78 }; - const args15 = [(f: rs.Formatter) => Reading.fmt$fmt_Debug(part, f)]; - put(out, rs.fmtFormat([args15[0], "|", rs.fmtSpec({ precision: 2 }, args15[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args15[0])]).v); - } else { - let state: rs.u32 = (takeBits(data)[0] | 1) >>> 0; - let iterStart: rs.i32 = 0; - const iterEnd: rs.i32 = 64; - while (iterStart++ < iterEnd) { - const x: rs.f32 = rs.f32FromBits(step(rs.place(() => state, (value) => state = value))); - const args13 = [(f: rs.Formatter) => rs.f32Display(x, f), (f: rs.Formatter) => rs.f32Debug(x, f), (f: rs.Formatter) => rs.f32LowerExp(x, f)]; - put(out, rs.fmtFormat([args13[0], " ", args13[1], " ", args13[2]]).v); - } - let iterStart2: rs.i32 = 0; - const iterEnd2: rs.i32 = 64; - while (true) { - if (!(iterStart2++ < iterEnd2)) { - break b0; - } - const r2: rs.u32 = step(rs.place(() => state, (value2) => state = value2)); - const x2: rs.f32 = Math.fround(Math.fround(r2 >>> 8) / Math.fround(rs.u32Shl(1, rs.u32Add(rs.u32Rem(r2, 16), 1)))); - const args14 = [(f: rs.Formatter) => rs.f32Debug(x2, f), (f: rs.Formatter) => rs.f32LowerExp(x2, f)]; - put(out, rs.fmtFormat([args14[0], " ", args14[1]]).v); - } + const w: rs.usize = rs.usizeDiv(p, 4); + const _13: rs.u8 = rs.u8Rem(kind, 5); + if (_13 === 0) { + const args17 = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32Debug(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32UpperExp(a, f), rs.fmtCount(p)]; + put(out, rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " ", args17[3], " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[0]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[1]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[2]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[3]), " ", rs.fmtSpec({ plus: true }, args17[0]), " ", rs.fmtSpec({ plus: true }, args17[1]), " ", rs.fmtSpec({ plus: true, precision: rs.fmtCountOf(args17[4]) }, args17[2])]).v); + const args18 = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32Debug(a, f), (f: rs.Formatter) => rs.f32UpperExp(a, f), rs.fmtCount(w), rs.fmtCount(p)]; + put(out, rs.fmtFormat([rs.fmtSpec({ zero: true, width: 8, precision: 3 }, args18[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args18[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args18[0]), "|", rs.fmtSpec({ align: "^", width: 12 }, args18[2]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args18[0]), "|", rs.fmtSpec({ alternate: true }, args18[2]), "|", rs.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args18[3]), "|", rs.fmtSpec({ zero: true, width: 10 }, args18[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args18[4]), precision: rs.fmtCountOf(args18[5]) }, args18[0])]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.f32Display(a, f)).v); + } else if (_13 === 1) { + const args16 = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32Debug(a, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 160 }, args16[0]), " ", rs.fmtSpec({ precision: 120 }, args16[1]), " ", rs.fmtSpec({ precision: 160 }, args16[2])]).v); + } else if (_13 === 2) { + const _72: [rs.f32, rs.ByteSlice] = take(_6[1]); + const b: rs.f32 = _72[0]; + const c: rs.f32 = take(_72[1])[0]; + putF32(out, rs.f32Clamp(a, b, c)); + } else if (_13 === 3) { + const _78: rs.Vec = rs.vecFrom([Math.fround(a * 0.5), -0.0, 9.999999747378752e-5, 1.0000000272564224e16, NaN]); + const part = { level: a, history: _78 }; + const args15 = [(f: rs.Formatter) => Reading.fmt$fmt_Debug(part, f)]; + put(out, rs.fmtFormat([args15[0], "|", rs.fmtSpec({ precision: 2 }, args15[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args15[0])]).v); + } else { + let state: rs.u32 = (takeBits(data)[0] | 1) >>> 0; + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 64; + while (iterStart++ < iterEnd) { + const x: rs.f32 = rs.f32FromBits(step(rs.place(() => state, (value) => state = value))); + const args13 = [(f: rs.Formatter) => rs.f32Display(x, f), (f: rs.Formatter) => rs.f32Debug(x, f), (f: rs.Formatter) => rs.f32LowerExp(x, f)]; + put(out, rs.fmtFormat([args13[0], " ", args13[1], " ", args13[2]]).v); + } + let iterStart2: rs.i32 = 0; + const iterEnd2: rs.i32 = 64; + while (iterStart2++ < iterEnd2) { + const r2: rs.u32 = step(rs.place(() => state, (value2) => state = value2)); + const x2: rs.f32 = Math.fround(Math.fround(r2 >>> 8) / Math.fround(rs.u32Shl(1, rs.u32Add(rs.u32Rem(r2, 16), 1)))); + const args14 = [(f: rs.Formatter) => rs.f32Debug(x2, f), (f: rs.Formatter) => rs.f32LowerExp(x2, f)]; + put(out, rs.fmtFormat([args14[0], " ", args14[1]]).v); } } } @@ -444,57 +435,52 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void */ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let _108!: rs.usize; - b0: { - const _4: rs.u8 = rs.u8Rem(kind, 3); - if (_4 === 0) { - const _6: rs.Result = rs.strFromUtf8(data); - if (_6.ok) { - one(_6.value, out); - } - } else if (_4 === 1) { - const s: rs.String = rs.stringNew(); - for (const b of rs.byteSliceView(data)) { - const _21: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)); - const _22: rs.usize = rs.usizeRem(b as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)).length); - rs.idx(_21, _22); - rs.stringPush(s, _21.data[_21.start + _22] as rs.char); - } - one(s.v, out); - } else { - let state: rs.u32 = (takeBits(data)[0] | 1) >>> 0; - let iterStart: rs.i32 = 0; - const iterEnd: rs.i32 = 16; - while (iterStart++ < iterEnd) { - const x: rs.f32 = rs.f32FromBits((step(rs.place(() => state, (value) => state = value)) & 2147483647) >>> 0); - const half: rs.f64 = ((x as rs.f64) + (rs.f32NextUp(x) as rs.f64)) / 2.0; - const p: rs.usize = rs.u32Add(rs.u32Rem(step(rs.place(() => state, (value2) => state = value2)), 30), 8) as rs.usize; - const args7 = [(f: rs.Formatter) => rs.f64LowerExp(half, f), rs.fmtCount(p)]; - one(rs.fmtFormat([rs.fmtSpec({ precision: rs.fmtCountOf(args7[1]) }, args7[0])]).v, out); - one(rs.fmtFormat([(f: rs.Formatter) => rs.f64LowerExp(half, f)]).v, out); - } - let iterStart2: rs.i32 = 0; - const iterEnd2: rs.i32 = 16; - while (true) { - if (!(iterStart2++ < iterEnd2)) { - break b0; - } - const r: rs.u32 = step(rs.place(() => state, (value3) => state = value3)); - const len: rs.usize = rs.u32Add(rs.u32Rem(r, 20), 1) as rs.usize; - const point: rs.usize = rs.usizeRem(r >>> 8 as rs.usize, rs.usizeAdd(len, 1)); - const s2: rs.String = rs.stringNew(); - let iterStart3: rs.usize = 0; - const iterEnd3: rs.usize = len; - while ((_108 = iterStart3++) < iterEnd3) { - if (_108 === point) { - rs.stringPush(s2, 46); - } - const _117: rs.char = rs.u8Add(48, rs.u32Rem(step(rs.place(() => state, (value4) => state = value4)), 10) & 0xff) as rs.char; - rs.stringPush(s2, _117); + const _4: rs.u8 = rs.u8Rem(kind, 3); + if (_4 === 0) { + const _6: rs.Result = rs.strFromUtf8(data); + if (_6.ok) { + one(_6.value, out); + } + } else if (_4 === 1) { + const s: rs.String = rs.stringNew(); + for (const b of rs.byteSliceView(data)) { + const _21: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)); + const _22: rs.usize = rs.usizeRem(b as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)).length); + rs.idx(_21, _22); + rs.stringPush(s, _21.data[_21.start + _22] as rs.char); + } + one(s.v, out); + } else { + let state: rs.u32 = (takeBits(data)[0] | 1) >>> 0; + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 16; + while (iterStart++ < iterEnd) { + const x: rs.f32 = rs.f32FromBits((step(rs.place(() => state, (value) => state = value)) & 2147483647) >>> 0); + const half: rs.f64 = ((x as rs.f64) + (rs.f32NextUp(x) as rs.f64)) / 2.0; + const p: rs.usize = rs.u32Add(rs.u32Rem(step(rs.place(() => state, (value2) => state = value2)), 30), 8) as rs.usize; + const args7 = [(f: rs.Formatter) => rs.f64LowerExp(half, f), rs.fmtCount(p)]; + one(rs.fmtFormat([rs.fmtSpec({ precision: rs.fmtCountOf(args7[1]) }, args7[0])]).v, out); + one(rs.fmtFormat([(f: rs.Formatter) => rs.f64LowerExp(half, f)]).v, out); + } + let iterStart2: rs.i32 = 0; + const iterEnd2: rs.i32 = 16; + while (iterStart2++ < iterEnd2) { + const r: rs.u32 = step(rs.place(() => state, (value3) => state = value3)); + const len: rs.usize = rs.u32Add(rs.u32Rem(r, 20), 1) as rs.usize; + const point: rs.usize = rs.usizeRem(r >>> 8 as rs.usize, rs.usizeAdd(len, 1)); + const s2: rs.String = rs.stringNew(); + let iterStart3: rs.usize = 0; + const iterEnd3: rs.usize = len; + while ((_108 = iterStart3++) < iterEnd3) { + if (_108 === point) { + rs.stringPush(s2, 46); } - const _133: rs.i64 = rs.i64Sub(rs.u32Rem(r >>> 16, 100) as rs.i64, 50); - const args9 = [(f: rs.Formatter) => rs.fmtPad(f, s2.v), (f: rs.Formatter) => rs.i64Display(_133, f)]; - one(rs.fmtFormat([args9[0], "e", args9[1]]).v, out); + const _117: rs.char = rs.u8Add(48, rs.u32Rem(step(rs.place(() => state, (value4) => state = value4)), 10) & 0xff) as rs.char; + rs.stringPush(s2, _117); } + const _133: rs.i64 = rs.i64Sub(rs.u32Rem(r >>> 16, 100) as rs.i64, 50); + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, s2.v), (f: rs.Formatter) => rs.i64Display(_133, f)]; + one(rs.fmtFormat([args9[0], "e", args9[1]]).v, out); } } } diff --git a/ts/fixtures/lang/slices/expected/slices.ts b/ts/fixtures/lang/slices/expected/slices.ts index e10da0658..9120c100a 100644 --- a/ts/fixtures/lang/slices/expected/slices.ts +++ b/ts/fixtures/lang/slices/expected/slices.ts @@ -1328,26 +1328,11 @@ export function ranges(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let _305!: rs.u8; let _344!: rs.u8; let _352!: rs.u8; - const _46: (a0: rs.Slice) => rs.u8 = (s2: rs.Slice): rs.u8 => { - return rs.iterFold(rs.iterSlice(rs.sliceItems(s2)), s2.length & 0xff, (acc: rs.u8, _32: rs.u32): rs.u8 => { - return rs.u8WrappingMul(acc, 31) ^ ((_32 >>> 5) & 0xff); - }); - }; - const _329: (a0: rs.usize, a1: rs.u8) => rs.RangeBound = (x2: rs.usize, k: rs.u8): rs.RangeBound => { - const _42: rs.u8 = rs.u8Rem(k, 3); - if (_42 === 0) { - return { tag: "Included", _0: x2 } as rs.RangeBound; - } - if (_42 === 1) { - return { tag: "Excluded", _0: x2 } as rs.RangeBound; - } - return { tag: "Unbounded" } as rs.RangeBound; - }; if (data.length >= 2) { const reach: rs.usize = rs.usizeAdd(rs.byteSliceRange(data, 2).length, 2); - const at: (a0: rs.u8) => rs.usize = (x3: rs.u8): rs.usize => { - if (!(x3 === 255)) { - return rs.usizeRem(x3 as rs.usize, reach); + const at: (a0: rs.u8) => rs.usize = (x: rs.u8): rs.usize => { + if (!(x === 255)) { + return rs.usizeRem(x as rs.usize, reach); } return 4294967295; }; @@ -1373,6 +1358,11 @@ export function ranges(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } _39[0].v = rs.u32Mul(_39[1] as rs.u32, 65599); } + const _46: (a0: rs.Slice) => rs.u8 = (s2: rs.Slice): rs.u8 => { + return rs.iterFold(rs.iterSlice(rs.sliceItems(s2)), s2.length & 0xff, (acc: rs.u8, _38: rs.u32): rs.u8 => { + return rs.u8WrappingMul(acc, 31) ^ ((_38 >>> 5) & 0xff); + }); + }; const _47: rs.u8 = rs.u8Rem(kind, 8); if (_47 === 0) { const _53: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); @@ -1617,6 +1607,16 @@ export function ranges(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const bounds11 = rs.sliceIndexBounds(_328, slice6.length); rs.byteVecPush(out, digest(rs.byteSliceRange(slice6, bounds11[0], bounds11[1]))); } else if (_47 === 5) { + const _329: (a0: rs.usize, a1: rs.u8) => rs.RangeBound = (x3: rs.usize, k: rs.u8): rs.RangeBound => { + const _410: rs.u8 = rs.u8Rem(k, 3); + if (_410 === 0) { + return { tag: "Included", _0: x3 } as rs.RangeBound; + } + if (_410 === 1) { + return { tag: "Excluded", _0: x3 } as rs.RangeBound; + } + return { tag: "Unbounded" } as rs.RangeBound; + }; const part4 = rs.byteSliceRange(data, 2).length & 0xff; const _333: rs.RangeBound = _329(a, part4); const _332: [rs.RangeBound, rs.RangeBound] = [_333, _329(b, rs.u8Div(kind, 8))]; @@ -2078,11 +2078,6 @@ export function runs$0(data: rs.ByteSlice): rs.u8 { * and array, which later writes to what it cloned leave as they were. */ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _11: (a0: rs.Slice) => rs.u8 = (s: rs.Slice): rs.u8 => { - return rs.iterFold(rs.iterSlice(rs.sliceItems(s)), s.length & 0xff, (acc: rs.u8, x: Noisy.Noisy): rs.u8 => { - return rs.u8WrappingMul(acc, 31) ^ x.tag; - }); - }; const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { return rs.u16Mul(_2 as rs.u16, 257); @@ -2090,6 +2085,11 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_26: rs.u8): Noisy.Noisy => { return new Noisy.Noisy(_26); }), undefined, 1, true); + const _11: (a0: rs.Slice) => rs.u8 = (s: rs.Slice): rs.u8 => { + return rs.iterFold(rs.iterSlice(rs.sliceItems(s)), s.length & 0xff, (acc: rs.u8, x: Noisy.Noisy): rs.u8 => { + return rs.u8WrappingMul(acc, 31) ^ x.tag; + }); + }; const _13: rs.u8 = rs.u8Rem(kind, 4); if (_13 === 0) { const _17: [rs.ArraySlice, rs.ByteSlice] = rs.sliceAsChunks(data, 2); @@ -2229,11 +2229,6 @@ export function runsMut$0(data: rs.ByteSlice): rs.u8 { * does one the slice's own writes follow; and at none, which panics. */ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _11: (a0: rs.Slice) => rs.u8 = (s: rs.Slice): rs.u8 => { - return rs.iterFold(rs.iterSlice(rs.sliceItems(s)), s.length & 0xff, (acc: rs.u8, x: Item.Item): rs.u8 => { - return rs.u8WrappingMul(acc, 31) ^ x.tag; - }); - }; const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { return rs.u16Mul(_2 as rs.u16, 257); @@ -2241,6 +2236,11 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): Item.Item => { return new Item.Item(_22); }), undefined, 1, true); + const _11: (a0: rs.Slice) => rs.u8 = (s: rs.Slice): rs.u8 => { + return rs.iterFold(rs.iterSlice(rs.sliceItems(s)), s.length & 0xff, (acc: rs.u8, x: Item.Item): rs.u8 => { + return rs.u8WrappingMul(acc, 31) ^ x.tag; + }); + }; const _12: rs.u8 = rs.u8Rem(kind, 5); if (_12 === 0) { const _16: [rs.ArraySlice, rs.ByteSlice] = rs.sliceAsChunks(rs.byteVecSlice(bytes), 3); diff --git a/ts/fixtures/lang/statics/expected/statics.Dropped.ts b/ts/fixtures/lang/statics/expected/statics.Dropped.ts index add877131..147868b5a 100644 --- a/ts/fixtures/lang/statics/expected/statics.Dropped.ts +++ b/ts/fixtures/lang/statics/expected/statics.Dropped.ts @@ -4,9 +4,7 @@ import * as rs from "./rs.ts"; import { DROPS } from "./statics.ts"; export function fmt$fmt_Debug(self: Dropped, f: rs.Formatter): rs.Result { - const _3: string = "Dropped"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Dropped", [(f: rs.Formatter) => rs.u8Debug(self._0, f)]); } /** Logs its id when it drops. */ diff --git a/ts/fixtures/lang/statics/expected/statics.ts b/ts/fixtures/lang/statics/expected/statics.ts index e934c34f5..f30aa28ea 100644 --- a/ts/fixtures/lang/statics/expected/statics.ts +++ b/ts/fixtures/lang/statics/expected/statics.ts @@ -500,9 +500,6 @@ export function writes(data: rs.ByteSlice, out: rs.ByteVec): void { } export function written$cell_LazyCell_statics_Dropped_statics_cell_closure0(op: rs.u8, make: (a0: rs.u8) => rs.LazyCell, out: rs.ByteVec): void { - const _18: (a0: rs.LazyCell) => rs.String = (l: rs.LazyCell): rs.String => { - return rs.fmtFormat([(f: rs.Formatter) => l.debug(f, "LazyCell", (value: Dropped.Dropped, f: rs.Formatter) => Dropped.fmt$fmt_Debug(value, f)), "|"]); - }; let _103: boolean = false; let a: rs.LazyCell = make(1); let b: rs.LazyCell = make(2); @@ -513,6 +510,9 @@ export function written$cell_LazyCell_statics_Dropped_statics_cell_closure0(op: if ((op & 2) !== 0) { rs.byteVecPush(out, b.force()._0); } + const _18: (a0: rs.LazyCell) => rs.String = (l: rs.LazyCell): rs.String => { + return rs.fmtFormat([(f: rs.Formatter) => l.debug(f, "LazyCell", (value: Dropped.Dropped, f: rs.Formatter) => Dropped.fmt$fmt_Debug(value, f)), "|"]); + }; const _20: rs.u8 = rs.u8Rem(op >> 2, 7); if (_20 === 0) { const _25: rs.LazyCell = a; @@ -566,9 +566,6 @@ export function written$cell_LazyCell_statics_Dropped_statics_cell_closure0(op: } export function written$sync_LazyLock_statics_Dropped_statics_lock_closure0(op: rs.u8, make: (a0: rs.u8) => rs.LazyLock, out: rs.ByteVec): void { - const _18: (a0: rs.LazyLock) => rs.String = (l: rs.LazyLock): rs.String => { - return rs.fmtFormat([(f: rs.Formatter) => l.debug(f, "LazyLock", (value: Dropped.Dropped, f: rs.Formatter) => Dropped.fmt$fmt_Debug(value, f)), "|"]); - }; let _103: boolean = false; let a: rs.LazyLock = make(1); let b: rs.LazyLock = make(2); @@ -579,6 +576,9 @@ export function written$sync_LazyLock_statics_Dropped_statics_lock_closure0(op: if ((op & 2) !== 0) { rs.byteVecPush(out, b.force()._0); } + const _18: (a0: rs.LazyLock) => rs.String = (l: rs.LazyLock): rs.String => { + return rs.fmtFormat([(f: rs.Formatter) => l.debug(f, "LazyLock", (value: Dropped.Dropped, f: rs.Formatter) => Dropped.fmt$fmt_Debug(value, f)), "|"]); + }; const _20: rs.u8 = rs.u8Rem(op >> 2, 7); if (_20 === 0) { const _25: rs.LazyLock = a; diff --git a/ts/fixtures/lang/strs/expected/strs.ts b/ts/fixtures/lang/strs/expected/strs.ts index 394e6f18a..29eb55fbe 100644 --- a/ts/fixtures/lang/strs/expected/strs.ts +++ b/ts/fixtures/lang/strs/expected/strs.ts @@ -288,124 +288,116 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let sliced!: string; const s: rs.String = text(data); const p: rs.String = pattern(kind, s.v); - b0: { - const _8: rs.u8 = rs.u8Rem(kind, 8); - if (_8 === 0) { - let n: rs.i32 = 0; - const iter: rs.Iter = rs.strSplit(s.v, p.v); - while (true) { - const _18: string | rs.Done = iter.next(); - if (_18 === rs.DONE) { - break; - } - put(out, _18); - n = rs.i32Add(n, 1); + const _8: rs.u8 = rs.u8Rem(kind, 8); + if (_8 === 0) { + let n: rs.i32 = 0; + const iter: rs.Iter = rs.strSplit(s.v, p.v); + while (true) { + const _18: string | rs.Done = iter.next(); + if (_18 === rs.DONE) { + break; } - rs.byteVecPush(out, n & 0xff); - put(out, option_unwrapOr$1iemzn8(rs.iterLast(rs.strSplit(s.v, p.v)), "none")); + put(out, _18); + n = rs.i32Add(n, 1); + } + rs.byteVecPush(out, n & 0xff); + put(out, option_unwrapOr$1iemzn8(rs.iterLast(rs.strSplit(s.v, p.v)), "none")); + } else if (_8 === 1) { + const iter2: rs.Iter<[rs.usize, string]> = rs.strMatchIndices(s.v, p.v); + while (true) { + const _42: [rs.usize, string] | rs.Done = iter2.next(); + if (_42 === rs.DONE) { + break; + } + const at: rs.usize = _42[0]; + putOffset(out, at); + put(out, _42[1]); + put(out, rs.strSlice(s.v, 0, at)); + const part6 = rs.usizeAdd(at, rs.stringLen(_42[1])); + put(out, rs.strSlice(s.v, part6)); + const part7 = rs.usizeAdd(at, rs.stringLen(_42[1])); + put(out, rs.strSlice(s.v, at, part7)); + } + } else if (_8 === 2) { + put(out, rs.strTrimStartMatches(s.v, p.v)); + put(out, rs.strTrimEndMatches(s.v, p.v)); + put(out, rs.strTrimEndMatches(rs.strTrimStartMatches(s.v, p.v), p.v)); + rs.byteVecPush(out, rs.strStartsWith(s.v, p.v) ? 1 : 0); + rs.byteVecPush(out, rs.strContains(s.v, p.v) ? 1 : 0); + rs.byteVecPush(out, rs.strContains(s.v, p.v) ? 1 : 0); + rs.byteVecPush(out, rs.strContains(s.v, "/") ? 1 : 0); + rs.byteVecPush(out, rs.strContains(s.v, (c: rs.char): boolean => { + return rs.isAsciiDigit(c); + }) ? 1 : 0); + putOffset(out, rs.strRfind(s.v, p.v)); + const _123: [string, string] | undefined = rs.strRsplitOnce(s.v, p.v); + if (_123 === undefined) { + rs.byteVecPush(out, 253); } else { - if (_8 === 1) { - const iter2: rs.Iter<[rs.usize, string]> = rs.strMatchIndices(s.v, p.v); - while (true) { - const _42: [rs.usize, string] | rs.Done = iter2.next(); - if (_42 === rs.DONE) { - break b0; - } - const at: rs.usize = _42[0]; - putOffset(out, at); - put(out, _42[1]); - put(out, rs.strSlice(s.v, 0, at)); - const part6 = rs.usizeAdd(at, rs.stringLen(_42[1])); - put(out, rs.strSlice(s.v, part6)); - const part7 = rs.usizeAdd(at, rs.stringLen(_42[1])); - put(out, rs.strSlice(s.v, at, part7)); - } + put(out, _123[0]); + put(out, _123[1]); + } + } else if (_8 === 3) { + const iter3: rs.Iter = rs.iterSuccessors(s.v, (path: string): string | undefined => { + const _73: string = path; + return then$0havnzo(!(path.length === 0), (): string => { + return option_mapOr$19xt0tb(rs.strRfind(_73, "/"), "", (slash: rs.usize): string => { + return rs.strSlice(_73, 0, slash); + }); + }); + }); + while (true) { + const _139: string | rs.Done = iter3.next(); + if (_139 === rs.DONE) { + break; } - if (_8 === 2) { - put(out, rs.strTrimStartMatches(s.v, p.v)); - put(out, rs.strTrimEndMatches(s.v, p.v)); - put(out, rs.strTrimEndMatches(rs.strTrimStartMatches(s.v, p.v), p.v)); - rs.byteVecPush(out, rs.strStartsWith(s.v, p.v) ? 1 : 0); - rs.byteVecPush(out, rs.strContains(s.v, p.v) ? 1 : 0); - rs.byteVecPush(out, rs.strContains(s.v, p.v) ? 1 : 0); - rs.byteVecPush(out, rs.strContains(s.v, "/") ? 1 : 0); - rs.byteVecPush(out, rs.strContains(s.v, (c: rs.char): boolean => { - return rs.isAsciiDigit(c); - }) ? 1 : 0); - putOffset(out, rs.strRfind(s.v, p.v)); - const _123: [string, string] | undefined = rs.strRsplitOnce(s.v, p.v); - if (_123 === undefined) { - rs.byteVecPush(out, 253); - } else { - put(out, _123[0]); - put(out, _123[1]); - } - } else { - if (_8 === 3) { - const iter3: rs.Iter = rs.iterSuccessors(s.v, (path: string): string | undefined => { - const _73: string = path; - return then$0havnzo(!(path.length === 0), (): string => { - return option_mapOr$19xt0tb(rs.strRfind(_73, "/"), "", (slash: rs.usize): string => { - return rs.strSlice(_73, 0, slash); - }); - }); - }); - while (true) { - const _139: string | rs.Done = iter3.next(); - if (_139 === rs.DONE) { - break b0; - } - put(out, _139); - } - } - if (_8 === 4) { - const keep: rs.usize = rs.usizeAdd(rs.u8Rem(rs.u8Div(kind, 8), 4) as rs.usize, 1); - put(out, option_unwrapOr$1iemzn8(option_map$0h0w6xi(rs.iterNth(rs.strMatchIndices(s.v, "/"), rs.usizeSub(keep, 1)), (_2: [rs.usize, string]): string => { - return rs.strSlice(s.v, 0, _2[0]); - }), "none")); - const part5 = option_mapOr$1wbabuw(rs.iterNth(rs.strMatchIndices(s.v, "/"), rs.usizeSub(keep, 1)), s.len, (_22: [rs.usize, string]): rs.usize => { - return rs.usizeAdd(_22[0], 1); - }); - put(out, rs.strSlice(s.v, part5)); - } else if (_8 === 5) { - const parts: rs.Vec = rs.iterToVec(rs.strSplit(s.v, "/"), "next", 8); - const _186: rs.Slice = rs.sliceFrom(parts.items); - const _188: string = p.v; - put(out, rs.strsJoin(rs.sliceItems(_186), _188).v); - const _199: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(parts.items), (part3: string): rs.String => { - return rs.stringFrom(part3); - }), undefined, 12, true).items); - const _201: string = p.v; - put(out, rs.strsJoin(rs.sliceItems(_199), _201).v); - put(out, rs.strsJoin(["a", "", s.v], "/").v); - } else { - const at2: (a0: rs.u8) => rs.usize = (b2: rs.u8): rs.usize => { - if ((kind & 32) === 0) { - return rs.usizeRem(b2 as rs.usize, rs.usizeAdd(s.len, 2)); - } - return rs.usizeSaturatingSub(rs.usizeAdd(s.len, 1), rs.usizeRem(b2 as rs.usize, 4)); - }; - if (!(data.length >= 2)) { - _219 = [0, 0] as [rs.usize, rs.usize]; - } else { - _219 = [at2(data.data[data.start]), at2(data.data[data.start + 1])] as [rs.usize, rs.usize]; - } - const a: rs.usize = _219[0]; - const b: rs.usize = _219[1]; - const _233: rs.u8 = rs.u8Rem(rs.u8Div(kind, 8), 4); - if (_233 === 0) { - sliced = rs.strSlice(s.v, a, b); - } else if (_233 === 1) { - sliced = rs.strSlice(s.v, a); - } else if (_233 === 2) { - sliced = rs.strSlice(s.v, 0, b); - } else { - sliced = rs.strSlice(s.v, 0); - } - put(out, sliced); - } + put(out, _139); + } + } else if (_8 === 4) { + const keep: rs.usize = rs.usizeAdd(rs.u8Rem(rs.u8Div(kind, 8), 4) as rs.usize, 1); + put(out, option_unwrapOr$1iemzn8(option_map$0h0w6xi(rs.iterNth(rs.strMatchIndices(s.v, "/"), rs.usizeSub(keep, 1)), (_2: [rs.usize, string]): string => { + return rs.strSlice(s.v, 0, _2[0]); + }), "none")); + const part5 = option_mapOr$1wbabuw(rs.iterNth(rs.strMatchIndices(s.v, "/"), rs.usizeSub(keep, 1)), s.len, (_22: [rs.usize, string]): rs.usize => { + return rs.usizeAdd(_22[0], 1); + }); + put(out, rs.strSlice(s.v, part5)); + } else if (_8 === 5) { + const parts: rs.Vec = rs.iterToVec(rs.strSplit(s.v, "/"), "next", 8); + const _186: rs.Slice = rs.sliceFrom(parts.items); + const _188: string = p.v; + put(out, rs.strsJoin(rs.sliceItems(_186), _188).v); + const _199: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(parts.items), (part3: string): rs.String => { + return rs.stringFrom(part3); + }), undefined, 12, true).items); + const _201: string = p.v; + put(out, rs.strsJoin(rs.sliceItems(_199), _201).v); + put(out, rs.strsJoin(["a", "", s.v], "/").v); + } else { + const at2: (a0: rs.u8) => rs.usize = (b2: rs.u8): rs.usize => { + if ((kind & 32) === 0) { + return rs.usizeRem(b2 as rs.usize, rs.usizeAdd(s.len, 2)); } + return rs.usizeSaturatingSub(rs.usizeAdd(s.len, 1), rs.usizeRem(b2 as rs.usize, 4)); + }; + if (!(data.length >= 2)) { + _219 = [0, 0] as [rs.usize, rs.usize]; + } else { + _219 = [at2(data.data[data.start]), at2(data.data[data.start + 1])] as [rs.usize, rs.usize]; + } + const a: rs.usize = _219[0]; + const b: rs.usize = _219[1]; + const _233: rs.u8 = rs.u8Rem(rs.u8Div(kind, 8), 4); + if (_233 === 0) { + sliced = rs.strSlice(s.v, a, b); + } else if (_233 === 1) { + sliced = rs.strSlice(s.v, a); + } else if (_233 === 2) { + sliced = rs.strSlice(s.v, 0, b); + } else { + sliced = rs.strSlice(s.v, 0); } + put(out, sliced); } } @@ -740,8 +732,8 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const arg26 = parsed.value; put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtBool(arg26, f)]).v); } else { - const part13 = new rs.ParseBoolError(); - const args191 = [(f: rs.Formatter) => rs.fmtParseBoolErrorDisplay(part13, f), (f: rs.Formatter) => rs.fmtParseBoolErrorDebug(part13, f)]; + const _82: rs.ParseBoolError = new rs.ParseBoolError(); + const args191 = [(f: rs.Formatter) => rs.fmtParseBoolErrorDisplay(_82, f), (f: rs.Formatter) => rs.fmtParseBoolErrorDebug(_82, f)]; put(out, rs.fmtFormat([args191[0], "|", args191[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args191[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args191[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args191[1]), "|", rs.fmtSpec({ alternate: true }, args191[1])]).v); } } @@ -1979,66 +1971,60 @@ export function pointers(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return _2[0]; }), rs.iterSlice([s.len])), "next", 4); const sub: string = rs.strSlice(s.v, starts.items[rs.idx(starts.items, rs.usizeRem(rs.u8Div(kind, 4) as rs.usize, starts.items.length))]); - b0: { - const _27: rs.u8 = rs.u8Rem(kind, 4); - if (_27 === 0) { - const whole: rs.ByteVec = rs.byteVecWithCapacity(s.len); - rs.ptrCopy(rs.strAsPtr(s.v), rs.byteVecAsPtr(whole), s.len); - rs.byteVecSetLen(whole, s.len); - rs.byteVecExtendFromSlice(out, rs.byteVecSlice(whole)); - const framed: rs.ByteVec = rs.byteVecOf(170, rs.usizeAdd(rs.stringLen(sub), 2)); - rs.ptrCopy(rs.strAsPtr(sub), rs.ptrAdd(rs.byteVecAsPtr(framed), 1), rs.stringLen(sub)); - rs.byteVecExtendFromSlice(out, rs.byteVecSlice(framed)); - } else if (_27 === 1) { - const p: rs.Place = rs.strAsPtr(sub); - const iter: rs.RangeInclusive = new rs.RangeInclusive(0, rs.stringLen(sub), rs.usizeStep); - while (true) { - const _65: rs.usize | rs.Done = iter.next(); - if (_65 === rs.DONE) { - break; - } - const i: rs.usize = _65; - const tail: rs.ByteSlice = rs.ptrByteSlice(rs.ptrAdd(p, i), rs.usizeSub(rs.stringLen(sub), i), true); - rs.byteVecPush(out, tail.length & 0xff); - rs.byteVecExtendFromSlice(out, option_unwrapOr$0yvilko(rs.byteSliceGetRange(tail, 0, 2), tail)); + const _27: rs.u8 = rs.u8Rem(kind, 4); + if (_27 === 0) { + const whole: rs.ByteVec = rs.byteVecWithCapacity(s.len); + rs.ptrCopy(rs.strAsPtr(s.v), rs.byteVecAsPtr(whole), s.len); + rs.byteVecSetLen(whole, s.len); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(whole)); + const framed: rs.ByteVec = rs.byteVecOf(170, rs.usizeAdd(rs.stringLen(sub), 2)); + rs.ptrCopy(rs.strAsPtr(sub), rs.ptrAdd(rs.byteVecAsPtr(framed), 1), rs.stringLen(sub)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(framed)); + } else if (_27 === 1) { + const p: rs.Place = rs.strAsPtr(sub); + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, rs.stringLen(sub), rs.usizeStep); + while (true) { + const _65: rs.usize | rs.Done = iter.next(); + if (_65 === rs.DONE) { + break; } - put(out, rs.strFromUtf8Unchecked(rs.ptrByteSlice(p, rs.stringLen(sub), true))); - } else { - if (_27 === 2) { - const p2: rs.Place = rs.strAsPtr(s.v); - const end: rs.Place = rs.ptrAdd(p2, s.len); - let q: rs.Place = p2; - while (rs.ptrOffsetFrom(end, q) > 0) { - rs.byteVecPush(out, q.v); - q = rs.ptrAdd(q, 1); - } - rs.byteVecPush(out, rs.ptrOffsetFrom(q, p2) & 0xff); - const pointer = end; - let back: rs.Place = rs.optionUnwrap(pointer === rs.NULL ? undefined : pointer); - while (true) { - if (!(rs.ptrOffsetFrom(back, p2) > 0)) { - break b0; - } - back = rs.ptrAdd(back, -1); - rs.byteVecPush(out, back.v); - } + const i: rs.usize = _65; + const tail: rs.ByteSlice = rs.ptrByteSlice(rs.ptrAdd(p, i), rs.usizeSub(rs.stringLen(sub), i), true); + rs.byteVecPush(out, tail.length & 0xff); + rs.byteVecExtendFromSlice(out, option_unwrapOr$0yvilko(rs.byteSliceGetRange(tail, 0, 2), tail)); + } + put(out, rs.strFromUtf8Unchecked(rs.ptrByteSlice(p, rs.stringLen(sub), true))); + } else if (_27 === 2) { + const p2: rs.Place = rs.strAsPtr(s.v); + const end: rs.Place = rs.ptrAdd(p2, s.len); + let q: rs.Place = p2; + while (rs.ptrOffsetFrom(end, q) > 0) { + rs.byteVecPush(out, q.v); + q = rs.ptrAdd(q, 1); + } + rs.byteVecPush(out, rs.ptrOffsetFrom(q, p2) & 0xff); + const pointer = end; + let back: rs.Place = rs.optionUnwrap(pointer === rs.NULL ? undefined : pointer); + while (rs.ptrOffsetFrom(back, p2) > 0) { + back = rs.ptrAdd(back, -1); + rs.byteVecPush(out, back.v); + } + } else { + const fixed: Fixed.Fixed = Fixed.new(); + const iter2: rs.Iter = rs.iterChain(rs.strSplit(s.v, "/"), rs.iterSlice([sub])); + while (true) { + const _126: string | rs.Done = iter2.next(); + if (_126 === rs.DONE) { + break; } - const fixed: Fixed.Fixed = Fixed.new(); - const iter2: rs.Iter = rs.iterChain(rs.strSplit(s.v, "/"), rs.iterSlice([sub])); - while (true) { - const _126: string | rs.Done = iter2.next(); - if (_126 === rs.DONE) { - break; - } - const _130: rs.Result = Fixed.tryPushStr(fixed, _126); - if (_130.ok) { - rs.byteVecPush(out, fixed.len & 0xff); - } else { - put(out, _130.error); - } + const _130: rs.Result = Fixed.tryPushStr(fixed, _126); + if (_130.ok) { + rs.byteVecPush(out, fixed.len & 0xff); + } else { + put(out, _130.error); } - put(out, Fixed.asStr(fixed)); } + put(out, Fixed.asStr(fixed)); } } diff --git a/ts/fixtures/lang/wrappers/expected/wrappers.ts b/ts/fixtures/lang/wrappers/expected/wrappers.ts index 1d1ce5201..189f1c0cd 100644 --- a/ts/fixtures/lang/wrappers/expected/wrappers.ts +++ b/ts/fixtures/lang/wrappers/expected/wrappers.ts @@ -248,22 +248,22 @@ export function boundOf(kind: rs.u8, a: rs.u64): rs.RangeBound { export function wrappers(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let scale!: Scale.Scale; let name!: string; + const at: (a0: rs.usize) => rs.u8 = (i3: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i3), 0); + }; const _5: (a0: rs.u8) => rs.u64 = (b3: rs.u8): rs.u64 => { - const _3: rs.u8 = rs.u8Rem(b3, 4); - if (_3 === 0) { + const _33: rs.u8 = rs.u8Rem(b3, 4); + if (_33 === 0) { return b3 as rs.u64; } - if (_3 === 1) { + if (_33 === 1) { return rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, b3 as rs.u64); } - if (_3 === 2) { + if (_33 === 2) { return rs.u64Add({ hi: 0x200000, lo: 0 } as rs.u64, b3 as rs.u64); } return rs.u64Mul(b3 as rs.u64, 7); }; - const at: (a0: rs.usize) => rs.u8 = (i3: rs.usize): rs.u8 => { - return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i3), 0); - }; const part = at(0); const _9: rs.u64 = _5(part); const part2 = at(1); diff --git a/ts/fixtures/lang/wraps/expected/wraps.Tick.ts b/ts/fixtures/lang/wraps/expected/wraps.Tick.ts index f30a16a87..14f4c5619 100644 --- a/ts/fixtures/lang/wraps/expected/wraps.Tick.ts +++ b/ts/fixtures/lang/wraps/expected/wraps.Tick.ts @@ -3,75 +3,51 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug_i128(self: Tick, f: rs.Formatter): rs.Result { - const _3: string = "Tick"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.i128Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Tick", [(f: rs.Formatter) => rs.i128Debug(self._0, f)]); } export function fmt$fmt_Debug_i16(self: Tick, f: rs.Formatter): rs.Result { - const _3: string = "Tick"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.i16Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Tick", [(f: rs.Formatter) => rs.i16Debug(self._0, f)]); } export function fmt$fmt_Debug_i32(self: Tick, f: rs.Formatter): rs.Result { - const _3: string = "Tick"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.i32Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Tick", [(f: rs.Formatter) => rs.i32Debug(self._0, f)]); } export function fmt$fmt_Debug_i64(self: Tick, f: rs.Formatter): rs.Result { - const _3: string = "Tick"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.i64Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Tick", [(f: rs.Formatter) => rs.i64Debug(self._0, f)]); } export function fmt$fmt_Debug_i8(self: Tick, f: rs.Formatter): rs.Result { - const _3: string = "Tick"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.i8Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Tick", [(f: rs.Formatter) => rs.i8Debug(self._0, f)]); } export function fmt$fmt_Debug_isize(self: Tick, f: rs.Formatter): rs.Result { - const _3: string = "Tick"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.isizeDebug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Tick", [(f: rs.Formatter) => rs.isizeDebug(self._0, f)]); } export function fmt$fmt_Debug_u128(self: Tick, f: rs.Formatter): rs.Result { - const _3: string = "Tick"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.u128Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Tick", [(f: rs.Formatter) => rs.u128Debug(self._0, f)]); } export function fmt$fmt_Debug_u16(self: Tick, f: rs.Formatter): rs.Result { - const _3: string = "Tick"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.u16Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Tick", [(f: rs.Formatter) => rs.u16Debug(self._0, f)]); } export function fmt$fmt_Debug_u32(self: Tick, f: rs.Formatter): rs.Result { - const _3: string = "Tick"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.u32Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Tick", [(f: rs.Formatter) => rs.u32Debug(self._0, f)]); } export function fmt$fmt_Debug_u64(self: Tick, f: rs.Formatter): rs.Result { - const _3: string = "Tick"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.u64Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Tick", [(f: rs.Formatter) => rs.u64Debug(self._0, f)]); } export function fmt$fmt_Debug_u8(self: Tick, f: rs.Formatter): rs.Result { - const _3: string = "Tick"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Tick", [(f: rs.Formatter) => rs.u8Debug(self._0, f)]); } export function fmt$fmt_Debug_usize(self: Tick, f: rs.Formatter): rs.Result { - const _3: string = "Tick"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.usizeDebug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Tick", [(f: rs.Formatter) => rs.usizeDebug(self._0, f)]); } export function default$Default_i128(): Tick { diff --git a/ts/fixtures/lang/wraps/expected/wraps.ts b/ts/fixtures/lang/wraps/expected/wraps.ts index 5a0786bc3..9a7323118 100644 --- a/ts/fixtures/lang/wraps/expected/wraps.ts +++ b/ts/fixtures/lang/wraps/expected/wraps.ts @@ -226,9 +226,6 @@ export function hashed$wraps_Tick_usize(v: Tick.Tick): rs.u64 { * shift amount, which may pass the width many times over. */ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _30: (a0: rs.ByteVec, a1: rs.u8) => undefined = (out2: rs.ByteVec, v: rs.u8): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u8ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.u8 = (at: rs.usize): rs.u8 => { const buf: Uint8Array = Uint8Array.of(0); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -249,6 +246,9 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 1, i2)), 0); }; const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _30: (a0: rs.ByteVec, a1: rs.u8) => undefined = (out2: rs.ByteVec, v: rs.u8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u8ToBeBytes(v))); + }; const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { const part45 = rs.u8WrappingAdd(a, b); @@ -409,9 +409,6 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { * shift amount, which may pass the width many times over. */ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _30: (a0: rs.ByteVec, a1: rs.u16) => undefined = (out2: rs.ByteVec, v: rs.u16): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u16ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.u16 = (at: rs.usize): rs.u16 => { const buf: Uint8Array = rs.bytes(2); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -432,6 +429,9 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 2, i2)), 0); }; const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _30: (a0: rs.ByteVec, a1: rs.u16) => undefined = (out2: rs.ByteVec, v: rs.u16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u16ToBeBytes(v))); + }; const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { const part45 = rs.u16WrappingAdd(a, b); @@ -592,9 +592,6 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { * shift amount, which may pass the width many times over. */ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _30: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out2: rs.ByteVec, v: rs.u32): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u32ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.u32 = (at: rs.usize): rs.u32 => { const buf: Uint8Array = rs.bytes(4); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -615,6 +612,9 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 4, i2)), 0); }; const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _30: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out2: rs.ByteVec, v: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u32ToBeBytes(v))); + }; const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { const part45 = rs.u32WrappingAdd(a, b); @@ -775,9 +775,6 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { * shift amount, which may pass the width many times over. */ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _30: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, v: rs.u64): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u64ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.u64 = (at: rs.usize): rs.u64 => { const buf: Uint8Array = rs.bytes(8); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -798,6 +795,9 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 8, i2)), 0); }; const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _30: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, v: rs.u64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u64ToBeBytes(v))); + }; const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { const part45 = rs.u64WrappingAdd(a, b); @@ -958,9 +958,6 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { * shift amount, which may pass the width many times over. */ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _30: (a0: rs.ByteVec, a1: rs.u128) => undefined = (out2: rs.ByteVec, v: rs.u128): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.u128 = (at: rs.usize): rs.u128 => { const buf: Uint8Array = rs.bytes(16); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -981,6 +978,9 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 16, i2)), 0); }; const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _30: (a0: rs.ByteVec, a1: rs.u128) => undefined = (out2: rs.ByteVec, v: rs.u128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v))); + }; const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { const part45 = rs.u128WrappingAdd(a, b); @@ -1141,9 +1141,6 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { * shift amount, which may pass the width many times over. */ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _30: (a0: rs.ByteVec, a1: rs.usize) => undefined = (out2: rs.ByteVec, v: rs.usize): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.usizeToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.usize = (at: rs.usize): rs.usize => { const buf: Uint8Array = rs.bytes(4); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -1164,6 +1161,9 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 4, i2)), 0); }; const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _30: (a0: rs.ByteVec, a1: rs.usize) => undefined = (out2: rs.ByteVec, v: rs.usize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.usizeToBeBytes(v))); + }; const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { const part45 = rs.usizeWrappingAdd(a, b); @@ -1324,9 +1324,6 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { * shift amount, which may pass the width many times over. */ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _30: (a0: rs.ByteVec, a1: rs.i8) => undefined = (out2: rs.ByteVec, v: rs.i8): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i8ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.i8 = (at: rs.usize): rs.i8 => { const buf: Uint8Array = Uint8Array.of(0); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -1347,6 +1344,9 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 1, i2)), 0); }; const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _30: (a0: rs.ByteVec, a1: rs.i8) => undefined = (out2: rs.ByteVec, v: rs.i8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i8ToBeBytes(v))); + }; const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { const part45 = rs.i8WrappingAdd(a, b); @@ -1509,9 +1509,6 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { * shift amount, which may pass the width many times over. */ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _30: (a0: rs.ByteVec, a1: rs.i16) => undefined = (out2: rs.ByteVec, v: rs.i16): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i16ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.i16 = (at: rs.usize): rs.i16 => { const buf: Uint8Array = rs.bytes(2); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -1532,6 +1529,9 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 2, i2)), 0); }; const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _30: (a0: rs.ByteVec, a1: rs.i16) => undefined = (out2: rs.ByteVec, v: rs.i16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i16ToBeBytes(v))); + }; const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { const part45 = rs.i16WrappingAdd(a, b); @@ -1694,9 +1694,6 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { * shift amount, which may pass the width many times over. */ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _30: (a0: rs.ByteVec, a1: rs.i32) => undefined = (out2: rs.ByteVec, v: rs.i32): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i32ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.i32 = (at: rs.usize): rs.i32 => { const buf: Uint8Array = rs.bytes(4); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -1717,6 +1714,9 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 4, i2)), 0); }; const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _30: (a0: rs.ByteVec, a1: rs.i32) => undefined = (out2: rs.ByteVec, v: rs.i32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i32ToBeBytes(v))); + }; const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { const part45 = rs.i32WrappingAdd(a, b); @@ -1879,9 +1879,6 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { * shift amount, which may pass the width many times over. */ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _30: (a0: rs.ByteVec, a1: rs.i64) => undefined = (out2: rs.ByteVec, v: rs.i64): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i64ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.i64 = (at: rs.usize): rs.i64 => { const buf: Uint8Array = rs.bytes(8); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -1902,6 +1899,9 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 8, i2)), 0); }; const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _30: (a0: rs.ByteVec, a1: rs.i64) => undefined = (out2: rs.ByteVec, v: rs.i64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i64ToBeBytes(v))); + }; const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { const part45 = rs.i64WrappingAdd(a, b); @@ -2064,9 +2064,6 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { * shift amount, which may pass the width many times over. */ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _30: (a0: rs.ByteVec, a1: rs.i128) => undefined = (out2: rs.ByteVec, v: rs.i128): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.i128 = (at: rs.usize): rs.i128 => { const buf: Uint8Array = rs.bytes(16); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -2087,6 +2084,9 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 16, i2)), 0); }; const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _30: (a0: rs.ByteVec, a1: rs.i128) => undefined = (out2: rs.ByteVec, v: rs.i128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v))); + }; const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { const part45 = rs.i128WrappingAdd(a, b); @@ -2249,9 +2249,6 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { * shift amount, which may pass the width many times over. */ export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _30: (a0: rs.ByteVec, a1: rs.isize) => undefined = (out2: rs.ByteVec, v: rs.isize): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.isizeToBeBytes(v))); - }; const take: (a0: rs.usize) => rs.isize = (at: rs.usize): rs.isize => { const buf: Uint8Array = rs.bytes(4); const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceFrom(buf))); @@ -2272,6 +2269,9 @@ export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 4, i2)), 0); }; const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _30: (a0: rs.ByteVec, a1: rs.isize) => undefined = (out2: rs.ByteVec, v: rs.isize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.isizeToBeBytes(v))); + }; const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { const part45 = rs.isizeWrappingAdd(a, b); diff --git a/ts/fixtures/lang/zeros/expected/zeros.Names.ts b/ts/fixtures/lang/zeros/expected/zeros.Names.ts index 80555a6d0..9ba6300cf 100644 --- a/ts/fixtures/lang/zeros/expected/zeros.Names.ts +++ b/ts/fixtures/lang/zeros/expected/zeros.Names.ts @@ -17,7 +17,7 @@ export function clone$Clone(self: Names): Names { } export function fmt$fmt_Debug(_self: Names, f: rs.Formatter): rs.Result { - return rs.fmtDebugTupleFields(f, "Names", [(f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "u8", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "alloc::string::String", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "(i64, bool)", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "&str", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "[u16; 3]", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "alloc::vec::Vec>", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "fn(u8) -> u8", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "lang_zeros_fixture::zeros::Unit", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "lang_zeros_fixture::zeros::Tagged<()>", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "()", ">"])]); + return rs.fmtDebugFields(f, "Names", [(f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "u8", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "alloc::string::String", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "(i64, bool)", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "&str", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "[u16; 3]", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "alloc::vec::Vec>", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "fn(u8) -> u8", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "lang_zeros_fixture::zeros::Unit", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "lang_zeros_fixture::zeros::Tagged<()>", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "()", ">"])]); } export function default$Default(): Names { diff --git a/ts/fixtures/lang/zeros/expected/zeros.Rest.ts b/ts/fixtures/lang/zeros/expected/zeros.Rest.ts index 462d31760..6c87dd880 100644 --- a/ts/fixtures/lang/zeros/expected/zeros.Rest.ts +++ b/ts/fixtures/lang/zeros/expected/zeros.Rest.ts @@ -9,10 +9,7 @@ export function clone$Clone(self: Rest): Rest { } export function fmt$fmt_Debug(self: Rest, f: rs.Formatter): rs.Result { - const _3: string = "Rest"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.fmtRangeFull(self._0, f); - const _6: rs.Fmt = (f: rs.Formatter) => rs.fmtWriteStr(f, "Empty"); - return rs.debugTupleFinish(rs.debugTupleField(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4), _6)); + return rs.fmtDebugFields(f, "Rest", [(f: rs.Formatter) => rs.fmtRangeFull(self._0, f), (f: rs.Formatter) => rs.fmtWriteStr(f, "Empty")]); } export function default$Default(): Rest { diff --git a/ts/fixtures/lang/zeros/expected/zeros.Tagged.ts b/ts/fixtures/lang/zeros/expected/zeros.Tagged.ts index 5e14b17d7..c01474d7a 100644 --- a/ts/fixtures/lang/zeros/expected/zeros.Tagged.ts +++ b/ts/fixtures/lang/zeros/expected/zeros.Tagged.ts @@ -10,29 +10,11 @@ export function clone$Clone_String(self: Tagged): Tagged { } export function fmt$fmt_Debug_String(self: Tagged, f: rs.Formatter): rs.Result { - const _3: string = "Tagged"; - const _4: string = "n"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.n, f); - const _7: string = "of"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "alloc::string::String", ">"]); - const _10: string = "pin"; - const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtWriteStr(f, "PhantomPinned"); - const _13: string = "unit"; - const _14: rs.Fmt = (f: rs.Formatter) => rs.fmtUnit(self.unit, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11), _13, _14)); + return rs.fmtDebugFields(f, "Tagged n of pin unit", [(f: rs.Formatter) => rs.u8Debug(self.n, f), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "alloc::string::String", ">"]), (f: rs.Formatter) => rs.fmtWriteStr(f, "PhantomPinned"), (f: rs.Formatter) => rs.fmtUnit(self.unit, f)]); } export function fmt$fmt_Debug_u8(self: Tagged, f: rs.Formatter): rs.Result { - const _3: string = "Tagged"; - const _4: string = "n"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.n, f); - const _7: string = "of"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "u8", ">"]); - const _10: string = "pin"; - const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtWriteStr(f, "PhantomPinned"); - const _13: string = "unit"; - const _14: rs.Fmt = (f: rs.Formatter) => rs.fmtUnit(self.unit, f); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11), _13, _14)); + return rs.fmtDebugFields(f, "Tagged n of pin unit", [(f: rs.Formatter) => rs.u8Debug(self.n, f), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "u8", ">"]), (f: rs.Formatter) => rs.fmtWriteStr(f, "PhantomPinned"), (f: rs.Formatter) => rs.fmtUnit(self.unit, f)]); } export function default$Default_String(): Tagged { diff --git a/ts/fixtures/lang/zeros/expected/zeros.ts b/ts/fixtures/lang/zeros/expected/zeros.ts index 241ffb053..872e0bef0 100644 --- a/ts/fixtures/lang/zeros/expected/zeros.ts +++ b/ts/fixtures/lang/zeros/expected/zeros.ts @@ -36,7 +36,10 @@ export function none$String(): rs.String[] { } export function units(): Unit.Unit[] { - return [{}, {}, {}]; + const item = {}; + return Array.from({ length: 3 }, (): Unit.Unit => { + return item; + }); } export function one(): One.One { @@ -67,37 +70,40 @@ export function made$zeros_Unit(): Unit.Unit { /** The case `kind` picks, on `data`; each puts what it read. */ export function zeros(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _72: (a0: rs.u8) => One.One = (_2: rs.u8): One.One => { - return "Only" as One.One; - }; rs.atomicStore(LOG, 0, 0); const n: rs.usize = data.length; const _8: rs.u8 = rs.u8Rem(kind, 7); if (_8 === 0) { - const _11: Unit.Unit = Unit.clone$Clone({}); + const _10: Unit.Unit = {}; + const _11: Unit.Unit = Unit.clone$Clone(_10); const _13: Pair.Pair = Pair.clone$Clone(pair()); const _16: Unit.Unit = made$zeros_Unit(); phantom$u8(); - rs.byteVecPush(out, (Unit.eq$cmp_PartialEq(_11, {}) ? 1 : 0) | (((Unit.eq$cmp_PartialEq(_13._0, _16) ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, (Unit.eq$cmp_PartialEq(_11, _10) ? 1 : 0) | (((Unit.eq$cmp_PartialEq(_13._0, _16) ? 1 : 0) << 1) & 0xff)); const _40: One.One = One.clone$Clone("Only" as One.One); const args6 = [(f: rs.Formatter) => Unit.fmt$fmt_Debug(_11, f), (f: rs.Formatter) => One.fmt$fmt_Debug(_40, f)]; rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); } else if (_8 === 1) { - rs.byteVecPush(out, rs.iterCount(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_213: rs.u8): Uint8Array => { + rs.byteVecPush(out, rs.iterCount(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_212: rs.u8): Uint8Array => { return Uint8Array.of(); })) & 0xff); - rs.byteVecPush(out, rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_214: rs.u8): Unit.Unit => { + rs.byteVecPush(out, rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_213: rs.u8): Unit.Unit => { return {}; }), undefined, 0, true).items.length & 0xff); - rs.byteVecPush(out, rs.iterCount(rs.iterFlatten(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): Unit.Unit[] => { - return [{}, {}, {}]; + rs.byteVecPush(out, rs.iterCount(rs.iterFlatten(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_214: rs.u8): Unit.Unit[] => { + const item = {}; + return Array.from({ length: 3 }, (): Unit.Unit => { + return item; + }); }), (value: Unit.Unit[]) => rs.iterSlice(value), true, 3)) & 0xff); - rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_216: rs.u8): Pair.Pair => { + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): Pair.Pair => { return pair(); }), (p: Pair.Pair): boolean => { return Unit.eq$cmp_PartialEq(p._0, { _0: {}, _1: undefined }._0); })) & 0xff); - rs.byteVecPush(out, One.eq$cmp_PartialEq(_72(1), one()) ? 1 : 0); + rs.byteVecPush(out, One.eq$cmp_PartialEq(((_216: rs.u8): One.One => { + return "Only" as One.One; + })(1), one()) ? 1 : 0); } else if (_8 === 2) { const _87: Unit.Unit = unit(); const _88: rs.Slice = rs.sliceFrom(none$String()); @@ -109,8 +115,11 @@ export function zeros(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else if (_8 === 3) { const _108: (a0: rs.u8) => rs.u8 = adder(); adder(); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_211: rs.u8): rs.u8 => { - return _108(_211); + const _110: Holds.Holds<(a0: rs.u8) => rs.u8> = new Holds.Holds((b3: rs.u8): rs.u8 => { + return b3 ^ 90; + }); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_210: rs.u8): rs.u8 => { + return _108(_210); }), undefined, true); rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b5: rs.u8): rs.u8 => { return rs.u8WrappingAdd(b5, 1); @@ -120,17 +129,15 @@ export function zeros(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.iterExtendBytes(out, rs.iterMap(_122, (b6: rs.u8): rs.u8 => { return rs.u8WrappingAdd(b6, 1); }), undefined, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_212: rs.u8): rs.u8 => { - return new Holds.Holds((b: rs.u8): rs.u8 => { - return b ^ 90; - })._0(_212); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_211: rs.u8): rs.u8 => { + return _110._0(_211); }), undefined, true); } else if (_8 === 4) { new Quiet.Quiet()[Symbol.dispose](); new Loud.Loud()[Symbol.dispose](); loud(); new Loud.Loud()[Symbol.dispose](); - const v: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_210: rs.u8): Loud.Loud => { + const v: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_28: rs.u8): Loud.Loud => { return new Loud.Loud(); }), undefined, 0, true); rs.byteVecPush(out, v.items.length & 0xff); @@ -141,7 +148,7 @@ export function zeros(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.atomicLoad(LOG, 0))), undefined, true); } else if (_8 === 5) { const v2: rs.Vec = rs.vecWithCapacity(n, 0); - const _154: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_28: rs.u8): undefined => {}); + const _154: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_27: rs.u8): undefined => {}); rs.iterExtend(v2, _154, undefined, 0, true); rs.byteVecPush(out, rs.vecFromElem({}, n, undefined).items.length & 0xff); rs.byteVecPush(out, v2.items.length & 0xff); @@ -160,27 +167,27 @@ export function zeros(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }), n)) & 0xff); let captured = n; rs.iterExtendBytes(out, rs.iterFromFn((): rs.u8 | undefined => { - const _22: rs.usize | undefined = rs.usizeCheckedSub(captured, 1); - if (_22 !== undefined) { - captured = _22; + const _2: rs.usize | undefined = rs.usizeCheckedSub(captured, 1); + if (_2 !== undefined) { + captured = _2; return captured & 0xff; } return undefined; }), "next"); rs.iterEmpty(); - rs.byteVecPush(out, rs.iterMap(rs.iterEmpty() as rs.Iter, (b2: rs.u8): rs.u8 => { - return rs.u8Add(b2, 1); + rs.byteVecPush(out, rs.iterMap(rs.iterEmpty() as rs.Iter, (b: rs.u8): rs.u8 => { + return rs.u8Add(b, 1); }).sizeHint()[0] & 0xff); - rs.byteVecPush(out, rs.iterCount(rs.iterMap(rs.iterEmpty() as rs.Iter, (b3: rs.u8): rs.u8 => { - return rs.u8Add(b3, 1); + rs.byteVecPush(out, rs.iterCount(rs.iterMap(rs.iterEmpty() as rs.Iter, (b2: rs.u8): rs.u8 => { + return rs.u8Add(b2, 1); })) & 0xff); rs.iterEmpty(); rs.iterEmpty() as rs.Iter; rs.iterRev(rs.iterEmpty() as rs.Iter); - rs.iterFilter(rs.iterRev(rs.iterEmpty() as rs.Iter), (_23: rs.u8): boolean => { + rs.iterFilter(rs.iterRev(rs.iterEmpty() as rs.Iter), (_22: rs.u8): boolean => { return true; }); - rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterRev(rs.iterEmpty() as rs.Iter), (_27: rs.u8): boolean => { + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterRev(rs.iterEmpty() as rs.Iter), (_23: rs.u8): boolean => { return true; })) & 0xff); } @@ -437,6 +444,7 @@ export function unitEq(_u: undefined, n: rs.u8): rs.u8 { /** `n` if `p`, reassigned, equals another `PhantomData`, which it always does. */ export function rewritten(_1: undefined, n: rs.u8): rs.u8 { + _1 = undefined; if (false) { return 0; } @@ -522,16 +530,21 @@ export function writes(kind: rs.u8, _dataData: Uint8Array, _dataStart: number, d rs.byteVecPush(out, (true ? 1 : 0) | ((n << 1) & 0xff)); } else if (_9 === 1) { rs.byteVecPush(out, true ? 1 : 0); + const _53: Unit.Unit = {}; unit(); Unit.default$Default(); - rs.byteVecPush(out, (Unit.eq$cmp_PartialEq({}, Unit.default$Default()) ? 1 : 0) | ((n << 1) & 0xff)); - rs.byteVecPush(out, Defaulted.eq$cmp_PartialEq({}, Defaulted.default$Default()) ? 1 : 0); + const _60: Unit.Unit = Unit.default$Default(); + rs.byteVecPush(out, (Unit.eq$cmp_PartialEq(_53, _60) ? 1 : 0) | ((n << 1) & 0xff)); + const _71: Defaulted.Defaulted = {}; + const _72: Defaulted.Defaulted = Defaulted.default$Default(); + rs.byteVecPush(out, Defaulted.eq$cmp_PartialEq(_71, _72) ? 1 : 0); } else if (_9 === 2) { raw(1); raw(2); raw(3); raw(4); - const q: Unit.Unit = {}; + const _92: Unit.Unit = {}; + const q: Unit.Unit = _92; unit(); const _96: Unit.Unit = {}; rs.byteVecPush(out, (Unit.eq$cmp_PartialEq(q, _96) ? 1 : 0) | ((n << 1) & 0xff)); @@ -540,7 +553,9 @@ export function writes(kind: rs.u8, _dataData: Uint8Array, _dataStart: number, d rs.cellReplace(_113, undefined); rs.cellReplace(_113, undefined); rs.cellSet(_113, undefined); - const units: rs.Slice = rs.sliceFrom([undefined, undefined, undefined]); + const units: rs.Slice = rs.sliceFrom(Array.from({ length: 3 }, (): undefined => { + return undefined; + })); rs.sliceSwap(units, 0, n as rs.usize); const v: rs.Vec = rs.vecFromElem({}, 2, undefined); rs.sliceSwap(rs.sliceFrom(v.items), 0, 1); diff --git a/ts/fixtures/model/expected/harness.ts b/ts/fixtures/model/expected/harness.ts index 130938510..2bbdca727 100644 --- a/ts/fixtures/model/expected/harness.ts +++ b/ts/fixtures/model/expected/harness.ts @@ -104,11 +104,10 @@ export function putResult$moq_net_Timescale_harness_conversions_closure0(out: rs rs.byteVecPush(out, 1); ok(out, value); } else { + const _10: TimeOverflow.TimeOverflow = {}; rs.byteVecPush(out, 0); - const arg = {}; - putText(out, rs.fmtToString((f: rs.Formatter) => TimeOverflow.fmt$fmt_Display(arg, f))); - const arg2 = {}; - putText(out, rs.fmtFormat([(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(arg2, f)])); + putText(out, rs.fmtToString((f: rs.Formatter) => TimeOverflow.fmt$fmt_Display(_10, f))); + putText(out, rs.fmtFormat([(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(_10, f)])); } } @@ -119,11 +118,10 @@ export function putResult$moq_net_Timescale_harness_timescales_closure0(out: rs. rs.byteVecPush(out, 1); ok(out, value); } else { + const _10: TimeOverflow.TimeOverflow = {}; rs.byteVecPush(out, 0); - const arg = {}; - putText(out, rs.fmtToString((f: rs.Formatter) => TimeOverflow.fmt$fmt_Display(arg, f))); - const arg2 = {}; - putText(out, rs.fmtFormat([(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(arg2, f)])); + putText(out, rs.fmtToString((f: rs.Formatter) => TimeOverflow.fmt$fmt_Display(_10, f))); + putText(out, rs.fmtFormat([(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(_10, f)])); } } @@ -134,11 +132,10 @@ export function putResult$moq_net_Timescale_harness_timescales_closure1(out: rs. rs.byteVecPush(out, 1); ok(out, value); } else { + const _10: TimeOverflow.TimeOverflow = {}; rs.byteVecPush(out, 0); - const arg = {}; - putText(out, rs.fmtToString((f: rs.Formatter) => TimeOverflow.fmt$fmt_Display(arg, f))); - const arg2 = {}; - putText(out, rs.fmtFormat([(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(arg2, f)])); + putText(out, rs.fmtToString((f: rs.Formatter) => TimeOverflow.fmt$fmt_Display(_10, f))); + putText(out, rs.fmtFormat([(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(_10, f)])); } } @@ -149,11 +146,10 @@ export function putResult$moq_net_Timescale_harness_timescales_closure2(out: rs. rs.byteVecPush(out, 1); ok(out, value); } else { + const _10: TimeOverflow.TimeOverflow = {}; rs.byteVecPush(out, 0); - const arg = {}; - putText(out, rs.fmtToString((f: rs.Formatter) => TimeOverflow.fmt$fmt_Display(arg, f))); - const arg2 = {}; - putText(out, rs.fmtFormat([(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(arg2, f)])); + putText(out, rs.fmtToString((f: rs.Formatter) => TimeOverflow.fmt$fmt_Display(_10, f))); + putText(out, rs.fmtFormat([(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(_10, f)])); } } @@ -164,11 +160,10 @@ export function putResult$moq_net_Timestamp_harness_durations_closure0(out: rs.B rs.byteVecPush(out, 1); ok(out, value); } else { + const _10: TimeOverflow.TimeOverflow = {}; rs.byteVecPush(out, 0); - const arg = {}; - putText(out, rs.fmtToString((f: rs.Formatter) => TimeOverflow.fmt$fmt_Display(arg, f))); - const arg2 = {}; - putText(out, rs.fmtFormat([(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(arg2, f)])); + putText(out, rs.fmtToString((f: rs.Formatter) => TimeOverflow.fmt$fmt_Display(_10, f))); + putText(out, rs.fmtFormat([(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(_10, f)])); } } @@ -179,11 +174,10 @@ export function putResult$moq_net_Timestamp_harness_put_timestamp(out: rs.ByteVe rs.byteVecPush(out, 1); putTimestamp(out, value); } else { + const _10: TimeOverflow.TimeOverflow = {}; rs.byteVecPush(out, 0); - const arg = {}; - putText(out, rs.fmtToString((f: rs.Formatter) => TimeOverflow.fmt$fmt_Display(arg, f))); - const arg2 = {}; - putText(out, rs.fmtFormat([(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(arg2, f)])); + putText(out, rs.fmtToString((f: rs.Formatter) => TimeOverflow.fmt$fmt_Display(_10, f))); + putText(out, rs.fmtFormat([(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(_10, f)])); } } diff --git a/ts/fixtures/stock/expected/buf.ts b/ts/fixtures/stock/expected/buf.ts index 4327589b5..6f40394d3 100644 --- a/ts/fixtures/stock/expected/buf.ts +++ b/ts/fixtures/stock/expected/buf.ts @@ -2356,9 +2356,6 @@ export function far(dataData: Uint8Array, dataStart: number, dataLen: number, ou * no other handle holds it, and the `Bytes` taken back takes it only then too. */ export function reclaims(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - const _60: (a0: rs.BytesMut, a1: rs.ByteVec) => undefined = (buf2: rs.BytesMut, out2: rs.ByteVec): undefined => { - rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u32ToBeBytes(buf2.cap as rs.u32).reverse())); - }; if (dataLen === 4) { const cap: rs.u8 = dataData[dataStart]; const kept: rs.u8 = dataData[dataStart + 1]; @@ -2390,6 +2387,9 @@ export function reclaims(dataData: Uint8Array, dataStart: number, dataLen: numbe clone = undefined; lib_drop$Option_bytes_Bytes(taken3); } + const _60: (a0: rs.BytesMut, a1: rs.ByteVec) => undefined = (buf2: rs.BytesMut, out2: rs.ByteVec): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u32ToBeBytes(buf2.cap as rs.u32).reverse())); + }; rs.byteVecPush(out, rs.bytesMutTryReclaim(buf, add2) ? 1 : 0); _60(buf, out); rs.bytesMutReserve(buf, rs.usizeMul(add2, 2)); @@ -3561,10 +3561,11 @@ export function chunkWrite(chunk: rs.ByteSlice, op: rs.u8, n: rs.u8, out: rs.Byt while (true) { const _28: [rs.usize, rs.u8] | rs.Done = iter.next(); if (_28 === rs.DONE) { - break b1; + break; } UninitSlice.writeByte(chunk, _28[0], _28[1]); } + break b1; } if (_20 === 1) { UninitSlice.copyFromSlice(UninitSlice.indexMut$ops_IndexMut_ops_RangeTo_usize(chunk, { end: k }, { file: "fixtures/stock/src/buf.rs", line: 702, col: 19 }), rs.byteVecSlice(src)); diff --git a/ts/fixtures/stock/expected/maps.ts b/ts/fixtures/stock/expected/maps.ts index 5d9fbff43..6218ba96b 100644 --- a/ts/fixtures/stock/expected/maps.ts +++ b/ts/fixtures/stock/expected/maps.ts @@ -290,66 +290,63 @@ export function numbers(n: rs.HashTable, kind: rs.u8, op: rs.u8, key: rs const rehash: (a0: rs.u32) => rs.u64 = (e6: rs.u32): rs.u64 => { return hash(kind, (e6 >>> 16) & 0xffff); }; - b0: { - const _12: rs.u8 = rs.u8Rem(op, 6); - if (_12 === 0) { - const drops: rs.Cell = new rs.Cell(0); - const held: maps_Counted.Counted = new maps_Counted.Counted(drops); - const _18: rs.TableEntry = rs.tableEntry(n, h, ours, rehash); - const captured = held; - const e: rs.TableEntry = rs.tableAndModifyMut(_18, rs.closure((e8: rs.Place): undefined => { - e8.v = rs.u32Add(e8.v, rs.u32Add(1, captured._0.v)); - captured[Symbol.dispose](); - }, (): void => { - captured[Symbol.dispose](); - }), rs.drop); - put(out, drops.v as rs.usize); - put(out, rs.tableOrInsert(e, ((key as rs.u32) << 16) >>> 0).v as rs.usize); - } else if (_12 === 1) { - const _34: rs.Place | undefined = rs.tableFindMut(n, h, ours); - if (_34 === undefined) { - put(out, rs.tableInsertUnique(n, h, ((key as rs.u32) << 16) >>> 0, rehash).v as rs.usize); - } else { - _34.v = rs.u32Add(_34.v, 2); - } - } else if (_12 === 2) { - const _46: rs.Result, rs.TableEntry> = rs.tableFindEntry(n, h, ours); - if (_46.ok) { - const e2: rs.TableEntry = _46.value; - const _49: rs.Place = e2; - _49.v = rs.u32Add(_49.v, 3); - const e3: rs.Place = e2; - e3.v = rs.u32Add(e3.v, 4); - } - } else if (_12 === 3) { - rs.tableRetainMut(n, (e7: rs.Place): boolean => { - e7.v = rs.u32Add(e7.v, 5); - return ((e7.v & 255) >>> 0) < 200; - }); + const _12: rs.u8 = rs.u8Rem(op, 6); + if (_12 === 0) { + const drops: rs.Cell = new rs.Cell(0); + const held: maps_Counted.Counted = new maps_Counted.Counted(drops); + const _18: rs.TableEntry = rs.tableEntry(n, h, ours, rehash); + const captured = held; + const e: rs.TableEntry = rs.tableAndModifyMut(_18, rs.closure((e8: rs.Place): undefined => { + e8.v = rs.u32Add(e8.v, rs.u32Add(1, captured._0.v)); + captured[Symbol.dispose](); + }, (): void => { + captured[Symbol.dispose](); + }), rs.drop); + put(out, drops.v as rs.usize); + put(out, rs.tableOrInsert(e, ((key as rs.u32) << 16) >>> 0).v as rs.usize); + } else if (_12 === 1) { + const _34: rs.Place | undefined = rs.tableFindMut(n, h, ours); + if (_34 === undefined) { + put(out, rs.tableInsertUnique(n, h, ((key as rs.u32) << 16) >>> 0, rehash).v as rs.usize); } else { - if (_12 === 4) { - const iter: rs.Iter> = rs.hashValuesMut(n); - while (true) { - const _58: rs.Place | rs.Done = iter.next(); - if (_58 === rs.DONE) { - break; - } - _58.v = (_58.v ^ 1) >>> 0; - } - const iter2: rs.Iter> = rs.hashValuesMut(n); - while (true) { - const _64: rs.Place | rs.Done = iter2.next(); - if (_64 === rs.DONE) { - break b0; - } - _64.v = rs.u32Add(_64.v, 1); - } + _34.v = rs.u32Add(_34.v, 2); + } + } else if (_12 === 2) { + const _46: rs.Result, rs.TableEntry> = rs.tableFindEntry(n, h, ours); + if (_46.ok) { + const e2: rs.TableEntry = _46.value; + const _49: rs.Place = e2; + _49.v = rs.u32Add(_49.v, 3); + const e3: rs.Place = e2; + e3.v = rs.u32Add(e3.v, 4); + } + } else if (_12 === 3) { + rs.tableRetainMut(n, (e7: rs.Place): boolean => { + e7.v = rs.u32Add(e7.v, 5); + return ((e7.v & 255) >>> 0) < 200; + }); + } else if (_12 === 4) { + const iter: rs.Iter> = rs.hashValuesMut(n); + while (true) { + const _58: rs.Place | rs.Done = iter.next(); + if (_58 === rs.DONE) { + break; } - const _69: rs.TableEntry = rs.tableEntry(n, h, ours, rehash); - if (rs.tableOccupied(_69)) { - const _72: rs.Place = _69; - _72.v = rs.u32Add(_72.v, 6); + _58.v = (_58.v ^ 1) >>> 0; + } + const iter2: rs.Iter> = rs.hashValuesMut(n); + while (true) { + const _64: rs.Place | rs.Done = iter2.next(); + if (_64 === rs.DONE) { + break; } + _64.v = rs.u32Add(_64.v, 1); + } + } else { + const _69: rs.TableEntry = rs.tableEntry(n, h, ours, rehash); + if (rs.tableOccupied(_69)) { + const _72: rs.Place = _69; + _72.v = rs.u32Add(_72.v, 6); } } const items: rs.Vec = rs.iterToVec(rs.hashValues(n), "next", 4); @@ -969,9 +966,6 @@ export function ends$hashlink_linked_hash_map_Values_u16_u32_maps_linked_iters_c export function linkedIters(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let _15!: rs.u16; let it!: ValuesMut.ValuesMut; - const _34: (a0: [rs.u16, rs.u32]) => rs.usize = (_2: [rs.u16, rs.u32]): rs.usize => { - return rs.usizeAdd(rs.usizeMul(_2[0] as rs.usize, 4096), _2[1] as rs.usize); - }; let _104: boolean = false; if (dataLen >= 2) { const m: LinkedHashMap.LinkedHashMap = LinkedHashMap.withHasher$u16_u32_hash_RandomState(rs.randomState()); @@ -985,6 +979,9 @@ export function linkedIters(dataData: Uint8Array, dataStart: number, dataLen: nu } const k: rs.usize = rs.u8Shr(dataData[dataStart + 1], 3) as rs.usize; const _35: rs.u8 = rs.u8Rem(dataData[dataStart + 1], 8); + const _34: (a0: [rs.u16, rs.u32]) => rs.usize = (_2: [rs.u16, rs.u32]): rs.usize => { + return rs.usizeAdd(rs.usizeMul(_2[0] as rs.usize, 4096), _2[1] as rs.usize); + }; if (_35 === 0) { ends$hashlink_linked_hash_map_Iter_u16_u32_maps_linked_iters_closure0(LinkedHashMap.iter$u16_u32_hash_RandomState(m), new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2), out, (_215: [rs.u16, rs.u32]): rs.usize => { return rs.usizeAdd(rs.usizeMul(_215[0] as rs.usize, 4096), _215[1] as rs.usize); @@ -1256,47 +1253,47 @@ export function ownFromIter(data: rs.ByteSlice, out: rs.ByteVec): void { * last, or of one byte flipped. */ export function equal(data: rs.ByteSlice, out: rs.ByteVec): void { - const _22: (a0: rs.ByteSlice) => rs.HashMap = (bytes: rs.ByteSlice): rs.HashMap => { - const _3: rs.Iter<[rs.u16, rs.u32]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_2: rs.u8): [rs.u16, rs.u32] => { - const b: rs.u8 = _2; - return [rs.u8Rem(b, 8) as rs.u16, b as rs.u32] as [rs.u16, rs.u32]; - }); - return rs.hashExtend(rs.hashNew() as rs.HashMap, _3, undefined, undefined, undefined, 117440512); - }; const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const reversed: rs.ByteVec = rs.iterToByteVec(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), undefined, true); - const flipped: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_23: [rs.usize, rs.u8]): rs.u8 => { - const i: rs.usize = _23[0]; - const b2: rs.u8 = _23[1]; + const flipped: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_2: [rs.usize, rs.u8]): rs.u8 => { + const i: rs.usize = _2[0]; + const b: rs.u8 = _2[1]; if (!(i === rs.usizeDiv(data.length, 2))) { - return b2; + return b; } - return b2 ^ 33; + return b ^ 33; }), undefined, true); const shorter: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.usizeSaturatingSub(data.length, 1)); - const pairs: (a0: rs.u8, a1: rs.ByteSlice) => rs.HashMap<[rs.u8, boolean], rs.u8> = (seed: rs.u8, bytes2: rs.ByteSlice): rs.HashMap<[rs.u8, boolean], rs.u8> => { - const _54: Seeded.Seeded = new Seeded.Seeded(seed, log); - const m: rs.HashMap<[rs.u8, boolean], rs.u8> = rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same])), _54) as rs.HashMap<[rs.u8, boolean], rs.u8>; - const iterS: Uint8Array = rs.byteSliceView(bytes2); + const pairs: (a0: rs.u8, a1: rs.ByteSlice) => rs.HashMap<[rs.u8, boolean], rs.u8> = (seed: rs.u8, bytes: rs.ByteSlice): rs.HashMap<[rs.u8, boolean], rs.u8> => { + const _53: Seeded.Seeded = new Seeded.Seeded(seed, log); + const m: rs.HashMap<[rs.u8, boolean], rs.u8> = rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same])), _53) as rs.HashMap<[rs.u8, boolean], rs.u8>; + const iterS: Uint8Array = rs.byteSliceView(bytes); let iterI: number = 0; while (true) { const _83: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; if (_83 === rs.DONE) { return m; } - const b3: rs.u8 = _83; - const _142: [rs.u8, boolean] = [rs.u8Rem(b3, 8), rs.u8Rem(b3, 3) === 0]; - rs.hashInsert(m, _142, b3 >> 5); + const b2: rs.u8 = _83; + const _142: [rs.u8, boolean] = [rs.u8Rem(b2, 8), rs.u8Rem(b2, 3) === 0]; + rs.hashInsert(m, _142, b2 >> 5); } }; - const keys: (a0: rs.u8, a1: rs.ByteSlice) => rs.HashSet = (seed2: rs.u8, bytes3: rs.ByteSlice): rs.HashSet => { + const keys: (a0: rs.u8, a1: rs.ByteSlice) => rs.HashSet = (seed2: rs.u8, bytes2: rs.ByteSlice): rs.HashSet => { const s: rs.HashSet = rs.hashNew(undefined, new Seeded.Seeded(seed2, log)) as rs.HashSet; - const _84: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes3)), (b4: rs.u8): rs.u8 => { - return rs.u8Rem(b4, 16); + const _84: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes2)), (b3: rs.u8): rs.u8 => { + return rs.u8Rem(b3, 16); }); rs.hashExtendKeys(s, _84, undefined, undefined, 469762048); return s; }; + const _22: (a0: rs.ByteSlice) => rs.HashMap = (bytes3: rs.ByteSlice): rs.HashMap => { + const _3: rs.Iter<[rs.u16, rs.u32]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes3)), (_23: rs.u8): [rs.u16, rs.u32] => { + const b4: rs.u8 = _23; + return [rs.u8Rem(b4, 8) as rs.u16, b4 as rs.u32] as [rs.u16, rs.u32]; + }); + return rs.hashExtend(rs.hashNew() as rs.HashMap, _3, undefined, undefined, undefined, 117440512); + }; const _26: [rs.HashMap<[rs.u8, boolean], rs.u8>, rs.HashSet, rs.HashMap] = [pairs(1, data), keys(1, data), _22(data)]; const left: rs.HashMap<[rs.u8, boolean], rs.u8> = _26[0]; const set: rs.HashSet = _26[1]; diff --git a/ts/fixtures/stock/expected/smallvec.CollectionAllocErr.ts b/ts/fixtures/stock/expected/smallvec.CollectionAllocErr.ts index c0e464dfe..c8122f60f 100644 --- a/ts/fixtures/stock/expected/smallvec.CollectionAllocErr.ts +++ b/ts/fixtures/stock/expected/smallvec.CollectionAllocErr.ts @@ -6,10 +6,7 @@ export function fmt$fmt_Debug(self: CollectionAllocErr, f: rs.Formatter): rs.Res if (self.tag === "CapacityOverflow") { return rs.fmtWriteStr(f, "CapacityOverflow"); } - const _6: string = "AllocErr"; - const _7: string = "layout"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtLayoutDebug(self.layout, f); - return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _6), _7, _8)); + return rs.fmtDebugFields(f, "AllocErr layout", [(f: rs.Formatter) => rs.fmtLayoutDebug(self.layout, f)]); } /** Error type for APIs with fallible heap allocation */ diff --git a/ts/fixtures/task/expected/drops.ts b/ts/fixtures/task/expected/drops.ts index 19bc6053f..f8563c97b 100644 --- a/ts/fixtures/task/expected/drops.ts +++ b/ts/fixtures/task/expected/drops.ts @@ -800,20 +800,15 @@ export function options(log: Log.Log, id: rs.u32): void { * value once, where Rust drops it. */ export function elements(log: Log.Log, id: rs.u32): void { - const _7: (a0: Guard.Guard | undefined) => rs.u32 | undefined = (o3: Guard.Guard | undefined): rs.u32 | undefined => { - return option_map$02u0dmi(o3, Guard.id); - }; - const _348: (a0: Key.Key | undefined) => rs.u32 | undefined = (o4: Key.Key | undefined): rs.u32 | undefined => { - return option_map$0bmexgo(o4, (k: Key.Key): rs.u32 => { - return k.id; - }); - }; const guard: (a0: rs.u32) => Guard.Guard = (n: rs.u32): Guard.Guard => { return Guard.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; const key: (a0: rs.u32) => Key.Key = (n2: rs.u32): Key.Key => { return Key.new(rs.u32Add(id, n2), Log.clone$Clone(log)); }; + const _7: (a0: Guard.Guard | undefined) => rs.u32 | undefined = (o3: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o3, Guard.id); + }; const v2: rs.Vec = new rs.Vec(); const _12: Guard.Guard | undefined = guard(1); v2.items.push(_12); @@ -822,19 +817,19 @@ export function elements(log: Log.Log, id: rs.u32): void { v2.items.push(_21); v2.items.push(undefined as Guard.Guard | undefined); const v: rs.Vec = v2; - const _34: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.sliceFirst(rs.sliceFrom(v.items), rs.None), (o5: Guard.Guard | undefined): rs.u32 | undefined => { - return option_map$02u0dmi(o5, Guard.id); + const _34: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.sliceFirst(rs.sliceFrom(v.items), rs.None), (o4: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o4, Guard.id); }); - const _39: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.sliceLast(rs.sliceFrom(v.items), rs.None), (o6: Guard.Guard | undefined): rs.u32 | undefined => { - return option_map$02u0dmi(o6, Guard.id); + const _39: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.sliceLast(rs.sliceFrom(v.items), rs.None), (o5: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o5, Guard.id); }); const args51 = [(f: rs.Formatter) => rs.fmtOption(_34, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_39, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; Log.note(log, rs.fmtFormat(["vec ", args51[0], " ", args51[1]])); - const _54: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.sliceGet(rs.sliceFrom(v.items), 1, rs.None), (o7: Guard.Guard | undefined): rs.u32 | undefined => { - return option_map$02u0dmi(o7, Guard.id); + const _54: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.sliceGet(rs.sliceFrom(v.items), 1, rs.None), (o6: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o6, Guard.id); }); - const _59: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.sliceGet(rs.sliceFrom(v.items), 4, rs.None), (o8: Guard.Guard | undefined): rs.u32 | undefined => { - return option_map$02u0dmi(o8, Guard.id); + const _59: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.sliceGet(rs.sliceFrom(v.items), 4, rs.None), (o7: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o7, Guard.id); }); const args52 = [(f: rs.Formatter) => rs.fmtOption(_54, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_59, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; Log.note(log, rs.fmtFormat(["get ", args52[0], " ", args52[1]])); @@ -849,20 +844,20 @@ export function elements(log: Log.Log, id: rs.u32): void { rs.drop(_77.v); _77.v = undefined; } - const kept: Guard.Guard | undefined | rs.None = rs.vecPopIfMut(v, (o9: rs.Place): boolean => { - rs.drop(o9.v); - o9.v = undefined; + const kept: Guard.Guard | undefined | rs.None = rs.vecPopIfMut(v, (o8: rs.Place): boolean => { + rs.drop(o8.v); + o8.v = undefined; return false; }, undefined, rs.None); - const taken: Guard.Guard | undefined | rs.None = rs.vecPopIfMut(v, (o10: rs.Place): boolean => { - const _318: Guard.Guard | undefined = guard(12); - rs.drop(o10.v); - o10.v = _318; + const taken: Guard.Guard | undefined | rs.None = rs.vecPopIfMut(v, (o9: rs.Place): boolean => { + const _314: Guard.Guard | undefined = guard(12); + rs.drop(o9.v); + o9.v = _314; return true; }, undefined, rs.None); const _95: boolean = kept !== rs.None; - const _98: rs.u32 | undefined | rs.None = option_map$1x5kkz1(taken, (o11: Guard.Guard | undefined): rs.u32 | undefined => { - return option_map$02u0dmi(o11, Guard.id); + const _98: rs.u32 | undefined | rs.None = option_map$1x5kkz1(taken, (o10: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o10, Guard.id); }); const args53 = [(f: rs.Formatter) => rs.fmtBool(_95, f), (f: rs.Formatter) => rs.fmtOption(_98, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; Log.note(log, rs.fmtFormat(["pop_if ", args53[0], " ", args53[1]])); @@ -878,17 +873,17 @@ export function elements(log: Log.Log, id: rs.u32): void { break; } } - const part4 = option_map$1x5kkz1(rs.vecPop(v, rs.None), (o12: Guard.Guard | undefined): rs.u32 | undefined => { - const _011: rs.u32 | undefined = _7(o12); - rs.drop(o12); - return _011; + const part4 = option_map$1x5kkz1(rs.vecPop(v, rs.None), (o11: Guard.Guard | undefined): rs.u32 | undefined => { + const _09: rs.u32 | undefined = _7(o11); + rs.drop(o11); + return _09; }); Log.note(log, rs.fmtFormat(["popped ", (f: rs.Formatter) => rs.fmtOption(part4, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)])); const captured = guard(14); const _151: Guard.Guard | undefined | rs.None = rs.vecPopIfMut(v, rs.closure((_2: rs.Place): boolean => { - const _012: boolean = Guard.id(captured) > 0; + const _010: boolean = Guard.id(captured) > 0; captured[Symbol.dispose](); - return _012; + return _010; }, (): void => { captured[Symbol.dispose](); }), rs.drop, rs.None); @@ -898,18 +893,18 @@ export function elements(log: Log.Log, id: rs.u32): void { Log.note(log, _145); v.items.push(undefined as Guard.Guard | undefined); const captured2 = guard(15); - const part8 = option_map$1x5kkz1(rs.vecPopIfMut(v, rs.closure((o13: rs.Place): boolean => { + const part8 = option_map$1x5kkz1(rs.vecPopIfMut(v, rs.closure((o12: rs.Place): boolean => { const part6 = Guard.id(captured2); Log.note(log, rs.fmtFormat(["test ", (f: rs.Formatter) => rs.u32Display(part6, f)])); - const _013: boolean = o13.v === undefined; + const _011: boolean = o12.v === undefined; captured2[Symbol.dispose](); - return _013; + return _011; }, (): void => { captured2[Symbol.dispose](); - }), rs.drop, rs.None), (o14: Guard.Guard | undefined): rs.u32 | undefined => { - const _014: rs.u32 | undefined = _7(o14); - rs.drop(o14); - return _014; + }), rs.drop, rs.None), (o13: Guard.Guard | undefined): rs.u32 | undefined => { + const _012: rs.u32 | undefined = _7(o13); + rs.drop(o13); + return _012; }); Log.note(log, rs.fmtFormat(["called ", (f: rs.Formatter) => rs.fmtOption(part8, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)])); const q: rs.VecDeque = rs.dequeNew(8) as rs.VecDeque; @@ -919,15 +914,15 @@ export function elements(log: Log.Log, id: rs.u32): void { const _192: Guard.Guard | undefined = guard(5); rs.dequePushFront(q, _192); rs.dequePushBack(q, undefined as Guard.Guard | undefined); - const _205: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequeEnd(q, false, rs.None), (o15: Guard.Guard | undefined): rs.u32 | undefined => { + const _205: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequeEnd(q, false, rs.None), (o14: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o14, Guard.id); + }); + const _209: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequeEnd(q, true, rs.None), (o15: Guard.Guard | undefined): rs.u32 | undefined => { return option_map$02u0dmi(o15, Guard.id); }); - const _209: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequeEnd(q, true, rs.None), (o16: Guard.Guard | undefined): rs.u32 | undefined => { + const _213: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequeGet(q, 4, rs.None), (o16: Guard.Guard | undefined): rs.u32 | undefined => { return option_map$02u0dmi(o16, Guard.id); }); - const _213: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequeGet(q, 4, rs.None), (o17: Guard.Guard | undefined): rs.u32 | undefined => { - return option_map$02u0dmi(o17, Guard.id); - }); const args61 = [(f: rs.Formatter) => rs.fmtOption(_205, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_209, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_213, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; Log.note(log, rs.fmtFormat(["deque ", args61[0], " ", args61[1], " ", args61[2]])); const _222: rs.Place | undefined = rs.dequeEndMut(q); @@ -936,13 +931,13 @@ export function elements(log: Log.Log, id: rs.u32): void { _222.v = undefined; } const removed: Guard.Guard | undefined | rs.None = rs.dequeRemove(q, 2, rs.None); - const _235: rs.u32 | undefined | rs.None = option_map$1x5kkz1(removed, (o18: Guard.Guard | undefined): rs.u32 | undefined => { - return option_map$02u0dmi(o18, Guard.id); + const _235: rs.u32 | undefined | rs.None = option_map$1x5kkz1(removed, (o17: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o17, Guard.id); }); - const _239: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequeRemove(q, 3, rs.None), (o19: Guard.Guard | undefined): rs.u32 | undefined => { - const _019: rs.u32 | undefined = _7(o19); - rs.drop(o19); - return _019; + const _239: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequeRemove(q, 3, rs.None), (o18: Guard.Guard | undefined): rs.u32 | undefined => { + const _017: rs.u32 | undefined = _7(o18); + rs.drop(o18); + return _017; }); const args62 = [(f: rs.Formatter) => rs.fmtOption(_235, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_239, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; Log.note(log, rs.fmtFormat(["remove ", args62[0], " ", args62[1]])); @@ -953,25 +948,25 @@ export function elements(log: Log.Log, id: rs.u32): void { rs.dequePushBack(q, _258); rs.dequePushFront(q, undefined as Guard.Guard | undefined); const back: Guard.Guard | undefined | rs.None = rs.dequeSwapRemove(q, 0, true, rs.None); - const _273: rs.u32 | undefined | rs.None = option_map$1x5kkz1(back, (o20: Guard.Guard | undefined): rs.u32 | undefined => { - return option_map$02u0dmi(o20, Guard.id); + const _273: rs.u32 | undefined | rs.None = option_map$1x5kkz1(back, (o19: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o19, Guard.id); }); - const _277: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequeSwapRemove(q, 9, false, rs.None), (o21: Guard.Guard | undefined): rs.u32 | undefined => { - const _021: rs.u32 | undefined = _7(o21); - rs.drop(o21); - return _021; + const _277: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequeSwapRemove(q, 9, false, rs.None), (o20: Guard.Guard | undefined): rs.u32 | undefined => { + const _019: rs.u32 | undefined = _7(o20); + rs.drop(o20); + return _019; }); - const _283: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequeSwapRemove(q, 1, false, rs.None), (o22: Guard.Guard | undefined): rs.u32 | undefined => { - const _022: rs.u32 | undefined = _7(o22); - rs.drop(o22); - return _022; + const _283: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequeSwapRemove(q, 1, false, rs.None), (o21: Guard.Guard | undefined): rs.u32 | undefined => { + const _020: rs.u32 | undefined = _7(o21); + rs.drop(o21); + return _020; }); const args63 = [(f: rs.Formatter) => rs.fmtOption(_273, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_277, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_283, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; Log.note(log, rs.fmtFormat(["swap_remove ", args63[0], " ", args63[1], " ", args63[2]])); rs.drop(back); const front: Guard.Guard | undefined | rs.None = rs.dequePopFront(q, rs.None); - const part12 = option_map$1x5kkz1(front, (o23: Guard.Guard | undefined): rs.u32 | undefined => { - return option_map$02u0dmi(o23, Guard.id); + const part12 = option_map$1x5kkz1(front, (o22: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o22, Guard.id); }); Log.note(log, rs.fmtFormat(["front ", (f: rs.Formatter) => rs.fmtOption(part12, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)])); while (true) { @@ -985,18 +980,23 @@ export function elements(log: Log.Log, id: rs.u32): void { break; } } - const _334: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequePopFront(q, rs.None), (o24: Guard.Guard | undefined): rs.u32 | undefined => { - const _024: rs.u32 | undefined = _7(o24); - rs.drop(o24); - return _024; + const _334: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequePopFront(q, rs.None), (o23: Guard.Guard | undefined): rs.u32 | undefined => { + const _022: rs.u32 | undefined = _7(o23); + rs.drop(o23); + return _022; }); - const _340: rs.u32 | undefined | rs.None = option_map$1x5kkz1(front, (o25: Guard.Guard | undefined): rs.u32 | undefined => { - const _025: rs.u32 | undefined = _7(o25); - rs.drop(o25); - return _025; + const _340: rs.u32 | undefined | rs.None = option_map$1x5kkz1(front, (o24: Guard.Guard | undefined): rs.u32 | undefined => { + const _023: rs.u32 | undefined = _7(o24); + rs.drop(o24); + return _023; }); const args66 = [(f: rs.Formatter) => rs.fmtOption(_334, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_340, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; Log.note(log, rs.fmtFormat(["emptied ", args66[0], " ", args66[1]])); + const _348: (a0: Key.Key | undefined) => rs.u32 | undefined = (o25: Key.Key | undefined): rs.u32 | undefined => { + return option_map$0bmexgo(o25, (k: Key.Key): rs.u32 => { + return k.id; + }); + }; const heap: rs.BinaryHeap = rs.heapNew() as rs.BinaryHeap; const _352: Key.Key | undefined = key(7); rs.heapPush(heap, _352, rs.cmpLe(rs.cmpOption(Key.partialCmp$cmp_PartialOrd))); diff --git a/ts/fixtures/task/expected/drops/called.ts b/ts/fixtures/task/expected/drops/called.ts index b4957ec1a..c62bb34d2 100644 --- a/ts/fixtures/task/expected/drops/called.ts +++ b/ts/fixtures/task/expected/drops/called.ts @@ -13,9 +13,6 @@ import * as Guard from "../model.Guard.ts"; export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { let broke!: rs.u32 | undefined; let f!: Guard.Guard; - const _536: () => rs.Iter = (): rs.Iter => { - return rs.vecIntoIter(new rs.Vec(), rs.drop); - }; let _679: boolean = false; let _678: boolean = false; const guard: (a0: rs.u32) => Guard.Guard = (n3: rs.u32): Guard.Guard => { @@ -454,6 +451,9 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { const part5 = rs.refCellReplaceWith(cell2, rs.once(doubled), true); Log.note(log, rs.fmtFormat(["by Fn ", (f: rs.Formatter) => rs.u32Display(part5, f)])); } else if (_17 === 10) { + const _536: () => rs.Iter = (): rs.Iter => { + return rs.vecIntoIter(new rs.Vec(), rs.drop); + }; const _539: rs.Iter = _536(); _679 = false; const captured3 = c; @@ -525,9 +525,9 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { const args61 = [(f: rs.Formatter) => rs.u32Display(_143, f), (f: rs.Formatter) => rs.u32Display(_174, f), (f: rs.Formatter) => rs.fmtPad(f, _205.v)]; rs.panicFmt(["try_fold of g", args61[0], " with g", args61[1], " after\n", args61[2]]); } else { - const _04: rs.u32 | undefined = rs.u32Add(n4, Guard.id(g2)); + const _03: rs.u32 | undefined = rs.u32Add(n4, Guard.id(g2)); g2[Symbol.dispose](); - return _04; + return _03; } }, (): void => { captured2[Symbol.dispose](); diff --git a/ts/fixtures/task/expected/drops/folds.ts b/ts/fixtures/task/expected/drops/folds.ts index 3c450ae3c..854888e42 100644 --- a/ts/fixtures/task/expected/drops/folds.ts +++ b/ts/fixtures/task/expected/drops/folds.ts @@ -1719,13 +1719,6 @@ export function options(log: Log.Log, id: rs.u32): void { * it loses, and the iterator with the closure it holds once it ends, at once if empty. */ export function reducers(log: Log.Log, id: rs.u32): void { - const _41: (a0: Guard.Guard | undefined) => rs.u32 | undefined = (g: Guard.Guard | undefined): rs.u32 | undefined => { - return option_map$06w9waf(g, (g2: Guard.Guard): rs.u32 => { - const _02: rs.u32 = Guard.id(g2); - g2[Symbol.dispose](); - return _02; - }); - }; const guard: (a0: rs.u32) => Guard.Guard = (n: rs.u32): Guard.Guard => { return Guard.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; @@ -1737,12 +1730,12 @@ export function reducers(log: Log.Log, id: rs.u32): void { const d: Guard.Guard = _9[1]; const _18: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); const captured = c; - const most: Guard.Guard | undefined = rs.iterMaxBy(rs.iterMap(_18, rs.closure((g3: Guard.Guard): Guard.Guard => { - const _92: rs.u32 = Guard.id(g3); + const most: Guard.Guard | undefined = rs.iterMaxBy(rs.iterMap(_18, rs.closure((g: Guard.Guard): Guard.Guard => { + const _92: rs.u32 = Guard.id(g); const _122: rs.u32 = Guard.id(captured); const args7 = [(f: rs.Formatter) => rs.u32Display(_92, f), (f: rs.Formatter) => rs.u32Display(_122, f)]; Log.note(log, rs.fmtFormat(["map ", args7[0], " ", args7[1]])); - return g3; + return g; }, (): void => { captured[Symbol.dispose](); })), (a: Guard.Guard, b: Guard.Guard): rs.Ordering => { @@ -1752,7 +1745,7 @@ export function reducers(log: Log.Log, id: rs.u32): void { return rs.cmp(rs.u32Rem(Guard.id(a2), 3), rs.u32Rem(Guard.id(b2), 3)); }, true, rs.drop); const kept: Guard.Guard | undefined = rs.iterReduce(rs.vecIntoIter(guards(1, 4), rs.drop), (a3: Guard.Guard, b3: Guard.Guard): Guard.Guard => { - let _08!: Guard.Guard; + let _06!: Guard.Guard; let _292: boolean = false; let _28: boolean = false; _292 = true; @@ -1763,31 +1756,38 @@ export function reducers(log: Log.Log, id: rs.u32): void { Log.note(log, rs.fmtFormat(["reduce ", args10[0], " ", args10[1]])); if (!(rs.u32Rem(Guard.id(b3), 2) === 0)) { _292 = false; - _08 = a3; + _06 = a3; } else { _28 = false; - _08 = b3; + _06 = b3; } if (_28) { b3[Symbol.dispose](); } if (_292) { a3[Symbol.dispose](); - return _08; + return _06; } - return _08; + return _06; }, true); const _36: rs.Iter = rs.vecIntoIter(guards(4, 4), rs.drop); const captured2 = d; - const none: rs.u32 | undefined = rs.iterReduce(rs.iterMap(_36, rs.closure((g4: Guard.Guard): rs.u32 => { - const _09: rs.u32 = rs.u32Add(Guard.id(g4), Guard.id(captured2)); - g4[Symbol.dispose](); - return _09; + const none: rs.u32 | undefined = rs.iterReduce(rs.iterMap(_36, rs.closure((g2: Guard.Guard): rs.u32 => { + const _07: rs.u32 = rs.u32Add(Guard.id(g2), Guard.id(captured2)); + g2[Symbol.dispose](); + return _07; }, (): void => { captured2[Symbol.dispose](); })), (a4: rs.u32, b4: rs.u32): rs.u32 => { return rs.u32Add(a4, b4); }, true); + const _41: (a0: Guard.Guard | undefined) => rs.u32 | undefined = (g3: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$06w9waf(g3, (g4: Guard.Guard): rs.u32 => { + const _010: rs.u32 = Guard.id(g4); + g4[Symbol.dispose](); + return _010; + }); + }; const _48: rs.u32 | undefined = _41(most); const _52: rs.u32 | undefined = _41(least); const _56: rs.u32 | undefined = _41(kept); diff --git a/ts/fixtures/task/expected/drops/iters.ts b/ts/fixtures/task/expected/drops/iters.ts index 912c224fe..f5b1210e8 100644 --- a/ts/fixtures/task/expected/drops/iters.ts +++ b/ts/fixtures/task/expected/drops/iters.ts @@ -661,11 +661,6 @@ export function extended(log: Log.Log, id: rs.u32): void { * two `TrustedLen` sides of unlike lengths reads neither. */ export function compared(log: Log.Log, id: rs.u32, arg: rs.u8): void { - const _12: (a0: rs.Ordering | undefined) => rs.i8 = (o: rs.Ordering | undefined): rs.i8 => { - return option_mapOr$16nkz0h(o, 9, (o2: rs.Ordering): rs.i8 => { - return o2; - }); - }; let _283: boolean = false; const key: (a0: rs.u32) => Key.Key = (n: rs.u32): Key.Key => { return Key.new(rs.u32Add(id, n), Log.clone$Clone(log)); @@ -683,6 +678,11 @@ export function compared(log: Log.Log, id: rs.u32, arg: rs.u8): void { return guard(_26); }), undefined, 8, true); }; + const _12: (a0: rs.Ordering | undefined) => rs.i8 = (o: rs.Ordering | undefined): rs.i8 => { + return option_mapOr$16nkz0h(o, 9, (o2: rs.Ordering): rs.i8 => { + return o2; + }); + }; const c: Guard.Guard = guard(10); _283 = true; const _16: rs.u8 = rs.u8Rem(arg, 9); diff --git a/ts/fixtures/task/expected/model.Listing.ts b/ts/fixtures/task/expected/model.Listing.ts index 8aa1d2b02..ea204036e 100644 --- a/ts/fixtures/task/expected/model.Listing.ts +++ b/ts/fixtures/task/expected/model.Listing.ts @@ -7,12 +7,7 @@ export function default$Default(): Listing { } export function fmt$fmt_Debug(self: Listing, f: rs.Formatter): rs.Result { - const _3: string = "Listing"; - const _4: string = "last"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(self.last, f, rs.u64Debug); - const _7: string = "listed"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtList(self.listed.items, f, rs.u64Debug); - return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + return rs.fmtDebugFields(f, "Listing last listed", [(f: rs.Formatter) => rs.fmtOption(self.last, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtList(self.listed.items, f, rs.u64Debug)]); } /** What [`front`] lists. */ diff --git a/ts/fixtures/task/expected/model.ts b/ts/fixtures/task/expected/model.ts index a070bb29f..64d5deb62 100644 --- a/ts/fixtures/task/expected/model.ts +++ b/ts/fixtures/task/expected/model.ts @@ -1164,7 +1164,8 @@ export function temporaries(log: Log.Log, id: rs.u32): void { Guard.note(head, "head"); Guard.note(rest[1], "rest"); guard(1090)[Symbol.dispose](); - const part2 = rs.sliceFrom([]).length; + const _87: Guard.Guard[] = []; + const part2 = rs.sliceFrom(_87).length; Log.note(log, rs.fmtFormat(["empty ", (f: rs.Formatter) => rs.usizeDisplay(part2, f)])); const captured = guard(1100); const part3 = rs.closure((): rs.u32 => { diff --git a/ts/fixtures/tokio/expected/log.Item.ts b/ts/fixtures/tokio/expected/log.Item.ts index eba29f389..285cfff56 100644 --- a/ts/fixtures/tokio/expected/log.Item.ts +++ b/ts/fixtures/tokio/expected/log.Item.ts @@ -4,9 +4,7 @@ import * as rs from "./rs.ts"; import { note } from "./log.ts"; export function fmt$fmt_Debug(self: Item, f: rs.Formatter): rs.Result { - const _3: string = "Item"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "Item", [(f: rs.Formatter) => rs.u8Debug(self._0, f)]); } /** A value sent through a channel, which logs as it drops. */ diff --git a/ts/fixtures/tokio/expected/mpsc.ts b/ts/fixtures/tokio/expected/mpsc.ts index b0b146d74..4d1524d36 100644 --- a/ts/fixtures/tokio/expected/mpsc.ts +++ b/ts/fixtures/tokio/expected/mpsc.ts @@ -182,13 +182,13 @@ export function stepRun(s: mpsc_State.State, op: rs.u8, arg: rs.u8): void { const item2: Item.Item = mpsc_State.item(s); _522 = true; const _60: mpsc_Tx.Tx | undefined = mpsc_State.sender(s, arg); - b24: { + b25: { if (_60 !== undefined) { if (_60.tag === "Bounded") { const tx3: rs.MpscSender = _60._0; _522 = false; Executor.spawn$mpsc_step_run_closure4(s.exec, new stepRunFuture$closure4(tx3, arg, item2)); - break b24; + break b25; } } if (_60 !== undefined) { @@ -203,7 +203,7 @@ export function stepRun(s: mpsc_State.State, op: rs.u8, arg: rs.u8): void { const first: Item.Item = mpsc_State.item(s); _524 = true; const _69: mpsc_Tx.Tx | undefined = mpsc_State.sender(s, arg); - b20: { + b21: { if (_69 !== undefined) { if (_69.tag === "Bounded") { const tx4: rs.MpscSender = _69._0; @@ -211,7 +211,7 @@ export function stepRun(s: mpsc_State.State, op: rs.u8, arg: rs.u8): void { const sent: rs.usize = rs.usizeRem(arg >> 4 as rs.usize, 3); _524 = false; Executor.spawn$mpsc_step_run_closure5(s.exec, new stepRunFuture$closure5(tx4, n, first, sent)); - break b20; + break b21; } } if (_69 !== undefined) { @@ -258,7 +258,7 @@ export function stepRun(s: mpsc_State.State, op: rs.u8, arg: rs.u8): void { s.owned.items[at5] = undefined; const permit2: rs.MpscOwnedPermit = rs.optionExpect(taken2, "live"); const _134: mpsc_Tx.Tx | undefined = mpsc_State.sender(s, 0); - b12: { + b13: { if (_134 !== undefined) { if (_134.tag === "Bounded") { const tx6: rs.MpscSender = _134._0; @@ -273,7 +273,7 @@ export function stepRun(s: mpsc_State.State, op: rs.u8, arg: rs.u8): void { const args42 = [(f: rs.Formatter) => rs.fmtBool(_145, f), (f: rs.Formatter) => rs.fmtBool(_149, f)]; note(rs.fmtFormat(["same ", args42[0], " ", args42[1]])); tx6[Symbol.dispose](); - break b12; + break b13; } } if (_134 !== undefined) { diff --git a/ts/fixtures/tokio/expected/tokio/sync/oneshot/error.RecvError.ts b/ts/fixtures/tokio/expected/tokio/sync/oneshot/error.RecvError.ts index 06aeaab9b..9fe4ad0f6 100644 --- a/ts/fixtures/tokio/expected/tokio/sync/oneshot/error.RecvError.ts +++ b/ts/fixtures/tokio/expected/tokio/sync/oneshot/error.RecvError.ts @@ -3,9 +3,7 @@ import * as rs from "../../../rs.ts"; export function fmt$fmt_Debug(self: RecvError, f: rs.Formatter): rs.Result { - const _3: string = "RecvError"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.fmtUnit(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "RecvError", [(f: rs.Formatter) => rs.fmtUnit(self._0, f)]); } /** diff --git a/ts/fixtures/tokio/expected/tokio/sync/watch/error.RecvError.ts b/ts/fixtures/tokio/expected/tokio/sync/watch/error.RecvError.ts index 3fca41b67..6acd4c430 100644 --- a/ts/fixtures/tokio/expected/tokio/sync/watch/error.RecvError.ts +++ b/ts/fixtures/tokio/expected/tokio/sync/watch/error.RecvError.ts @@ -3,9 +3,7 @@ import * as rs from "../../../rs.ts"; export function fmt$fmt_Debug(self: RecvError, f: rs.Formatter): rs.Result { - const _3: string = "RecvError"; - const _4: rs.Fmt = (f: rs.Formatter) => rs.fmtUnit(self._0, f); - return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); + return rs.fmtDebugFields(f, "RecvError", [(f: rs.Formatter) => rs.fmtUnit(self._0, f)]); } /** Error produced when receiving a change notification. */ diff --git a/ts/runtime/rs/char.ts b/ts/runtime/rs/char.ts index 7e33ae33c..716459e0a 100644 --- a/ts/runtime/rs/char.ts +++ b/ts/runtime/rs/char.ts @@ -6,8 +6,8 @@ import { type ByteSlice, type Debug, debugListEntry, debugListFinish, debugStructField, debugStructFinish, debugTupleField, debugTupleFinish, Err, type FmtResult, type Formatter, fmtCharDebug, fmtDebugList, fmtDebugStruct, fmtDebugStructFields, fmtDebugTuple, fmtOption, fmtOwned, fmtPad, fmtSpec, fmtUnit, fmtWriteFmt, OK, Ok, type Place, panic, panicFmt, type Result, Slice } from "../rs.ts"; import { type char, type u8, type u16, u16Debug, u16LowerHex, type u32, u32UpperHex, type usize, usizeDisplay } from "./int.ts"; -import { type Clones, DONE, type Done, Iter, iterFlatMap, iterHeld, type SizeHint } from "./iter.ts"; -import { type String as RsString, strChars, stringCased } from "./str.ts"; +import { type Clones, DONE, type Done, Iter, iterFlatMap, iterFlattenParts, iterHeld, type SizeHint } from "./iter.ts"; +import { type String as RsString, strChars, stringCased, stringExtendChars, stringNew, stringPush, stringReserve } from "./str.ts"; import { drop as dispose } from "./task.ts"; import { ALPHABETIC, CASE_IGNORABLE, LOWERCASE, NUMERIC, TITLECASE, TO_LOWERCASE, TO_LOWERCASE_MULTI, TO_UPPERCASE, TO_UPPERCASE_MULTI, UNPRINTABLE, UPPERCASE } from "./unicode.ts"; import type { Location } from "./location.ts"; @@ -270,7 +270,7 @@ class CaseMapping extends Chars { /** `EscapeUnicode`, `EscapeDefault`, and `EscapeDebug`: std's `EscapeIterInner` of what it writes. */ class Escape extends Chars { - // Whether it is `escape_debug`'s char as it is, which std writes even once it has yielded it. + // Whether it is `escape_debug`'s char as it is, which std writes only until it yields it. readonly #literal: boolean; constructor(chars: readonly char[], literal: boolean) { @@ -285,9 +285,10 @@ class Escape extends Chars { return it; } - /** The literal char by `write_char`, else what is still alive by one `write_str`. */ + /** The literal char by `write_char` while it is alive, else what is still alive by one `write_str`. */ display(f: Formatter): FmtResult { - return this.#literal ? f.out.writeChar(this.chars[0]) : f.out.writeStr(this.rest()); + if (!this.#literal) return f.out.writeStr(this.rest()); + return this.front < this.back ? f.out.writeChar(this.chars[0]) : OK; } debug(f: Formatter, name: string): FmtResult { @@ -351,6 +352,32 @@ export function strEscapeDefault(s: string): Iter { return iterFlatMap(strChars(s), charEscapeDefault, undefined, true); } +/** + * `String`'s `Extend` of a `str::escape_default`, as std specializes it: room for what its + * parts say they have left, then each, with room for ten bytes before each char of its + * source that escapes as `\u{..}`. + */ +export function stringExtendEscapeDefault(s: RsString, it: Iter): RsString { + const [front, source, back] = iterFlattenParts(it); + const lower = (part: Iter | undefined) => part?.sizeHint()[0] ?? 0; + stringReserve(s, (lower(front) + lower(source) + lower(back)) as usize); + if (front !== undefined) stringExtendChars(s, front); + if (source !== undefined) { + for (let escape = source.next(); escape !== DONE; escape = source.next()) { + const chars = escape as Iter; + if (chars.sizeHint()[0] > 2) stringReserve(s, 10 as usize); + for (let c = chars.next(); c !== DONE; c = chars.next()) stringPush(s, c); + } + } + if (back !== undefined) stringExtendChars(s, back); + return s; +} + +/** `to_string` and `collect` of a `str::escape_default`, as std specializes them: `stringExtendEscapeDefault` of a new `String` by a clone. */ +export function stringFromEscapeDefault(it: Iter): RsString { + return stringExtendEscapeDefault(stringNew(), it.clone()); +} + /** `str::escape_debug`: each char's `escape_debug`, as std's `flat_map` of them. */ export function strEscapeDebug(s: string): Iter { return iterFlatMap(strChars(s), charEscapeDebug, undefined, true); diff --git a/ts/runtime/rs/iter.ts b/ts/runtime/rs/iter.ts index 96a6ae3be..a3f5f7a53 100644 --- a/ts/runtime/rs/iter.ts +++ b/ts/runtime/rs/iter.ts @@ -973,6 +973,12 @@ export function iterFlatMap(it: Iter, f: (item: T) => U, into?: (val return new FlattenIter(new MapIter(it, f), into ?? (itself as (value: U) => Iter), fused, size, oneShot); } +/** A `flatten`'s or `flat_map`'s front iterator, source, and back iterator, as std's `into_parts` gives them. */ +export function iterFlattenParts(it: Iter): [Iter | undefined, Iter | undefined, Iter | undefined] { + if (!(it instanceof FlattenIter)) throw new TypeError("iterFlattenParts of an iterator that is not a flatten"); + return [it.front, it.outer, it.back]; +} + /** * `flatten`: `into` makes each item an iterator, as `IntoIterator` does, `fused` is as * `flat_map`'s, `size` is each item's length if it is an array, and `oneShot` says each @@ -4529,6 +4535,14 @@ class FuseIter extends Iter implements Disposable { return this.inner === undefined ? DONE : this.clear(this.inner.nextBack()); } + /** std's: its iterator's, dropped if it falls short unless it is fused. */ + override advanceBackBy(n: number, drop?: Drop): number { + if (this.inner === undefined) return n; + const left = this.inner.advanceBackBy(n, drop); + if (left !== 0) this.clear(DONE); + return left; + } + override len(): number { return this.inner === undefined ? 0 : this.inner.len(); } diff --git a/ts/runtime/rs/str.ts b/ts/runtime/rs/str.ts index 944e55f1d..cafa42e44 100644 --- a/ts/runtime/rs/str.ts +++ b/ts/runtime/rs/str.ts @@ -1512,12 +1512,11 @@ function fromUtf16(len: number, unit: (i: number) => number): Result number): RsString { - const s = stringNew(); - stringReserve(s, Math.ceil(len / 2) as usize); + const s = stringWithCapacity(Math.ceil(len / 2) as usize); stringPushChars(s, fromUtf16Units(len, unit, true) as string); return s; } @@ -1670,6 +1669,11 @@ export function stringExtendChars(s: RsString, it: Iter, drops = false): R return s; } +/** `FromIterator` of `String`: room for the least `it` says it has, then `stringExtendChars`. */ +export function stringFromChars(it: Iter, drops = false): RsString { + return stringExtendChars(stringWithCapacity(it.sizeHint()[0] as usize), it, drops); +} + /** `String` as a tuple's part, of chars, which reserves as `stringReserve`. */ export const STRING_CHARS_PART: Part = { reserve: stringReserve, diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 14fef056d..d0ce0025e 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -2226,6 +2226,13 @@ fn collect<'tcx>( let drops = iter_drops(b, from, span); Expr::rs("stringFromStrings", tail(vec![iter], vec![drops])) } + // std's own for a `str::escape_default`, and room for the least the iterator + // says it has for any other of chars, but not of `&char`s. + _ if str_escape_default(b.t, from) => Expr::rs("stringFromEscapeDefault", vec![iter]), + _ if item.is_char() => { + let drops = iter_drops(b, from, span); + Expr::rs("stringFromChars", tail(vec![iter], vec![drops])) + } _ => string_extend(b, Expr::rs("stringNew", vec![]), iter, item, from, span)?, }; Some(match std { @@ -2280,6 +2287,9 @@ pub(super) fn string_extend<'tcx>( iter: Ty<'tcx>, span: Span, ) -> Option { + if str_escape_default(b.t, iter) { + return Some(Expr::rs("stringExtendEscapeDefault", vec![s, items])); + } let extend = if text_items(b.t, item)? { "stringExtend" } else { @@ -2289,6 +2299,12 @@ pub(super) fn string_extend<'tcx>( Some(Expr::rs(extend, tail(vec![s, items], vec![drops]))) } +/// Whether `ty` is `str::EscapeDefault`, which `String`'s `Extend`, `FromIterator`, and +/// `ToString` reserve for by its parts. +pub(super) fn str_escape_default<'tcx>(t: &Translator<'_, 'tcx>, ty: Ty<'tcx>) -> bool { + matches!(ty.kind(), ty::Adt(adt, _) if library::std_path(t.tcx, adt.did()) == ["str", "iter", "EscapeDefault"]) +} + /// Whether a `String` extends by `item`s of text, a `&str`, `String`, `Box`, or /// `Cow`, rather than chars, through any `&`: `None` for any other. pub(super) fn text_items<'tcx>(t: &Translator<'_, 'tcx>, item: Ty<'tcx>) -> Option { diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index d5beb823b..f288c5a01 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -3274,6 +3274,9 @@ fn mapping<'tcx>( let value = args.pop()?; let size = match ty.kind() { ty::Adt(..) if textual(tcx, ty) && !string(tcx, ty) => return Some(string_from(text(tcx, ty, value))), + ty::Adt(..) if super::iter::str_escape_default(b.t, ty) => { + return Some(Expr::rs("stringFromEscapeDefault", vec![value])); + } ty::Adt(..) if b.t.std_of(ty) == Some(Std::Arguments) => { return Some(Expr::rs("fmtFormat", vec![value])); } From 460e0d2a8b23f988e19d8b5241977018ada4f667 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 12 Nov 2026 21:22:14 -0800 Subject: [PATCH 06/13] test(ts): refresh snapshots for String's char collects Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/ascii/expected/ascii.ts | 5 +-- ts/fixtures/lang/boxes/expected/boxes.ts | 3 +- ts/fixtures/lang/clones/expected/clones.ts | 5 +-- .../lang/conversions/expected/conversions.ts | 10 ++--- ts/fixtures/lang/cows/expected/cows.ts | 9 ++-- ts/fixtures/lang/hints/expected/hints.ts | 5 +-- ts/fixtures/lang/locks/expected/locks.ts | 5 +-- ts/fixtures/lang/manual/expected/manual.ts | 5 +-- .../lang/searches/expected/searches.ts | 8 ++-- ts/fixtures/lang/strs/expected/strs.ts | 45 +++++++------------ ts/fixtures/stock/expected/fixed.ts | 3 +- ts/fixtures/task/expected/drops/inside.ts | 3 +- 12 files changed, 40 insertions(+), 66 deletions(-) diff --git a/ts/fixtures/lang/ascii/expected/ascii.ts b/ts/fixtures/lang/ascii/expected/ascii.ts index 9832b0f0a..24f295051 100644 --- a/ts/fixtures/lang/ascii/expected/ascii.ts +++ b/ts/fixtures/lang/ascii/expected/ascii.ts @@ -262,10 +262,9 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.strEqIgnoreAsciiCase(_124, _127) ? 1 : 0); rs.byteVecPush(out, rs.strEqIgnoreAsciiCase(_124, rs.stringFrom(rs.strToAsciiUppercase(_127)).v) ? 1 : 0); put(out, rs.stringFrom(rs.strToAsciiUppercase(s.v)).v); - const _154: rs.Iter = rs.iterFilter(rs.strChars(s.v), (a0: rs.char): boolean => { + put(out, rs.stringFromChars(rs.iterFilter(rs.strChars(s.v), (a0: rs.char): boolean => { return rs.isAsciiAlphanumeric(a0); - }); - put(out, rs.stringExtendChars(rs.stringNew(), _154).v); + })).v); put(out, rs.stringFrom(rs.strToAsciiLowercase(s.v)).v); put(out, rs.strTrimAsciiStart(s.v)); put(out, rs.strTrimAsciiEnd(s.v)); diff --git a/ts/fixtures/lang/boxes/expected/boxes.ts b/ts/fixtures/lang/boxes/expected/boxes.ts index eee334b97..8c1196182 100644 --- a/ts/fixtures/lang/boxes/expected/boxes.ts +++ b/ts/fixtures/lang/boxes/expected/boxes.ts @@ -407,8 +407,7 @@ export function boxes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const fromRef4: string = s.v; const fromString: string = rs.stringClone(s).v; const into2: string = rs.stringClone(s).v; - const _655: rs.Iter = rs.iterRev(rs.strChars(s.v)); - const collected4: string = rs.stringExtendChars(rs.stringNew(), _655).v; + const collected4: string = rs.stringFromChars(rs.iterRev(rs.strChars(s.v))).v; const empty4: string = ""; put(out, fromRef4); put(out, fromString); diff --git a/ts/fixtures/lang/clones/expected/clones.ts b/ts/fixtures/lang/clones/expected/clones.ts index d72527307..71def3f21 100644 --- a/ts/fixtures/lang/clones/expected/clones.ts +++ b/ts/fixtures/lang/clones/expected/clones.ts @@ -6737,14 +6737,13 @@ export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return x67; }, out); } else if (_9 === 3) { - const _111: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_273: rs.u8): rs.char => { + const text: rs.String = rs.stringFromChars(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_273: rs.u8): rs.char => { const _518: rs.usize = rs.u8Rem(_273, 4) as rs.usize; if (!(_518 < 4)) { rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _518); } return [97, 233, 20013, 129408][_518]; - }); - const text: rs.String = rs.stringExtendChars(rs.stringNew(), _111); + })); turns$str_Chars_clones_iters_closure53_clones_iters_closure54(rs.strChars(text.v), (it53: rs.Iter): rs.char | undefined => { return rs.iterToOption(it53.nextBack()); }, plan, (c4: rs.char): rs.u8 => { diff --git a/ts/fixtures/lang/conversions/expected/conversions.ts b/ts/fixtures/lang/conversions/expected/conversions.ts index 955bbb90c..1a2bf9183 100644 --- a/ts/fixtures/lang/conversions/expected/conversions.ts +++ b/ts/fixtures/lang/conversions/expected/conversions.ts @@ -5999,10 +5999,9 @@ export function measured(data: rs.ByteSlice, out: rs.ByteVec): void { const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u64 => { return _2 as rs.u64; }), undefined, 8, true); - const _8: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): rs.char => { + const text: rs.String = rs.stringFromChars(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): rs.char => { return _25 as rs.char; - }); - const text: rs.String = rs.stringExtendChars(rs.stringNew(), _8); + })); Named.make$conversions_Value(data, 0); const _13: rs.usize = rs.byteSliceRange(data, 0, 0).length; rs.byteSliceRange(data, 0, 0); @@ -6591,10 +6590,9 @@ export function referenced$u8(data: rs.ByteSlice, out: rs.ByteVec): void { * `Vec`s behind `&`, `&mut`, and a reference to one, as moq's buffers reach them. */ export function referencedBytes(data: rs.ByteSlice, out: rs.ByteVec): void { - const _4: rs.Iter = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_2: rs.u8): rs.char => { + const text: rs.String = rs.stringFromChars(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_2: rs.u8): rs.char => { return _2 as rs.char; - }); - const text: rs.String = rs.stringExtendChars(rs.stringNew(), _4); + })); const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); readBytes$ref_str(text.v, out); readBytes$ref_String(text, out); diff --git a/ts/fixtures/lang/cows/expected/cows.ts b/ts/fixtures/lang/cows/expected/cows.ts index aa20e1619..4abf30d19 100644 --- a/ts/fixtures/lang/cows/expected/cows.ts +++ b/ts/fixtures/lang/cows/expected/cows.ts @@ -196,8 +196,7 @@ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _35: rs.StrCow = new rs.Borrowed(s.v); const _37: rs.StrCow = new rs.Borrowed(first); const _38: rs.StrCow = rs.stringNew(); - const _40: rs.Iter = rs.iterRev(rs.strChars(first)); - const _39: rs.StrCow = rs.stringExtendChars(rs.stringNew(), _40); + const _39: rs.StrCow = rs.stringFromChars(rs.iterRev(rs.strChars(first))); const iterS: rs.StrCow[] = [_27, _29, _31, _32, _35, _37, _38, new rs.Borrowed("fallback"), _39]; for (const _45 of iterS) { rs.byteVecPush(out, borrows(_45)); @@ -247,8 +246,7 @@ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void (c2 as rs.Borrowed).slice = first; } if (!(c2 instanceof rs.Borrowed)) { - const _138: rs.Iter = rs.iterRev(rs.strChars(first)); - const _137: rs.String = rs.stringExtendChars(rs.stringNew(), _138); + const _137: rs.String = rs.stringFromChars(rs.iterRev(rs.strChars(first))); (c2 as rs.String) = _137; } put(out, rs.strCowStr(c2)); @@ -280,8 +278,7 @@ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void b18: { if (d instanceof rs.Borrowed) { if (!((d as rs.Borrowed).slice.length === 0)) { - const _190: rs.Iter = rs.iterSkip(rs.strChars((d as rs.Borrowed).slice), 1); - _184 = rs.stringExtendChars(rs.stringNew(), _190); + _184 = rs.stringFromChars(rs.iterSkip(rs.strChars((d as rs.Borrowed).slice), 1)); break b18; } } diff --git a/ts/fixtures/lang/hints/expected/hints.ts b/ts/fixtures/lang/hints/expected/hints.ts index 115ad5e27..05063bdb2 100644 --- a/ts/fixtures/lang/hints/expected/hints.ts +++ b/ts/fixtures/lang/hints/expected/hints.ts @@ -2001,14 +2001,13 @@ export function hints(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { put(out, it2.sizeHint()); } } else if (_37 === 16) { - const _353: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_29: rs.u8): rs.char => { + const s: rs.String = rs.stringFromChars(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_29: rs.u8): rs.char => { const _5: rs.usize = rs.u8Rem(_29, 4) as rs.usize; if (!(_5 < 4)) { rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _5); } return [97, 233, 128512, 2048][_5]; - }); - const s: rs.String = rs.stringExtendChars(rs.stringNew(), _353); + })); const _355: rs.u8 = rs.u8Rem(arm, 4); if (_355 === 0) { walk$str_Chars(rs.strChars(s.v), steps, out); diff --git a/ts/fixtures/lang/locks/expected/locks.ts b/ts/fixtures/lang/locks/expected/locks.ts index 6607e3f4e..f0c40a26c 100644 --- a/ts/fixtures/lang/locks/expected/locks.ts +++ b/ts/fixtures/lang/locks/expected/locks.ts @@ -612,10 +612,9 @@ export function mutexMapped(data: rs.ByteSlice, out: rs.ByteVec): void { * as std writes what each lends. */ export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { - const _4: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b: rs.u8): rs.char => { + const text: rs.String = rs.stringFromChars(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b: rs.u8): rs.char => { return rs.u8Add(97, rs.u8Rem(b, 26)) as rs.char; - }); - const text: rs.String = rs.stringExtendChars(rs.stringNew(), _4); + })); const mutex: rs.Mutex<[rs.u8, rs.String]> = new rs.Mutex([data.length & 0xff, rs.stringClone(text)] as [rs.u8, rs.String]); const lock: rs.RefCell<[rs.ByteVec, rs.String]> = new rs.RefCell([rs.byteSliceToByteVec(data), text] as [rs.ByteVec, rs.String]); const guard: rs.Mutex<[rs.u8, rs.String]> = rs.mutexLock(mutex); diff --git a/ts/fixtures/lang/manual/expected/manual.ts b/ts/fixtures/lang/manual/expected/manual.ts index 068d69729..49e48d8cb 100644 --- a/ts/fixtures/lang/manual/expected/manual.ts +++ b/ts/fixtures/lang/manual/expected/manual.ts @@ -104,10 +104,9 @@ export function needs$unit(): boolean { * generic body that branches on it does, as std's collections do; and types' names. */ export function needsDrops(data: rs.ByteSlice, out: rs.ByteVec): void { - const _4: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { + const captured = rs.stringFromChars(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { return _2 as rs.char; - }); - const captured = rs.stringExtendChars(rs.stringNew(), _4); + })); const named: () => rs.usize = (): rs.usize => { return captured.len; }; diff --git a/ts/fixtures/lang/searches/expected/searches.ts b/ts/fixtures/lang/searches/expected/searches.ts index b5b4c8415..314de8e69 100644 --- a/ts/fixtures/lang/searches/expected/searches.ts +++ b/ts/fixtures/lang/searches/expected/searches.ts @@ -3683,8 +3683,7 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void front$tuple2_usize_ref_str_str_RMatchIndices_char(rs.strRmatchIndices(_50, String.fromCodePoint(c)), out); } } else if (_42 === 1) { - const _109: rs.Iter = rs.iterTake(rs.iterSkip(rs.strChars(s.v), rs.u8Div(pick, 64) as rs.usize), rs.u8Rem(rs.u8Div(pick, 16), 4) as rs.usize); - const needle: rs.String = rs.stringExtendChars(rs.stringNew(), _109); + const needle: rs.String = rs.stringFromChars(rs.iterTake(rs.iterSkip(rs.strChars(s.v), rs.u8Div(pick, 64) as rs.usize), rs.u8Rem(rs.u8Div(pick, 16), 4) as rs.usize)); const _125: string = s.v; const _127: rs.u8 = rs.u8Rem(m, 9); if (_127 === 0) { @@ -3871,14 +3870,13 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void * low bits of each byte, read from the end each byte's high bit picks. */ export function texts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _5: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { + const s: rs.String = rs.stringFromChars(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { const _52: rs.usize = rs.u8Rem(_2, 16) as rs.usize; if (!(_52 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _52); } return [10, 13, 97, 32, 9, 11, 133, 160, 5760, 8202, 8203, 8232, 12288, 65279, 233, 128512][_52]; - }); - const s: rs.String = rs.stringExtendChars(rs.stringNew(), _5); + })); const _7: rs.u8 = rs.u8Rem(kind, 5); if (_7 === 0) { both$tuple2_usize_char_str_CharIndices(rs.strCharIndices(s.v), data, out); diff --git a/ts/fixtures/lang/strs/expected/strs.ts b/ts/fixtures/lang/strs/expected/strs.ts index 29eb55fbe..6790a793c 100644 --- a/ts/fixtures/lang/strs/expected/strs.ts +++ b/ts/fixtures/lang/strs/expected/strs.ts @@ -1156,22 +1156,17 @@ export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const named: Named.Named = { name: text(rs.byteSliceRange(data, 0, rs.usizeDiv(data.length, 2))) }; const _21: rs.u8 = rs.u8Rem(kind, 4); if (_21 === 0) { - const _27: rs.Iter = rs.strChars(s.v); - put(out, rs.stringExtendChars(rs.stringNew(), _27).v); - const _34: rs.Iter = rs.iterFilter(rs.iterRev(rs.strChars(s.v)), (c: rs.char): boolean => { + put(out, rs.stringFromChars(rs.strChars(s.v)).v); + put(out, rs.stringFromChars(rs.iterFilter(rs.iterRev(rs.strChars(s.v)), (c: rs.char): boolean => { return !rs.isAsciiDigit(c); - }); - put(out, rs.stringExtendChars(rs.stringNew(), _34).v); + })).v); const _43: rs.Iter = rs.iterSlice(chars.items); put(out, rs.stringExtendChars(rs.stringNew(), _43).v); - const _50: rs.Iter = rs.iterSkip(rs.iterSlice(chars.items), 1); - put(out, rs.stringExtendChars(rs.stringNew(), _50).v); + put(out, rs.stringFromChars(rs.iterSkip(rs.iterSlice(chars.items), 1)).v); rs.iterEmpty(); - put(out, rs.stringExtendChars(rs.stringNew(), rs.iterEmpty() as rs.Iter).v); - const _64: rs.Iter = rs.iterOption(rs.charFromU32(kind as rs.u32)); - put(out, rs.stringExtendChars(rs.stringNew(), _64).v); - const counted: Counted.Counted = { items: rs.sliceFrom(chars.items), nexts }; - put(out, rs.stringExtendChars(rs.stringNew(), rs.iterFrom(counted, Counted.next$iter_Iterator_char)).v); + put(out, rs.stringFromChars(rs.iterEmpty() as rs.Iter).v); + put(out, rs.stringFromChars(rs.iterOption(rs.charFromU32(kind as rs.u32))).v); + put(out, rs.stringFromChars(rs.iterFrom({ items: rs.sliceFrom(chars.items), nexts }, Counted.next$iter_Iterator_char)).v); } else if (_21 === 1) { const _79: rs.Iter = rs.iterSlice(parts.items); put(out, rs.stringExtend(rs.stringNew(), _79).v); @@ -1188,8 +1183,7 @@ export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { })).v); rs.iterEmpty(); put(out, rs.stringFromStrings(rs.iterEmpty() as rs.Iter).v); - const _114: rs.Iter = rs.iterRev(rs.strChars(s.v)); - put(out, rs.strCowStr(rs.stringExtendChars(rs.stringNew(), _114))); + put(out, rs.strCowStr(rs.stringFromChars(rs.iterRev(rs.strChars(s.v))))); const _122: rs.Iter = rs.iterSlice(parts.items); put(out, rs.stringExtend(rs.stringNew(), _122).v); const owned: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(parts.items), (p6: string): rs.String => { @@ -1303,8 +1297,7 @@ export function drainBy(s: rs.String, form: rs.u8, a: rs.u8, b: rs.u8, steps: rs _71 = false; } else if (_49 === 2) { _71 = false; - const _57: rs.Iter = drain; - put(out, rs.stringExtendChars(rs.stringNew(), _57, true).v); + put(out, rs.stringFromChars(drain, true).v); } else { put(out, rs.stringDrainAsStr(drain)); _71 = false; @@ -1357,8 +1350,7 @@ export function drains(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _49: rs.u8 = rs.u8Rem(form, 4); if (_49 === 0) { const _56: { end: rs.usize } = { end: offset(s.v, a) }; - const _54: rs.Iter = rs.stringDrain(s, _56); - put(out, rs.stringExtendChars(rs.stringNew(), _54, true).v); + put(out, rs.stringFromChars(rs.stringDrain(s, _56), true).v); } else if (_49 === 1) { const _64: rs.RangeFrom = new rs.RangeFrom(offset(s.v, a), rs.usizeStep); rs.byteVecPush(out, rs.ownedCount(rs.stringDrain(s, _64)) & 0xff); @@ -1414,8 +1406,7 @@ export function hinted(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (_38 === 0) { rs.stringExtendChars(t, rs.iterMap(new rs.Range(0, n), f)); } else if (_38 === 1) { - const _44: rs.Iter = rs.iterMap(rs.iterChain(new rs.RangeInclusive(0, n, rs.u32Step), new rs.Range(0, n)), f); - t = rs.stringExtendChars(rs.stringNew(), _44); + t = rs.stringFromChars(rs.iterMap(rs.iterChain(new rs.RangeInclusive(0, n, rs.u32Step), new rs.Range(0, n)), f)); } else if (_38 === 2) { rs.stringExtendChars(t, rs.iterSkip(rs.iterMap(new rs.Range(0, rs.u64Or(rs.u64Shl(n as rs.u64, 8), m as rs.u64), rs.u64Step), (i4: rs.u64): rs.char => { return f(rs.u64Low(i4)); @@ -1770,7 +1761,7 @@ export function escaped$str_EscapeDefault(out: rs.ByteVec, it: rs.Iter) putChar(out2, c); }); while (rs.iterToOption(it.next()) !== undefined) { - put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)).v); + put(out, rs.stringFromEscapeDefault(it).v); } } @@ -1795,14 +1786,13 @@ export function escaped$str_EscapeUnicode(out: rs.ByteVec, it: rs.Iter) * and each iterator's size hints as it goes. */ export function unicode(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const _5: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { + const s: rs.String = rs.stringFromChars(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { const _54: rs.usize = rs.u8Rem(_2, 32) as rs.usize; if (!(_54 < 32)) { rs.panic("index out of bounds: the len is " + 32 + " but the index is " + _54); } return [931, 931, 962, 65, 97, 453, 66560, 223, 304, 912, 64259, 46, 39, 58, 769, 837, 173, 119143, 32, 49, 20013, 128512, 233, 34, 92, 10, 9, 0, 127, 57344, 65279, 1114111][_54]; - }); - const s: rs.String = rs.stringExtendChars(rs.stringNew(), _5); + })); const words: rs.Vec = rs.iterToVec(rs.strSplit(s.v, " "), "next", 8); const _11: rs.u8 = rs.u8Rem(kind, 5); if (_11 === 0) { @@ -1830,7 +1820,7 @@ export function unicode(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const part2 = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(words.items), (a06: string): rs.Iter => { return rs.strEscapeDefault(a06); }), (e: rs.Iter): rs.String => { - return rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(e, f)); + return rs.stringFromEscapeDefault(e); }), undefined, 12, true); put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part2.items, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]).v); } else if (_11 === 3) { @@ -1854,10 +1844,9 @@ export function unicode(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void }), (a02: rs.Iter): rs.usize => { return rs.iterCount(a02); }), undefined, 4, true); - const _150: rs.Iter = rs.iterMap(rs.charDecodeUtf16(rs.iterSlice(units.items)), (a03: rs.Result): rs.char => { + const _164: boolean = rs.eqStr(rs.stringFromChars(rs.iterMap(rs.charDecodeUtf16(rs.iterSlice(units.items)), (a03: rs.Result): rs.char => { return rs.resultUnwrap(a03, rs.fmtDecodeUtf16ErrorDebug); - }); - const _164: boolean = rs.eqStr(rs.stringExtendChars(rs.stringNew(), _150), s); + })), s); const args14 = [(f: rs.Formatter) => rs.fmtList(units.items, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(each4.items, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBool(_164, f)]; put(out, rs.fmtFormat([args14[0], "|", args14[1], "|", args14[2]]).v); } diff --git a/ts/fixtures/stock/expected/fixed.ts b/ts/fixtures/stock/expected/fixed.ts index 4ea3825c5..de1094791 100644 --- a/ts/fixtures/stock/expected/fixed.ts +++ b/ts/fixtures/stock/expected/fixed.ts @@ -25,8 +25,7 @@ export function strings(data: rs.ByteSlice, out: rs.ByteVec): void { break b2; } if (_23 === 1) { - const _31: rs.Iter = rs.iterRepeatN(c, b >> 5 as rs.usize); - const run: rs.String = rs.stringExtendChars(rs.stringNew(), _31); + const run: rs.String = rs.stringFromChars(rs.iterRepeatN(c, b >> 5 as rs.usize)); const _36: rs.Result> = ArrayString.tryPushStr$12(s, run.v); if (_36.ok) { rs.byteVecPush(out, 0); diff --git a/ts/fixtures/task/expected/drops/inside.ts b/ts/fixtures/task/expected/drops/inside.ts index 78bb51c72..c2de49286 100644 --- a/ts/fixtures/task/expected/drops/inside.ts +++ b/ts/fixtures/task/expected/drops/inside.ts @@ -77,8 +77,7 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.drop(it); const s: rs.String = rs.stringFrom("abcdef"); const _180: Spent.Spent = new Spent.Spent(guard(12), 1, 3); - const _178: rs.Iter = rs.stringDrain(s, rs.dropAfter(_180, (range14) => rs.boundsChecked(rs.boundsOf(range14, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), s.len), rs.drop)); - const part18 = rs.stringExtendChars(rs.stringNew(), _178, true); + const part18 = rs.stringFromChars(rs.stringDrain(s, rs.dropAfter(_180, (range14) => rs.boundsChecked(rs.boundsOf(range14, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), s.len), rs.drop)), true); Log.note(log, rs.fmtFormat(["text ", (f: rs.Formatter) => rs.fmtPad(f, part18.v)])); const _190: Spent.Spent = new Spent.Spent(guard(13), 0, 1); rs.stringReplaceRange(s, rs.dropAfter(_190, (range15) => rs.boundsChecked(rs.boundsOf(range15, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), s.len), rs.drop), "xy"); From dadc4f97bca89380919aea1d6a0ba0f75eb7f2f7 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 12 Nov 2026 21:26:51 -0800 Subject: [PATCH 07/13] style: format Co-Authored-By: Claude Opus 5.5 --- go/src/lower/library.rs | 9 ++++++--- ts/src/lower/library.rs | 5 ++++- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/go/src/lower/library.rs b/go/src/lower/library.rs index 6d47c75e4..4647ffdec 100644 --- a/go/src/lower/library.rs +++ b/go/src/lower/library.rs @@ -397,9 +397,12 @@ pub fn call_with<'tcx>( "::debug_struct_fields_finish" => { expr(format!("{}.debugFields({}, {})", a[0], a[1], a[2])) } - k if k.starts_with("::debug_struct_field") && k.ends_with("_finish") => { - expr(format!("{}.debugFields({}, []fmtDyn{{{}}})", a[0], a[1], a[2..].join(", "))) - } + k if k.starts_with("::debug_struct_field") && k.ends_with("_finish") => expr(format!( + "{}.debugFields({}, []fmtDyn{{{}}})", + a[0], + a[1], + a[2..].join(", ") + )), "::debug_c_like_enum_write_str" => { expr(format!("{}.debugEnum({}, {})", a[0], a[1], a[2])) } diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index f288c5a01..a7f36f07b 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -3053,7 +3053,10 @@ fn mapping<'tcx>( } ("panicking", "panic") => Expr::rs("panic", [args, hook_at(b)].concat()), // `panic!()`, `unreachable!()`, `unimplemented!()`, and `todo!()` without a message. - ("panicking", "panic_default_msg" | "unreachable_default_msg" | "unimplemented_default_msg" | "todo_default_msg") => { + ( + "panicking", + "panic_default_msg" | "unreachable_default_msg" | "unimplemented_default_msg" | "todo_default_msg", + ) => { let message = match name.as_str() { "panic_default_msg" => "explicit panic", "unreachable_default_msg" => "internal error: entered unreachable code", From 33330ce4e567b17931bc688975ec6cf72bf0d441 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 12 Nov 2026 21:38:34 -0800 Subject: [PATCH 08/13] ci(nightly): a canary on the newest nightly rust-overlay names Co-Authored-By: Claude Opus 5.5 --- .github/workflows/nightly.yml | 37 +++++++++++++++++++++++++++++++++++ sh/canary.sh | 26 ++++++++++++++++++++++++ 2 files changed, 63 insertions(+) create mode 100755 sh/canary.sh diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 8d79a734f..93201a3f4 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -269,6 +269,43 @@ jobs: name: census path: ts/target/census + # Every driver on the newest nightly rust-overlay names, so the next bump's breaks are + # known before it starts. It fails no merge and opens no issue: the report waits on + # every job but this one. Each module runs after another's failure. + canary: + name: Newest nightly + runs-on: ubuntu-24.04-arm + timeout-minutes: 90 + continue-on-error: true + + steps: + - name: Checkout + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + + - uses: ./.github/actions/nix + + - name: Toolchain + run: | + channel=$(sh/canary.sh) + echo "Canary on \`$channel\`" >> "$GITHUB_STEP_SUMMARY" + + - name: Driver + run: nix develop --command bash -c 'just driver check && just driver test' + + - name: Export + if: ${{ !cancelled() }} + run: nix develop --command bash -c 'just ffi check && just ffi test' + + - name: Go + if: ${{ !cancelled() }} + run: nix develop --command bash -c 'just go check && just go test' + + - name: TypeScript + if: ${{ !cancelled() }} + run: nix develop --command bash -c 'just ts check && just ts moq && just ts test' + # A scheduled run's failure opens one issue, or comments on the one still open, and a # pass closes it, so a suite only this workflow runs cannot fail unseen. Only the # schedule, which runs main, gets the write token: a dispatch can run any branch. diff --git a/sh/canary.sh b/sh/canary.sh new file mode 100755 index 000000000..995129764 --- /dev/null +++ b/sh/canary.sh @@ -0,0 +1,26 @@ +#!/usr/bin/env bash +# Point ts/rust-toolchain.toml, the nightly every driver links, at the newest one +# rust-overlay names that ships each component and target the file lists, and print +# it: the nightly's canary, which finds the next bump's breaks before it starts. +# It rewrites flake.lock and the toolchain file in place; commit neither. +set -euo pipefail + +cd "$(git rev-parse --show-toplevel)" +nix flake update rust-overlay +version=$(nix eval --raw --impure --expr ' + let + flake = builtins.getFlake (toString ./.); + pkgs = import flake.inputs.nixpkgs { + system = builtins.currentSystem; + overlays = [ (import flake.inputs.rust-overlay) ]; + }; + file = (builtins.fromTOML (builtins.readFile ./ts/rust-toolchain.toml)).toolchain; + in + (pkgs.rust-bin.selectLatestNightlyWith (t: t.minimal.override { + extensions = file.components; + targets = file.targets; + })).version') +channel="nightly-${version##*-nightly-}" +sed -i "s/^channel = \".*\"/channel = \"$channel\"/" ts/rust-toolchain.toml +grep -q "^channel = \"$channel\"$" ts/rust-toolchain.toml +echo "$channel" From 7af0a7954a3936c1fed21c1ca45f911a825441b4 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 12 Nov 2026 21:55:28 -0800 Subject: [PATCH 09/13] chore(quest): schedule the next nightly bump for 2026-12-24 Co-Authored-By: Claude Opus 5.5 --- quest/m0/nightly-bump.md | 58 +++++++++++++++++++++++++--------------- 1 file changed, 37 insertions(+), 21 deletions(-) diff --git a/quest/m0/nightly-bump.md b/quest/m0/nightly-bump.md index b579c80e4..63ad44a61 100644 --- a/quest/m0/nightly-bump.md +++ b/quest/m0/nightly-bump.md @@ -4,34 +4,50 @@ The nightly every driver here links (`ts/rust-toolchain.toml`, which `driver/`, `ffi/`, and `go/` symlink) moves to a current one, with `flake.lock`'s rust-overlay bumped to name -it, and a nightly canary job, which fails no one's merge, builds each driver against the -newest nightly so the next bump's breaks are known before it starts. This quest recurs: -the PR that finishes a run creates the next. +it. This quest recurs: the PR that finishes a run creates the next. ## Plan -Decided with the maintainer on 2026-11-12, in the quest audit: ✅ a recurring bump, in m0. -The pin is `nightly-2026-10-15` and has not moved since the repository's first commit, -`.github/dependabot.yml` covers only nix and GitHub Actions, and three quests wait on a -newer nightly: [the FMA allowance](/quest/m3/ts-fma-allowance.md), -[relink](/quest/m3/relink.md), and [TPDE](/quest/m3/tpde.md). +Decided with the maintainer on 2026-11-12, in the quest audit: ✅ a recurring bump, in m0, +every six weeks, one Rust release cycle. Nothing ends the recurrence while a driver here +links `rustc_private`. The period is the maintainer's to change. - Each run: bump the toolchain file and the overlay, port every driver to rustc's changed - internals, and pass `just gate`. Differential output must not change; a fixture whose - expected output moves is a finding to explain in the PR, not to regenerate. -- The first run adds the canary to `nightly.yml`: it overrides the toolchain to the - newest nightly the overlay names and builds `driver/`, `ffi/`, `ts/`, and `go/`. It is - allowed to fail, and opens no issue. -- `go/` is parked with no consumer ([its epic](/quest/m4/go/README.md)), and its roughly - 5,600 lines over rustc's internals are ported with the rest. Report what that port cost in the - PR, so the maintainer can weigh keeping it. + internals and std's changed behavior, and pass `just gate`. Differential output must + not change. A code snapshot that moves is a finding to explain in the PR, by its cause, + before it is regenerated. +- Start from the nightly's "Newest nightly" job (`canary` in `nightly.yml`), which runs + every module's checks and tests on the newest nightly rust-overlay names: its failures + are this run's work list. +- `rustc-dev` ships the compiler's source under `lib/rustlib/rustc-src`, and `rust-src` + ships std's; diff the old and new toolchains' trees to find what moved. `cargo fix + --broken-code` applies most mechanical renames. - The benchmark's own nightly in `flake.nix` is a corpus change that lands on its own (`bench/build/corpus.toml`); it is [TPDE](/quest/m3/tpde.md)'s to bump, not this quest's. -- Recurrence: the finishing PR re-creates this file at the same path with a `Scheduled` - date six weeks later, one Rust release cycle, and carries forward what the run learned: - which internals moved and what the canary showed. Chosen by the audit without asking; - the period is the maintainer's to change. Nothing ends the recurrence while a driver - here links `rustc_private`. +- The finishing PR re-creates this file at the same path with a `Scheduled` date six + weeks later and carries forward what the run learned. + +What the 2026-10-15 to 2026-11-12 run learned: + +- rustc internals: `GenericArgsRef` is gone and `GenericArgs` is a `Copy` value with no + slice `Index` of a range (`as_slice`, `as_tcx_slice`); `ParamEnv::caller_bounds()` is an + accessor (`.all_clauses(tcx).iter()`, with `CallerBoundsIterator`); `LayoutData::align` + is an `Align`; tool attributes are `Attribute::Tool(AttrItem)` (`tcx.tool_attrs`), and a + doc comment is `AttributeExt::doc_str_and_fragment_kind`. +- Expansion and std moved more than the compiler did, and only the differential tests + caught it: derived `Debug` passes the type's and fields' names joined by spaces and, + past four variants, indexes a joined string (`debug_c_like_enum_write_str`); + `vec![x; n]` calls `from_elem_global`; `panic!()`, `unreachable!()`, + `unimplemented!()`, and `todo!()` call `*_default_msg`; `String`'s char collects reserve + the size hint exactly, and `str::escape_default` specializes them; `Fuse` forwards + `advance_back_by`; `EscapeDebug` drops its char once yielded; `IoSlice::advance` and + `Ready` reword their panics; `Pattern` is an `unsafe trait`, and `Allocator` is stable. +- `go/`'s port added 41 lines and removed 35 over 7 files, all of them derived `Debug` or + the mechanical renames, against `ts/`'s 380 and 302 over 36. Public API: none. + +## Scheduled + +- 2026-12-24 - six weeks after the 2026-11-12 run From 131e92649a61aa0f5b4fc9fd3e48b2ef959eb80a Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 13 Nov 2026 02:54:47 -0800 Subject: [PATCH 10/13] fix(ts): follow 1.102's Skip::advance_by(0), keep vec::from_elem, and cover the unfused paths Skip takes no step when advanced by none while it still skips. std::vec::from_elem is now a stable deprecated wrapper over from_elem_global, so both map. The iters fixture gains an unfused iterator through Skip and Fuse, and panics covers unimplemented!() with no message. Co-Authored-By: Claude Opus 5.5 --- .../lang/capacity/expected/capacity.ts | 397 +++++++++--------- ts/fixtures/lang/capacity/src/capacity.rs | 8 +- .../lang/iters/expected/iters.Flicker.ts | 25 ++ ts/fixtures/lang/iters/expected/iters.ts | 27 ++ ts/fixtures/lang/iters/expected/lib.ts | 4 +- ts/fixtures/lang/iters/src/iters.rs | 49 +++ ts/fixtures/lang/iters/src/lib.rs | 1 + .../lang/panics/hook/expected/hooked.Short.ts | 2 +- .../lang/panics/hook/expected/hooked.Shown.ts | 2 +- .../lang/panics/hook/expected/hooked.ts | 244 +++++------ ts/fixtures/lang/panics/src/hooked.rs | 3 +- ts/runtime/rs/iter.ts | 3 + ts/src/lower/library.rs | 4 +- ts/src/lower/mir/holders.rs | 2 +- 14 files changed, 453 insertions(+), 318 deletions(-) create mode 100644 ts/fixtures/lang/iters/expected/iters.Flicker.ts diff --git a/ts/fixtures/lang/capacity/expected/capacity.ts b/ts/fixtures/lang/capacity/expected/capacity.ts index 410e05db8..37866b049 100644 --- a/ts/fixtures/lang/capacity/expected/capacity.ts +++ b/ts/fixtures/lang/capacity/expected/capacity.ts @@ -198,27 +198,31 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d const rest: rs.Vec = rs.iterToVec(it2, "next", 1280, true, 1280); sized(out, rest.items.length, rs.vecCapacity(rest, 1280)); } else if (_39 === 24) { - v = rs.vecFromElem(copy$array_u64(make(arg)), rs.u8Rem(arg, 6) as rs.usize, copy$array_u64); + if ((arg & 64) === 0) { + v = rs.vecFromElem(copy$array_u64(make(arg)), rs.u8Rem(arg, 6) as rs.usize, copy$array_u64); + } else { + v = rs.vecFromElem(copy$array_u64(make(arg)), rs.u8Rem(arg, 6) as rs.usize, copy$array_u64); + } } else if (_39 === 25) { - const _205: rs.Vec = v; - const _206: (a0: rs.Slice) => boolean = (_26: rs.Slice): boolean => { + const _211: rs.Vec = v; + const _212: (a0: rs.Slice) => boolean = (_26: rs.Slice): boolean => { return rs.u8Rem(arg, 2) === 1; }; - rs.vecPopIf(_205, (held2) => _206(rs.sliceFrom(held2))); + rs.vecPopIf(_211, (held2) => _212(rs.sliceFrom(held2))); } else if (_39 === 26) { v = rs.slicesJoin(rs.sliceFrom([rs.vecFrom(v.items.map(copy$array_u64)), v]), 1280, undefined, rs.vecSlice, copy$array_u64); } else if (_39 === 27) { v = rs.iterToVec(rs.iterSlice(rs.arraySliceItems(rs.arraySliceFrom(v.items, rs.sliceFrom))), "next", 1280, true, 1280); } else if (_39 === 28) { const own: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 1280); - const _225: rs.u64[] = copy$array_u64(make(arg)); - own.items.push(_225); + const _231: rs.u64[] = copy$array_u64(make(arg)); + own.items.push(_231); rs.vecCloneFrom(own, v, 1280, copy$array_u64); v = own; } else if (_39 === 29) { const other: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 1280); - const _236: rs.Iter = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); - rs.iterExtend(other, _236, undefined, 1280, true); + const _242: rs.Iter = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); + rs.iterExtend(other, _242, undefined, 1280, true); rs.vecAppend(v, other, 1280); sized(out, other.items.length, rs.vecCapacity(other, 1280)); } else if (_39 === 30 || _39 === 31) { @@ -253,36 +257,36 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d } else { end = len; } - const _323: rs.usize = ((arg >> 5) & 3) as rs.usize; - if (!(_323 < 4)) { - rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _323); - } - const n: rs.usize = [0, 2, 6, 17][_323]; - const _329: rs.u8 = (arg >> 3) & 3; - if (_329 === 0) { - const _334: rs.Vec = v; - const _335: rs.Range = new rs.Range(start, end); - const _337: rs.Iter = rs.iterMap(new rs.Range(0, n & 0xff), make); - rs.drop(rs.spliceFrom(rs.vecSplice(_334, _335, 1280), _337, true)); - } else if (_329 === 1) { - const _341: rs.Vec = v; - const _342: rs.Range = new rs.Range(start, end); - const _344: rs.Iter = rs.iterMap(rs.iterFilter(new rs.Range(0, n & 0xff), (i3: rs.u8): boolean => { + const _329: rs.usize = ((arg >> 5) & 3) as rs.usize; + if (!(_329 < 4)) { + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _329); + } + const n: rs.usize = [0, 2, 6, 17][_329]; + const _335: rs.u8 = (arg >> 3) & 3; + if (_335 === 0) { + const _340: rs.Vec = v; + const _341: rs.Range = new rs.Range(start, end); + const _343: rs.Iter = rs.iterMap(new rs.Range(0, n & 0xff), make); + rs.drop(rs.spliceFrom(rs.vecSplice(_340, _341, 1280), _343, true)); + } else if (_335 === 1) { + const _347: rs.Vec = v; + const _348: rs.Range = new rs.Range(start, end); + const _350: rs.Iter = rs.iterMap(rs.iterFilter(new rs.Range(0, n & 0xff), (i3: rs.u8): boolean => { return rs.u8Rem(i3, 4) !== 1; }), make); - rs.drop(rs.spliceFrom(rs.vecSplice(_341, _342, 1280), _344)); - } else if (_329 === 2) { - const _349: rs.Vec = v; - const _350: rs.Range = new rs.Range(start, end); - const _352: rs.Iter = rs.iterMap(rs.iterChain(new rs.Range(0, n & 0xff), rs.iterFilter(new rs.Range(0, n & 0xff), (i2: rs.u8): boolean => { + rs.drop(rs.spliceFrom(rs.vecSplice(_347, _348, 1280), _350)); + } else if (_335 === 2) { + const _355: rs.Vec = v; + const _356: rs.Range = new rs.Range(start, end); + const _358: rs.Iter = rs.iterMap(rs.iterChain(new rs.Range(0, n & 0xff), rs.iterFilter(new rs.Range(0, n & 0xff), (i2: rs.u8): boolean => { return rs.u8Rem(i2, 2) === 0; })), make); - rs.drop(rs.spliceFrom(rs.vecSplice(_349, _350, 1280), _352)); + rs.drop(rs.spliceFrom(rs.vecSplice(_355, _356, 1280), _358)); } else { - const _360: rs.Vec = v; - const _361: rs.Range = new rs.Range(start, end); - const _363: rs.Vec = rs.vecFromElem(copy$array_u64(make(arg)), n, copy$array_u64); - rs.drop(rs.spliceFrom(rs.vecSplice(_360, _361, 1280), rs.vecIntoIter(_363), true)); + const _366: rs.Vec = v; + const _367: rs.Range = new rs.Range(start, end); + const _369: rs.Vec = rs.vecFromElem(copy$array_u64(make(arg)), n, copy$array_u64); + rs.drop(rs.spliceFrom(rs.vecSplice(_366, _367, 1280), rs.vecIntoIter(_369), true)); } } else if (_39 === 36) { const keep3: () => boolean = alternate(); @@ -293,15 +297,15 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d const pairs: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 6) as rs.usize, 2560); const iter4: rs.Iter>> = rs.arraySliceChunksExact(rs.arraySliceFrom(v.items, rs.sliceFrom), 2); while (true) { - const _392: rs.ArraySlice> | rs.Done = iter4.next(); - if (_392 === rs.DONE) { + const _398: rs.ArraySlice> | rs.Done = iter4.next(); + if (_398 === rs.DONE) { break; } - rs.idx(_392, 0); - const _399: rs.u64[] = copy$array_u64(rs.sliceToArray(rs.arraySliceAt(_392, 0))); - rs.idx(_392, 1); - const _398: rs.u64[][] = [_399, copy$array_u64(rs.sliceToArray(rs.arraySliceAt(_392, 1)))]; - pairs.items.push(_398); + rs.idx(_398, 0); + const _405: rs.u64[] = copy$array_u64(rs.sliceToArray(rs.arraySliceAt(_398, 0))); + rs.idx(_398, 1); + const _404: rs.u64[][] = [_405, copy$array_u64(rs.sliceToArray(rs.arraySliceAt(_398, 1)))]; + pairs.items.push(_404); } const flat: rs.Vec = rs.vecIntoFlattened(pairs, 2, 1280); sized(out, flat.items.length, rs.vecCapacity(flat, 1280)); @@ -441,7 +445,11 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, const rest: rs.Vec<[rs.u64, rs.u8]> = rs.iterToVec(it2, "next", 16, true, 16); sized(out, rest.items.length, rs.vecCapacity(rest, 16)); } else if (_39 === 24) { - v = rs.vecFromElem(copy$tuple2_u64_u8(make(arg)), rs.u8Rem(arg, 6) as rs.usize, copy$tuple2_u64_u8); + if ((arg & 64) === 0) { + v = rs.vecFromElem(copy$tuple2_u64_u8(make(arg)), rs.u8Rem(arg, 6) as rs.usize, copy$tuple2_u64_u8); + } else { + v = rs.vecFromElem(copy$tuple2_u64_u8(make(arg)), rs.u8Rem(arg, 6) as rs.usize, copy$tuple2_u64_u8); + } } else if (_39 === 25) { rs.vecPopIf(v, (_26: [rs.u64, rs.u8]): boolean => { return rs.u8Rem(arg, 2) === 1; @@ -452,14 +460,14 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, v = rs.iterToVec(rs.iterSlice(v.items), "next", 16, true, 16); } else if (_39 === 28) { const own: rs.Vec<[rs.u64, rs.u8]> = rs.vecWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 16); - const _225: [rs.u64, rs.u8] = copy$tuple2_u64_u8(make(arg)); - own.items.push(_225); + const _231: [rs.u64, rs.u8] = copy$tuple2_u64_u8(make(arg)); + own.items.push(_231); rs.vecCloneFrom(own, v, 16, copy$tuple2_u64_u8); v = own; } else if (_39 === 29) { const other: rs.Vec<[rs.u64, rs.u8]> = rs.vecWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 16); - const _236: rs.Iter<[rs.u64, rs.u8]> = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); - rs.iterExtend(other, _236, undefined, 16, true); + const _242: rs.Iter<[rs.u64, rs.u8]> = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); + rs.iterExtend(other, _242, undefined, 16, true); rs.vecAppend(v, other, 16); sized(out, other.items.length, rs.vecCapacity(other, 16)); } else if (_39 === 30 || _39 === 31) { @@ -494,36 +502,36 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, } else { end = len; } - const _323: rs.usize = ((arg >> 5) & 3) as rs.usize; - if (!(_323 < 4)) { - rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _323); - } - const n: rs.usize = [0, 2, 6, 17][_323]; - const _329: rs.u8 = (arg >> 3) & 3; - if (_329 === 0) { - const _334: rs.Vec<[rs.u64, rs.u8]> = v; - const _335: rs.Range = new rs.Range(start, end); - const _337: rs.Iter<[rs.u64, rs.u8]> = rs.iterMap(new rs.Range(0, n & 0xff), make); - rs.drop(rs.spliceFrom(rs.vecSplice(_334, _335, 16), _337, true)); - } else if (_329 === 1) { - const _341: rs.Vec<[rs.u64, rs.u8]> = v; - const _342: rs.Range = new rs.Range(start, end); - const _344: rs.Iter<[rs.u64, rs.u8]> = rs.iterMap(rs.iterFilter(new rs.Range(0, n & 0xff), (i3: rs.u8): boolean => { + const _329: rs.usize = ((arg >> 5) & 3) as rs.usize; + if (!(_329 < 4)) { + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _329); + } + const n: rs.usize = [0, 2, 6, 17][_329]; + const _335: rs.u8 = (arg >> 3) & 3; + if (_335 === 0) { + const _340: rs.Vec<[rs.u64, rs.u8]> = v; + const _341: rs.Range = new rs.Range(start, end); + const _343: rs.Iter<[rs.u64, rs.u8]> = rs.iterMap(new rs.Range(0, n & 0xff), make); + rs.drop(rs.spliceFrom(rs.vecSplice(_340, _341, 16), _343, true)); + } else if (_335 === 1) { + const _347: rs.Vec<[rs.u64, rs.u8]> = v; + const _348: rs.Range = new rs.Range(start, end); + const _350: rs.Iter<[rs.u64, rs.u8]> = rs.iterMap(rs.iterFilter(new rs.Range(0, n & 0xff), (i3: rs.u8): boolean => { return rs.u8Rem(i3, 4) !== 1; }), make); - rs.drop(rs.spliceFrom(rs.vecSplice(_341, _342, 16), _344)); - } else if (_329 === 2) { - const _349: rs.Vec<[rs.u64, rs.u8]> = v; - const _350: rs.Range = new rs.Range(start, end); - const _352: rs.Iter<[rs.u64, rs.u8]> = rs.iterMap(rs.iterChain(new rs.Range(0, n & 0xff), rs.iterFilter(new rs.Range(0, n & 0xff), (i2: rs.u8): boolean => { + rs.drop(rs.spliceFrom(rs.vecSplice(_347, _348, 16), _350)); + } else if (_335 === 2) { + const _355: rs.Vec<[rs.u64, rs.u8]> = v; + const _356: rs.Range = new rs.Range(start, end); + const _358: rs.Iter<[rs.u64, rs.u8]> = rs.iterMap(rs.iterChain(new rs.Range(0, n & 0xff), rs.iterFilter(new rs.Range(0, n & 0xff), (i2: rs.u8): boolean => { return rs.u8Rem(i2, 2) === 0; })), make); - rs.drop(rs.spliceFrom(rs.vecSplice(_349, _350, 16), _352)); + rs.drop(rs.spliceFrom(rs.vecSplice(_355, _356, 16), _358)); } else { - const _360: rs.Vec<[rs.u64, rs.u8]> = v; - const _361: rs.Range = new rs.Range(start, end); - const _363: rs.Vec<[rs.u64, rs.u8]> = rs.vecFromElem(copy$tuple2_u64_u8(make(arg)), n, copy$tuple2_u64_u8); - rs.drop(rs.spliceFrom(rs.vecSplice(_360, _361, 16), rs.vecIntoIter(_363), true)); + const _366: rs.Vec<[rs.u64, rs.u8]> = v; + const _367: rs.Range = new rs.Range(start, end); + const _369: rs.Vec<[rs.u64, rs.u8]> = rs.vecFromElem(copy$tuple2_u64_u8(make(arg)), n, copy$tuple2_u64_u8); + rs.drop(rs.spliceFrom(rs.vecSplice(_366, _367, 16), rs.vecIntoIter(_369), true)); } } else if (_39 === 36) { const keep3: () => boolean = alternate(); @@ -534,15 +542,15 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, const pairs: rs.Vec<[rs.u64, rs.u8][]> = rs.vecWithCapacity(rs.u8Rem(arg, 6) as rs.usize, 32); const iter4: rs.Iter> = rs.sliceChunksExact(rs.sliceFrom(v.items), 2); while (true) { - const _392: rs.Slice<[rs.u64, rs.u8]> | rs.Done = iter4.next(); - if (_392 === rs.DONE) { + const _398: rs.Slice<[rs.u64, rs.u8]> | rs.Done = iter4.next(); + if (_398 === rs.DONE) { break; } - rs.idx(_392, 0); - const _399: [rs.u64, rs.u8] = copy$tuple2_u64_u8(copy$tuple2_u64_u8(_392.data[_392.start])); - rs.idx(_392, 1); - const _398: [rs.u64, rs.u8][] = [_399, copy$tuple2_u64_u8(copy$tuple2_u64_u8(_392.data[_392.start + 1]))]; - pairs.items.push(_398); + rs.idx(_398, 0); + const _405: [rs.u64, rs.u8] = copy$tuple2_u64_u8(copy$tuple2_u64_u8(_398.data[_398.start])); + rs.idx(_398, 1); + const _404: [rs.u64, rs.u8][] = [_405, copy$tuple2_u64_u8(copy$tuple2_u64_u8(_398.data[_398.start + 1]))]; + pairs.items.push(_404); } const flat: rs.Vec<[rs.u64, rs.u8]> = rs.vecIntoFlattened(pairs, 2, 16); sized(out, flat.items.length, rs.vecCapacity(flat, 16)); @@ -682,7 +690,11 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n const rest: rs.Vec = rs.iterToVec(it2, "next", 2, true, 2); sized(out, rest.items.length, rs.vecCapacity(rest, 2)); } else if (_39 === 24) { - v = rs.vecFromElem(make(arg), rs.u8Rem(arg, 6) as rs.usize, undefined); + if ((arg & 64) === 0) { + v = rs.vecFromElem(make(arg), rs.u8Rem(arg, 6) as rs.usize, undefined); + } else { + v = rs.vecFromElem(make(arg), rs.u8Rem(arg, 6) as rs.usize, undefined); + } } else if (_39 === 25) { rs.vecPopIfMut(v, (_26: rs.Place): boolean => { return rs.u8Rem(arg, 2) === 1; @@ -693,14 +705,14 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n v = rs.iterToVec(rs.iterSlice(v.items), "next", 2, true, 2); } else if (_39 === 28) { const own: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 2); - const _225: rs.u16 = make(arg); - own.items.push(_225); + const _231: rs.u16 = make(arg); + own.items.push(_231); rs.vecCloneFrom(own, v, 2); v = own; } else if (_39 === 29) { const other: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 2); - const _236: rs.Iter = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); - rs.iterExtend(other, _236, undefined, 2, true); + const _242: rs.Iter = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); + rs.iterExtend(other, _242, undefined, 2, true); rs.vecAppend(v, other, 2); sized(out, other.items.length, rs.vecCapacity(other, 2)); } else if (_39 === 30 || _39 === 31) { @@ -735,36 +747,36 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n } else { end = len; } - const _323: rs.usize = ((arg >> 5) & 3) as rs.usize; - if (!(_323 < 4)) { - rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _323); - } - const n: rs.usize = [0, 2, 6, 17][_323]; - const _329: rs.u8 = (arg >> 3) & 3; - if (_329 === 0) { - const _334: rs.Vec = v; - const _335: rs.Range = new rs.Range(start, end); - const _337: rs.Iter = rs.iterMap(new rs.Range(0, n & 0xff), make); - rs.drop(rs.spliceFrom(rs.vecSplice(_334, _335, 2), _337, true)); - } else if (_329 === 1) { - const _341: rs.Vec = v; - const _342: rs.Range = new rs.Range(start, end); - const _344: rs.Iter = rs.iterMap(rs.iterFilter(new rs.Range(0, n & 0xff), (i3: rs.u8): boolean => { + const _329: rs.usize = ((arg >> 5) & 3) as rs.usize; + if (!(_329 < 4)) { + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _329); + } + const n: rs.usize = [0, 2, 6, 17][_329]; + const _335: rs.u8 = (arg >> 3) & 3; + if (_335 === 0) { + const _340: rs.Vec = v; + const _341: rs.Range = new rs.Range(start, end); + const _343: rs.Iter = rs.iterMap(new rs.Range(0, n & 0xff), make); + rs.drop(rs.spliceFrom(rs.vecSplice(_340, _341, 2), _343, true)); + } else if (_335 === 1) { + const _347: rs.Vec = v; + const _348: rs.Range = new rs.Range(start, end); + const _350: rs.Iter = rs.iterMap(rs.iterFilter(new rs.Range(0, n & 0xff), (i3: rs.u8): boolean => { return rs.u8Rem(i3, 4) !== 1; }), make); - rs.drop(rs.spliceFrom(rs.vecSplice(_341, _342, 2), _344)); - } else if (_329 === 2) { - const _349: rs.Vec = v; - const _350: rs.Range = new rs.Range(start, end); - const _352: rs.Iter = rs.iterMap(rs.iterChain(new rs.Range(0, n & 0xff), rs.iterFilter(new rs.Range(0, n & 0xff), (i2: rs.u8): boolean => { + rs.drop(rs.spliceFrom(rs.vecSplice(_347, _348, 2), _350)); + } else if (_335 === 2) { + const _355: rs.Vec = v; + const _356: rs.Range = new rs.Range(start, end); + const _358: rs.Iter = rs.iterMap(rs.iterChain(new rs.Range(0, n & 0xff), rs.iterFilter(new rs.Range(0, n & 0xff), (i2: rs.u8): boolean => { return rs.u8Rem(i2, 2) === 0; })), make); - rs.drop(rs.spliceFrom(rs.vecSplice(_349, _350, 2), _352)); + rs.drop(rs.spliceFrom(rs.vecSplice(_355, _356, 2), _358)); } else { - const _360: rs.Vec = v; - const _361: rs.Range = new rs.Range(start, end); - const _363: rs.Vec = rs.vecFromElem(make(arg), n, undefined); - rs.drop(rs.spliceFrom(rs.vecSplice(_360, _361, 2), rs.vecIntoIter(_363), true)); + const _366: rs.Vec = v; + const _367: rs.Range = new rs.Range(start, end); + const _369: rs.Vec = rs.vecFromElem(make(arg), n, undefined); + rs.drop(rs.spliceFrom(rs.vecSplice(_366, _367, 2), rs.vecIntoIter(_369), true)); } } else if (_39 === 36) { const keep3: () => boolean = alternate(); @@ -775,15 +787,15 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n const pairs: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 6) as rs.usize, 4); const iter4: rs.Iter> = rs.sliceChunksExact(rs.sliceFrom(v.items), 2); while (true) { - const _392: rs.Slice | rs.Done = iter4.next(); - if (_392 === rs.DONE) { + const _398: rs.Slice | rs.Done = iter4.next(); + if (_398 === rs.DONE) { break; } - rs.idx(_392, 0); - const _399: rs.u16 = _392.data[_392.start]; - rs.idx(_392, 1); - const _398: rs.u16[] = [_399, _392.data[_392.start + 1]]; - pairs.items.push(_398); + rs.idx(_398, 0); + const _405: rs.u16 = _398.data[_398.start]; + rs.idx(_398, 1); + const _404: rs.u16[] = [_405, _398.data[_398.start + 1]]; + pairs.items.push(_404); } const flat: rs.Vec = rs.vecIntoFlattened(pairs, 2, 2); sized(out, flat.items.length, rs.vecCapacity(flat, 2)); @@ -921,7 +933,11 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu const rest: rs.ByteVec = rs.iterToByteVec(it2, "next", true, 1); sized(out, rest.length, rest.data.length); } else if (_39 === 24) { - v = rs.byteVecOf(make(arg), rs.u8Rem(arg, 6) as rs.usize); + if ((arg & 64) === 0) { + v = rs.byteVecOf(make(arg), rs.u8Rem(arg, 6) as rs.usize); + } else { + v = rs.byteVecOf(make(arg), rs.u8Rem(arg, 6) as rs.usize); + } } else if (_39 === 25) { rs.byteVecPopIf(v, (_26: rs.Place): boolean => { return rs.u8Rem(arg, 2) === 1; @@ -932,14 +948,14 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu v = rs.iterToByteVec(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(v))), "next", true, 1); } else if (_39 === 28) { const own: rs.ByteVec = rs.byteVecWithCapacity(rs.u8Rem(arg, 8) as rs.usize); - const _225: rs.u8 = make(arg); - rs.byteVecPush(own, _225); + const _231: rs.u8 = make(arg); + rs.byteVecPush(own, _231); rs.byteVecCloneFrom(own, v); v = own; } else if (_39 === 29) { const other: rs.ByteVec = rs.byteVecWithCapacity(rs.u8Rem(arg, 8) as rs.usize); - const _236: rs.Iter = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); - rs.iterExtendBytes(other, _236, undefined, true); + const _242: rs.Iter = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); + rs.iterExtendBytes(other, _242, undefined, true); rs.byteVecAppend(v, other); sized(out, other.length, other.data.length); } else if (_39 === 30 || _39 === 31) { @@ -974,36 +990,36 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu } else { end = len; } - const _323: rs.usize = ((arg >> 5) & 3) as rs.usize; - if (!(_323 < 4)) { - rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _323); - } - const n: rs.usize = [0, 2, 6, 17][_323]; - const _329: rs.u8 = (arg >> 3) & 3; - if (_329 === 0) { - const _334: rs.ByteVec = v; - const _335: rs.Range = new rs.Range(start, end); - const _337: rs.Iter = rs.iterMap(new rs.Range(0, n & 0xff), make); - rs.drop(rs.spliceFrom(rs.byteVecSplice(_334, _335), _337, true)); - } else if (_329 === 1) { - const _341: rs.ByteVec = v; - const _342: rs.Range = new rs.Range(start, end); - const _344: rs.Iter = rs.iterMap(rs.iterFilter(new rs.Range(0, n & 0xff), (i3: rs.u8): boolean => { + const _329: rs.usize = ((arg >> 5) & 3) as rs.usize; + if (!(_329 < 4)) { + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _329); + } + const n: rs.usize = [0, 2, 6, 17][_329]; + const _335: rs.u8 = (arg >> 3) & 3; + if (_335 === 0) { + const _340: rs.ByteVec = v; + const _341: rs.Range = new rs.Range(start, end); + const _343: rs.Iter = rs.iterMap(new rs.Range(0, n & 0xff), make); + rs.drop(rs.spliceFrom(rs.byteVecSplice(_340, _341), _343, true)); + } else if (_335 === 1) { + const _347: rs.ByteVec = v; + const _348: rs.Range = new rs.Range(start, end); + const _350: rs.Iter = rs.iterMap(rs.iterFilter(new rs.Range(0, n & 0xff), (i3: rs.u8): boolean => { return rs.u8Rem(i3, 4) !== 1; }), make); - rs.drop(rs.spliceFrom(rs.byteVecSplice(_341, _342), _344)); - } else if (_329 === 2) { - const _349: rs.ByteVec = v; - const _350: rs.Range = new rs.Range(start, end); - const _352: rs.Iter = rs.iterMap(rs.iterChain(new rs.Range(0, n & 0xff), rs.iterFilter(new rs.Range(0, n & 0xff), (i2: rs.u8): boolean => { + rs.drop(rs.spliceFrom(rs.byteVecSplice(_347, _348), _350)); + } else if (_335 === 2) { + const _355: rs.ByteVec = v; + const _356: rs.Range = new rs.Range(start, end); + const _358: rs.Iter = rs.iterMap(rs.iterChain(new rs.Range(0, n & 0xff), rs.iterFilter(new rs.Range(0, n & 0xff), (i2: rs.u8): boolean => { return rs.u8Rem(i2, 2) === 0; })), make); - rs.drop(rs.spliceFrom(rs.byteVecSplice(_349, _350), _352)); + rs.drop(rs.spliceFrom(rs.byteVecSplice(_355, _356), _358)); } else { - const _360: rs.ByteVec = v; - const _361: rs.Range = new rs.Range(start, end); - const _363: rs.ByteVec = rs.byteVecOf(make(arg), n); - rs.drop(rs.spliceFrom(rs.byteVecSplice(_360, _361), rs.byteVecIntoIter(_363), true)); + const _366: rs.ByteVec = v; + const _367: rs.Range = new rs.Range(start, end); + const _369: rs.ByteVec = rs.byteVecOf(make(arg), n); + rs.drop(rs.spliceFrom(rs.byteVecSplice(_366, _367), rs.byteVecIntoIter(_369), true)); } } else if (_39 === 36) { const keep3: () => boolean = alternate(); @@ -1014,15 +1030,15 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu const pairs: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 6) as rs.usize, 2); const iter4: rs.Iter = rs.byteSliceChunksExact(rs.byteVecSlice(v), 2); while (true) { - const _392: rs.ByteSlice | rs.Done = iter4.next(); - if (_392 === rs.DONE) { + const _398: rs.ByteSlice | rs.Done = iter4.next(); + if (_398 === rs.DONE) { break; } - rs.idx(_392, 0); - const _399: rs.u8 = _392.data[_392.start]; - rs.idx(_392, 1); - const _398: Uint8Array = Uint8Array.of(_399, _392.data[_392.start + 1]); - pairs.items.push(_398); + rs.idx(_398, 0); + const _405: rs.u8 = _398.data[_398.start]; + rs.idx(_398, 1); + const _404: Uint8Array = Uint8Array.of(_405, _398.data[_398.start + 1]); + pairs.items.push(_404); } const flat: rs.ByteVec = rs.byteVecIntoFlattened(pairs, 2); sized(out, flat.length, flat.data.length); @@ -1167,8 +1183,13 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: const rest: rs.Vec = rs.iterToVec(it2, undefined, 0, true); sized(out, rest.items.length, rs.vecCapacity(rest, 0)); } else if (_39 === 24) { - make(arg); - v = rs.vecFromElem(undefined, rs.u8Rem(arg, 6) as rs.usize, undefined); + if ((arg & 64) === 0) { + make(arg); + v = rs.vecFromElem(undefined, rs.u8Rem(arg, 6) as rs.usize, undefined); + } else { + make(arg); + v = rs.vecFromElem(undefined, rs.u8Rem(arg, 6) as rs.usize, undefined); + } } else if (_39 === 25) { rs.vecPopIfMut(v, (_26: rs.Place): boolean => { return rs.u8Rem(arg, 2) === 1; @@ -1185,8 +1206,8 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: v = own; } else if (_39 === 29) { const other: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 0); - const _236: rs.Iter = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); - rs.iterExtend(other, _236, undefined, 0, true); + const _242: rs.Iter = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); + rs.iterExtend(other, _242, undefined, 0, true); rs.vecAppend(v, other, 0); sized(out, other.items.length, rs.vecCapacity(other, 0)); } else if (_39 === 30 || _39 === 31) { @@ -1200,9 +1221,9 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: newLen = rs.u8Rem(arg, 24) as rs.usize; } if (rs.u8Rem(op, 41) === 30) { - const _265: rs.Vec = v; + const _271: rs.Vec = v; make(arg); - rs.vecResize(_265, newLen, undefined, 0, undefined); + rs.vecResize(_271, newLen, undefined, 0, undefined); } else { rs.vecResizeWith(v, newLen, (): undefined => { make(arg); @@ -1223,37 +1244,37 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: } else { end = len; } - const _323: rs.usize = ((arg >> 5) & 3) as rs.usize; - if (!(_323 < 4)) { - rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _323); - } - const n: rs.usize = [0, 2, 6, 17][_323]; - const _329: rs.u8 = (arg >> 3) & 3; - if (_329 === 0) { - const _334: rs.Vec = v; - const _335: rs.Range = new rs.Range(start, end); - const _337: rs.Iter = rs.iterMap(new rs.Range(0, n & 0xff), make); - rs.drop(rs.spliceFrom(rs.vecSplice(_334, _335, 0), _337, true)); - } else if (_329 === 1) { - const _341: rs.Vec = v; - const _342: rs.Range = new rs.Range(start, end); - const _344: rs.Iter = rs.iterMap(rs.iterFilter(new rs.Range(0, n & 0xff), (i3: rs.u8): boolean => { + const _329: rs.usize = ((arg >> 5) & 3) as rs.usize; + if (!(_329 < 4)) { + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _329); + } + const n: rs.usize = [0, 2, 6, 17][_329]; + const _335: rs.u8 = (arg >> 3) & 3; + if (_335 === 0) { + const _340: rs.Vec = v; + const _341: rs.Range = new rs.Range(start, end); + const _343: rs.Iter = rs.iterMap(new rs.Range(0, n & 0xff), make); + rs.drop(rs.spliceFrom(rs.vecSplice(_340, _341, 0), _343, true)); + } else if (_335 === 1) { + const _347: rs.Vec = v; + const _348: rs.Range = new rs.Range(start, end); + const _350: rs.Iter = rs.iterMap(rs.iterFilter(new rs.Range(0, n & 0xff), (i3: rs.u8): boolean => { return rs.u8Rem(i3, 4) !== 1; }), make); - rs.drop(rs.spliceFrom(rs.vecSplice(_341, _342, 0), _344)); - } else if (_329 === 2) { - const _349: rs.Vec = v; - const _350: rs.Range = new rs.Range(start, end); - const _352: rs.Iter = rs.iterMap(rs.iterChain(new rs.Range(0, n & 0xff), rs.iterFilter(new rs.Range(0, n & 0xff), (i2: rs.u8): boolean => { + rs.drop(rs.spliceFrom(rs.vecSplice(_347, _348, 0), _350)); + } else if (_335 === 2) { + const _355: rs.Vec = v; + const _356: rs.Range = new rs.Range(start, end); + const _358: rs.Iter = rs.iterMap(rs.iterChain(new rs.Range(0, n & 0xff), rs.iterFilter(new rs.Range(0, n & 0xff), (i2: rs.u8): boolean => { return rs.u8Rem(i2, 2) === 0; })), make); - rs.drop(rs.spliceFrom(rs.vecSplice(_349, _350, 0), _352)); + rs.drop(rs.spliceFrom(rs.vecSplice(_355, _356, 0), _358)); } else { - const _360: rs.Vec = v; + const _366: rs.Vec = v; make(arg); - const _361: rs.Range = new rs.Range(start, end); - const _363: rs.Vec = rs.vecFromElem(undefined, n, undefined); - rs.drop(rs.spliceFrom(rs.vecSplice(_360, _361, 0), rs.vecIntoIter(_363), true)); + const _367: rs.Range = new rs.Range(start, end); + const _369: rs.Vec = rs.vecFromElem(undefined, n, undefined); + rs.drop(rs.spliceFrom(rs.vecSplice(_366, _367, 0), rs.vecIntoIter(_369), true)); } } else if (_39 === 36) { const keep3: () => boolean = alternate(); @@ -1264,14 +1285,14 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: const pairs: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 6) as rs.usize, 0); const iter4: rs.Iter> = rs.sliceChunksExact(rs.sliceFrom(v.items), 2); while (true) { - const _392: rs.Slice | rs.Done = iter4.next(); - if (_392 === rs.DONE) { + const _398: rs.Slice | rs.Done = iter4.next(); + if (_398 === rs.DONE) { break; } - rs.idx(_392, 0); - _392.data[_392.start]; - rs.idx(_392, 1); - _392.data[_392.start + 1]; + rs.idx(_398, 0); + _398.data[_398.start]; + rs.idx(_398, 1); + _398.data[_398.start + 1]; pairs.items.push([undefined, undefined]); } const flat: rs.Vec = rs.vecIntoFlattened(pairs, 2, 0); diff --git a/ts/fixtures/lang/capacity/src/capacity.rs b/ts/fixtures/lang/capacity/src/capacity.rs index 45ed9cb4e..49a51d57e 100644 --- a/ts/fixtures/lang/capacity/src/capacity.rs +++ b/ts/fixtures/lang/capacity/src/capacity.rs @@ -127,7 +127,13 @@ fn vec_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) let rest = it.collect::>(); sized(out, rest.len(), rest.capacity()); } - 24 => v = vec![make(arg); usize::from(arg % 6)], + // `vec!`, or the deprecated function it once called, which std keeps and still fills + // the same. + 24 => match arg & 0x40 { + 0 => v = vec![make(arg); usize::from(arg % 6)], + #[allow(deprecated)] + _ => v = std::vec::from_elem(make(arg), usize::from(arg % 6)), + }, 25 => drop(v.pop_if(|_| arg % 2 == 1)), // Joined, with room for exactly what it joins. 26 => v = [v.clone(), v].concat(), diff --git a/ts/fixtures/lang/iters/expected/iters.Flicker.ts b/ts/fixtures/lang/iters/expected/iters.Flicker.ts new file mode 100644 index 000000000..b233acd63 --- /dev/null +++ b/ts/fixtures/lang/iters/expected/iters.Flicker.ts @@ -0,0 +1,25 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "./rs.ts"; + +/** An iterator that is not fused: it ends once, then yields `data`, then ends for good. */ +export interface Flicker { + dataData: Uint8Array; + dataStart: number; + dataLen: number; + calls: rs.usize; +} + +export function next$iter_Iterator(self: Flicker): rs.u8 | rs.Done { + self.calls = rs.usizeAdd(self.calls, 1); + if (self.calls === 1) { + return rs.DONE; + } + return rs.iterFromOption(rs.byteSliceGet(new rs.ByteSlice(self.dataData, self.dataStart, self.dataLen), rs.usizeSub(self.calls, 2))); +} + +export function nextBack$iter_DoubleEndedIterator(self: Flicker): rs.u8 | undefined { + return rs.iterToOption(next$iter_Iterator(self)); +} + +//# sourceMappingURL=iters.Flicker.ts.map diff --git a/ts/fixtures/lang/iters/expected/iters.ts b/ts/fixtures/lang/iters/expected/iters.ts index 62888f99b..5e93fa8a8 100644 --- a/ts/fixtures/lang/iters/expected/iters.ts +++ b/ts/fixtures/lang/iters/expected/iters.ts @@ -11,6 +11,7 @@ import * as Bumped from "./iters.Bumped.ts"; import * as Countdown from "./iters.Countdown.ts"; import * as Doubled from "./iters.Doubled.ts"; import * as Evens from "./iters.Evens.ts"; +import * as Flicker from "./iters.Flicker.ts"; import * as Gaps from "./iters.Gaps.ts"; import * as Halving from "./iters.Halving.ts"; import * as Held from "./iters.Held.ts"; @@ -11638,4 +11639,30 @@ export function heldFields(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo } } +/** + * Adaptors over an iterator that is not fused, advanced through a `Chain`'s `nth`: a + * `skip`, which takes no step while advanced by none, and a `fuse` advanced from the back, + * which drops its iterator once it falls short. Then what each still yields. + */ +export function unfused(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const flicker: () => Flicker.Flicker = (): Flicker.Flicker => { + return { dataData: data.data, dataStart: data.start, dataLen: data.length, calls: 0 }; + }; + const n: rs.usize = rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), 3) as rs.usize; + const _11: rs.u8 = rs.u8Rem(kind, 3); + if (_11 === 0) { + const s: rs.Iter = rs.iterSkip(rs.iterFrom(flicker(), Flicker.next$iter_Iterator, undefined, { back: (it: Flicker.Flicker) => rs.iterFromOption(Flicker.nextBack$iter_DoubleEndedIterator(it)) }), 1); + rs.iterExtendBytes(out, rs.iterOption(rs.iterNth(rs.iterChain(rs.iterBorrow(s), rs.iterSlice(Uint8Array.of(153))), n)), undefined, true); + rs.iterExtendBytes(out, s, "next"); + } else if (_11 === 1) { + const r: rs.Iter = rs.iterRev(rs.iterFuse(rs.iterFrom(flicker(), Flicker.next$iter_Iterator, undefined, { back: (it: Flicker.Flicker) => rs.iterFromOption(Flicker.nextBack$iter_DoubleEndedIterator(it)) }))); + rs.iterExtendBytes(out, rs.iterOption(rs.iterNth(rs.iterChain(rs.iterBorrow(r), rs.iterSlice(Uint8Array.of(153))), n)), undefined, true); + rs.iterExtendBytes(out, r, "next"); + } else { + const f: rs.Iter = rs.iterFuse(rs.iterFrom(flicker(), Flicker.next$iter_Iterator, undefined, { back: (it: Flicker.Flicker) => rs.iterFromOption(Flicker.nextBack$iter_DoubleEndedIterator(it)) })); + rs.iterExtendBytes(out, rs.iterOption(rs.iterNthBack(f, n)), undefined, true); + rs.iterExtendBytes(out, f, "next"); + } +} + //# sourceMappingURL=iters.ts.map diff --git a/ts/fixtures/lang/iters/expected/lib.ts b/ts/fixtures/lang/iters/expected/lib.ts index dc4d2aa3f..7f0c42d76 100644 --- a/ts/fixtures/lang/iters/expected/lib.ts +++ b/ts/fixtures/lang/iters/expected/lib.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { adaptors, consumers, reducers, peekedOthers, skips, ranked, ranges, options, optionItems, own, values, returned, zips, zipsBack, rangeFroms, rangeMethods, compares, lent, byValue, heldFields } from "./iters.ts"; +import { adaptors, consumers, reducers, peekedOthers, skips, ranked, ranges, options, optionItems, own, values, returned, zips, zipsBack, rangeFroms, rangeMethods, compares, lent, byValue, heldFields, unfused } from "./iters.ts"; import type * as Ticks from "./iters.Ticks.ts"; export function drop$iters_Ticks(_1: Ticks.Ticks): void { @@ -41,7 +41,7 @@ export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.By optionItems(data8, out8); }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::lent", (_218: rs.u8, data9: rs.ByteSlice, out9: rs.ByteVec): undefined => { lent(data9, out9); - }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::by_value", byValue as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::held_fields", heldFields as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::by_value", byValue as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::held_fields", heldFields as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::unfused", unfused as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/iters/src/iters.rs b/ts/fixtures/lang/iters/src/iters.rs index 265b64bc2..ee50546ee 100644 --- a/ts/fixtures/lang/iters/src/iters.rs +++ b/ts/fixtures/lang/iters/src/iters.rs @@ -2212,3 +2212,52 @@ pub fn held_fields(kind: u8, data: &[u8], out: &mut Vec) { ), } } + +/// An iterator that is not fused: it ends once, then yields `data`, then ends for good. +struct Flicker<'a> { + data: &'a [u8], + calls: usize, +} + +impl Iterator for Flicker<'_> { + type Item = u8; + + fn next(&mut self) -> Option { + self.calls += 1; + match self.calls { + 1 => None, + calls => self.data.get(calls - 2).copied(), + } + } +} + +impl DoubleEndedIterator for Flicker<'_> { + fn next_back(&mut self) -> Option { + self.next() + } +} + +/// Adaptors over an iterator that is not fused, advanced through a `Chain`'s `nth`: a +/// `skip`, which takes no step while advanced by none, and a `fuse` advanced from the back, +/// which drops its iterator once it falls short. Then what each still yields. +pub fn unfused(kind: u8, data: &[u8], out: &mut Vec) { + let flicker = || Flicker { data, calls: 0 }; + let n = usize::from(data.first().copied().unwrap_or(0) % 3); + match kind % 3 { + 0 => { + let mut s = flicker().skip(1); + out.extend(s.by_ref().chain([0x99]).nth(n)); + out.extend(s); + } + 1 => { + let mut r = flicker().fuse().rev(); + out.extend(r.by_ref().chain([0x99]).nth(n)); + out.extend(r); + } + _ => { + let mut f = flicker().fuse(); + out.extend(f.nth_back(n)); + out.extend(f); + } + } +} diff --git a/ts/fixtures/lang/iters/src/lib.rs b/ts/fixtures/lang/iters/src/lib.rs index 7c2a00243..5bf8fbc8a 100644 --- a/ts/fixtures/lang/iters/src/lib.rs +++ b/ts/fixtures/lang/iters/src/lib.rs @@ -38,5 +38,6 @@ fn cases() -> Vec<(&'static str, Case)> { ("iters::lent", |_, data, out| iters::lent(data, out)), ("iters::by_value", iters::by_value), ("iters::held_fields", iters::held_fields), + ("iters::unfused", iters::unfused), ] } diff --git a/ts/fixtures/lang/panics/hook/expected/hooked.Short.ts b/ts/fixtures/lang/panics/hook/expected/hooked.Short.ts index 7a0a34eed..8c29bef93 100644 --- a/ts/fixtures/lang/panics/hook/expected/hooked.Short.ts +++ b/ts/fixtures/lang/panics/hook/expected/hooked.Short.ts @@ -15,7 +15,7 @@ export function next$iter_Iterator(self: Short): rs.u8 | rs.Done { } export function sizeHint$iter_Iterator(self: Short): [rs.usize, rs.usize | undefined] { - const len: rs.usize = rs.usizeAdd(self._0 as rs.usize, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 439, col: 19 }); + const len: rs.usize = rs.usizeAdd(self._0 as rs.usize, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 440, col: 19 }); return [len, len] as [rs.usize, rs.usize | undefined]; } diff --git a/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts b/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts index c65470a9a..39ecc7f56 100644 --- a/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts +++ b/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts @@ -20,7 +20,7 @@ export function fmt$fmt_Display(self: Shown, f: rs.Formatter): rs.Result) & 0xff); } @@ -210,9 +212,9 @@ export function aborted(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const captured2 = prev; rs.setHook(rs.closure((info: rs.PanicHookInfo): undefined => { record(info); - const _4: rs.u8 = rs.u8Rem(captured, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 167, col: 15 }); + const _4: rs.u8 = rs.u8Rem(captured, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 168, col: 15 }); if (_4 === 0) { - rs.panicFmt(["again"], { file: "fixtures/lang/panics/src/hooked.rs", line: 168, col: 18 }); + rs.panicFmt(["again"], { file: "fixtures/lang/panics/src/hooked.rs", line: 169, col: 18 }); } else if (_4 === 1) { rs.drop(rs.takeHook()); } else { @@ -222,13 +224,13 @@ export function aborted(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.drop(captured2); }), { capacity: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/raw_vec/mod.rs", line: 29, col: 5 }, trusted_capacity: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/spec_from_iter_nested.rs", line: 57, col: 18 }, swap_remove: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 2180, col: 13 }, vec_set_len: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 2140, col: 9 }, into_flattened: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 3757, col: 36 }, rotate_left: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/slice/mod.rs", line: 3900, col: 9 }, rotate_right: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/slice/mod.rs", line: 3946, col: 9 }, ord_violation: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/slice/sort/shared/smallsort.rs", line: 854, col: 5 }, ord_clamp: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cmp.rs", line: 1166, col: 9 }, f32_clamp: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/num/f32.rs", line: 1441, col: 9 }, f64_clamp: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/num/f64.rs", line: 1420, col: 9 }, encode_utf8: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/char/methods.rs", line: 2581, col: 9 }, encode_utf16: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/char/methods.rs", line: 2675, col: 13 }, format: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/fmt.rs", line: 657, col: 14 }, to_string: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/string.rs", line: 3049, col: 14 }, debug_struct_fields: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/fmt/mod.rs", line: 2589, col: 41 }, debug_enum: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/fmt/mod.rs", line: 2606, col: 26 }, exact_len: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/traits/exact_size.rs", line: 122, col: 9 }, join_len: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/str.rs", line: 177, col: 10 }, int_sum: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }, int_forward: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/range.rs", line: 554, col: 1 }, char_forward: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/range.rs", line: 119, col: 45 }, hash_capacity: { file: "/cargo/registry/25cdd57fae9f0462/hashbrown-0.17.1/src/raw.rs", line: 36, col: 40 }, btree_range_equal_BTreeSet: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 110, col: 21 }, btree_range_equal_BTreeMap: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 112, col: 21 }, btree_range_order_BTreeSet: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 119, col: 21 }, btree_range_order_BTreeMap: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 121, col: 21 }, deque_insert: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 2614, col: 9 }, deque_swap_i: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 1062, col: 9 }, deque_swap_j: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 1063, col: 9 }, deque_rotate_left: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 3200, col: 9 }, deque_rotate_right: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 3245, col: 9 }, deque_split_off: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 2726, col: 9 }, list_split_off: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/linked_list.rs", line: 1067, col: 9 }, mutex_lock: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/std/src/sys/sync/mutex/no_threads.rs", line: 31, col: 9 }, once_force: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/std/src/sync/once.rs", line: 227, col: 20 }, reentrant_init: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell/once.rs", line: 325, col: 66 }, lazy_poisoned: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell/lazy.rs", line: 386, col: 5 }, ready_poll: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/future/ready.rs", line: 23, col: 35 }, ready_into_inner: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/future/ready.rs", line: 46, col: 16 }, duration_new: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 283, col: 18 }, duration_from_mins: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 542, col: 13 }, duration_from_hours: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 512, col: 13 }, duration_add: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1397, col: 31 }, duration_sub: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1417, col: 31 }, duration_mul: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1437, col: 31 }, zip_next_back: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/adapters/zip.rs", line: 213, col: 5 }, bytes_advance: { file: "bytes/source/lib.rs", line: 207, col: 5 }, bytes_does_not_fit: { file: "bytes/source/lib.rs", line: 215, col: 5 }, bytes_slice: { file: "bytes/source/bytes.rs", line: 374, col: 28 }, bytes_slice_ref_start: { file: "bytes/source/bytes.rs", line: 426, col: 9 }, bytes_slice_ref_end: { file: "bytes/source/bytes.rs", line: 432, col: 9 }, bytes_split_off: { file: "bytes/source/bytes.rs", line: 481, col: 9 }, bytes_split_to: { file: "bytes/source/bytes.rs", line: 533, col: 9 }, bytes_buf_advance: { file: "bytes/source/bytes.rs", line: 694, col: 9 }, bytes_mut_split_off: { file: "bytes/source/bytes_mut.rs", line: 329, col: 9 }, bytes_mut_split_to: { file: "bytes/source/bytes_mut.rs", line: 408, col: 9 }, bytes_mut_set_len: { file: "bytes/source/bytes_mut.rs", line: 545, col: 9 }, bytes_mut_overflow: { file: "bytes/source/bytes_mut.rs", line: 700, col: 21 }, bytes_mut_overflow_offset: { file: "bytes/source/bytes_mut.rs", line: 720, col: 29 }, bytes_mut_buf_advance: { file: "bytes/source/bytes_mut.rs", line: 1246, col: 9 } }); rs.byteVecPush(out, n); - const _13: rs.u8 = rs.u8Rem(kind, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 174, col: 11 }); + const _13: rs.u8 = rs.u8Rem(kind, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 175, col: 11 }); if (_13 === 3 || _13 === 4) { - const _19: Shown.Shown = { again: rs.u8Rem(kind, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 175, col: 56 }) === 4 }; + const _19: Shown.Shown = { again: rs.u8Rem(kind, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 176, col: 56 }) === 4 }; const args6 = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => Shown.fmt$fmt_Display(_19, f)]; - rs.panicFmt(["first ", args6[0], " ", args6[1]], { file: "fixtures/lang/panics/src/hooked.rs", line: 175, col: 18 }); + rs.panicFmt(["first ", args6[0], " ", args6[1]], { file: "fixtures/lang/panics/src/hooked.rs", line: 176, col: 18 }); } else { - rs.panicFmt(["first ", (f: rs.Formatter) => rs.u8Display(n, f)], { file: "fixtures/lang/panics/src/hooked.rs", line: 176, col: 14 }); + rs.panicFmt(["first ", (f: rs.Formatter) => rs.u8Display(n, f)], { file: "fixtures/lang/panics/src/hooked.rs", line: 177, col: 14 }); } } @@ -259,13 +261,13 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _19: rs.u16[] = [n as rs.u16]; const set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterSlice(_19), true, undefined, undefined, 2, true); b0: { - const k: rs.u8 = rs.u8Rem(kind, 87, { file: "fixtures/lang/panics/src/hooked.rs", line: 198, col: 11 }); + const k: rs.u8 = rs.u8Rem(kind, 87, { file: "fixtures/lang/panics/src/hooked.rs", line: 199, col: 11 }); if (k === 0) { - rs.byteVecPush(out, rs.byteVecWithCapacity(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 199, col: 48 })).length & 0xff); + rs.byteVecPush(out, rs.byteVecWithCapacity(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 200, col: 48 })).length & 0xff); } else if (k === 1) { - rs.byteSliceRotateRight(rs.byteVecSlice(rs.byteVecFrom(rs.byteVecView(v))), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 200, col: 37 })); + rs.byteSliceRotateRight(rs.byteVecSlice(rs.byteVecFrom(rs.byteVecView(v))), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 201, col: 37 })); } else if (k === 2) { - rs.byteVecPush(out, rs.clamp(n, rs.max(n, 1), rs.u8Sub(rs.max(n, 1), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 201, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 201, col: 25 })); + rs.byteVecPush(out, rs.clamp(n, rs.max(n, 1), rs.u8Sub(rs.max(n, 1), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 202, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 202, col: 25 })); } else if (k === 3) { rs.byteVecPush(out, rs.u8FromF64(rs.f64Clamp(n as rs.f64, 1.0, 0.0))); } else if (k === 4) { @@ -273,7 +275,7 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else if (k === 5) { rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.charEncodeUtf8(rs.max(n, 128) as rs.char, rs.byteSliceFrom(Uint8Array.of(0))).v)); } else if (k === 6) { - const _62: rs.char = rs.optionUnwrap(rs.charFromU32(rs.u32Add(128512, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 206, col: 28 })), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 207, col: 18 }); + const _62: rs.char = rs.optionUnwrap(rs.charFromU32(rs.u32Add(128512, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 207, col: 28 })), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 208, col: 18 }); const _69: rs.u16[] = [0]; rs.byteVecPush(out, rs.charEncodeUtf16(_62, rs.sliceFrom(_69)).length & 0xff); } else if (k === 7) { @@ -282,7 +284,7 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return _250[1]; }), "next"); } else if (k === 8) { - const _81: rs.Range = new rs.Range(rs.u16Add(n as rs.u16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 215, col: 35 }), n as rs.u16); + const _81: rs.Range = new rs.Range(rs.u16Add(n as rs.u16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 216, col: 35 }), n as rs.u16); rs.iterExtendBytes(out, rs.iterMap(rs.btreeRange(map, _81), (_244: [rs.u16, rs.u8]): rs.u8 => { return _244[1]; }), "next"); @@ -292,29 +294,29 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return _239 & 0xff; }), "next"); } else if (k === 10) { - const _97: rs.Range = new rs.Range(rs.u16Add(n as rs.u16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 220, col: 36 }), n as rs.u16); + const _97: rs.Range = new rs.Range(rs.u16Add(n as rs.u16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 221, col: 36 }), n as rs.u16); rs.iterExtendBytes(out, rs.iterMap(rs.btreeRangeKeys(set, _97), (_237: rs.u16): rs.u8 => { return _237 & 0xff; }), "next"); } else if (k === 11) { - rs.dequeInsert(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 221, col: 36 }), n); + rs.dequeInsert(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 222, col: 36 }), n); } else if (k === 12) { - rs.dequeSwap(rs.dequeClone(deque), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 222, col: 34 }), 0); + rs.dequeSwap(rs.dequeClone(deque), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 223, col: 34 }), 0); } else if (k === 13) { - rs.dequeSwap(rs.dequeClone(deque), 0, rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 223, col: 37 })); + rs.dequeSwap(rs.dequeClone(deque), 0, rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 224, col: 37 })); } else if (k === 14) { - rs.dequeRotate(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 224, col: 41 })); + rs.dequeRotate(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 225, col: 41 })); } else if (k === 15) { - rs.dequeRotate(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 225, col: 42 }), true); + rs.dequeRotate(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 226, col: 42 }), true); } else if (k === 16) { - rs.iterExtendBytes(out, rs.dequeIntoIter(rs.dequeSplitOff(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 226, col: 50 }))), undefined, true); + rs.iterExtendBytes(out, rs.dequeIntoIter(rs.dequeSplitOff(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 227, col: 50 }))), undefined, true); } else if (k === 17) { const _136: Uint8Array = Uint8Array.of(n); - rs.iterExtendBytes(out, rs.listIter(rs.listSplitOff(rs.listExtend(rs.listNew() as rs.LinkedList, rs.iterSlice(_136)), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 227, col: 58 }))), undefined, true); + rs.iterExtendBytes(out, rs.listIter(rs.listSplitOff(rs.listExtend(rs.listNew() as rs.LinkedList, rs.iterSlice(_136)), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 228, col: 58 }))), undefined, true); } else if (k === 18) { const mutex: rs.Mutex = new rs.Mutex(n); const _held: rs.Result, rs.Mutex> = rs.Ok(rs.mutexLock(mutex)); - const _146: rs.Mutex = rs.resultUnwrap(rs.Ok(rs.mutexLock(mutex)), rs.fmtPoisonErrorDebug, { file: "fixtures/lang/panics/src/hooked.rs", line: 231, col: 36 }); + const _146: rs.Mutex = rs.resultUnwrap(rs.Ok(rs.mutexLock(mutex)), rs.fmtPoisonErrorDebug, { file: "fixtures/lang/panics/src/hooked.rs", line: 232, col: 36 }); rs.byteVecPush(out, _146.value); rs.mutexUnlock(_146); drop$Result_sync_MutexGuard_u8_sync_PoisonError_sync_MutexGuard_u8(_held); @@ -351,40 +353,40 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } rs.byteVecPush(out, ready2.intoInner()); } else if (k === 23) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationNew({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u32Add(1000000000, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 258, col: 48 }))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationNew({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u32Add(1000000000, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 259, col: 48 }))) & 0xff); } else if (k === 24) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromMins(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 259, col: 44 }))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromMins(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 260, col: 44 }))) & 0xff); } else if (k === 25) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromHours(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 260, col: 45 }))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromHours(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 261, col: 45 }))) & 0xff); } else if (k === 26) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationSub({ secs: 0, nanos: 0 }, rs.durationFromSecs(rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 261, col: 62 })))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationSub({ secs: 0, nanos: 0 }, rs.durationFromSecs(rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 262, col: 62 })))) & 0xff); } else if (k === 27) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationMul({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.u32Add(n as rs.u32, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 262, col: 41 }))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationMul({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.u32Add(n as rs.u32, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 263, col: 41 }))) & 0xff); } else if (k === 28) { const _231: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); - const _233: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 263, col: 44 }), rs.usizeStep); + const _233: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 264, col: 44 }), rs.usizeStep); rs.byteVecExtendFromWithin(_231, _233, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 3704, col: 21 }); } else if (k === 29) { const _238: rs.VecDeque = rs.dequeClone(deque); - const _240: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 264, col: 46 }), rs.usizeStep); + const _240: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 265, col: 46 }), rs.usizeStep); rs.iterExtendBytes(out, rs.dequeDrain(_238, _240, undefined, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 2000, col: 36 }), "next"); } else if (k === 30) { - const _245: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 265, col: 38 }), rs.usizeStep); + const _245: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 266, col: 38 }), rs.usizeStep); rs.iterExtendBytes(out, rs.dequeRange(deque, _245, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 1847, col: 36 }), undefined, true); } else if (k === 31) { const _251: rs.VecDeque = rs.dequeClone(deque); - const _253: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 266, col: 50 }), rs.usizeStep); + const _253: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 267, col: 50 }), rs.usizeStep); rs.iterExtendBytes(out, rs.iterMap(rs.dequeRangeMut(_251, _253, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 1847, col: 36 }), (v6: rs.Place): rs.u8 => { return v6.v; }), undefined, true); } else if (k === 32) { const cell2: rs.RefCell = new rs.RefCell(rs.byteVecFrom(Uint8Array.of(n))); - const _held2: rs.RefCell = rs.refCellBorrow(cell2, { file: "fixtures/lang/panics/src/hooked.rs", line: 269, col: 30 }); + const _held2: rs.RefCell = rs.refCellBorrow(cell2, { file: "fixtures/lang/panics/src/hooked.rs", line: 270, col: 30 }); rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.refCellReplace(cell2, new rs.ByteVec(), { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell.rs", line: 1436, col: 14 })), undefined, true); rs.refRelease(_held2); } else if (k === 33) { ((cell4: rs.RefCell): undefined => { - rs.refCellBorrow(cell4, { file: "fixtures/lang/panics/src/hooked.rs", line: 273, col: 54 }); + rs.refCellBorrow(cell4, { file: "fixtures/lang/panics/src/hooked.rs", line: 274, col: 54 }); })(SHARED.get()); rs.localKeyWithBorrowMutPlace(SHARED, (v5: rs.Place): undefined => { v5.v = n; @@ -400,25 +402,25 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }); } else if (k === 35) { const _277: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); - const _279: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 280, col: 43 }), rs.usizeStep); + const _279: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 281, col: 43 }), rs.usizeStep); const _282: Uint8Array = Uint8Array.of(n); rs.iterExtendBytes(out, rs.spliceFrom(rs.byteVecSplice(_277, _279, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 3095, col: 36 }), rs.iterSlice(_282), true), "next"); } else if (k === 36) { - rs.iterExtendBytes(out, rs.iterOption(option_map$04ry0e1(option_map$18ftgyp(rs.charFromDigit(n as rs.u32, rs.u32Add(37, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 282, col: 44 }), { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/char/convert.rs", line: 332, col: 9 }), (a02: rs.char): rs.u32 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$04ry0e1(option_map$18ftgyp(rs.charFromDigit(n as rs.u32, rs.u32Add(37, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 283, col: 44 }), { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/char/convert.rs", line: 332, col: 9 }), (a02: rs.char): rs.u32 => { return a02 as rs.u32; }), (c2: rs.u32): rs.u8 => { return c2 & 0xff; })), undefined, true); } else if (k === 37) { - const _294: rs.usize = rs.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 286, col: 59 }); + const _294: rs.usize = rs.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 287, col: 59 }); if (!(_294 < 2)) { - rs.panicSizes(["index out of bounds: the len is ", 2, " but the index is ", _294], { file: "fixtures/lang/panics/src/hooked.rs", line: 286, col: 21 }); + rs.panicSizes(["index out of bounds: the len is ", 2, " but the index is ", _294], { file: "fixtures/lang/panics/src/hooked.rs", line: 287, col: 21 }); } rs.fence([0, 4][_294], { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/sync/atomic.rs", line: 4822, col: 24 }); } else if (k === 38) { - const _301: rs.usize = rs.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 287, col: 68 }); + const _301: rs.usize = rs.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 288, col: 68 }); if (!(_301 < 2)) { - rs.panicSizes(["index out of bounds: the len is ", 2, " but the index is ", _301], { file: "fixtures/lang/panics/src/hooked.rs", line: 287, col: 30 }); + rs.panicSizes(["index out of bounds: the len is ", 2, " but the index is ", _301], { file: "fixtures/lang/panics/src/hooked.rs", line: 288, col: 30 }); } rs.fence([0, 4][_301], { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/sync/atomic.rs", line: 4907, col: 24 }); } else if (k === 39) { @@ -436,91 +438,91 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else if (k === 45) { rs.byteVecPush(out, rs.u64Low(rs.durationAsSecs(rs.durationSum(rs.iterSlice([{ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.durationFromSecs(rs.max(n, 1) as rs.u64)]), undefined, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1513, col: 9 }))) & 0xff); } else if (k === 46) { - rs.byteVecPush(out, rs.u64Low(rs.durationAsSecs(rs.durationSum(rs.iterSlice([{ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.durationNew(rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 301, col: 43 }), 0)]), undefined, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1520, col: 9 }))) & 0xff); + rs.byteVecPush(out, rs.u64Low(rs.durationAsSecs(rs.durationSum(rs.iterSlice([{ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.durationNew(rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 302, col: 43 }), 0)]), undefined, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1520, col: 9 }))) & 0xff); } else if (k === 47) { const _365: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); - const _367: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 306, col: 47 }), rs.usizeStep); + const _367: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 307, col: 47 }), rs.usizeStep); rs.iterExtendBytes(out, rs.byteVecExtractIf(_365, _367, (_217: rs.Place): boolean => { return true; }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/extract_if.rs", line: 43, col: 36 }), "next"); } else if (k === 48) { const _374: rs.Vec = rs.vecFrom([n as rs.u16]); - const _377: { end: rs.usize } = { end: rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 307, col: 56 }) }; + const _377: { end: rs.usize } = { end: rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 308, col: 56 }) }; rs.byteVecPush(out, rs.ownedCount(rs.vecExtractIfMut(_374, _377, (_210: rs.Place): boolean => { return true; }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/extract_if.rs", line: 43, col: 36 }), undefined, undefined) & 0xff); } else if (k === 49) { - rs.iterExtendBytes(out, rs.iterTake(new rs.RangeFrom(rs.u8Sub(255, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 308, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 308, col: 27 }), rs.u8Step), 3), undefined, true); + rs.iterExtendBytes(out, rs.iterTake(new rs.RangeFrom(rs.u8Sub(255, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 309, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 309, col: 27 }), rs.u8Step), 3), undefined, true); } else if (k === 50) { - rs.iterExtendBytes(out, rs.iterOption(rs.iterNth(new rs.RangeFrom(rs.u8Sub(255, rs.u8Rem(n, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 309, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 309, col: 27 }), rs.u8Step), rs.usizeAdd(rs.u8Rem(n, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 309, col: 62 }) as rs.usize, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 309, col: 50 }))), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(rs.iterNth(new rs.RangeFrom(rs.u8Sub(255, rs.u8Rem(n, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 310, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 310, col: 27 }), rs.u8Step), rs.usizeAdd(rs.u8Rem(n, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 310, col: 62 }) as rs.usize, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 310, col: 50 }))), undefined, true); } else if (k === 51) { - rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(new rs.RangeFrom(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 310, col: 48 }) as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 310, col: 27 }), rs.u64Step), 3), (x: rs.u64): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(new rs.RangeFrom(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 311, col: 48 }) as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 311, col: 27 }), rs.u64Step), 3), (x: rs.u64): rs.u8 => { return rs.u64Low(x) & 0xff; }), undefined, true); } else if (k === 52) { - rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(new rs.RangeFrom(rs.optionUnwrap(rs.charFromU32(rs.u32Sub(1114111, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 312, col: 51 }) as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 312, col: 29 })), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 312, col: 59 }), rs.charStep), 3), (c: rs.char): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(new rs.RangeFrom(rs.optionUnwrap(rs.charFromU32(rs.u32Sub(1114111, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 313, col: 51 }) as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 313, col: 29 })), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 313, col: 59 }), rs.charStep), 3), (c: rs.char): rs.u8 => { return c & 0xff; }), undefined, true); } else if (k === 68) { - if (!(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 318, col: 15 }) === 0)) { - const v3: rs.Vec = rs.vecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 325, col: 51 }), 4); - const _442: rs.usize = rs.usizeAdd(rs.vecCapacity(v3, 4), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 327, col: 32 }); + if (!(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 319, col: 15 }) === 0)) { + const v3: rs.Vec = rs.vecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 326, col: 51 }), 4); + const _442: rs.usize = rs.usizeAdd(rs.vecCapacity(v3, 4), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 328, col: 32 }); rs.vecSetLen(v3, _442, 4, (): rs.u32 => { return (undefined as unknown) as rs.u32; }); rs.byteVecPush(out, v3.items.length & 0xff); } else { - const v2: rs.ByteVec = rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 319, col: 50 })); - rs.byteVecSetLen(v2, rs.usizeAdd(v2.data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 321, col: 32 })); + const v2: rs.ByteVec = rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 320, col: 50 })); + rs.byteVecSetLen(v2, rs.usizeAdd(v2.data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 322, col: 32 })); rs.byteVecPush(out, v2.length & 0xff); } } else if (k === 69) { const _451: rs.ByteSlice = rs.byteSliceFrom(rs.bytes(2).fill((0 as unknown) as rs.u8)); - const part2 = rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 330, col: 81 }); - rs.byteSliceCopyFromSlice(_451, rs.byteSliceRange(rs.byteVecSlice(v), 0, part2, { file: "fixtures/lang/panics/src/hooked.rs", line: 330, col: 78 }), { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/mem/maybe_uninit.rs", line: 1205, col: 14 }); + const part2 = rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 331, col: 81 }); + rs.byteSliceCopyFromSlice(_451, rs.byteSliceRange(rs.byteVecSlice(v), 0, part2, { file: "fixtures/lang/panics/src/hooked.rs", line: 331, col: 78 }), { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/mem/maybe_uninit.rs", line: 1205, col: 14 }); } else if (k === 70) { rs.sliceWriteCloneOfSlice(rs.sliceFrom(Array.from({ length: 2 }, (): rs.String => { return (undefined as unknown) as rs.String; - })), rs.sliceRange(rs.sliceFrom([rs.stringNew()]), 0, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 331, col: 106 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 331, col: 103 }), (a0: rs.String): rs.String => { + })), rs.sliceRange(rs.sliceFrom([rs.stringNew()]), 0, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 332, col: 106 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 332, col: 103 }), (a0: rs.String): rs.String => { return rs.stringClone(a0); }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/mem/maybe_uninit.rs", line: 1265, col: 9 }); } else if (k === 71) { - rs.byteVecPush(out, rs.sliceNewUninit(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 332, col: 55 }), 2, (): rs.u16 => { + rs.byteVecPush(out, rs.sliceNewUninit(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 333, col: 55 }), 2, (): rs.u16 => { return (undefined as unknown) as rs.u16; }).length & 0xff); } else if (k === 72) { let lent: rs.ByteSlice = rs.byteVecSlice(v); - const _482: rs.usize = rs.usizeAdd(rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 335, col: 26 }), 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 335, col: 26 }); + const _482: rs.usize = rs.usizeAdd(rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 336, col: 26 }), 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 336, col: 26 }); rs.ioSliceAdvance(rs.place(() => lent, (value2) => lent = value2), _482, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/io/io_slice/repr_generic.rs", line: 15, col: 37 }); rs.byteVecExtendFromSlice(out, lent); } else if (k === 73) { const lent2: rs.ByteSlice[] = [rs.byteVecSlice(v)]; let left: rs.Slice = rs.sliceFrom(lent2); - const _498: rs.usize = rs.usizeAdd(rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 341, col: 57 }), 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 341, col: 57 }); + const _498: rs.usize = rs.usizeAdd(rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 342, col: 57 }), 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 342, col: 57 }); rs.ioSliceAdvanceSlices(rs.place(() => left, (value) => left = value), _498, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/io/io_slice.rs", line: 308, col: 13 }); rs.byteVecPush(out, left.length & 0xff); } else if (k === 74) { - rs.byteVecInsert(rs.byteVecFrom(rs.byteVecView(v)), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 344, col: 32 }), n, { file: "fixtures/lang/panics/src/hooked.rs", line: 344, col: 25 }); + rs.byteVecInsert(rs.byteVecFrom(rs.byteVecView(v)), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 345, col: 32 }), n, { file: "fixtures/lang/panics/src/hooked.rs", line: 345, col: 25 }); } else if (k === 75) { - rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecSplitOff(rs.byteVecFrom(rs.byteVecView(v)), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 345, col: 46 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 345, col: 36 })), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecSplitOff(rs.byteVecFrom(rs.byteVecView(v)), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 346, col: 46 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 346, col: 36 })), undefined, true); } else if (k === 76) { - rs.byteVecPush(out, rs.vecRemove(rs.vecFrom([n as rs.u16]), rs.usizeAdd(at, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 346, col: 50 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 346, col: 43 }) & 0xff); + rs.byteVecPush(out, rs.vecRemove(rs.vecFrom([n as rs.u16]), rs.usizeAdd(at, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 347, col: 50 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 347, col: 43 }) & 0xff); } else if (k === 77) { - rs.byteVecPush(out, rs.vecSwapRemove(rs.vecFrom([n as rs.u16]), rs.usizeAdd(at, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 347, col: 55 })) & 0xff); + rs.byteVecPush(out, rs.vecSwapRemove(rs.vecFrom([n as rs.u16]), rs.usizeAdd(at, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 348, col: 55 })) & 0xff); } else if (k === 78) { - rs.vecInsert(rs.vecFrom([n as rs.u16]), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 348, col: 41 }), 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 348, col: 34 }); + rs.vecInsert(rs.vecFrom([n as rs.u16]), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 349, col: 41 }), 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 349, col: 34 }); } else if (k === 79) { - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.vecSplitOff(rs.vecFrom([n as rs.u16]), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 349, col: 55 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 349, col: 45 }).items), (_29: rs.u16): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.vecSplitOff(rs.vecFrom([n as rs.u16]), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 350, col: 55 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 350, col: 45 }).items), (_29: rs.u16): rs.u8 => { return _29 & 0xff; }), undefined, true); } else if (k === 80) { const _550: rs.ByteSlice = rs.byteVecSlice(rs.byteVecFrom(rs.byteVecView(v))); - const _554: rs.Range = new rs.Range(rs.usizeAdd(at, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 350, col: 37 }), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 350, col: 45 })); - rs.byteSliceCopyWithin(_550, _554.start, _554.end, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 350, col: 25 }); + const _554: rs.Range = new rs.Range(rs.usizeAdd(at, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 351, col: 37 }), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 351, col: 45 })); + rs.byteSliceCopyWithin(_550, _554.start, _554.end, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 351, col: 25 }); } else if (k === 81) { - rs.byteVecPush(out, rs.u64Low(rs.u64Clamp(n as rs.u64, rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 351, col: 43 }), n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 351, col: 37 })) & 0xff); + rs.byteVecPush(out, rs.u64Low(rs.u64Clamp(n as rs.u64, rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 352, col: 43 }), n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 352, col: 37 })) & 0xff); } else if (k === 82) { - rs.byteVecPush(out, rs.clamp(rs.i32Neg(n as rs.i32, { file: "fixtures/lang/panics/src/hooked.rs", line: 352, col: 24 }), 0, -1, { file: "fixtures/lang/panics/src/hooked.rs", line: 352, col: 40 }) & 0xff); + rs.byteVecPush(out, rs.clamp(rs.i32Neg(n as rs.i32, { file: "fixtures/lang/panics/src/hooked.rs", line: 353, col: 24 }), 0, -1, { file: "fixtures/lang/panics/src/hooked.rs", line: 353, col: 40 }) & 0xff); } else if (k === 83) { const arg = {}; rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => Failing.fmt$fmt_Display(arg, f)]).v)); @@ -532,18 +534,18 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else { if (53 <= k) { if (k <= 56) { - joined(rs.u8Sub(k, 53, { file: "fixtures/lang/panics/src/hooked.rs", line: 316, col: 31 }), n, out); + joined(rs.u8Sub(k, 53, { file: "fixtures/lang/panics/src/hooked.rs", line: 317, col: 31 }), n, out); break b0; } } if (57 <= k) { if (k <= 67) { - rs.byteVecPush(out, compared(rs.u8Sub(k, 57, { file: "fixtures/lang/panics/src/hooked.rs", line: 317, col: 42 }), n)); + rs.byteVecPush(out, compared(rs.u8Sub(k, 57, { file: "fixtures/lang/panics/src/hooked.rs", line: 318, col: 42 }), n)); break b0; } } - const _593: Short.Short = { _0: rs.u8Rem(n, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 356, col: 31 }) }; - const _596: rs.Range = new rs.Range(0, rs.u8Add(rs.u8Rem(n, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 356, col: 45 }), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 356, col: 45 })); + const _593: Short.Short = { _0: rs.u8Rem(n, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 357, col: 31 }) }; + const _596: rs.Range = new rs.Range(0, rs.u8Add(rs.u8Rem(n, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 357, col: 45 }), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 357, col: 45 })); rs.iterExtendBytes(out, rs.iterMap(rs.iterRev(rs.iterZip(rs.iterFrom(_593, Short.next$iter_Iterator, undefined, { hint: Short.sizeHint$iter_Iterator, back: (it: Short.Short) => rs.iterFromOption(Short.nextBack$iter_DoubleEndedIterator(it)) }), _596)), (_2: [rs.u8, rs.u8]): rs.u8 => { return _2[0] ^ _2[1]; }), "next"); @@ -559,16 +561,16 @@ export function joined(kind: rs.u8, n: rs.u8, out: rs.ByteVec): void { let joined!: rs.ByteVec; const big: rs.ByteVec = rs.byteVecOf(n, 1 << 16); const refs: (a0: rs.usize) => rs.Vec = (count: rs.usize): rs.Vec => { - return rs.vecFromElem(rs.byteSliceRange(rs.byteVecSlice(big), 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 374, col: 40 }), count, undefined); + return rs.vecFromElem(rs.byteSliceRange(rs.byteVecSlice(big), 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 375, col: 40 }), count, undefined); }; if (kind === 0) { - joined = rs.byteSlicesJoin(rs.sliceFrom(refs(rs.usizeAdd(1 << 16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 376, col: 19 })).items)); + joined = rs.byteSlicesJoin(rs.sliceFrom(refs(rs.usizeAdd(1 << 16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 377, col: 19 })).items)); } else if (kind === 1) { - joined = rs.byteSlicesJoin(rs.sliceFrom(refs(rs.usizeAdd(1 << 16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 377, col: 19 })).items), rs.byteSliceFrom(Uint8Array.of(n))); + joined = rs.byteSlicesJoin(rs.sliceFrom(refs(rs.usizeAdd(1 << 16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 378, col: 19 })).items), rs.byteSliceFrom(Uint8Array.of(n))); } else if (kind === 2) { - joined = rs.byteSlicesJoin(rs.sliceFrom(refs(rs.usizeAdd(1 << 15, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 378, col: 19 })).items)); + joined = rs.byteSlicesJoin(rs.sliceFrom(refs(rs.usizeAdd(1 << 15, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 379, col: 19 })).items)); } else { - joined = rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.slicesJoin(rs.sliceFrom(rs.vecFromElem(rs.sliceFrom(rs.vecFromElem(n as rs.u16, 1 << 16, undefined).items), rs.usizeAdd(1 << 14, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 381, col: 42 }), undefined).items), 2, rs.sliceFrom([1])).items), (_2: rs.u16): rs.u8 => { + joined = rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.slicesJoin(rs.sliceFrom(rs.vecFromElem(rs.sliceFrom(rs.vecFromElem(n as rs.u16, 1 << 16, undefined).items), rs.usizeAdd(1 << 14, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 382, col: 42 }), undefined).items), 2, rs.sliceFrom([1])).items), (_2: rs.u16): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -586,10 +588,10 @@ export function compared(kind: rs.u8, n: rs.u8): rs.u8 { const _5: [rs.RefCell, rs.RefCell] = [new rs.RefCell(n), new rs.RefCell(rs.u8WrappingAdd(n, 1))]; const a: rs.RefCell = _5[0]; const b: rs.RefCell = _5[1]; - if (!(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 393, col: 20 }) === 0)) { - _held = rs.refCellBorrowMut(b, { file: "fixtures/lang/panics/src/hooked.rs", line: 393, col: 59 }); + if (!(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 394, col: 20 }) === 0)) { + _held = rs.refCellBorrowMut(b, { file: "fixtures/lang/panics/src/hooked.rs", line: 394, col: 59 }); } else { - _held = rs.refCellBorrowMut(a, { file: "fixtures/lang/panics/src/hooked.rs", line: 393, col: 35 }); + _held = rs.refCellBorrowMut(a, { file: "fixtures/lang/panics/src/hooked.rs", line: 394, col: 35 }); } const _15: (a0: rs.Ordering | undefined) => rs.u8 = (o: rs.Ordering | undefined): rs.u8 => { return option_mapOr$14runhi(o, 9, (o2: rs.Ordering): rs.u8 => { @@ -641,11 +643,11 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const at: rs.usize = n as rs.usize; const whole: rs.ByteSlice = rs.bytesFromVec(rs.byteVecOf(n, 4)); b0: { - const k: rs.u8 = rs.u8Rem(kind, 33, { file: "fixtures/lang/panics/src/hooked.rs", line: 461, col: 24 }); + const k: rs.u8 = rs.u8Rem(kind, 33, { file: "fixtures/lang/panics/src/hooked.rs", line: 462, col: 24 }); if (0 <= k) { if (k <= 1) { rs.setHook((info: rs.PanicHookInfo): undefined => { - const at2: rs.Location = rs.optionUnwrap(info.location, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 463, col: 38 }); + const at2: rs.Location = rs.optionUnwrap(info.location, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 464, col: 38 }); const _10: string = at2.file; const _126: rs.u32 = at2.line; const _14: rs.u32 = at2.col; @@ -654,16 +656,16 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.localKeyWithBorrowMut(NOTE, (note: rs.String): undefined => { rs.stringPushStr(note, line.v); }, { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/std/src/thread/local.rs", line: 721, col: 38 }); - rs.panicFmt(["unread"], { file: "fixtures/lang/panics/src/hooked.rs", line: 466, col: 13 }); + rs.panicFmt(["unread"], { file: "fixtures/lang/panics/src/hooked.rs", line: 467, col: 13 }); }, { capacity: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/raw_vec/mod.rs", line: 29, col: 5 }, trusted_capacity: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/spec_from_iter_nested.rs", line: 57, col: 18 }, swap_remove: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 2180, col: 13 }, vec_set_len: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 2140, col: 9 }, into_flattened: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/vec/mod.rs", line: 3757, col: 36 }, rotate_left: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/slice/mod.rs", line: 3900, col: 9 }, rotate_right: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/slice/mod.rs", line: 3946, col: 9 }, ord_violation: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/slice/sort/shared/smallsort.rs", line: 854, col: 5 }, ord_clamp: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cmp.rs", line: 1166, col: 9 }, f32_clamp: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/num/f32.rs", line: 1441, col: 9 }, f64_clamp: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/num/f64.rs", line: 1420, col: 9 }, encode_utf8: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/char/methods.rs", line: 2581, col: 9 }, encode_utf16: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/char/methods.rs", line: 2675, col: 13 }, format: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/fmt.rs", line: 657, col: 14 }, to_string: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/string.rs", line: 3049, col: 14 }, debug_struct_fields: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/fmt/mod.rs", line: 2589, col: 41 }, debug_enum: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/fmt/mod.rs", line: 2606, col: 26 }, exact_len: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/traits/exact_size.rs", line: 122, col: 9 }, join_len: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/str.rs", line: 177, col: 10 }, int_sum: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }, int_forward: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/range.rs", line: 554, col: 1 }, char_forward: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/range.rs", line: 119, col: 45 }, hash_capacity: { file: "/cargo/registry/25cdd57fae9f0462/hashbrown-0.17.1/src/raw.rs", line: 36, col: 40 }, btree_range_equal_BTreeSet: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 110, col: 21 }, btree_range_equal_BTreeMap: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 112, col: 21 }, btree_range_order_BTreeSet: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 119, col: 21 }, btree_range_order_BTreeMap: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/btree/search.rs", line: 121, col: 21 }, deque_insert: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 2614, col: 9 }, deque_swap_i: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 1062, col: 9 }, deque_swap_j: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 1063, col: 9 }, deque_rotate_left: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 3200, col: 9 }, deque_rotate_right: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 3245, col: 9 }, deque_split_off: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/vec_deque/mod.rs", line: 2726, col: 9 }, list_split_off: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/alloc/src/collections/linked_list.rs", line: 1067, col: 9 }, mutex_lock: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/std/src/sys/sync/mutex/no_threads.rs", line: 31, col: 9 }, once_force: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/std/src/sync/once.rs", line: 227, col: 20 }, reentrant_init: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell/once.rs", line: 325, col: 66 }, lazy_poisoned: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/cell/lazy.rs", line: 386, col: 5 }, ready_poll: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/future/ready.rs", line: 23, col: 35 }, ready_into_inner: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/future/ready.rs", line: 46, col: 16 }, duration_new: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 283, col: 18 }, duration_from_mins: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 542, col: 13 }, duration_from_hours: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 512, col: 13 }, duration_add: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1397, col: 31 }, duration_sub: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1417, col: 31 }, duration_mul: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/time.rs", line: 1437, col: 31 }, zip_next_back: { file: "/rustc/3ef0c22cdb86ac42dc6b8f0f1ec36857daa6f2a1/library/core/src/iter/adapters/zip.rs", line: 213, col: 5 }, bytes_advance: { file: "bytes/source/lib.rs", line: 207, col: 5 }, bytes_does_not_fit: { file: "bytes/source/lib.rs", line: 215, col: 5 }, bytes_slice: { file: "bytes/source/bytes.rs", line: 374, col: 28 }, bytes_slice_ref_start: { file: "bytes/source/bytes.rs", line: 426, col: 9 }, bytes_slice_ref_end: { file: "bytes/source/bytes.rs", line: 432, col: 9 }, bytes_split_off: { file: "bytes/source/bytes.rs", line: 481, col: 9 }, bytes_split_to: { file: "bytes/source/bytes.rs", line: 533, col: 9 }, bytes_buf_advance: { file: "bytes/source/bytes.rs", line: 694, col: 9 }, bytes_mut_split_off: { file: "bytes/source/bytes_mut.rs", line: 329, col: 9 }, bytes_mut_split_to: { file: "bytes/source/bytes_mut.rs", line: 408, col: 9 }, bytes_mut_set_len: { file: "bytes/source/bytes_mut.rs", line: 545, col: 9 }, bytes_mut_overflow: { file: "bytes/source/bytes_mut.rs", line: 700, col: 21 }, bytes_mut_overflow_offset: { file: "bytes/source/bytes_mut.rs", line: 720, col: 29 }, bytes_mut_buf_advance: { file: "bytes/source/bytes_mut.rs", line: 1246, col: 9 } }); const subset: rs.ByteSlice = rs.bytesSlice(whole, 0, 1); if (k === 0) { - const _22: rs.ByteSlice = rs.bytesSlice(whole, rs.usizeAdd(1, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 470, col: 34 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 470, col: 30 })); + const _22: rs.ByteSlice = rs.bytesSlice(whole, rs.usizeAdd(1, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 471, col: 34 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 471, col: 30 })); held = rs.bytesSliceRef(_22, subset); rs.bytesDrop(_22); } else { const _32: rs.ByteSlice = rs.bytesSlice(whole, 0, 1); - const _35: rs.ByteSlice = rs.byteSliceRange(whole, 0, rs.usizeAdd(2, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 471, col: 58 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 471, col: 54 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 471, col: 51 }); + const _35: rs.ByteSlice = rs.byteSliceRange(whole, 0, rs.usizeAdd(2, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 472, col: 58 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 472, col: 54 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 472, col: 51 }); held = rs.bytesSliceRef(_32, _35); rs.bytesDrop(_32); } @@ -675,38 +677,38 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } } hook(); - const shared: rs.BytesMut = rs.bytesMutFrom(rs.byteSliceRange(rs.byteSliceFrom(rs.bytes(8).fill(n)), 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 477, col: 44 })); - const _52: rs.u8 = rs.u8Rem(kind, 33, { file: "fixtures/lang/panics/src/hooked.rs", line: 478, col: 11 }); + const shared: rs.BytesMut = rs.bytesMutFrom(rs.byteSliceRange(rs.byteSliceFrom(rs.bytes(8).fill(n)), 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 478, col: 44 })); + const _52: rs.u8 = rs.u8Rem(kind, 33, { file: "fixtures/lang/panics/src/hooked.rs", line: 479, col: 11 }); if (_52 === 2) { - const _56: rs.ByteSlice = rs.bytesSlice(whole, rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 479, col: 49 }), 2); + const _56: rs.ByteSlice = rs.bytesSlice(whole, rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 480, col: 49 }), 2); rs.byteVecExtendFromSlice(out, _56); rs.bytesDrop(_56); } else if (_52 === 3) { - const _63: rs.ByteSlice = rs.bytesSlice(whole, 0, rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 480, col: 51 })); + const _63: rs.ByteSlice = rs.bytesSlice(whole, 0, rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 481, col: 51 })); rs.byteVecExtendFromSlice(out, _63); rs.bytesDrop(_63); } else if (_52 === 4) { - const _72: rs.RangeInclusive = new rs.RangeInclusive(rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 481, col: 62 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 481, col: 49 }), 4294967295, rs.usizeStep); + const _72: rs.RangeInclusive = new rs.RangeInclusive(rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 482, col: 62 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 482, col: 49 }), 4294967295, rs.usizeStep); const _70: rs.ByteSlice = rs.bytesSliceInclusive(whole, _72); rs.byteVecExtendFromSlice(out, _70); rs.bytesDrop(_70); } else if (_52 === 5) { let _81: rs.ByteSlice = rs.bytesClone(whole); - const _83: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 482, col: 60 }); + const _83: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 483, col: 60 }); const _79: rs.ByteSlice = rs.bytesSplitTo(rs.place(() => _81, (value9) => _81 = value9), _83); rs.byteVecExtendFromSlice(out, _79); rs.bytesDrop(_79); rs.bytesDrop(_81); } else if (_52 === 6) { let _89: rs.ByteSlice = rs.bytesClone(whole); - const _91: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 483, col: 61 }); + const _91: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 484, col: 61 }); const _87: rs.ByteSlice = rs.bytesSplitOff(rs.place(() => _89, (value8) => _89 = value8), _91); rs.byteVecExtendFromSlice(out, _87); rs.bytesDrop(_87); rs.bytesDrop(_89); } else if (_52 === 7) { let _94: rs.ByteSlice = rs.bytesClone(whole); - const _96: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 484, col: 36 }); + const _96: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 485, col: 36 }); rs.bytesAdvance(rs.place(() => _94, (value7) => _94 = value7), _96); rs.bytesDrop(_94); } else if (_52 === 8) { @@ -715,12 +717,12 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.bytesDrop(_101); } else if (_52 === 9) { let _107: rs.ByteSlice = rs.bytesClone(whole); - const _109: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 486, col: 50 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 486, col: 46 }); + const _109: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 487, col: 50 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 487, col: 46 }); rs.byteVecPush(out, rs.u64Low(rs.u64FromBeBytes(rs.bytesReadInt(rs.place(() => _107, (value5) => _107 = value5), 8, _109, false, false))) & 0xff); rs.bytesDrop(_107); } else if (_52 === 10) { - let _114: rs.ByteSlice = rs.byteSliceRange(data, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 487, col: 21 }); - const _116: rs.usize = rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 487, col: 35 }); + let _114: rs.ByteSlice = rs.byteSliceRange(data, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 488, col: 21 }); + const _116: rs.usize = rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 488, col: 35 }); rs.byteSliceAdvance(rs.place(() => _114, (value4) => _114 = value4), _116); } else if (_52 === 11) { let _120: rs.ByteSlice = rs.bytesClone(whole); @@ -729,75 +731,75 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.bytesDrop(_120); } else if (_52 === 12) { let _129: rs.ByteSlice = rs.bytesClone(whole); - const _131: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 489, col: 66 }); + const _131: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 490, col: 66 }); const _127: rs.ByteSlice = rs.bytesSplitTo(rs.place(() => _129, (value2) => _129 = value2), _131); rs.byteVecExtendFromSlice(out, _127); rs.bytesDrop(_127); rs.bytesDrop(_129); } else if (_52 === 13) { - let _137: rs.ByteSlice = rs.byteSliceRange(data, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 490, col: 44 }); - const _139: rs.usize = rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 490, col: 64 }); + let _137: rs.ByteSlice = rs.byteSliceRange(data, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 491, col: 44 }); + const _139: rs.usize = rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 491, col: 64 }); const _135: rs.ByteSlice = rs.byteSliceCopyToBytes(rs.place(() => _137, (value) => _137 = value), _139); rs.byteVecExtendFromSlice(out, _135); rs.bytesDrop(_135); } else if (_52 === 14) { const _146: rs.BytesMut = rs.bytesMutFrom(data); - const _144: rs.BytesMut = rs.bytesMutSplitTo(_146, rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 491, col: 68 })); + const _144: rs.BytesMut = rs.bytesMutSplitTo(_146, rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 492, col: 68 })); rs.byteVecExtendFromSlice(out, rs.bytesMutView(_144)); _144[Symbol.dispose](); _146[Symbol.dispose](); } else if (_52 === 15) { const _154: rs.BytesMut = rs.bytesMutWithCapacity(4); - const _152: rs.BytesMut = rs.bytesMutSplitOff(_154, rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 492, col: 75 })); + const _152: rs.BytesMut = rs.bytesMutSplitOff(_154, rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 493, col: 75 })); rs.byteVecExtendFromSlice(out, rs.bytesMutView(_152)); _152[Symbol.dispose](); _154[Symbol.dispose](); } else if (_52 === 16) { - const b: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 494, col: 49 })); - rs.bytesMutSetLen(b, rs.usizeAdd(b.cap, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 496, col: 32 })); + const b: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 495, col: 49 })); + rs.bytesMutSetLen(b, rs.usizeAdd(b.cap, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 497, col: 32 })); rs.byteVecPush(out, b.length & 0xff); b[Symbol.dispose](); } else if (_52 === 17) { - const b2: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 500, col: 49 })); - rs.bytesMutAdvanceMut(b2, rs.usizeAdd(b2.cap, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 502, col: 36 })); + const b2: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 501, col: 49 })); + rs.bytesMutAdvanceMut(b2, rs.usizeAdd(b2.cap, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 503, col: 36 })); rs.byteVecPush(out, b2.length & 0xff); b2[Symbol.dispose](); } else if (_52 === 18) { - const v: rs.ByteVec = rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 506, col: 50 })); - rs.byteVecAdvanceMut(v, rs.usizeAdd(v.data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 508, col: 36 })); + const v: rs.ByteVec = rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 507, col: 50 })); + rs.byteVecAdvanceMut(v, rs.usizeAdd(v.data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 509, col: 36 })); rs.byteVecPush(out, v.length & 0xff); } else if (_52 === 19) { const _197: rs.BytesMut = rs.bytesMutFrom(data); - rs.bytesMutAdvance(_197, rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 511, col: 44 })); + rs.bytesMutAdvance(_197, rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 512, col: 44 })); _197[Symbol.dispose](); } else if (_52 === 20) { - const _204: rs.BytesMut = rs.bytesMutFrom(rs.byteSliceRange(data, 0, rs.min(data.length, 3), { file: "fixtures/lang/panics/src/hooked.rs", line: 512, col: 44 })); + const _204: rs.BytesMut = rs.bytesMutFrom(rs.byteSliceRange(data, 0, rs.min(data.length, 3), { file: "fixtures/lang/panics/src/hooked.rs", line: 513, col: 44 })); rs.byteVecPush(out, (rs.bytesMutReadWord(_204, 4, false) as rs.u32) & 0xff); _204[Symbol.dispose](); } else if (_52 === 21) { - const _212: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 513, col: 48 })); + const _212: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 514, col: 48 })); rs.byteVecPush(out, _212.cap & 0xff); _212[Symbol.dispose](); } else if (_52 === 22) { const _tail: rs.BytesMut = rs.bytesMutSplitOff(shared, 4); - rs.bytesMutReserve(shared, rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 517, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 517, col: 28 })); + rs.bytesMutReserve(shared, rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 518, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 518, col: 28 })); _tail[Symbol.dispose](); } else if (_52 === 23) { rs.bytesMutSplitTo(shared, 4)[Symbol.dispose](); - rs.bytesMutReserve(shared, rs.usizeSub(4294967295 - 4, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 522, col: 45 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 522, col: 28 })); + rs.bytesMutReserve(shared, rs.usizeSub(4294967295 - 4, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 523, col: 45 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 523, col: 28 })); } else if (_52 === 24) { const _235: rs.u64 = n as rs.u64; - const _236: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 524, col: 49 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 524, col: 45 }); + const _236: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 525, col: 49 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 525, col: 45 }); rs.bytesMutPutInt(shared, rs.u64ToBeBytes(_235), _236, false); } else if (_52 === 25) { const _240: rs.i64 = n as rs.i64; - const _241: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 525, col: 45 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 525, col: 41 }); + const _241: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 526, col: 45 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 526, col: 41 }); rs.byteVecPutInt(out, rs.i64ToBeBytes(_240), _241, false); } else if (_52 === 26) { - rs.byteVecPutFill(out, n, rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 526, col: 53 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 526, col: 40 })); + rs.byteVecPutFill(out, n, rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 527, col: 53 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 527, col: 40 })); } else if (_52 === 27) { const _253: Take.Take = buf_impl_take$bytes_Buf_bytes_Bytes(rs.bytesClone(whole), 2); - const _251: rs.ByteSlice = Take.copyToBytes$bytes_Buf_bytes_Bytes(_253, rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 527, col: 74 })); + const _251: rs.ByteSlice = Take.copyToBytes$bytes_Buf_bytes_Bytes(_253, rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 528, col: 74 })); rs.byteVecExtendFromSlice(out, _251); rs.bytesDrop(_251); drop$bytes_buf_Take_bytes_Bytes(_253); @@ -807,15 +809,15 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { drop$bytes_buf_Take_bytes_Bytes(_261); } else if (_52 === 29) { const chunk: rs.ByteSlice = rs.bytesMutChunkMut(shared); - UninitSlice.writeByte(chunk, rs.usizeAdd(UninitSlice.len(chunk), rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 532, col: 44 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 532, col: 30 }), n); + UninitSlice.writeByte(chunk, rs.usizeAdd(UninitSlice.len(chunk), rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 533, col: 44 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 533, col: 30 }), n); } else if (_52 === 30) { - UninitSlice.writeByte(UninitSlice.indexMut$ops_IndexMut_ops_RangeFrom_usize(rs.byteVecChunkMut(rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 534, col: 40 }))), new rs.RangeFrom(rs.usizeAdd(65, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 534, col: 65 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 534, col: 60 }), rs.usizeStep), { file: "fixtures/lang/panics/src/hooked.rs", line: 534, col: 59 }), 0, n); + UninitSlice.writeByte(UninitSlice.indexMut$ops_IndexMut_ops_RangeFrom_usize(rs.byteVecChunkMut(rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 535, col: 40 }))), new rs.RangeFrom(rs.usizeAdd(65, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 535, col: 65 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 535, col: 60 }), rs.usizeStep), { file: "fixtures/lang/panics/src/hooked.rs", line: 535, col: 59 }), 0, n); } else if (_52 === 31) { const _287: rs.BytesMut = rs.bytesMutWithCapacity(0); - UninitSlice.copyFromSlice(UninitSlice.indexMut$ops_IndexMut_ops_RangeTo_usize(rs.bytesMutChunkMut(_287), { end: rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 535, col: 45 }) }, { file: "fixtures/lang/panics/src/hooked.rs", line: 535, col: 42 }), rs.byteSliceFrom(rs.bytes(3).fill(n))); + UninitSlice.copyFromSlice(UninitSlice.indexMut$ops_IndexMut_ops_RangeTo_usize(rs.bytesMutChunkMut(_287), { end: rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 536, col: 45 }) }, { file: "fixtures/lang/panics/src/hooked.rs", line: 536, col: 42 }), rs.byteSliceFrom(rs.bytes(3).fill(n))); _287[Symbol.dispose](); } else { - const _297: rs.BytesMut = rs.bytesMutZeroed(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 536, col: 40 })); + const _297: rs.BytesMut = rs.bytesMutZeroed(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 537, col: 40 })); rs.byteVecPush(out, _297.length & 0xff); _297[Symbol.dispose](); } @@ -831,7 +833,7 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { */ export function edition2018Panicked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { b0: { - if (!(rs.u8Rem(kind, 7, { file: "fixtures/lang/panics/src/hooked.rs", line: 544, col: 8 }) !== 6)) { + if (!(rs.u8Rem(kind, 7, { file: "fixtures/lang/panics/src/hooked.rs", line: 545, col: 8 }) !== 6)) { if (!(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0) > 200)) { break b0; } @@ -851,7 +853,7 @@ export function tokioStock(_kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): v const _10: [rs.OneshotSender, rs.OneshotReceiver] = rs.oneshotChannel(); const tx: rs.OneshotSender = _10[0]; const rx: rs.OneshotReceiver = _10[1]; - rs.resultUnwrap(rs.oneshotSend(tx, n), rs.u8Debug, { file: "fixtures/lang/panics/src/hooked.rs", line: 556, col: 16 }); + rs.resultUnwrap(rs.oneshotSend(tx, n), rs.u8Debug, { file: "fixtures/lang/panics/src/hooked.rs", line: 557, col: 16 }); const cx: rs.Context = rs.NOOP_WAKER; let iterStart: rs.i32 = 0; const iterEnd: rs.i32 = 2; diff --git a/ts/fixtures/lang/panics/src/hooked.rs b/ts/fixtures/lang/panics/src/hooked.rs index ddc1b29f3..72fb8e28c 100644 --- a/ts/fixtures/lang/panics/src/hooked.rs +++ b/ts/fixtures/lang/panics/src/hooked.rs @@ -84,7 +84,7 @@ pub fn panicked(kind: u8, data: &[u8], out: &mut Vec) { let n = data.first().copied().unwrap_or(0); hook(); let v = vec![n, n]; - match kind % 37 { + match kind % 38 { 0 => panic!("literal"), 1 => panic!("formatted {n}"), 2 => out.push(v[usize::from(n) + 2]), @@ -133,6 +133,7 @@ pub fn panicked(kind: u8, data: &[u8], out: &mut Vec) { let x = std::num::NonZero::new(i16::from(n.max(200))).unwrap(); out.extend_from_slice(&unsafe { x.unchecked_mul(x) }.get().to_be_bytes()); } + 36 => unimplemented!(), _ => { let len = HashMap::::with_capacity(usize::MAX).len(); out.push(len as u8); diff --git a/ts/runtime/rs/iter.ts b/ts/runtime/rs/iter.ts index a3f5f7a53..d3dad63c3 100644 --- a/ts/runtime/rs/iter.ts +++ b/ts/runtime/rs/iter.ts @@ -3732,6 +3732,9 @@ class SkipIter extends Adaptor { /** std's: what it skips and `n` more in one step, and the rest of `n` if that saturated a `usize`. */ override advanceBy(n: number, drop?: Drop): number { + // std's: no step at all while it still skips, so an iterator that is not fused is not + // seen ending where no count could say so. + if (this.n > 0 && n === 0) return 0; const skip = this.n; const both = Math.min(skip + n, USIZE_MAX); const left = this.inner.advanceBy(both, drop); diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index a7f36f07b..dcc87aced 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -1091,7 +1091,7 @@ fn discards(owner: &str, name: &str) -> Option<&'static [usize]> { // over, and `fill` its value if there is no slot for it. ("slice", "fill" | "fill_with" | "clone_from_slice") => &[0], // `vec![x; 0]` drops `x`. - ("vec", "from_elem_global") => &[0], + ("vec", "from_elem" | "from_elem_global") => &[0], // `get_or_init::` drops its function uncalled if the cell is set. ("OnceCell" | "OnceLock", "get_or_init" | "get_or_try_init") => &[1], // A guard's map calls its function, filtered or not. @@ -2555,7 +2555,7 @@ fn mapping<'tcx>( ("Box", "assume_init") => args.pop()?, // `vec![x; n]`: `n - 1` clones of `x`, then `x` itself, which the caller gives as its // own, as it does whatever std keeps, or `x` dropped where `n` is 0. - ("vec", "from_elem_global") => { + ("vec", "from_elem" | "from_elem_global") => { let elem = targ(gargs, 0); let mut values = args; match byte(elem) { diff --git a/ts/src/lower/mir/holders.rs b/ts/src/lower/mir/holders.rs index 5fa1ad1b9..ae8cd3402 100644 --- a/ts/src/lower/mir/holders.rs +++ b/ts/src/lower/mir/holders.rs @@ -597,7 +597,7 @@ impl<'x, 'a, 'tcx> Trace<'x, 'a, 'tcx> { fn repeats(&self, def_id: DefId, args: ty::GenericArgs<'tcx>) -> bool { let tcx = self.t.tcx; crate::lower::library::is_std(tcx, def_id) - && matches!(crate::lower::library::key(tcx, def_id), Some((owner, name)) if owner == "vec" && name == "from_elem_global") + && matches!(crate::lower::library::key(tcx, def_id), Some((owner, name)) if owner == "vec" && matches!(name.as_str(), "from_elem" | "from_elem_global")) && !self.shows_pointer(args.type_at(0)) && !self.drops_own_code(args.type_at(0)) } From 7b55fb2f513242cd63ddb59de64e2d74eae5d3e5 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 13 Nov 2026 03:09:13 -0800 Subject: [PATCH 11/13] chore(quest): carry Skip and vec::from_elem into the nightly bump's learnings Co-Authored-By: Claude Opus 5.5 --- quest/m0/nightly-bump.md | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/quest/m0/nightly-bump.md b/quest/m0/nightly-bump.md index 63ad44a61..71b9d79ea 100644 --- a/quest/m0/nightly-bump.md +++ b/quest/m0/nightly-bump.md @@ -38,11 +38,16 @@ What the 2026-10-15 to 2026-11-12 run learned: - Expansion and std moved more than the compiler did, and only the differential tests caught it: derived `Debug` passes the type's and fields' names joined by spaces and, past four variants, indexes a joined string (`debug_c_like_enum_write_str`); - `vec![x; n]` calls `from_elem_global`; `panic!()`, `unreachable!()`, - `unimplemented!()`, and `todo!()` call `*_default_msg`; `String`'s char collects reserve - the size hint exactly, and `str::escape_default` specializes them; `Fuse` forwards - `advance_back_by`; `EscapeDebug` drops its char once yielded; `IoSlice::advance` and - `Ready` reword their panics; `Pattern` is an `unsafe trait`, and `Allocator` is stable. + `vec![x; n]` calls `from_elem_global`, and `vec::from_elem` became a stable wrapper over + it; `panic!()`, `unreachable!()`, `unimplemented!()`, and `todo!()` call + `*_default_msg`; `String`'s char collects reserve the size hint exactly, and + `str::escape_default` specializes them; `Fuse` forwards `advance_back_by`; + `EscapeDebug` drops its char once yielded; `IoSlice::advance` and `Ready` reword their + panics; `Pattern` is an `unsafe trait`, and `Allocator` is stable. +- The tests missed one change that the review found: `Skip::advance_by(0)` takes no step, + which only a non-fused iterator shows. Diff `rust-src`'s `library/` between the two + toolchains and check each runtime-mirrored change against the ts and go runtimes, + rather than trusting a green differential run. - `go/`'s port added 41 lines and removed 35 over 7 files, all of them derived `Debug` or the mechanical renames, against `ts/`'s 380 and 302 over 36. From 80b3a727a6675b9669642c568250f67e9222c7bb Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 13 Nov 2026 09:55:36 -0800 Subject: [PATCH 12/13] fix(nightly): canary checks the dev shell's profile and skips modules when its toolchain step fails Co-Authored-By: Claude Opus 5.5 --- .github/workflows/nightly.yml | 8 +++++--- sh/canary.sh | 5 ++++- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 93201a3f4..aee005be3 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -287,23 +287,25 @@ jobs: - uses: ./.github/actions/nix - name: Toolchain + id: toolchain run: | channel=$(sh/canary.sh) echo "Canary on \`$channel\`" >> "$GITHUB_STEP_SUMMARY" - name: Driver + if: ${{ !cancelled() && steps.toolchain.outcome == 'success' }} run: nix develop --command bash -c 'just driver check && just driver test' - name: Export - if: ${{ !cancelled() }} + if: ${{ !cancelled() && steps.toolchain.outcome == 'success' }} run: nix develop --command bash -c 'just ffi check && just ffi test' - name: Go - if: ${{ !cancelled() }} + if: ${{ !cancelled() && steps.toolchain.outcome == 'success' }} run: nix develop --command bash -c 'just go check && just go test' - name: TypeScript - if: ${{ !cancelled() }} + if: ${{ !cancelled() && steps.toolchain.outcome == 'success' }} run: nix develop --command bash -c 'just ts check && just ts moq && just ts test' # A scheduled run's failure opens one issue, or comments on the one still open, and a diff --git a/sh/canary.sh b/sh/canary.sh index 995129764..423845188 100755 --- a/sh/canary.sh +++ b/sh/canary.sh @@ -7,6 +7,7 @@ set -euo pipefail cd "$(git rev-parse --show-toplevel)" nix flake update rust-overlay +# shellcheck disable=SC2016 # the Nix expression interpolates, not the shell version=$(nix eval --raw --impure --expr ' let flake = builtins.getFlake (toString ./.); @@ -16,7 +17,9 @@ version=$(nix eval --raw --impure --expr ' }; file = (builtins.fromTOML (builtins.readFile ./ts/rust-toolchain.toml)).toolchain; in - (pkgs.rust-bin.selectLatestNightlyWith (t: t.minimal.override { + # fromRustupToolchainFile, which builds the dev shell, uses the default profile + # when the file names none: check the same one, so the two agree. + (pkgs.rust-bin.selectLatestNightlyWith (t: t.${file.profile or "default"}.override { extensions = file.components; targets = file.targets; })).version') From efd1d296695d70788f2271e1645128c30271394b Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 13 Nov 2026 10:40:19 -0800 Subject: [PATCH 13/13] fix(ts): String's Extend specializes EscapeDefault on the given type, not its IntoIter The capacity caller now drives every strings op, 48 to 53, which it skipped. Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/capacity/caller.ts | 4 ++-- .../expected/capacity.Escaped$strings.ts | 13 +++++++++++++ ts/fixtures/lang/capacity/expected/capacity.ts | 8 +++++++- ts/fixtures/lang/capacity/src/capacity.rs | 17 ++++++++++++++++- ts/src/lower/collections.rs | 2 +- ts/src/lower/iter.rs | 13 +++++++------ ts/src/lower/mir/call.rs | 2 +- 7 files changed, 47 insertions(+), 12 deletions(-) create mode 100644 ts/fixtures/lang/capacity/expected/capacity.Escaped$strings.ts diff --git a/ts/fixtures/lang/capacity/caller.ts b/ts/fixtures/lang/capacity/caller.ts index 922ae7b2f..28796b0f2 100644 --- a/ts/fixtures/lang/capacity/caller.ts +++ b/ts/fixtures/lang/capacity/caller.ts @@ -35,8 +35,8 @@ const capacityCases = [ ), ...Array.from({ length: 5 * 2 * 256 }, (_, i) => Uint8Array.of(...op("capacity::vecs"), i % 5, (Math.floor(i / 5) % 2) * 0x11, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 35, Math.floor(i / 10))), ...Array.from({ length: 8 * 6 }, (_, i) => Uint8Array.of(...op("capacity::collects"), i % 8, [0, 1, 2, 5, 9, 23][Math.floor(i / 8)], 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)), - ...Array.from({ length: 48 * 4 * 4 }, (_, i) => { - const [step, first, arg] = [i % 48, [0, 0x29, 0x0e, 0x0f][Math.floor(i / 48) % 4], [1, 6, 0xc3, 0xe2][Math.floor(i / 192)]]; + ...Array.from({ length: 54 * 4 * 4 }, (_, i) => { + const [step, first, arg] = [i % 54, [0, 0x29, 0x0e, 0x0f][Math.floor(i / 54) % 4], [1, 6, 0xc3, 0xe2][Math.floor(i / 216)]]; return Uint8Array.of(...op("capacity::strings"), first, 1, 3, 0, 2, 1, 1, step, arg, step, arg ^ 3, 0, 1); }), ]; diff --git a/ts/fixtures/lang/capacity/expected/capacity.Escaped$strings.ts b/ts/fixtures/lang/capacity/expected/capacity.Escaped$strings.ts new file mode 100644 index 000000000..26d83193c --- /dev/null +++ b/ts/fixtures/lang/capacity/expected/capacity.Escaped$strings.ts @@ -0,0 +1,13 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "./rs.ts"; + +export interface Escaped { + _0: string; +} + +export function intoIter$strings_iter_IntoIterator(self: Escaped): rs.Iter { + return rs.strEscapeDefault(self._0); +} + +//# sourceMappingURL=capacity.Escaped$strings.ts.map diff --git a/ts/fixtures/lang/capacity/expected/capacity.ts b/ts/fixtures/lang/capacity/expected/capacity.ts index 37866b049..a17f0b0e9 100644 --- a/ts/fixtures/lang/capacity/expected/capacity.ts +++ b/ts/fixtures/lang/capacity/expected/capacity.ts @@ -2,6 +2,7 @@ import * as rs from "./rs.ts"; import { copy$array_ref_str, copy$array_u64, copy$array_usize, copy$tuple2_u64_u8, of$String } from "./lib.ts"; +import * as Escaped$strings from "./capacity.Escaped$strings.ts"; import * as Holds from "./capacity.Holds.ts"; import { then$1b5wr43, then$0tujtct, then$0svbdod, then$17csa2h, then$0g2g1ls } from "./core/bool.ts"; import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOr$05jq4mv as option_unwrapOr$05jq4mv, unwrapOrDefault$0avqj0t as option_unwrapOrDefault$0avqj0t, map$1n6i7tn as option_map$1n6i7tn, map$12r4ivp as option_map$12r4ivp, map$03x2fqt as option_map$03x2fqt, map$1o9z3sm as option_map$1o9z3sm, map$1d4d0v7 as option_map$1d4d0v7, mapOr$0yzb10z as option_mapOr$0yzb10z, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$0z4nmg2 as option_mapOr$0z4nmg2 } from "./core/option.ts"; @@ -3774,7 +3775,7 @@ export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): voi rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _56); } const c: rs.char = [97, 233, 20013, 128512][_56]; - const _64: rs.u8 = rs.u8Rem(op, 53); + const _64: rs.u8 = rs.u8Rem(op, 54); if (_64 === 0) { rs.stringPush(s, c); } else if (_64 === 1) { @@ -3981,6 +3982,11 @@ export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): voi _525 = rs.stringFromEscapeDefault(escape); } s = _525; + } else if (_64 === 53) { + const grown2: rs.String = rs.stringNew(); + const _532: Escaped$strings.Escaped = { _0: s.v }; + rs.stringExtendChars(grown2, Escaped$strings.intoIter$strings_iter_IntoIterator(_532)); + s = grown2; } sized(out, s.len, s.cap); } diff --git a/ts/fixtures/lang/capacity/src/capacity.rs b/ts/fixtures/lang/capacity/src/capacity.rs index 49a51d57e..b50bdd0bc 100644 --- a/ts/fixtures/lang/capacity/src/capacity.rs +++ b/ts/fixtures/lang/capacity/src/capacity.rs @@ -684,7 +684,7 @@ pub fn strings(first: u8, steps: &[u8], out: &mut Vec) { for step in steps.chunks(2) { let (op, arg) = (step[0], step.get(1).copied().unwrap_or(0)); let c = CHARS[usize::from(arg) % CHARS.len()]; - match op % 53 { + match op % 54 { 0 => s.push(c), 1 => s.push_str(text(arg)), 2 => s.reserve(amount(arg, s.len(), 1)), @@ -835,6 +835,21 @@ pub fn strings(first: u8, steps: &[u8], out: &mut Vec) { _ => escape.collect(), }; } + // Through a wrapper whose `into_iter` is one, which std's `Extend` reads as any + // other iterator of chars: it specializes on the type it is given. + 53 => { + struct Escaped<'a>(&'a str); + impl<'a> IntoIterator for Escaped<'a> { + type Item = char; + type IntoIter = std::str::EscapeDefault<'a>; + fn into_iter(self) -> Self::IntoIter { + self.0.escape_default() + } + } + let mut grown = String::new(); + grown.extend(Escaped(&s)); + s = grown; + } _ => {} } sized(out, s.len(), s.capacity()); diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index 7e89b943d..6b7f3162e 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -2207,7 +2207,7 @@ pub fn extend<'tcx>( } let std = b.t.std_of(coll)?; if std == Std::String { - return super::iter::string_extend(b, target, items, item, iter, span); + return super::iter::string_extend(b, target, items, item, (iter, iter), span); } // Of a `TrustedLen` iterator into a vector, by `for_each`, reserving its upper bound first. let trusted = super::iter::implements(b.t, iter, "TrustedLen"); diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index d0ce0025e..c6c14b7f4 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -2233,7 +2233,7 @@ fn collect<'tcx>( let drops = iter_drops(b, from, span); Expr::rs("stringFromChars", tail(vec![iter], vec![drops])) } - _ => string_extend(b, Expr::rs("stringNew", vec![]), iter, item, from, span)?, + _ => string_extend(b, Expr::rs("stringNew", vec![]), iter, item, (from, from), span)?, }; Some(match std { Std::Box => s.member("v"), @@ -2276,18 +2276,19 @@ pub(super) fn str_array(ty: Ty<'_>) -> bool { matches!(ty.kind(), ty::Array(elem, _) if elem.is_ref() && elem.peel_refs().is_str()) } -/// `s` extended by `items`, an iterator of type `iter` of `item`s, as `String`'s `Extend` -/// reads it, by `for_each`: of chars, through any `&`, or of text, a `&str`, `String`, -/// `Box`, or `Cow`. +/// `s` extended by `items`, an iterator of type `iter` of `item`s made of a `source`, as +/// `String`'s `Extend` reads it, by `for_each`: of chars, through any `&`, or of text, a +/// `&str`, `String`, `Box`, or `Cow`. std specializes on `source`'s own type, +/// so a wrapper whose `into_iter` is a `str::EscapeDefault` is read as any other. pub(super) fn string_extend<'tcx>( b: &mut Body<'_, '_, 'tcx>, s: Expr, items: Expr, item: Ty<'tcx>, - iter: Ty<'tcx>, + (source, iter): (Ty<'tcx>, Ty<'tcx>), span: Span, ) -> Option { - if str_escape_default(b.t, iter) { + if str_escape_default(b.t, source) { return Some(Expr::rs("stringExtendEscapeDefault", vec![s, items])); } let extend = if text_items(b.t, item)? { diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index 95df24054..0e57a5ebf 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -876,7 +876,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { return done(Expr::rs("stringExtendArray", vec![s, items]), true); } done( - crate::lower::iter::string_extend(self.b, s, items, item, iter, span)?, + crate::lower::iter::string_extend(self.b, s, items, item, (source, iter), span)?, true, ) }