fidl_fuchsia_kernel__common/
fidl_fuchsia_kernel__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11/// Maximum number of bytes in a command string
12pub const DEBUG_COMMAND_MAX: u32 = 1024;
13
14#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
15#[repr(C)]
16pub struct CounterUpdateInspectVmoResponse {
17    pub status: i32,
18}
19
20impl fidl::Persistable for CounterUpdateInspectVmoResponse {}
21
22#[derive(Clone, Debug, PartialEq)]
23pub struct CpuStats {
24    /// This is the total number of CPUs on the actual device. This may not be the same as the length
25    /// of the vector `per_cpu_stats` as it is possible the underlying syscall will not return stats
26    /// for all CPUs.
27    pub actual_num_cpus: u64,
28    pub per_cpu_stats: Option<Vec<PerCpuStats>>,
29}
30
31impl fidl::Persistable for CpuStats {}
32
33#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
34pub struct DebugBrokerSendDebugCommandRequest {
35    pub command: String,
36}
37
38impl fidl::Persistable for DebugBrokerSendDebugCommandRequest {}
39
40#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
41#[repr(C)]
42pub struct DebugBrokerSendDebugCommandResponse {
43    pub status: i32,
44}
45
46impl fidl::Persistable for DebugBrokerSendDebugCommandResponse {}
47
48#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
49pub struct DebugBrokerSetTracingEnabledRequest {
50    pub enabled: bool,
51}
52
53impl fidl::Persistable for DebugBrokerSetTracingEnabledRequest {}
54
55#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
56#[repr(C)]
57pub struct DebugBrokerSetTracingEnabledResponse {
58    pub status: i32,
59}
60
61impl fidl::Persistable for DebugBrokerSetTracingEnabledResponse {}
62
63#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
64#[repr(C)]
65pub struct StatsGetCpuLoadRequest {
66    pub duration: i64,
67}
68
69impl fidl::Persistable for StatsGetCpuLoadRequest {}
70
71#[derive(Clone, Debug, PartialEq, PartialOrd)]
72pub struct StatsGetCpuLoadResponse {
73    pub per_cpu_load: Vec<f32>,
74}
75
76impl fidl::Persistable for StatsGetCpuLoadResponse {}
77
78#[derive(Clone, Debug, PartialEq)]
79pub struct StatsGetCpuStatsResponse {
80    pub stats: CpuStats,
81}
82
83impl fidl::Persistable for StatsGetCpuStatsResponse {}
84
85#[derive(Clone, Debug, PartialEq)]
86pub struct StatsGetMemoryStatsExtendedResponse {
87    pub stats: MemoryStatsExtended,
88}
89
90impl fidl::Persistable for StatsGetMemoryStatsExtendedResponse {}
91
92#[derive(Clone, Debug, PartialEq)]
93pub struct StatsGetMemoryStatsResponse {
94    pub stats: MemoryStats,
95}
96
97impl fidl::Persistable for StatsGetMemoryStatsResponse {}
98
99#[derive(Clone, Debug, Default, PartialEq)]
100pub struct MemoryStats {
101    pub total_bytes: Option<u64>,
102    pub free_bytes: Option<u64>,
103    pub wired_bytes: Option<u64>,
104    pub total_heap_bytes: Option<u64>,
105    pub free_heap_bytes: Option<u64>,
106    pub vmo_bytes: Option<u64>,
107    pub mmu_overhead_bytes: Option<u64>,
108    pub ipc_bytes: Option<u64>,
109    pub other_bytes: Option<u64>,
110    pub free_loaned_bytes: Option<u64>,
111    pub cache_bytes: Option<u64>,
112    pub slab_bytes: Option<u64>,
113    pub zram_bytes: Option<u64>,
114    pub vmo_reclaim_total_bytes: Option<u64>,
115    pub vmo_reclaim_newest_bytes: Option<u64>,
116    pub vmo_reclaim_oldest_bytes: Option<u64>,
117    pub vmo_reclaim_disabled_bytes: Option<u64>,
118    pub vmo_discardable_locked_bytes: Option<u64>,
119    pub vmo_discardable_unlocked_bytes: Option<u64>,
120    #[doc(hidden)]
121    pub __source_breaking: fidl::marker::SourceBreaking,
122}
123
124impl fidl::Persistable for MemoryStats {}
125
126#[derive(Clone, Debug, Default, PartialEq)]
127pub struct MemoryStatsCompression {
128    pub uncompressed_storage_bytes: Option<u64>,
129    pub compressed_storage_bytes: Option<u64>,
130    pub compressed_fragmentation_bytes: Option<u64>,
131    pub compression_time: Option<i64>,
132    pub decompression_time: Option<i64>,
133    pub total_page_compression_attempts: Option<u64>,
134    pub failed_page_compression_attempts: Option<u64>,
135    pub total_page_decompressions: Option<u64>,
136    pub compressed_page_evictions: Option<u64>,
137    pub eager_page_compressions: Option<u64>,
138    pub memory_pressure_page_compressions: Option<u64>,
139    pub critical_memory_page_compressions: Option<u64>,
140    pub pages_decompressed_unit_ns: Option<u64>,
141    pub pages_decompressed_within_log_time: Option<[u64; 8]>,
142    #[doc(hidden)]
143    pub __source_breaking: fidl::marker::SourceBreaking,
144}
145
146impl fidl::Persistable for MemoryStatsCompression {}
147
148#[derive(Clone, Debug, Default, PartialEq)]
149pub struct MemoryStatsExtended {
150    pub total_bytes: Option<u64>,
151    pub free_bytes: Option<u64>,
152    pub wired_bytes: Option<u64>,
153    pub total_heap_bytes: Option<u64>,
154    pub free_heap_bytes: Option<u64>,
155    pub vmo_bytes: Option<u64>,
156    pub vmo_pager_total_bytes: Option<u64>,
157    pub vmo_pager_newest_bytes: Option<u64>,
158    pub vmo_pager_oldest_bytes: Option<u64>,
159    pub vmo_discardable_locked_bytes: Option<u64>,
160    pub vmo_discardable_unlocked_bytes: Option<u64>,
161    pub mmu_overhead_bytes: Option<u64>,
162    pub ipc_bytes: Option<u64>,
163    pub other_bytes: Option<u64>,
164    #[doc(hidden)]
165    pub __source_breaking: fidl::marker::SourceBreaking,
166}
167
168impl fidl::Persistable for MemoryStatsExtended {}
169
170#[derive(Clone, Debug, Default, PartialEq)]
171pub struct PerCpuStats {
172    pub cpu_number: Option<u32>,
173    pub flags: Option<u32>,
174    pub idle_time: Option<i64>,
175    pub reschedules: Option<u64>,
176    pub context_switches: Option<u64>,
177    pub irq_preempts: Option<u64>,
178    pub yields: Option<u64>,
179    pub ints: Option<u64>,
180    pub timer_ints: Option<u64>,
181    pub timers: Option<u64>,
182    pub page_faults: Option<u64>,
183    pub exceptions: Option<u64>,
184    pub syscalls: Option<u64>,
185    pub reschedule_ipis: Option<u64>,
186    pub generic_ipis: Option<u64>,
187    #[doc(hidden)]
188    pub __source_breaking: fidl::marker::SourceBreaking,
189}
190
191impl fidl::Persistable for PerCpuStats {}
192
193pub mod counter_ordinals {
194    pub const GET_INSPECT_VMO: u64 = 0x6ea9b2e6b2791b81;
195    pub const UPDATE_INSPECT_VMO: u64 = 0x1d25eb7995a0539f;
196}
197
198pub mod cpu_resource_ordinals {
199    pub const GET: u64 = 0x41e1103acf4215e4;
200}
201
202pub mod debug_broker_ordinals {
203    pub const SEND_DEBUG_COMMAND: u64 = 0x1ee270f83b5d6ff6;
204    pub const SET_TRACING_ENABLED: u64 = 0x12e368d05329b30e;
205}
206
207pub mod debug_resource_ordinals {
208    pub const GET: u64 = 0x1d79d77ea12a6474;
209}
210
211pub mod debuglog_resource_ordinals {
212    pub const GET: u64 = 0x6e78c1ff74765225;
213}
214
215pub mod energy_info_resource_ordinals {
216    pub const GET: u64 = 0x5f5cc9f0745f61d0;
217}
218
219pub mod hypervisor_resource_ordinals {
220    pub const GET: u64 = 0x1c312131d3b824a2;
221}
222
223pub mod info_resource_ordinals {
224    pub const GET: u64 = 0x1de8edcb4abc2067;
225}
226
227pub mod iommu_resource_ordinals {
228    pub const GET: u64 = 0x5af309b619aa7c5b;
229}
230
231pub mod ioport_resource_ordinals {
232    pub const GET: u64 = 0x4db20876b537c52b;
233}
234
235pub mod irq_resource_ordinals {
236    pub const GET: u64 = 0x491be54504b041e9;
237}
238
239pub mod mexec_resource_ordinals {
240    pub const GET: u64 = 0xff93e6722900f54;
241}
242
243pub mod mmio_resource_ordinals {
244    pub const GET: u64 = 0x66747b9c5a6dfe7b;
245}
246
247pub mod msi_resource_ordinals {
248    pub const GET: u64 = 0x360a97e47e8c4f1f;
249}
250
251pub mod power_resource_ordinals {
252    pub const GET: u64 = 0x2b8df8ca24d1e866;
253}
254
255pub mod profile_resource_ordinals {
256    pub const GET: u64 = 0x3003a0c14de1fa86;
257}
258
259pub mod root_job_ordinals {
260    pub const GET: u64 = 0x73acb63f93d53eac;
261}
262
263pub mod root_job_for_inspect_ordinals {
264    pub const GET: u64 = 0x73acb63f93d53eac;
265}
266
267pub mod smc_resource_ordinals {
268    pub const GET: u64 = 0x392cbd495b84ede7;
269}
270
271pub mod stall_resource_ordinals {
272    pub const GET: u64 = 0x5edf4c8629a9781a;
273}
274
275pub mod stats_ordinals {
276    pub const GET_MEMORY_STATS: u64 = 0x686677932ae41074;
277    pub const GET_MEMORY_STATS_EXTENDED: u64 = 0x60faa0f8aa38c29f;
278    pub const GET_MEMORY_STATS_COMPRESSION: u64 = 0x544a09995befb531;
279    pub const GET_CPU_STATS: u64 = 0x470e2684ca1ca19e;
280    pub const GET_CPU_LOAD: u64 = 0x4c8f0f05e7034666;
281}
282
283pub mod tracing_resource_ordinals {
284    pub const GET: u64 = 0x299bc179aa54c6aa;
285}
286
287pub mod vmex_resource_ordinals {
288    pub const GET: u64 = 0x33db32deed650699;
289}
290
291mod internal {
292    use super::*;
293
294    impl fidl::encoding::ValueTypeMarker for CounterUpdateInspectVmoResponse {
295        type Borrowed<'a> = &'a Self;
296        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
297            value
298        }
299    }
300
301    unsafe impl fidl::encoding::TypeMarker for CounterUpdateInspectVmoResponse {
302        type Owned = Self;
303
304        #[inline(always)]
305        fn inline_align(_context: fidl::encoding::Context) -> usize {
306            4
307        }
308
309        #[inline(always)]
310        fn inline_size(_context: fidl::encoding::Context) -> usize {
311            4
312        }
313        #[inline(always)]
314        fn encode_is_copy() -> bool {
315            true
316        }
317
318        #[inline(always)]
319        fn decode_is_copy() -> bool {
320            true
321        }
322    }
323
324    unsafe impl<D: fidl::encoding::ResourceDialect>
325        fidl::encoding::Encode<CounterUpdateInspectVmoResponse, D>
326        for &CounterUpdateInspectVmoResponse
327    {
328        #[inline]
329        unsafe fn encode(
330            self,
331            encoder: &mut fidl::encoding::Encoder<'_, D>,
332            offset: usize,
333            _depth: fidl::encoding::Depth,
334        ) -> fidl::Result<()> {
335            encoder.debug_check_bounds::<CounterUpdateInspectVmoResponse>(offset);
336            unsafe {
337                // Copy the object into the buffer.
338                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
339                (buf_ptr as *mut CounterUpdateInspectVmoResponse)
340                    .write_unaligned((self as *const CounterUpdateInspectVmoResponse).read());
341                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
342                // done second because the memcpy will write garbage to these bytes.
343            }
344            Ok(())
345        }
346    }
347    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
348        fidl::encoding::Encode<CounterUpdateInspectVmoResponse, D> for (T0,)
349    {
350        #[inline]
351        unsafe fn encode(
352            self,
353            encoder: &mut fidl::encoding::Encoder<'_, D>,
354            offset: usize,
355            depth: fidl::encoding::Depth,
356        ) -> fidl::Result<()> {
357            encoder.debug_check_bounds::<CounterUpdateInspectVmoResponse>(offset);
358            // Zero out padding regions. There's no need to apply masks
359            // because the unmasked parts will be overwritten by fields.
360            // Write the fields.
361            self.0.encode(encoder, offset + 0, depth)?;
362            Ok(())
363        }
364    }
365
366    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
367        for CounterUpdateInspectVmoResponse
368    {
369        #[inline(always)]
370        fn new_empty() -> Self {
371            Self { status: fidl::new_empty!(i32, D) }
372        }
373
374        #[inline]
375        unsafe fn decode(
376            &mut self,
377            decoder: &mut fidl::encoding::Decoder<'_, D>,
378            offset: usize,
379            _depth: fidl::encoding::Depth,
380        ) -> fidl::Result<()> {
381            decoder.debug_check_bounds::<Self>(offset);
382            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
383            // Verify that padding bytes are zero.
384            // Copy from the buffer into the object.
385            unsafe {
386                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
387            }
388            Ok(())
389        }
390    }
391
392    impl fidl::encoding::ValueTypeMarker for CpuStats {
393        type Borrowed<'a> = &'a Self;
394        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
395            value
396        }
397    }
398
399    unsafe impl fidl::encoding::TypeMarker for CpuStats {
400        type Owned = Self;
401
402        #[inline(always)]
403        fn inline_align(_context: fidl::encoding::Context) -> usize {
404            8
405        }
406
407        #[inline(always)]
408        fn inline_size(_context: fidl::encoding::Context) -> usize {
409            24
410        }
411    }
412
413    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CpuStats, D> for &CpuStats {
414        #[inline]
415        unsafe fn encode(
416            self,
417            encoder: &mut fidl::encoding::Encoder<'_, D>,
418            offset: usize,
419            _depth: fidl::encoding::Depth,
420        ) -> fidl::Result<()> {
421            encoder.debug_check_bounds::<CpuStats>(offset);
422            // Delegate to tuple encoding.
423            fidl::encoding::Encode::<CpuStats, D>::encode(
424                (
425                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.actual_num_cpus),
426                    <fidl::encoding::Optional<fidl::encoding::Vector<PerCpuStats, 512>> as fidl::encoding::ValueTypeMarker>::borrow(&self.per_cpu_stats),
427                ),
428                encoder, offset, _depth
429            )
430        }
431    }
432    unsafe impl<
433            D: fidl::encoding::ResourceDialect,
434            T0: fidl::encoding::Encode<u64, D>,
435            T1: fidl::encoding::Encode<
436                fidl::encoding::Optional<fidl::encoding::Vector<PerCpuStats, 512>>,
437                D,
438            >,
439        > fidl::encoding::Encode<CpuStats, D> for (T0, T1)
440    {
441        #[inline]
442        unsafe fn encode(
443            self,
444            encoder: &mut fidl::encoding::Encoder<'_, D>,
445            offset: usize,
446            depth: fidl::encoding::Depth,
447        ) -> fidl::Result<()> {
448            encoder.debug_check_bounds::<CpuStats>(offset);
449            // Zero out padding regions. There's no need to apply masks
450            // because the unmasked parts will be overwritten by fields.
451            // Write the fields.
452            self.0.encode(encoder, offset + 0, depth)?;
453            self.1.encode(encoder, offset + 8, depth)?;
454            Ok(())
455        }
456    }
457
458    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CpuStats {
459        #[inline(always)]
460        fn new_empty() -> Self {
461            Self {
462                actual_num_cpus: fidl::new_empty!(u64, D),
463                per_cpu_stats: fidl::new_empty!(
464                    fidl::encoding::Optional<fidl::encoding::Vector<PerCpuStats, 512>>,
465                    D
466                ),
467            }
468        }
469
470        #[inline]
471        unsafe fn decode(
472            &mut self,
473            decoder: &mut fidl::encoding::Decoder<'_, D>,
474            offset: usize,
475            _depth: fidl::encoding::Depth,
476        ) -> fidl::Result<()> {
477            decoder.debug_check_bounds::<Self>(offset);
478            // Verify that padding bytes are zero.
479            fidl::decode!(u64, D, &mut self.actual_num_cpus, decoder, offset + 0, _depth)?;
480            fidl::decode!(
481                fidl::encoding::Optional<fidl::encoding::Vector<PerCpuStats, 512>>,
482                D,
483                &mut self.per_cpu_stats,
484                decoder,
485                offset + 8,
486                _depth
487            )?;
488            Ok(())
489        }
490    }
491
492    impl fidl::encoding::ValueTypeMarker for DebugBrokerSendDebugCommandRequest {
493        type Borrowed<'a> = &'a Self;
494        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
495            value
496        }
497    }
498
499    unsafe impl fidl::encoding::TypeMarker for DebugBrokerSendDebugCommandRequest {
500        type Owned = Self;
501
502        #[inline(always)]
503        fn inline_align(_context: fidl::encoding::Context) -> usize {
504            8
505        }
506
507        #[inline(always)]
508        fn inline_size(_context: fidl::encoding::Context) -> usize {
509            16
510        }
511    }
512
513    unsafe impl<D: fidl::encoding::ResourceDialect>
514        fidl::encoding::Encode<DebugBrokerSendDebugCommandRequest, D>
515        for &DebugBrokerSendDebugCommandRequest
516    {
517        #[inline]
518        unsafe fn encode(
519            self,
520            encoder: &mut fidl::encoding::Encoder<'_, D>,
521            offset: usize,
522            _depth: fidl::encoding::Depth,
523        ) -> fidl::Result<()> {
524            encoder.debug_check_bounds::<DebugBrokerSendDebugCommandRequest>(offset);
525            // Delegate to tuple encoding.
526            fidl::encoding::Encode::<DebugBrokerSendDebugCommandRequest, D>::encode(
527                (<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(
528                    &self.command,
529                ),),
530                encoder,
531                offset,
532                _depth,
533            )
534        }
535    }
536    unsafe impl<
537            D: fidl::encoding::ResourceDialect,
538            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>, D>,
539        > fidl::encoding::Encode<DebugBrokerSendDebugCommandRequest, D> for (T0,)
540    {
541        #[inline]
542        unsafe fn encode(
543            self,
544            encoder: &mut fidl::encoding::Encoder<'_, D>,
545            offset: usize,
546            depth: fidl::encoding::Depth,
547        ) -> fidl::Result<()> {
548            encoder.debug_check_bounds::<DebugBrokerSendDebugCommandRequest>(offset);
549            // Zero out padding regions. There's no need to apply masks
550            // because the unmasked parts will be overwritten by fields.
551            // Write the fields.
552            self.0.encode(encoder, offset + 0, depth)?;
553            Ok(())
554        }
555    }
556
557    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
558        for DebugBrokerSendDebugCommandRequest
559    {
560        #[inline(always)]
561        fn new_empty() -> Self {
562            Self { command: fidl::new_empty!(fidl::encoding::BoundedString<1024>, D) }
563        }
564
565        #[inline]
566        unsafe fn decode(
567            &mut self,
568            decoder: &mut fidl::encoding::Decoder<'_, D>,
569            offset: usize,
570            _depth: fidl::encoding::Depth,
571        ) -> fidl::Result<()> {
572            decoder.debug_check_bounds::<Self>(offset);
573            // Verify that padding bytes are zero.
574            fidl::decode!(
575                fidl::encoding::BoundedString<1024>,
576                D,
577                &mut self.command,
578                decoder,
579                offset + 0,
580                _depth
581            )?;
582            Ok(())
583        }
584    }
585
586    impl fidl::encoding::ValueTypeMarker for DebugBrokerSendDebugCommandResponse {
587        type Borrowed<'a> = &'a Self;
588        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
589            value
590        }
591    }
592
593    unsafe impl fidl::encoding::TypeMarker for DebugBrokerSendDebugCommandResponse {
594        type Owned = Self;
595
596        #[inline(always)]
597        fn inline_align(_context: fidl::encoding::Context) -> usize {
598            4
599        }
600
601        #[inline(always)]
602        fn inline_size(_context: fidl::encoding::Context) -> usize {
603            4
604        }
605        #[inline(always)]
606        fn encode_is_copy() -> bool {
607            true
608        }
609
610        #[inline(always)]
611        fn decode_is_copy() -> bool {
612            true
613        }
614    }
615
616    unsafe impl<D: fidl::encoding::ResourceDialect>
617        fidl::encoding::Encode<DebugBrokerSendDebugCommandResponse, D>
618        for &DebugBrokerSendDebugCommandResponse
619    {
620        #[inline]
621        unsafe fn encode(
622            self,
623            encoder: &mut fidl::encoding::Encoder<'_, D>,
624            offset: usize,
625            _depth: fidl::encoding::Depth,
626        ) -> fidl::Result<()> {
627            encoder.debug_check_bounds::<DebugBrokerSendDebugCommandResponse>(offset);
628            unsafe {
629                // Copy the object into the buffer.
630                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
631                (buf_ptr as *mut DebugBrokerSendDebugCommandResponse)
632                    .write_unaligned((self as *const DebugBrokerSendDebugCommandResponse).read());
633                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
634                // done second because the memcpy will write garbage to these bytes.
635            }
636            Ok(())
637        }
638    }
639    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
640        fidl::encoding::Encode<DebugBrokerSendDebugCommandResponse, D> for (T0,)
641    {
642        #[inline]
643        unsafe fn encode(
644            self,
645            encoder: &mut fidl::encoding::Encoder<'_, D>,
646            offset: usize,
647            depth: fidl::encoding::Depth,
648        ) -> fidl::Result<()> {
649            encoder.debug_check_bounds::<DebugBrokerSendDebugCommandResponse>(offset);
650            // Zero out padding regions. There's no need to apply masks
651            // because the unmasked parts will be overwritten by fields.
652            // Write the fields.
653            self.0.encode(encoder, offset + 0, depth)?;
654            Ok(())
655        }
656    }
657
658    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
659        for DebugBrokerSendDebugCommandResponse
660    {
661        #[inline(always)]
662        fn new_empty() -> Self {
663            Self { status: fidl::new_empty!(i32, D) }
664        }
665
666        #[inline]
667        unsafe fn decode(
668            &mut self,
669            decoder: &mut fidl::encoding::Decoder<'_, D>,
670            offset: usize,
671            _depth: fidl::encoding::Depth,
672        ) -> fidl::Result<()> {
673            decoder.debug_check_bounds::<Self>(offset);
674            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
675            // Verify that padding bytes are zero.
676            // Copy from the buffer into the object.
677            unsafe {
678                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
679            }
680            Ok(())
681        }
682    }
683
684    impl fidl::encoding::ValueTypeMarker for DebugBrokerSetTracingEnabledRequest {
685        type Borrowed<'a> = &'a Self;
686        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
687            value
688        }
689    }
690
691    unsafe impl fidl::encoding::TypeMarker for DebugBrokerSetTracingEnabledRequest {
692        type Owned = Self;
693
694        #[inline(always)]
695        fn inline_align(_context: fidl::encoding::Context) -> usize {
696            1
697        }
698
699        #[inline(always)]
700        fn inline_size(_context: fidl::encoding::Context) -> usize {
701            1
702        }
703    }
704
705    unsafe impl<D: fidl::encoding::ResourceDialect>
706        fidl::encoding::Encode<DebugBrokerSetTracingEnabledRequest, D>
707        for &DebugBrokerSetTracingEnabledRequest
708    {
709        #[inline]
710        unsafe fn encode(
711            self,
712            encoder: &mut fidl::encoding::Encoder<'_, D>,
713            offset: usize,
714            _depth: fidl::encoding::Depth,
715        ) -> fidl::Result<()> {
716            encoder.debug_check_bounds::<DebugBrokerSetTracingEnabledRequest>(offset);
717            // Delegate to tuple encoding.
718            fidl::encoding::Encode::<DebugBrokerSetTracingEnabledRequest, D>::encode(
719                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.enabled),),
720                encoder,
721                offset,
722                _depth,
723            )
724        }
725    }
726    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
727        fidl::encoding::Encode<DebugBrokerSetTracingEnabledRequest, D> for (T0,)
728    {
729        #[inline]
730        unsafe fn encode(
731            self,
732            encoder: &mut fidl::encoding::Encoder<'_, D>,
733            offset: usize,
734            depth: fidl::encoding::Depth,
735        ) -> fidl::Result<()> {
736            encoder.debug_check_bounds::<DebugBrokerSetTracingEnabledRequest>(offset);
737            // Zero out padding regions. There's no need to apply masks
738            // because the unmasked parts will be overwritten by fields.
739            // Write the fields.
740            self.0.encode(encoder, offset + 0, depth)?;
741            Ok(())
742        }
743    }
744
745    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
746        for DebugBrokerSetTracingEnabledRequest
747    {
748        #[inline(always)]
749        fn new_empty() -> Self {
750            Self { enabled: fidl::new_empty!(bool, D) }
751        }
752
753        #[inline]
754        unsafe fn decode(
755            &mut self,
756            decoder: &mut fidl::encoding::Decoder<'_, D>,
757            offset: usize,
758            _depth: fidl::encoding::Depth,
759        ) -> fidl::Result<()> {
760            decoder.debug_check_bounds::<Self>(offset);
761            // Verify that padding bytes are zero.
762            fidl::decode!(bool, D, &mut self.enabled, decoder, offset + 0, _depth)?;
763            Ok(())
764        }
765    }
766
767    impl fidl::encoding::ValueTypeMarker for DebugBrokerSetTracingEnabledResponse {
768        type Borrowed<'a> = &'a Self;
769        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
770            value
771        }
772    }
773
774    unsafe impl fidl::encoding::TypeMarker for DebugBrokerSetTracingEnabledResponse {
775        type Owned = Self;
776
777        #[inline(always)]
778        fn inline_align(_context: fidl::encoding::Context) -> usize {
779            4
780        }
781
782        #[inline(always)]
783        fn inline_size(_context: fidl::encoding::Context) -> usize {
784            4
785        }
786        #[inline(always)]
787        fn encode_is_copy() -> bool {
788            true
789        }
790
791        #[inline(always)]
792        fn decode_is_copy() -> bool {
793            true
794        }
795    }
796
797    unsafe impl<D: fidl::encoding::ResourceDialect>
798        fidl::encoding::Encode<DebugBrokerSetTracingEnabledResponse, D>
799        for &DebugBrokerSetTracingEnabledResponse
800    {
801        #[inline]
802        unsafe fn encode(
803            self,
804            encoder: &mut fidl::encoding::Encoder<'_, D>,
805            offset: usize,
806            _depth: fidl::encoding::Depth,
807        ) -> fidl::Result<()> {
808            encoder.debug_check_bounds::<DebugBrokerSetTracingEnabledResponse>(offset);
809            unsafe {
810                // Copy the object into the buffer.
811                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
812                (buf_ptr as *mut DebugBrokerSetTracingEnabledResponse)
813                    .write_unaligned((self as *const DebugBrokerSetTracingEnabledResponse).read());
814                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
815                // done second because the memcpy will write garbage to these bytes.
816            }
817            Ok(())
818        }
819    }
820    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
821        fidl::encoding::Encode<DebugBrokerSetTracingEnabledResponse, D> for (T0,)
822    {
823        #[inline]
824        unsafe fn encode(
825            self,
826            encoder: &mut fidl::encoding::Encoder<'_, D>,
827            offset: usize,
828            depth: fidl::encoding::Depth,
829        ) -> fidl::Result<()> {
830            encoder.debug_check_bounds::<DebugBrokerSetTracingEnabledResponse>(offset);
831            // Zero out padding regions. There's no need to apply masks
832            // because the unmasked parts will be overwritten by fields.
833            // Write the fields.
834            self.0.encode(encoder, offset + 0, depth)?;
835            Ok(())
836        }
837    }
838
839    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
840        for DebugBrokerSetTracingEnabledResponse
841    {
842        #[inline(always)]
843        fn new_empty() -> Self {
844            Self { status: fidl::new_empty!(i32, D) }
845        }
846
847        #[inline]
848        unsafe fn decode(
849            &mut self,
850            decoder: &mut fidl::encoding::Decoder<'_, D>,
851            offset: usize,
852            _depth: fidl::encoding::Depth,
853        ) -> fidl::Result<()> {
854            decoder.debug_check_bounds::<Self>(offset);
855            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
856            // Verify that padding bytes are zero.
857            // Copy from the buffer into the object.
858            unsafe {
859                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
860            }
861            Ok(())
862        }
863    }
864
865    impl fidl::encoding::ValueTypeMarker for StatsGetCpuLoadRequest {
866        type Borrowed<'a> = &'a Self;
867        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
868            value
869        }
870    }
871
872    unsafe impl fidl::encoding::TypeMarker for StatsGetCpuLoadRequest {
873        type Owned = Self;
874
875        #[inline(always)]
876        fn inline_align(_context: fidl::encoding::Context) -> usize {
877            8
878        }
879
880        #[inline(always)]
881        fn inline_size(_context: fidl::encoding::Context) -> usize {
882            8
883        }
884        #[inline(always)]
885        fn encode_is_copy() -> bool {
886            true
887        }
888
889        #[inline(always)]
890        fn decode_is_copy() -> bool {
891            true
892        }
893    }
894
895    unsafe impl<D: fidl::encoding::ResourceDialect>
896        fidl::encoding::Encode<StatsGetCpuLoadRequest, D> for &StatsGetCpuLoadRequest
897    {
898        #[inline]
899        unsafe fn encode(
900            self,
901            encoder: &mut fidl::encoding::Encoder<'_, D>,
902            offset: usize,
903            _depth: fidl::encoding::Depth,
904        ) -> fidl::Result<()> {
905            encoder.debug_check_bounds::<StatsGetCpuLoadRequest>(offset);
906            unsafe {
907                // Copy the object into the buffer.
908                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
909                (buf_ptr as *mut StatsGetCpuLoadRequest)
910                    .write_unaligned((self as *const StatsGetCpuLoadRequest).read());
911                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
912                // done second because the memcpy will write garbage to these bytes.
913            }
914            Ok(())
915        }
916    }
917    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i64, D>>
918        fidl::encoding::Encode<StatsGetCpuLoadRequest, D> for (T0,)
919    {
920        #[inline]
921        unsafe fn encode(
922            self,
923            encoder: &mut fidl::encoding::Encoder<'_, D>,
924            offset: usize,
925            depth: fidl::encoding::Depth,
926        ) -> fidl::Result<()> {
927            encoder.debug_check_bounds::<StatsGetCpuLoadRequest>(offset);
928            // Zero out padding regions. There's no need to apply masks
929            // because the unmasked parts will be overwritten by fields.
930            // Write the fields.
931            self.0.encode(encoder, offset + 0, depth)?;
932            Ok(())
933        }
934    }
935
936    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
937        for StatsGetCpuLoadRequest
938    {
939        #[inline(always)]
940        fn new_empty() -> Self {
941            Self { duration: fidl::new_empty!(i64, D) }
942        }
943
944        #[inline]
945        unsafe fn decode(
946            &mut self,
947            decoder: &mut fidl::encoding::Decoder<'_, D>,
948            offset: usize,
949            _depth: fidl::encoding::Depth,
950        ) -> fidl::Result<()> {
951            decoder.debug_check_bounds::<Self>(offset);
952            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
953            // Verify that padding bytes are zero.
954            // Copy from the buffer into the object.
955            unsafe {
956                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
957            }
958            Ok(())
959        }
960    }
961
962    impl fidl::encoding::ValueTypeMarker for StatsGetCpuLoadResponse {
963        type Borrowed<'a> = &'a Self;
964        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
965            value
966        }
967    }
968
969    unsafe impl fidl::encoding::TypeMarker for StatsGetCpuLoadResponse {
970        type Owned = Self;
971
972        #[inline(always)]
973        fn inline_align(_context: fidl::encoding::Context) -> usize {
974            8
975        }
976
977        #[inline(always)]
978        fn inline_size(_context: fidl::encoding::Context) -> usize {
979            16
980        }
981    }
982
983    unsafe impl<D: fidl::encoding::ResourceDialect>
984        fidl::encoding::Encode<StatsGetCpuLoadResponse, D> for &StatsGetCpuLoadResponse
985    {
986        #[inline]
987        unsafe fn encode(
988            self,
989            encoder: &mut fidl::encoding::Encoder<'_, D>,
990            offset: usize,
991            _depth: fidl::encoding::Depth,
992        ) -> fidl::Result<()> {
993            encoder.debug_check_bounds::<StatsGetCpuLoadResponse>(offset);
994            // Delegate to tuple encoding.
995            fidl::encoding::Encode::<StatsGetCpuLoadResponse, D>::encode(
996                (<fidl::encoding::Vector<f32, 512> as fidl::encoding::ValueTypeMarker>::borrow(
997                    &self.per_cpu_load,
998                ),),
999                encoder,
1000                offset,
1001                _depth,
1002            )
1003        }
1004    }
1005    unsafe impl<
1006            D: fidl::encoding::ResourceDialect,
1007            T0: fidl::encoding::Encode<fidl::encoding::Vector<f32, 512>, D>,
1008        > fidl::encoding::Encode<StatsGetCpuLoadResponse, D> for (T0,)
1009    {
1010        #[inline]
1011        unsafe fn encode(
1012            self,
1013            encoder: &mut fidl::encoding::Encoder<'_, D>,
1014            offset: usize,
1015            depth: fidl::encoding::Depth,
1016        ) -> fidl::Result<()> {
1017            encoder.debug_check_bounds::<StatsGetCpuLoadResponse>(offset);
1018            // Zero out padding regions. There's no need to apply masks
1019            // because the unmasked parts will be overwritten by fields.
1020            // Write the fields.
1021            self.0.encode(encoder, offset + 0, depth)?;
1022            Ok(())
1023        }
1024    }
1025
1026    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1027        for StatsGetCpuLoadResponse
1028    {
1029        #[inline(always)]
1030        fn new_empty() -> Self {
1031            Self { per_cpu_load: fidl::new_empty!(fidl::encoding::Vector<f32, 512>, D) }
1032        }
1033
1034        #[inline]
1035        unsafe fn decode(
1036            &mut self,
1037            decoder: &mut fidl::encoding::Decoder<'_, D>,
1038            offset: usize,
1039            _depth: fidl::encoding::Depth,
1040        ) -> fidl::Result<()> {
1041            decoder.debug_check_bounds::<Self>(offset);
1042            // Verify that padding bytes are zero.
1043            fidl::decode!(fidl::encoding::Vector<f32, 512>, D, &mut self.per_cpu_load, decoder, offset + 0, _depth)?;
1044            Ok(())
1045        }
1046    }
1047
1048    impl fidl::encoding::ValueTypeMarker for StatsGetCpuStatsResponse {
1049        type Borrowed<'a> = &'a Self;
1050        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1051            value
1052        }
1053    }
1054
1055    unsafe impl fidl::encoding::TypeMarker for StatsGetCpuStatsResponse {
1056        type Owned = Self;
1057
1058        #[inline(always)]
1059        fn inline_align(_context: fidl::encoding::Context) -> usize {
1060            8
1061        }
1062
1063        #[inline(always)]
1064        fn inline_size(_context: fidl::encoding::Context) -> usize {
1065            24
1066        }
1067    }
1068
1069    unsafe impl<D: fidl::encoding::ResourceDialect>
1070        fidl::encoding::Encode<StatsGetCpuStatsResponse, D> for &StatsGetCpuStatsResponse
1071    {
1072        #[inline]
1073        unsafe fn encode(
1074            self,
1075            encoder: &mut fidl::encoding::Encoder<'_, D>,
1076            offset: usize,
1077            _depth: fidl::encoding::Depth,
1078        ) -> fidl::Result<()> {
1079            encoder.debug_check_bounds::<StatsGetCpuStatsResponse>(offset);
1080            // Delegate to tuple encoding.
1081            fidl::encoding::Encode::<StatsGetCpuStatsResponse, D>::encode(
1082                (<CpuStats as fidl::encoding::ValueTypeMarker>::borrow(&self.stats),),
1083                encoder,
1084                offset,
1085                _depth,
1086            )
1087        }
1088    }
1089    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<CpuStats, D>>
1090        fidl::encoding::Encode<StatsGetCpuStatsResponse, D> for (T0,)
1091    {
1092        #[inline]
1093        unsafe fn encode(
1094            self,
1095            encoder: &mut fidl::encoding::Encoder<'_, D>,
1096            offset: usize,
1097            depth: fidl::encoding::Depth,
1098        ) -> fidl::Result<()> {
1099            encoder.debug_check_bounds::<StatsGetCpuStatsResponse>(offset);
1100            // Zero out padding regions. There's no need to apply masks
1101            // because the unmasked parts will be overwritten by fields.
1102            // Write the fields.
1103            self.0.encode(encoder, offset + 0, depth)?;
1104            Ok(())
1105        }
1106    }
1107
1108    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1109        for StatsGetCpuStatsResponse
1110    {
1111        #[inline(always)]
1112        fn new_empty() -> Self {
1113            Self { stats: fidl::new_empty!(CpuStats, D) }
1114        }
1115
1116        #[inline]
1117        unsafe fn decode(
1118            &mut self,
1119            decoder: &mut fidl::encoding::Decoder<'_, D>,
1120            offset: usize,
1121            _depth: fidl::encoding::Depth,
1122        ) -> fidl::Result<()> {
1123            decoder.debug_check_bounds::<Self>(offset);
1124            // Verify that padding bytes are zero.
1125            fidl::decode!(CpuStats, D, &mut self.stats, decoder, offset + 0, _depth)?;
1126            Ok(())
1127        }
1128    }
1129
1130    impl fidl::encoding::ValueTypeMarker for StatsGetMemoryStatsExtendedResponse {
1131        type Borrowed<'a> = &'a Self;
1132        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1133            value
1134        }
1135    }
1136
1137    unsafe impl fidl::encoding::TypeMarker for StatsGetMemoryStatsExtendedResponse {
1138        type Owned = Self;
1139
1140        #[inline(always)]
1141        fn inline_align(_context: fidl::encoding::Context) -> usize {
1142            8
1143        }
1144
1145        #[inline(always)]
1146        fn inline_size(_context: fidl::encoding::Context) -> usize {
1147            16
1148        }
1149    }
1150
1151    unsafe impl<D: fidl::encoding::ResourceDialect>
1152        fidl::encoding::Encode<StatsGetMemoryStatsExtendedResponse, D>
1153        for &StatsGetMemoryStatsExtendedResponse
1154    {
1155        #[inline]
1156        unsafe fn encode(
1157            self,
1158            encoder: &mut fidl::encoding::Encoder<'_, D>,
1159            offset: usize,
1160            _depth: fidl::encoding::Depth,
1161        ) -> fidl::Result<()> {
1162            encoder.debug_check_bounds::<StatsGetMemoryStatsExtendedResponse>(offset);
1163            // Delegate to tuple encoding.
1164            fidl::encoding::Encode::<StatsGetMemoryStatsExtendedResponse, D>::encode(
1165                (<MemoryStatsExtended as fidl::encoding::ValueTypeMarker>::borrow(&self.stats),),
1166                encoder,
1167                offset,
1168                _depth,
1169            )
1170        }
1171    }
1172    unsafe impl<
1173            D: fidl::encoding::ResourceDialect,
1174            T0: fidl::encoding::Encode<MemoryStatsExtended, D>,
1175        > fidl::encoding::Encode<StatsGetMemoryStatsExtendedResponse, D> for (T0,)
1176    {
1177        #[inline]
1178        unsafe fn encode(
1179            self,
1180            encoder: &mut fidl::encoding::Encoder<'_, D>,
1181            offset: usize,
1182            depth: fidl::encoding::Depth,
1183        ) -> fidl::Result<()> {
1184            encoder.debug_check_bounds::<StatsGetMemoryStatsExtendedResponse>(offset);
1185            // Zero out padding regions. There's no need to apply masks
1186            // because the unmasked parts will be overwritten by fields.
1187            // Write the fields.
1188            self.0.encode(encoder, offset + 0, depth)?;
1189            Ok(())
1190        }
1191    }
1192
1193    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1194        for StatsGetMemoryStatsExtendedResponse
1195    {
1196        #[inline(always)]
1197        fn new_empty() -> Self {
1198            Self { stats: fidl::new_empty!(MemoryStatsExtended, D) }
1199        }
1200
1201        #[inline]
1202        unsafe fn decode(
1203            &mut self,
1204            decoder: &mut fidl::encoding::Decoder<'_, D>,
1205            offset: usize,
1206            _depth: fidl::encoding::Depth,
1207        ) -> fidl::Result<()> {
1208            decoder.debug_check_bounds::<Self>(offset);
1209            // Verify that padding bytes are zero.
1210            fidl::decode!(MemoryStatsExtended, D, &mut self.stats, decoder, offset + 0, _depth)?;
1211            Ok(())
1212        }
1213    }
1214
1215    impl fidl::encoding::ValueTypeMarker for StatsGetMemoryStatsResponse {
1216        type Borrowed<'a> = &'a Self;
1217        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1218            value
1219        }
1220    }
1221
1222    unsafe impl fidl::encoding::TypeMarker for StatsGetMemoryStatsResponse {
1223        type Owned = Self;
1224
1225        #[inline(always)]
1226        fn inline_align(_context: fidl::encoding::Context) -> usize {
1227            8
1228        }
1229
1230        #[inline(always)]
1231        fn inline_size(_context: fidl::encoding::Context) -> usize {
1232            16
1233        }
1234    }
1235
1236    unsafe impl<D: fidl::encoding::ResourceDialect>
1237        fidl::encoding::Encode<StatsGetMemoryStatsResponse, D> for &StatsGetMemoryStatsResponse
1238    {
1239        #[inline]
1240        unsafe fn encode(
1241            self,
1242            encoder: &mut fidl::encoding::Encoder<'_, D>,
1243            offset: usize,
1244            _depth: fidl::encoding::Depth,
1245        ) -> fidl::Result<()> {
1246            encoder.debug_check_bounds::<StatsGetMemoryStatsResponse>(offset);
1247            // Delegate to tuple encoding.
1248            fidl::encoding::Encode::<StatsGetMemoryStatsResponse, D>::encode(
1249                (<MemoryStats as fidl::encoding::ValueTypeMarker>::borrow(&self.stats),),
1250                encoder,
1251                offset,
1252                _depth,
1253            )
1254        }
1255    }
1256    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<MemoryStats, D>>
1257        fidl::encoding::Encode<StatsGetMemoryStatsResponse, D> for (T0,)
1258    {
1259        #[inline]
1260        unsafe fn encode(
1261            self,
1262            encoder: &mut fidl::encoding::Encoder<'_, D>,
1263            offset: usize,
1264            depth: fidl::encoding::Depth,
1265        ) -> fidl::Result<()> {
1266            encoder.debug_check_bounds::<StatsGetMemoryStatsResponse>(offset);
1267            // Zero out padding regions. There's no need to apply masks
1268            // because the unmasked parts will be overwritten by fields.
1269            // Write the fields.
1270            self.0.encode(encoder, offset + 0, depth)?;
1271            Ok(())
1272        }
1273    }
1274
1275    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1276        for StatsGetMemoryStatsResponse
1277    {
1278        #[inline(always)]
1279        fn new_empty() -> Self {
1280            Self { stats: fidl::new_empty!(MemoryStats, D) }
1281        }
1282
1283        #[inline]
1284        unsafe fn decode(
1285            &mut self,
1286            decoder: &mut fidl::encoding::Decoder<'_, D>,
1287            offset: usize,
1288            _depth: fidl::encoding::Depth,
1289        ) -> fidl::Result<()> {
1290            decoder.debug_check_bounds::<Self>(offset);
1291            // Verify that padding bytes are zero.
1292            fidl::decode!(MemoryStats, D, &mut self.stats, decoder, offset + 0, _depth)?;
1293            Ok(())
1294        }
1295    }
1296
1297    impl MemoryStats {
1298        #[inline(always)]
1299        fn max_ordinal_present(&self) -> u64 {
1300            if let Some(_) = self.vmo_discardable_unlocked_bytes {
1301                return 19;
1302            }
1303            if let Some(_) = self.vmo_discardable_locked_bytes {
1304                return 18;
1305            }
1306            if let Some(_) = self.vmo_reclaim_disabled_bytes {
1307                return 17;
1308            }
1309            if let Some(_) = self.vmo_reclaim_oldest_bytes {
1310                return 16;
1311            }
1312            if let Some(_) = self.vmo_reclaim_newest_bytes {
1313                return 15;
1314            }
1315            if let Some(_) = self.vmo_reclaim_total_bytes {
1316                return 14;
1317            }
1318            if let Some(_) = self.zram_bytes {
1319                return 13;
1320            }
1321            if let Some(_) = self.slab_bytes {
1322                return 12;
1323            }
1324            if let Some(_) = self.cache_bytes {
1325                return 11;
1326            }
1327            if let Some(_) = self.free_loaned_bytes {
1328                return 10;
1329            }
1330            if let Some(_) = self.other_bytes {
1331                return 9;
1332            }
1333            if let Some(_) = self.ipc_bytes {
1334                return 8;
1335            }
1336            if let Some(_) = self.mmu_overhead_bytes {
1337                return 7;
1338            }
1339            if let Some(_) = self.vmo_bytes {
1340                return 6;
1341            }
1342            if let Some(_) = self.free_heap_bytes {
1343                return 5;
1344            }
1345            if let Some(_) = self.total_heap_bytes {
1346                return 4;
1347            }
1348            if let Some(_) = self.wired_bytes {
1349                return 3;
1350            }
1351            if let Some(_) = self.free_bytes {
1352                return 2;
1353            }
1354            if let Some(_) = self.total_bytes {
1355                return 1;
1356            }
1357            0
1358        }
1359    }
1360
1361    impl fidl::encoding::ValueTypeMarker for MemoryStats {
1362        type Borrowed<'a> = &'a Self;
1363        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1364            value
1365        }
1366    }
1367
1368    unsafe impl fidl::encoding::TypeMarker for MemoryStats {
1369        type Owned = Self;
1370
1371        #[inline(always)]
1372        fn inline_align(_context: fidl::encoding::Context) -> usize {
1373            8
1374        }
1375
1376        #[inline(always)]
1377        fn inline_size(_context: fidl::encoding::Context) -> usize {
1378            16
1379        }
1380    }
1381
1382    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MemoryStats, D>
1383        for &MemoryStats
1384    {
1385        unsafe fn encode(
1386            self,
1387            encoder: &mut fidl::encoding::Encoder<'_, D>,
1388            offset: usize,
1389            mut depth: fidl::encoding::Depth,
1390        ) -> fidl::Result<()> {
1391            encoder.debug_check_bounds::<MemoryStats>(offset);
1392            // Vector header
1393            let max_ordinal: u64 = self.max_ordinal_present();
1394            encoder.write_num(max_ordinal, offset);
1395            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1396            // Calling encoder.out_of_line_offset(0) is not allowed.
1397            if max_ordinal == 0 {
1398                return Ok(());
1399            }
1400            depth.increment()?;
1401            let envelope_size = 8;
1402            let bytes_len = max_ordinal as usize * envelope_size;
1403            #[allow(unused_variables)]
1404            let offset = encoder.out_of_line_offset(bytes_len);
1405            let mut _prev_end_offset: usize = 0;
1406            if 1 > max_ordinal {
1407                return Ok(());
1408            }
1409
1410            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1411            // are envelope_size bytes.
1412            let cur_offset: usize = (1 - 1) * envelope_size;
1413
1414            // Zero reserved fields.
1415            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1416
1417            // Safety:
1418            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1419            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1420            //   envelope_size bytes, there is always sufficient room.
1421            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1422                self.total_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1423                encoder,
1424                offset + cur_offset,
1425                depth,
1426            )?;
1427
1428            _prev_end_offset = cur_offset + envelope_size;
1429            if 2 > max_ordinal {
1430                return Ok(());
1431            }
1432
1433            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1434            // are envelope_size bytes.
1435            let cur_offset: usize = (2 - 1) * envelope_size;
1436
1437            // Zero reserved fields.
1438            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1439
1440            // Safety:
1441            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1442            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1443            //   envelope_size bytes, there is always sufficient room.
1444            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1445                self.free_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1446                encoder,
1447                offset + cur_offset,
1448                depth,
1449            )?;
1450
1451            _prev_end_offset = cur_offset + envelope_size;
1452            if 3 > max_ordinal {
1453                return Ok(());
1454            }
1455
1456            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1457            // are envelope_size bytes.
1458            let cur_offset: usize = (3 - 1) * envelope_size;
1459
1460            // Zero reserved fields.
1461            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1462
1463            // Safety:
1464            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1465            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1466            //   envelope_size bytes, there is always sufficient room.
1467            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1468                self.wired_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1469                encoder,
1470                offset + cur_offset,
1471                depth,
1472            )?;
1473
1474            _prev_end_offset = cur_offset + envelope_size;
1475            if 4 > max_ordinal {
1476                return Ok(());
1477            }
1478
1479            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1480            // are envelope_size bytes.
1481            let cur_offset: usize = (4 - 1) * envelope_size;
1482
1483            // Zero reserved fields.
1484            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1485
1486            // Safety:
1487            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1488            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1489            //   envelope_size bytes, there is always sufficient room.
1490            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1491                self.total_heap_bytes
1492                    .as_ref()
1493                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1494                encoder,
1495                offset + cur_offset,
1496                depth,
1497            )?;
1498
1499            _prev_end_offset = cur_offset + envelope_size;
1500            if 5 > max_ordinal {
1501                return Ok(());
1502            }
1503
1504            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1505            // are envelope_size bytes.
1506            let cur_offset: usize = (5 - 1) * envelope_size;
1507
1508            // Zero reserved fields.
1509            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1510
1511            // Safety:
1512            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1513            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1514            //   envelope_size bytes, there is always sufficient room.
1515            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1516                self.free_heap_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1517                encoder,
1518                offset + cur_offset,
1519                depth,
1520            )?;
1521
1522            _prev_end_offset = cur_offset + envelope_size;
1523            if 6 > max_ordinal {
1524                return Ok(());
1525            }
1526
1527            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1528            // are envelope_size bytes.
1529            let cur_offset: usize = (6 - 1) * envelope_size;
1530
1531            // Zero reserved fields.
1532            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1533
1534            // Safety:
1535            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1536            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1537            //   envelope_size bytes, there is always sufficient room.
1538            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1539                self.vmo_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1540                encoder,
1541                offset + cur_offset,
1542                depth,
1543            )?;
1544
1545            _prev_end_offset = cur_offset + envelope_size;
1546            if 7 > max_ordinal {
1547                return Ok(());
1548            }
1549
1550            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1551            // are envelope_size bytes.
1552            let cur_offset: usize = (7 - 1) * envelope_size;
1553
1554            // Zero reserved fields.
1555            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1556
1557            // Safety:
1558            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1559            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1560            //   envelope_size bytes, there is always sufficient room.
1561            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1562                self.mmu_overhead_bytes
1563                    .as_ref()
1564                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1565                encoder,
1566                offset + cur_offset,
1567                depth,
1568            )?;
1569
1570            _prev_end_offset = cur_offset + envelope_size;
1571            if 8 > max_ordinal {
1572                return Ok(());
1573            }
1574
1575            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1576            // are envelope_size bytes.
1577            let cur_offset: usize = (8 - 1) * envelope_size;
1578
1579            // Zero reserved fields.
1580            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1581
1582            // Safety:
1583            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1584            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1585            //   envelope_size bytes, there is always sufficient room.
1586            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1587                self.ipc_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1588                encoder,
1589                offset + cur_offset,
1590                depth,
1591            )?;
1592
1593            _prev_end_offset = cur_offset + envelope_size;
1594            if 9 > max_ordinal {
1595                return Ok(());
1596            }
1597
1598            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1599            // are envelope_size bytes.
1600            let cur_offset: usize = (9 - 1) * envelope_size;
1601
1602            // Zero reserved fields.
1603            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1604
1605            // Safety:
1606            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1607            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1608            //   envelope_size bytes, there is always sufficient room.
1609            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1610                self.other_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1611                encoder,
1612                offset + cur_offset,
1613                depth,
1614            )?;
1615
1616            _prev_end_offset = cur_offset + envelope_size;
1617            if 10 > max_ordinal {
1618                return Ok(());
1619            }
1620
1621            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1622            // are envelope_size bytes.
1623            let cur_offset: usize = (10 - 1) * envelope_size;
1624
1625            // Zero reserved fields.
1626            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1627
1628            // Safety:
1629            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1630            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1631            //   envelope_size bytes, there is always sufficient room.
1632            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1633                self.free_loaned_bytes
1634                    .as_ref()
1635                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1636                encoder,
1637                offset + cur_offset,
1638                depth,
1639            )?;
1640
1641            _prev_end_offset = cur_offset + envelope_size;
1642            if 11 > max_ordinal {
1643                return Ok(());
1644            }
1645
1646            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1647            // are envelope_size bytes.
1648            let cur_offset: usize = (11 - 1) * envelope_size;
1649
1650            // Zero reserved fields.
1651            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1652
1653            // Safety:
1654            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1655            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1656            //   envelope_size bytes, there is always sufficient room.
1657            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1658                self.cache_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1659                encoder,
1660                offset + cur_offset,
1661                depth,
1662            )?;
1663
1664            _prev_end_offset = cur_offset + envelope_size;
1665            if 12 > max_ordinal {
1666                return Ok(());
1667            }
1668
1669            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1670            // are envelope_size bytes.
1671            let cur_offset: usize = (12 - 1) * envelope_size;
1672
1673            // Zero reserved fields.
1674            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1675
1676            // Safety:
1677            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1678            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1679            //   envelope_size bytes, there is always sufficient room.
1680            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1681                self.slab_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1682                encoder,
1683                offset + cur_offset,
1684                depth,
1685            )?;
1686
1687            _prev_end_offset = cur_offset + envelope_size;
1688            if 13 > max_ordinal {
1689                return Ok(());
1690            }
1691
1692            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1693            // are envelope_size bytes.
1694            let cur_offset: usize = (13 - 1) * envelope_size;
1695
1696            // Zero reserved fields.
1697            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1698
1699            // Safety:
1700            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1701            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1702            //   envelope_size bytes, there is always sufficient room.
1703            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1704                self.zram_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1705                encoder,
1706                offset + cur_offset,
1707                depth,
1708            )?;
1709
1710            _prev_end_offset = cur_offset + envelope_size;
1711            if 14 > max_ordinal {
1712                return Ok(());
1713            }
1714
1715            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1716            // are envelope_size bytes.
1717            let cur_offset: usize = (14 - 1) * envelope_size;
1718
1719            // Zero reserved fields.
1720            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1721
1722            // Safety:
1723            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1724            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1725            //   envelope_size bytes, there is always sufficient room.
1726            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1727                self.vmo_reclaim_total_bytes
1728                    .as_ref()
1729                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1730                encoder,
1731                offset + cur_offset,
1732                depth,
1733            )?;
1734
1735            _prev_end_offset = cur_offset + envelope_size;
1736            if 15 > max_ordinal {
1737                return Ok(());
1738            }
1739
1740            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1741            // are envelope_size bytes.
1742            let cur_offset: usize = (15 - 1) * envelope_size;
1743
1744            // Zero reserved fields.
1745            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1746
1747            // Safety:
1748            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1749            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1750            //   envelope_size bytes, there is always sufficient room.
1751            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1752                self.vmo_reclaim_newest_bytes
1753                    .as_ref()
1754                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1755                encoder,
1756                offset + cur_offset,
1757                depth,
1758            )?;
1759
1760            _prev_end_offset = cur_offset + envelope_size;
1761            if 16 > max_ordinal {
1762                return Ok(());
1763            }
1764
1765            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1766            // are envelope_size bytes.
1767            let cur_offset: usize = (16 - 1) * envelope_size;
1768
1769            // Zero reserved fields.
1770            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1771
1772            // Safety:
1773            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1774            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1775            //   envelope_size bytes, there is always sufficient room.
1776            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1777                self.vmo_reclaim_oldest_bytes
1778                    .as_ref()
1779                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1780                encoder,
1781                offset + cur_offset,
1782                depth,
1783            )?;
1784
1785            _prev_end_offset = cur_offset + envelope_size;
1786            if 17 > max_ordinal {
1787                return Ok(());
1788            }
1789
1790            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1791            // are envelope_size bytes.
1792            let cur_offset: usize = (17 - 1) * envelope_size;
1793
1794            // Zero reserved fields.
1795            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1796
1797            // Safety:
1798            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1799            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1800            //   envelope_size bytes, there is always sufficient room.
1801            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1802                self.vmo_reclaim_disabled_bytes
1803                    .as_ref()
1804                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1805                encoder,
1806                offset + cur_offset,
1807                depth,
1808            )?;
1809
1810            _prev_end_offset = cur_offset + envelope_size;
1811            if 18 > max_ordinal {
1812                return Ok(());
1813            }
1814
1815            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1816            // are envelope_size bytes.
1817            let cur_offset: usize = (18 - 1) * envelope_size;
1818
1819            // Zero reserved fields.
1820            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1821
1822            // Safety:
1823            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1824            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1825            //   envelope_size bytes, there is always sufficient room.
1826            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1827                self.vmo_discardable_locked_bytes
1828                    .as_ref()
1829                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1830                encoder,
1831                offset + cur_offset,
1832                depth,
1833            )?;
1834
1835            _prev_end_offset = cur_offset + envelope_size;
1836            if 19 > max_ordinal {
1837                return Ok(());
1838            }
1839
1840            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1841            // are envelope_size bytes.
1842            let cur_offset: usize = (19 - 1) * envelope_size;
1843
1844            // Zero reserved fields.
1845            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1846
1847            // Safety:
1848            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1849            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1850            //   envelope_size bytes, there is always sufficient room.
1851            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1852                self.vmo_discardable_unlocked_bytes
1853                    .as_ref()
1854                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1855                encoder,
1856                offset + cur_offset,
1857                depth,
1858            )?;
1859
1860            _prev_end_offset = cur_offset + envelope_size;
1861
1862            Ok(())
1863        }
1864    }
1865
1866    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MemoryStats {
1867        #[inline(always)]
1868        fn new_empty() -> Self {
1869            Self::default()
1870        }
1871
1872        unsafe fn decode(
1873            &mut self,
1874            decoder: &mut fidl::encoding::Decoder<'_, D>,
1875            offset: usize,
1876            mut depth: fidl::encoding::Depth,
1877        ) -> fidl::Result<()> {
1878            decoder.debug_check_bounds::<Self>(offset);
1879            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1880                None => return Err(fidl::Error::NotNullable),
1881                Some(len) => len,
1882            };
1883            // Calling decoder.out_of_line_offset(0) is not allowed.
1884            if len == 0 {
1885                return Ok(());
1886            };
1887            depth.increment()?;
1888            let envelope_size = 8;
1889            let bytes_len = len * envelope_size;
1890            let offset = decoder.out_of_line_offset(bytes_len)?;
1891            // Decode the envelope for each type.
1892            let mut _next_ordinal_to_read = 0;
1893            let mut next_offset = offset;
1894            let end_offset = offset + bytes_len;
1895            _next_ordinal_to_read += 1;
1896            if next_offset >= end_offset {
1897                return Ok(());
1898            }
1899
1900            // Decode unknown envelopes for gaps in ordinals.
1901            while _next_ordinal_to_read < 1 {
1902                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1903                _next_ordinal_to_read += 1;
1904                next_offset += envelope_size;
1905            }
1906
1907            let next_out_of_line = decoder.next_out_of_line();
1908            let handles_before = decoder.remaining_handles();
1909            if let Some((inlined, num_bytes, num_handles)) =
1910                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1911            {
1912                let member_inline_size =
1913                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1914                if inlined != (member_inline_size <= 4) {
1915                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1916                }
1917                let inner_offset;
1918                let mut inner_depth = depth.clone();
1919                if inlined {
1920                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1921                    inner_offset = next_offset;
1922                } else {
1923                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1924                    inner_depth.increment()?;
1925                }
1926                let val_ref = self.total_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
1927                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1928                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1929                {
1930                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1931                }
1932                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1933                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1934                }
1935            }
1936
1937            next_offset += envelope_size;
1938            _next_ordinal_to_read += 1;
1939            if next_offset >= end_offset {
1940                return Ok(());
1941            }
1942
1943            // Decode unknown envelopes for gaps in ordinals.
1944            while _next_ordinal_to_read < 2 {
1945                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1946                _next_ordinal_to_read += 1;
1947                next_offset += envelope_size;
1948            }
1949
1950            let next_out_of_line = decoder.next_out_of_line();
1951            let handles_before = decoder.remaining_handles();
1952            if let Some((inlined, num_bytes, num_handles)) =
1953                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1954            {
1955                let member_inline_size =
1956                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1957                if inlined != (member_inline_size <= 4) {
1958                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1959                }
1960                let inner_offset;
1961                let mut inner_depth = depth.clone();
1962                if inlined {
1963                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1964                    inner_offset = next_offset;
1965                } else {
1966                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1967                    inner_depth.increment()?;
1968                }
1969                let val_ref = self.free_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
1970                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1971                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1972                {
1973                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1974                }
1975                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1976                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1977                }
1978            }
1979
1980            next_offset += envelope_size;
1981            _next_ordinal_to_read += 1;
1982            if next_offset >= end_offset {
1983                return Ok(());
1984            }
1985
1986            // Decode unknown envelopes for gaps in ordinals.
1987            while _next_ordinal_to_read < 3 {
1988                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1989                _next_ordinal_to_read += 1;
1990                next_offset += envelope_size;
1991            }
1992
1993            let next_out_of_line = decoder.next_out_of_line();
1994            let handles_before = decoder.remaining_handles();
1995            if let Some((inlined, num_bytes, num_handles)) =
1996                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1997            {
1998                let member_inline_size =
1999                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2000                if inlined != (member_inline_size <= 4) {
2001                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2002                }
2003                let inner_offset;
2004                let mut inner_depth = depth.clone();
2005                if inlined {
2006                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2007                    inner_offset = next_offset;
2008                } else {
2009                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2010                    inner_depth.increment()?;
2011                }
2012                let val_ref = self.wired_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2013                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2014                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2015                {
2016                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2017                }
2018                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2019                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2020                }
2021            }
2022
2023            next_offset += envelope_size;
2024            _next_ordinal_to_read += 1;
2025            if next_offset >= end_offset {
2026                return Ok(());
2027            }
2028
2029            // Decode unknown envelopes for gaps in ordinals.
2030            while _next_ordinal_to_read < 4 {
2031                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2032                _next_ordinal_to_read += 1;
2033                next_offset += envelope_size;
2034            }
2035
2036            let next_out_of_line = decoder.next_out_of_line();
2037            let handles_before = decoder.remaining_handles();
2038            if let Some((inlined, num_bytes, num_handles)) =
2039                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2040            {
2041                let member_inline_size =
2042                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2043                if inlined != (member_inline_size <= 4) {
2044                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2045                }
2046                let inner_offset;
2047                let mut inner_depth = depth.clone();
2048                if inlined {
2049                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2050                    inner_offset = next_offset;
2051                } else {
2052                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2053                    inner_depth.increment()?;
2054                }
2055                let val_ref = self.total_heap_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2056                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2057                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2058                {
2059                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2060                }
2061                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2062                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2063                }
2064            }
2065
2066            next_offset += envelope_size;
2067            _next_ordinal_to_read += 1;
2068            if next_offset >= end_offset {
2069                return Ok(());
2070            }
2071
2072            // Decode unknown envelopes for gaps in ordinals.
2073            while _next_ordinal_to_read < 5 {
2074                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2075                _next_ordinal_to_read += 1;
2076                next_offset += envelope_size;
2077            }
2078
2079            let next_out_of_line = decoder.next_out_of_line();
2080            let handles_before = decoder.remaining_handles();
2081            if let Some((inlined, num_bytes, num_handles)) =
2082                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2083            {
2084                let member_inline_size =
2085                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2086                if inlined != (member_inline_size <= 4) {
2087                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2088                }
2089                let inner_offset;
2090                let mut inner_depth = depth.clone();
2091                if inlined {
2092                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2093                    inner_offset = next_offset;
2094                } else {
2095                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2096                    inner_depth.increment()?;
2097                }
2098                let val_ref = self.free_heap_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2099                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2100                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2101                {
2102                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2103                }
2104                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2105                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2106                }
2107            }
2108
2109            next_offset += envelope_size;
2110            _next_ordinal_to_read += 1;
2111            if next_offset >= end_offset {
2112                return Ok(());
2113            }
2114
2115            // Decode unknown envelopes for gaps in ordinals.
2116            while _next_ordinal_to_read < 6 {
2117                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2118                _next_ordinal_to_read += 1;
2119                next_offset += envelope_size;
2120            }
2121
2122            let next_out_of_line = decoder.next_out_of_line();
2123            let handles_before = decoder.remaining_handles();
2124            if let Some((inlined, num_bytes, num_handles)) =
2125                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2126            {
2127                let member_inline_size =
2128                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2129                if inlined != (member_inline_size <= 4) {
2130                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2131                }
2132                let inner_offset;
2133                let mut inner_depth = depth.clone();
2134                if inlined {
2135                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2136                    inner_offset = next_offset;
2137                } else {
2138                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2139                    inner_depth.increment()?;
2140                }
2141                let val_ref = self.vmo_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2142                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2143                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2144                {
2145                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2146                }
2147                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2148                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2149                }
2150            }
2151
2152            next_offset += envelope_size;
2153            _next_ordinal_to_read += 1;
2154            if next_offset >= end_offset {
2155                return Ok(());
2156            }
2157
2158            // Decode unknown envelopes for gaps in ordinals.
2159            while _next_ordinal_to_read < 7 {
2160                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2161                _next_ordinal_to_read += 1;
2162                next_offset += envelope_size;
2163            }
2164
2165            let next_out_of_line = decoder.next_out_of_line();
2166            let handles_before = decoder.remaining_handles();
2167            if let Some((inlined, num_bytes, num_handles)) =
2168                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2169            {
2170                let member_inline_size =
2171                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2172                if inlined != (member_inline_size <= 4) {
2173                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2174                }
2175                let inner_offset;
2176                let mut inner_depth = depth.clone();
2177                if inlined {
2178                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2179                    inner_offset = next_offset;
2180                } else {
2181                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2182                    inner_depth.increment()?;
2183                }
2184                let val_ref =
2185                    self.mmu_overhead_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2186                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2187                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2188                {
2189                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2190                }
2191                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2192                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2193                }
2194            }
2195
2196            next_offset += envelope_size;
2197            _next_ordinal_to_read += 1;
2198            if next_offset >= end_offset {
2199                return Ok(());
2200            }
2201
2202            // Decode unknown envelopes for gaps in ordinals.
2203            while _next_ordinal_to_read < 8 {
2204                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2205                _next_ordinal_to_read += 1;
2206                next_offset += envelope_size;
2207            }
2208
2209            let next_out_of_line = decoder.next_out_of_line();
2210            let handles_before = decoder.remaining_handles();
2211            if let Some((inlined, num_bytes, num_handles)) =
2212                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2213            {
2214                let member_inline_size =
2215                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2216                if inlined != (member_inline_size <= 4) {
2217                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2218                }
2219                let inner_offset;
2220                let mut inner_depth = depth.clone();
2221                if inlined {
2222                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2223                    inner_offset = next_offset;
2224                } else {
2225                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2226                    inner_depth.increment()?;
2227                }
2228                let val_ref = self.ipc_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2229                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2230                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2231                {
2232                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2233                }
2234                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2235                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2236                }
2237            }
2238
2239            next_offset += envelope_size;
2240            _next_ordinal_to_read += 1;
2241            if next_offset >= end_offset {
2242                return Ok(());
2243            }
2244
2245            // Decode unknown envelopes for gaps in ordinals.
2246            while _next_ordinal_to_read < 9 {
2247                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2248                _next_ordinal_to_read += 1;
2249                next_offset += envelope_size;
2250            }
2251
2252            let next_out_of_line = decoder.next_out_of_line();
2253            let handles_before = decoder.remaining_handles();
2254            if let Some((inlined, num_bytes, num_handles)) =
2255                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2256            {
2257                let member_inline_size =
2258                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2259                if inlined != (member_inline_size <= 4) {
2260                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2261                }
2262                let inner_offset;
2263                let mut inner_depth = depth.clone();
2264                if inlined {
2265                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2266                    inner_offset = next_offset;
2267                } else {
2268                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2269                    inner_depth.increment()?;
2270                }
2271                let val_ref = self.other_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2272                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2273                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2274                {
2275                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2276                }
2277                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2278                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2279                }
2280            }
2281
2282            next_offset += envelope_size;
2283            _next_ordinal_to_read += 1;
2284            if next_offset >= end_offset {
2285                return Ok(());
2286            }
2287
2288            // Decode unknown envelopes for gaps in ordinals.
2289            while _next_ordinal_to_read < 10 {
2290                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2291                _next_ordinal_to_read += 1;
2292                next_offset += envelope_size;
2293            }
2294
2295            let next_out_of_line = decoder.next_out_of_line();
2296            let handles_before = decoder.remaining_handles();
2297            if let Some((inlined, num_bytes, num_handles)) =
2298                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2299            {
2300                let member_inline_size =
2301                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2302                if inlined != (member_inline_size <= 4) {
2303                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2304                }
2305                let inner_offset;
2306                let mut inner_depth = depth.clone();
2307                if inlined {
2308                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2309                    inner_offset = next_offset;
2310                } else {
2311                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2312                    inner_depth.increment()?;
2313                }
2314                let val_ref =
2315                    self.free_loaned_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2316                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2317                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2318                {
2319                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2320                }
2321                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2322                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2323                }
2324            }
2325
2326            next_offset += envelope_size;
2327            _next_ordinal_to_read += 1;
2328            if next_offset >= end_offset {
2329                return Ok(());
2330            }
2331
2332            // Decode unknown envelopes for gaps in ordinals.
2333            while _next_ordinal_to_read < 11 {
2334                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2335                _next_ordinal_to_read += 1;
2336                next_offset += envelope_size;
2337            }
2338
2339            let next_out_of_line = decoder.next_out_of_line();
2340            let handles_before = decoder.remaining_handles();
2341            if let Some((inlined, num_bytes, num_handles)) =
2342                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2343            {
2344                let member_inline_size =
2345                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2346                if inlined != (member_inline_size <= 4) {
2347                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2348                }
2349                let inner_offset;
2350                let mut inner_depth = depth.clone();
2351                if inlined {
2352                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2353                    inner_offset = next_offset;
2354                } else {
2355                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2356                    inner_depth.increment()?;
2357                }
2358                let val_ref = self.cache_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2359                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2360                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2361                {
2362                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2363                }
2364                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2365                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2366                }
2367            }
2368
2369            next_offset += envelope_size;
2370            _next_ordinal_to_read += 1;
2371            if next_offset >= end_offset {
2372                return Ok(());
2373            }
2374
2375            // Decode unknown envelopes for gaps in ordinals.
2376            while _next_ordinal_to_read < 12 {
2377                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2378                _next_ordinal_to_read += 1;
2379                next_offset += envelope_size;
2380            }
2381
2382            let next_out_of_line = decoder.next_out_of_line();
2383            let handles_before = decoder.remaining_handles();
2384            if let Some((inlined, num_bytes, num_handles)) =
2385                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2386            {
2387                let member_inline_size =
2388                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2389                if inlined != (member_inline_size <= 4) {
2390                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2391                }
2392                let inner_offset;
2393                let mut inner_depth = depth.clone();
2394                if inlined {
2395                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2396                    inner_offset = next_offset;
2397                } else {
2398                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2399                    inner_depth.increment()?;
2400                }
2401                let val_ref = self.slab_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2402                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2403                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2404                {
2405                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2406                }
2407                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2408                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2409                }
2410            }
2411
2412            next_offset += envelope_size;
2413            _next_ordinal_to_read += 1;
2414            if next_offset >= end_offset {
2415                return Ok(());
2416            }
2417
2418            // Decode unknown envelopes for gaps in ordinals.
2419            while _next_ordinal_to_read < 13 {
2420                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2421                _next_ordinal_to_read += 1;
2422                next_offset += envelope_size;
2423            }
2424
2425            let next_out_of_line = decoder.next_out_of_line();
2426            let handles_before = decoder.remaining_handles();
2427            if let Some((inlined, num_bytes, num_handles)) =
2428                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2429            {
2430                let member_inline_size =
2431                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2432                if inlined != (member_inline_size <= 4) {
2433                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2434                }
2435                let inner_offset;
2436                let mut inner_depth = depth.clone();
2437                if inlined {
2438                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2439                    inner_offset = next_offset;
2440                } else {
2441                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2442                    inner_depth.increment()?;
2443                }
2444                let val_ref = self.zram_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2445                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2446                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2447                {
2448                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2449                }
2450                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2451                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2452                }
2453            }
2454
2455            next_offset += envelope_size;
2456            _next_ordinal_to_read += 1;
2457            if next_offset >= end_offset {
2458                return Ok(());
2459            }
2460
2461            // Decode unknown envelopes for gaps in ordinals.
2462            while _next_ordinal_to_read < 14 {
2463                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2464                _next_ordinal_to_read += 1;
2465                next_offset += envelope_size;
2466            }
2467
2468            let next_out_of_line = decoder.next_out_of_line();
2469            let handles_before = decoder.remaining_handles();
2470            if let Some((inlined, num_bytes, num_handles)) =
2471                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2472            {
2473                let member_inline_size =
2474                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2475                if inlined != (member_inline_size <= 4) {
2476                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2477                }
2478                let inner_offset;
2479                let mut inner_depth = depth.clone();
2480                if inlined {
2481                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2482                    inner_offset = next_offset;
2483                } else {
2484                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2485                    inner_depth.increment()?;
2486                }
2487                let val_ref =
2488                    self.vmo_reclaim_total_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2489                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2490                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2491                {
2492                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2493                }
2494                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2495                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2496                }
2497            }
2498
2499            next_offset += envelope_size;
2500            _next_ordinal_to_read += 1;
2501            if next_offset >= end_offset {
2502                return Ok(());
2503            }
2504
2505            // Decode unknown envelopes for gaps in ordinals.
2506            while _next_ordinal_to_read < 15 {
2507                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2508                _next_ordinal_to_read += 1;
2509                next_offset += envelope_size;
2510            }
2511
2512            let next_out_of_line = decoder.next_out_of_line();
2513            let handles_before = decoder.remaining_handles();
2514            if let Some((inlined, num_bytes, num_handles)) =
2515                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2516            {
2517                let member_inline_size =
2518                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2519                if inlined != (member_inline_size <= 4) {
2520                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2521                }
2522                let inner_offset;
2523                let mut inner_depth = depth.clone();
2524                if inlined {
2525                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2526                    inner_offset = next_offset;
2527                } else {
2528                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2529                    inner_depth.increment()?;
2530                }
2531                let val_ref =
2532                    self.vmo_reclaim_newest_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2533                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2534                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2535                {
2536                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2537                }
2538                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2539                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2540                }
2541            }
2542
2543            next_offset += envelope_size;
2544            _next_ordinal_to_read += 1;
2545            if next_offset >= end_offset {
2546                return Ok(());
2547            }
2548
2549            // Decode unknown envelopes for gaps in ordinals.
2550            while _next_ordinal_to_read < 16 {
2551                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2552                _next_ordinal_to_read += 1;
2553                next_offset += envelope_size;
2554            }
2555
2556            let next_out_of_line = decoder.next_out_of_line();
2557            let handles_before = decoder.remaining_handles();
2558            if let Some((inlined, num_bytes, num_handles)) =
2559                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2560            {
2561                let member_inline_size =
2562                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2563                if inlined != (member_inline_size <= 4) {
2564                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2565                }
2566                let inner_offset;
2567                let mut inner_depth = depth.clone();
2568                if inlined {
2569                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2570                    inner_offset = next_offset;
2571                } else {
2572                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2573                    inner_depth.increment()?;
2574                }
2575                let val_ref =
2576                    self.vmo_reclaim_oldest_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2577                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2578                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2579                {
2580                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2581                }
2582                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2583                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2584                }
2585            }
2586
2587            next_offset += envelope_size;
2588            _next_ordinal_to_read += 1;
2589            if next_offset >= end_offset {
2590                return Ok(());
2591            }
2592
2593            // Decode unknown envelopes for gaps in ordinals.
2594            while _next_ordinal_to_read < 17 {
2595                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2596                _next_ordinal_to_read += 1;
2597                next_offset += envelope_size;
2598            }
2599
2600            let next_out_of_line = decoder.next_out_of_line();
2601            let handles_before = decoder.remaining_handles();
2602            if let Some((inlined, num_bytes, num_handles)) =
2603                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2604            {
2605                let member_inline_size =
2606                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2607                if inlined != (member_inline_size <= 4) {
2608                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2609                }
2610                let inner_offset;
2611                let mut inner_depth = depth.clone();
2612                if inlined {
2613                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2614                    inner_offset = next_offset;
2615                } else {
2616                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2617                    inner_depth.increment()?;
2618                }
2619                let val_ref =
2620                    self.vmo_reclaim_disabled_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2621                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2622                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2623                {
2624                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2625                }
2626                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2627                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2628                }
2629            }
2630
2631            next_offset += envelope_size;
2632            _next_ordinal_to_read += 1;
2633            if next_offset >= end_offset {
2634                return Ok(());
2635            }
2636
2637            // Decode unknown envelopes for gaps in ordinals.
2638            while _next_ordinal_to_read < 18 {
2639                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2640                _next_ordinal_to_read += 1;
2641                next_offset += envelope_size;
2642            }
2643
2644            let next_out_of_line = decoder.next_out_of_line();
2645            let handles_before = decoder.remaining_handles();
2646            if let Some((inlined, num_bytes, num_handles)) =
2647                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2648            {
2649                let member_inline_size =
2650                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2651                if inlined != (member_inline_size <= 4) {
2652                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2653                }
2654                let inner_offset;
2655                let mut inner_depth = depth.clone();
2656                if inlined {
2657                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2658                    inner_offset = next_offset;
2659                } else {
2660                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2661                    inner_depth.increment()?;
2662                }
2663                let val_ref = self
2664                    .vmo_discardable_locked_bytes
2665                    .get_or_insert_with(|| fidl::new_empty!(u64, D));
2666                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2667                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2668                {
2669                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2670                }
2671                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2672                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2673                }
2674            }
2675
2676            next_offset += envelope_size;
2677            _next_ordinal_to_read += 1;
2678            if next_offset >= end_offset {
2679                return Ok(());
2680            }
2681
2682            // Decode unknown envelopes for gaps in ordinals.
2683            while _next_ordinal_to_read < 19 {
2684                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2685                _next_ordinal_to_read += 1;
2686                next_offset += envelope_size;
2687            }
2688
2689            let next_out_of_line = decoder.next_out_of_line();
2690            let handles_before = decoder.remaining_handles();
2691            if let Some((inlined, num_bytes, num_handles)) =
2692                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2693            {
2694                let member_inline_size =
2695                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2696                if inlined != (member_inline_size <= 4) {
2697                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2698                }
2699                let inner_offset;
2700                let mut inner_depth = depth.clone();
2701                if inlined {
2702                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2703                    inner_offset = next_offset;
2704                } else {
2705                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2706                    inner_depth.increment()?;
2707                }
2708                let val_ref = self
2709                    .vmo_discardable_unlocked_bytes
2710                    .get_or_insert_with(|| fidl::new_empty!(u64, D));
2711                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2712                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2713                {
2714                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2715                }
2716                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2717                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2718                }
2719            }
2720
2721            next_offset += envelope_size;
2722
2723            // Decode the remaining unknown envelopes.
2724            while next_offset < end_offset {
2725                _next_ordinal_to_read += 1;
2726                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2727                next_offset += envelope_size;
2728            }
2729
2730            Ok(())
2731        }
2732    }
2733
2734    impl MemoryStatsCompression {
2735        #[inline(always)]
2736        fn max_ordinal_present(&self) -> u64 {
2737            if let Some(_) = self.pages_decompressed_within_log_time {
2738                return 14;
2739            }
2740            if let Some(_) = self.pages_decompressed_unit_ns {
2741                return 13;
2742            }
2743            if let Some(_) = self.critical_memory_page_compressions {
2744                return 12;
2745            }
2746            if let Some(_) = self.memory_pressure_page_compressions {
2747                return 11;
2748            }
2749            if let Some(_) = self.eager_page_compressions {
2750                return 10;
2751            }
2752            if let Some(_) = self.compressed_page_evictions {
2753                return 9;
2754            }
2755            if let Some(_) = self.total_page_decompressions {
2756                return 8;
2757            }
2758            if let Some(_) = self.failed_page_compression_attempts {
2759                return 7;
2760            }
2761            if let Some(_) = self.total_page_compression_attempts {
2762                return 6;
2763            }
2764            if let Some(_) = self.decompression_time {
2765                return 5;
2766            }
2767            if let Some(_) = self.compression_time {
2768                return 4;
2769            }
2770            if let Some(_) = self.compressed_fragmentation_bytes {
2771                return 3;
2772            }
2773            if let Some(_) = self.compressed_storage_bytes {
2774                return 2;
2775            }
2776            if let Some(_) = self.uncompressed_storage_bytes {
2777                return 1;
2778            }
2779            0
2780        }
2781    }
2782
2783    impl fidl::encoding::ValueTypeMarker for MemoryStatsCompression {
2784        type Borrowed<'a> = &'a Self;
2785        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2786            value
2787        }
2788    }
2789
2790    unsafe impl fidl::encoding::TypeMarker for MemoryStatsCompression {
2791        type Owned = Self;
2792
2793        #[inline(always)]
2794        fn inline_align(_context: fidl::encoding::Context) -> usize {
2795            8
2796        }
2797
2798        #[inline(always)]
2799        fn inline_size(_context: fidl::encoding::Context) -> usize {
2800            16
2801        }
2802    }
2803
2804    unsafe impl<D: fidl::encoding::ResourceDialect>
2805        fidl::encoding::Encode<MemoryStatsCompression, D> for &MemoryStatsCompression
2806    {
2807        unsafe fn encode(
2808            self,
2809            encoder: &mut fidl::encoding::Encoder<'_, D>,
2810            offset: usize,
2811            mut depth: fidl::encoding::Depth,
2812        ) -> fidl::Result<()> {
2813            encoder.debug_check_bounds::<MemoryStatsCompression>(offset);
2814            // Vector header
2815            let max_ordinal: u64 = self.max_ordinal_present();
2816            encoder.write_num(max_ordinal, offset);
2817            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2818            // Calling encoder.out_of_line_offset(0) is not allowed.
2819            if max_ordinal == 0 {
2820                return Ok(());
2821            }
2822            depth.increment()?;
2823            let envelope_size = 8;
2824            let bytes_len = max_ordinal as usize * envelope_size;
2825            #[allow(unused_variables)]
2826            let offset = encoder.out_of_line_offset(bytes_len);
2827            let mut _prev_end_offset: usize = 0;
2828            if 1 > max_ordinal {
2829                return Ok(());
2830            }
2831
2832            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2833            // are envelope_size bytes.
2834            let cur_offset: usize = (1 - 1) * envelope_size;
2835
2836            // Zero reserved fields.
2837            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2838
2839            // Safety:
2840            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2841            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2842            //   envelope_size bytes, there is always sufficient room.
2843            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2844                self.uncompressed_storage_bytes
2845                    .as_ref()
2846                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2847                encoder,
2848                offset + cur_offset,
2849                depth,
2850            )?;
2851
2852            _prev_end_offset = cur_offset + envelope_size;
2853            if 2 > max_ordinal {
2854                return Ok(());
2855            }
2856
2857            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2858            // are envelope_size bytes.
2859            let cur_offset: usize = (2 - 1) * envelope_size;
2860
2861            // Zero reserved fields.
2862            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2863
2864            // Safety:
2865            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2866            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2867            //   envelope_size bytes, there is always sufficient room.
2868            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2869                self.compressed_storage_bytes
2870                    .as_ref()
2871                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2872                encoder,
2873                offset + cur_offset,
2874                depth,
2875            )?;
2876
2877            _prev_end_offset = cur_offset + envelope_size;
2878            if 3 > max_ordinal {
2879                return Ok(());
2880            }
2881
2882            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2883            // are envelope_size bytes.
2884            let cur_offset: usize = (3 - 1) * envelope_size;
2885
2886            // Zero reserved fields.
2887            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2888
2889            // Safety:
2890            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2891            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2892            //   envelope_size bytes, there is always sufficient room.
2893            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2894                self.compressed_fragmentation_bytes
2895                    .as_ref()
2896                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2897                encoder,
2898                offset + cur_offset,
2899                depth,
2900            )?;
2901
2902            _prev_end_offset = cur_offset + envelope_size;
2903            if 4 > max_ordinal {
2904                return Ok(());
2905            }
2906
2907            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2908            // are envelope_size bytes.
2909            let cur_offset: usize = (4 - 1) * envelope_size;
2910
2911            // Zero reserved fields.
2912            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2913
2914            // Safety:
2915            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2916            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2917            //   envelope_size bytes, there is always sufficient room.
2918            fidl::encoding::encode_in_envelope_optional::<i64, D>(
2919                self.compression_time
2920                    .as_ref()
2921                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2922                encoder,
2923                offset + cur_offset,
2924                depth,
2925            )?;
2926
2927            _prev_end_offset = cur_offset + envelope_size;
2928            if 5 > max_ordinal {
2929                return Ok(());
2930            }
2931
2932            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2933            // are envelope_size bytes.
2934            let cur_offset: usize = (5 - 1) * envelope_size;
2935
2936            // Zero reserved fields.
2937            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2938
2939            // Safety:
2940            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2941            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2942            //   envelope_size bytes, there is always sufficient room.
2943            fidl::encoding::encode_in_envelope_optional::<i64, D>(
2944                self.decompression_time
2945                    .as_ref()
2946                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2947                encoder,
2948                offset + cur_offset,
2949                depth,
2950            )?;
2951
2952            _prev_end_offset = cur_offset + envelope_size;
2953            if 6 > max_ordinal {
2954                return Ok(());
2955            }
2956
2957            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2958            // are envelope_size bytes.
2959            let cur_offset: usize = (6 - 1) * envelope_size;
2960
2961            // Zero reserved fields.
2962            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2963
2964            // Safety:
2965            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2966            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2967            //   envelope_size bytes, there is always sufficient room.
2968            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2969                self.total_page_compression_attempts
2970                    .as_ref()
2971                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2972                encoder,
2973                offset + cur_offset,
2974                depth,
2975            )?;
2976
2977            _prev_end_offset = cur_offset + envelope_size;
2978            if 7 > max_ordinal {
2979                return Ok(());
2980            }
2981
2982            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2983            // are envelope_size bytes.
2984            let cur_offset: usize = (7 - 1) * envelope_size;
2985
2986            // Zero reserved fields.
2987            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2988
2989            // Safety:
2990            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2991            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2992            //   envelope_size bytes, there is always sufficient room.
2993            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2994                self.failed_page_compression_attempts
2995                    .as_ref()
2996                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2997                encoder,
2998                offset + cur_offset,
2999                depth,
3000            )?;
3001
3002            _prev_end_offset = cur_offset + envelope_size;
3003            if 8 > max_ordinal {
3004                return Ok(());
3005            }
3006
3007            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3008            // are envelope_size bytes.
3009            let cur_offset: usize = (8 - 1) * envelope_size;
3010
3011            // Zero reserved fields.
3012            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3013
3014            // Safety:
3015            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3016            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3017            //   envelope_size bytes, there is always sufficient room.
3018            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3019                self.total_page_decompressions
3020                    .as_ref()
3021                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3022                encoder,
3023                offset + cur_offset,
3024                depth,
3025            )?;
3026
3027            _prev_end_offset = cur_offset + envelope_size;
3028            if 9 > max_ordinal {
3029                return Ok(());
3030            }
3031
3032            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3033            // are envelope_size bytes.
3034            let cur_offset: usize = (9 - 1) * envelope_size;
3035
3036            // Zero reserved fields.
3037            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3038
3039            // Safety:
3040            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3041            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3042            //   envelope_size bytes, there is always sufficient room.
3043            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3044                self.compressed_page_evictions
3045                    .as_ref()
3046                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3047                encoder,
3048                offset + cur_offset,
3049                depth,
3050            )?;
3051
3052            _prev_end_offset = cur_offset + envelope_size;
3053            if 10 > max_ordinal {
3054                return Ok(());
3055            }
3056
3057            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3058            // are envelope_size bytes.
3059            let cur_offset: usize = (10 - 1) * envelope_size;
3060
3061            // Zero reserved fields.
3062            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3063
3064            // Safety:
3065            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3066            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3067            //   envelope_size bytes, there is always sufficient room.
3068            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3069                self.eager_page_compressions
3070                    .as_ref()
3071                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3072                encoder,
3073                offset + cur_offset,
3074                depth,
3075            )?;
3076
3077            _prev_end_offset = cur_offset + envelope_size;
3078            if 11 > max_ordinal {
3079                return Ok(());
3080            }
3081
3082            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3083            // are envelope_size bytes.
3084            let cur_offset: usize = (11 - 1) * envelope_size;
3085
3086            // Zero reserved fields.
3087            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3088
3089            // Safety:
3090            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3091            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3092            //   envelope_size bytes, there is always sufficient room.
3093            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3094                self.memory_pressure_page_compressions
3095                    .as_ref()
3096                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3097                encoder,
3098                offset + cur_offset,
3099                depth,
3100            )?;
3101
3102            _prev_end_offset = cur_offset + envelope_size;
3103            if 12 > max_ordinal {
3104                return Ok(());
3105            }
3106
3107            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3108            // are envelope_size bytes.
3109            let cur_offset: usize = (12 - 1) * envelope_size;
3110
3111            // Zero reserved fields.
3112            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3113
3114            // Safety:
3115            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3116            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3117            //   envelope_size bytes, there is always sufficient room.
3118            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3119                self.critical_memory_page_compressions
3120                    .as_ref()
3121                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3122                encoder,
3123                offset + cur_offset,
3124                depth,
3125            )?;
3126
3127            _prev_end_offset = cur_offset + envelope_size;
3128            if 13 > max_ordinal {
3129                return Ok(());
3130            }
3131
3132            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3133            // are envelope_size bytes.
3134            let cur_offset: usize = (13 - 1) * envelope_size;
3135
3136            // Zero reserved fields.
3137            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3138
3139            // Safety:
3140            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3141            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3142            //   envelope_size bytes, there is always sufficient room.
3143            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3144                self.pages_decompressed_unit_ns
3145                    .as_ref()
3146                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3147                encoder,
3148                offset + cur_offset,
3149                depth,
3150            )?;
3151
3152            _prev_end_offset = cur_offset + envelope_size;
3153            if 14 > max_ordinal {
3154                return Ok(());
3155            }
3156
3157            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3158            // are envelope_size bytes.
3159            let cur_offset: usize = (14 - 1) * envelope_size;
3160
3161            // Zero reserved fields.
3162            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3163
3164            // Safety:
3165            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3166            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3167            //   envelope_size bytes, there is always sufficient room.
3168            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u64, 8>, D>(
3169                self.pages_decompressed_within_log_time.as_ref().map(
3170                    <fidl::encoding::Array<u64, 8> as fidl::encoding::ValueTypeMarker>::borrow,
3171                ),
3172                encoder,
3173                offset + cur_offset,
3174                depth,
3175            )?;
3176
3177            _prev_end_offset = cur_offset + envelope_size;
3178
3179            Ok(())
3180        }
3181    }
3182
3183    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3184        for MemoryStatsCompression
3185    {
3186        #[inline(always)]
3187        fn new_empty() -> Self {
3188            Self::default()
3189        }
3190
3191        unsafe fn decode(
3192            &mut self,
3193            decoder: &mut fidl::encoding::Decoder<'_, D>,
3194            offset: usize,
3195            mut depth: fidl::encoding::Depth,
3196        ) -> fidl::Result<()> {
3197            decoder.debug_check_bounds::<Self>(offset);
3198            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3199                None => return Err(fidl::Error::NotNullable),
3200                Some(len) => len,
3201            };
3202            // Calling decoder.out_of_line_offset(0) is not allowed.
3203            if len == 0 {
3204                return Ok(());
3205            };
3206            depth.increment()?;
3207            let envelope_size = 8;
3208            let bytes_len = len * envelope_size;
3209            let offset = decoder.out_of_line_offset(bytes_len)?;
3210            // Decode the envelope for each type.
3211            let mut _next_ordinal_to_read = 0;
3212            let mut next_offset = offset;
3213            let end_offset = offset + bytes_len;
3214            _next_ordinal_to_read += 1;
3215            if next_offset >= end_offset {
3216                return Ok(());
3217            }
3218
3219            // Decode unknown envelopes for gaps in ordinals.
3220            while _next_ordinal_to_read < 1 {
3221                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3222                _next_ordinal_to_read += 1;
3223                next_offset += envelope_size;
3224            }
3225
3226            let next_out_of_line = decoder.next_out_of_line();
3227            let handles_before = decoder.remaining_handles();
3228            if let Some((inlined, num_bytes, num_handles)) =
3229                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3230            {
3231                let member_inline_size =
3232                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3233                if inlined != (member_inline_size <= 4) {
3234                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3235                }
3236                let inner_offset;
3237                let mut inner_depth = depth.clone();
3238                if inlined {
3239                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3240                    inner_offset = next_offset;
3241                } else {
3242                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3243                    inner_depth.increment()?;
3244                }
3245                let val_ref =
3246                    self.uncompressed_storage_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
3247                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3248                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3249                {
3250                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3251                }
3252                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3253                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3254                }
3255            }
3256
3257            next_offset += envelope_size;
3258            _next_ordinal_to_read += 1;
3259            if next_offset >= end_offset {
3260                return Ok(());
3261            }
3262
3263            // Decode unknown envelopes for gaps in ordinals.
3264            while _next_ordinal_to_read < 2 {
3265                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3266                _next_ordinal_to_read += 1;
3267                next_offset += envelope_size;
3268            }
3269
3270            let next_out_of_line = decoder.next_out_of_line();
3271            let handles_before = decoder.remaining_handles();
3272            if let Some((inlined, num_bytes, num_handles)) =
3273                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3274            {
3275                let member_inline_size =
3276                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3277                if inlined != (member_inline_size <= 4) {
3278                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3279                }
3280                let inner_offset;
3281                let mut inner_depth = depth.clone();
3282                if inlined {
3283                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3284                    inner_offset = next_offset;
3285                } else {
3286                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3287                    inner_depth.increment()?;
3288                }
3289                let val_ref =
3290                    self.compressed_storage_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
3291                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3292                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3293                {
3294                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3295                }
3296                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3297                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3298                }
3299            }
3300
3301            next_offset += envelope_size;
3302            _next_ordinal_to_read += 1;
3303            if next_offset >= end_offset {
3304                return Ok(());
3305            }
3306
3307            // Decode unknown envelopes for gaps in ordinals.
3308            while _next_ordinal_to_read < 3 {
3309                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3310                _next_ordinal_to_read += 1;
3311                next_offset += envelope_size;
3312            }
3313
3314            let next_out_of_line = decoder.next_out_of_line();
3315            let handles_before = decoder.remaining_handles();
3316            if let Some((inlined, num_bytes, num_handles)) =
3317                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3318            {
3319                let member_inline_size =
3320                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3321                if inlined != (member_inline_size <= 4) {
3322                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3323                }
3324                let inner_offset;
3325                let mut inner_depth = depth.clone();
3326                if inlined {
3327                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3328                    inner_offset = next_offset;
3329                } else {
3330                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3331                    inner_depth.increment()?;
3332                }
3333                let val_ref = self
3334                    .compressed_fragmentation_bytes
3335                    .get_or_insert_with(|| fidl::new_empty!(u64, D));
3336                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3337                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3338                {
3339                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3340                }
3341                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3342                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3343                }
3344            }
3345
3346            next_offset += envelope_size;
3347            _next_ordinal_to_read += 1;
3348            if next_offset >= end_offset {
3349                return Ok(());
3350            }
3351
3352            // Decode unknown envelopes for gaps in ordinals.
3353            while _next_ordinal_to_read < 4 {
3354                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3355                _next_ordinal_to_read += 1;
3356                next_offset += envelope_size;
3357            }
3358
3359            let next_out_of_line = decoder.next_out_of_line();
3360            let handles_before = decoder.remaining_handles();
3361            if let Some((inlined, num_bytes, num_handles)) =
3362                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3363            {
3364                let member_inline_size =
3365                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3366                if inlined != (member_inline_size <= 4) {
3367                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3368                }
3369                let inner_offset;
3370                let mut inner_depth = depth.clone();
3371                if inlined {
3372                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3373                    inner_offset = next_offset;
3374                } else {
3375                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3376                    inner_depth.increment()?;
3377                }
3378                let val_ref = self.compression_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
3379                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3380                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3381                {
3382                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3383                }
3384                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3385                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3386                }
3387            }
3388
3389            next_offset += envelope_size;
3390            _next_ordinal_to_read += 1;
3391            if next_offset >= end_offset {
3392                return Ok(());
3393            }
3394
3395            // Decode unknown envelopes for gaps in ordinals.
3396            while _next_ordinal_to_read < 5 {
3397                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3398                _next_ordinal_to_read += 1;
3399                next_offset += envelope_size;
3400            }
3401
3402            let next_out_of_line = decoder.next_out_of_line();
3403            let handles_before = decoder.remaining_handles();
3404            if let Some((inlined, num_bytes, num_handles)) =
3405                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3406            {
3407                let member_inline_size =
3408                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3409                if inlined != (member_inline_size <= 4) {
3410                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3411                }
3412                let inner_offset;
3413                let mut inner_depth = depth.clone();
3414                if inlined {
3415                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3416                    inner_offset = next_offset;
3417                } else {
3418                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3419                    inner_depth.increment()?;
3420                }
3421                let val_ref =
3422                    self.decompression_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
3423                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3424                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3425                {
3426                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3427                }
3428                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3429                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3430                }
3431            }
3432
3433            next_offset += envelope_size;
3434            _next_ordinal_to_read += 1;
3435            if next_offset >= end_offset {
3436                return Ok(());
3437            }
3438
3439            // Decode unknown envelopes for gaps in ordinals.
3440            while _next_ordinal_to_read < 6 {
3441                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3442                _next_ordinal_to_read += 1;
3443                next_offset += envelope_size;
3444            }
3445
3446            let next_out_of_line = decoder.next_out_of_line();
3447            let handles_before = decoder.remaining_handles();
3448            if let Some((inlined, num_bytes, num_handles)) =
3449                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3450            {
3451                let member_inline_size =
3452                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3453                if inlined != (member_inline_size <= 4) {
3454                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3455                }
3456                let inner_offset;
3457                let mut inner_depth = depth.clone();
3458                if inlined {
3459                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3460                    inner_offset = next_offset;
3461                } else {
3462                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3463                    inner_depth.increment()?;
3464                }
3465                let val_ref = self
3466                    .total_page_compression_attempts
3467                    .get_or_insert_with(|| fidl::new_empty!(u64, D));
3468                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3469                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3470                {
3471                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3472                }
3473                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3474                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3475                }
3476            }
3477
3478            next_offset += envelope_size;
3479            _next_ordinal_to_read += 1;
3480            if next_offset >= end_offset {
3481                return Ok(());
3482            }
3483
3484            // Decode unknown envelopes for gaps in ordinals.
3485            while _next_ordinal_to_read < 7 {
3486                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3487                _next_ordinal_to_read += 1;
3488                next_offset += envelope_size;
3489            }
3490
3491            let next_out_of_line = decoder.next_out_of_line();
3492            let handles_before = decoder.remaining_handles();
3493            if let Some((inlined, num_bytes, num_handles)) =
3494                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3495            {
3496                let member_inline_size =
3497                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3498                if inlined != (member_inline_size <= 4) {
3499                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3500                }
3501                let inner_offset;
3502                let mut inner_depth = depth.clone();
3503                if inlined {
3504                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3505                    inner_offset = next_offset;
3506                } else {
3507                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3508                    inner_depth.increment()?;
3509                }
3510                let val_ref = self
3511                    .failed_page_compression_attempts
3512                    .get_or_insert_with(|| fidl::new_empty!(u64, D));
3513                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3514                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3515                {
3516                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3517                }
3518                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3519                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3520                }
3521            }
3522
3523            next_offset += envelope_size;
3524            _next_ordinal_to_read += 1;
3525            if next_offset >= end_offset {
3526                return Ok(());
3527            }
3528
3529            // Decode unknown envelopes for gaps in ordinals.
3530            while _next_ordinal_to_read < 8 {
3531                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3532                _next_ordinal_to_read += 1;
3533                next_offset += envelope_size;
3534            }
3535
3536            let next_out_of_line = decoder.next_out_of_line();
3537            let handles_before = decoder.remaining_handles();
3538            if let Some((inlined, num_bytes, num_handles)) =
3539                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3540            {
3541                let member_inline_size =
3542                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3543                if inlined != (member_inline_size <= 4) {
3544                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3545                }
3546                let inner_offset;
3547                let mut inner_depth = depth.clone();
3548                if inlined {
3549                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3550                    inner_offset = next_offset;
3551                } else {
3552                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3553                    inner_depth.increment()?;
3554                }
3555                let val_ref =
3556                    self.total_page_decompressions.get_or_insert_with(|| fidl::new_empty!(u64, D));
3557                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3558                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3559                {
3560                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3561                }
3562                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3563                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3564                }
3565            }
3566
3567            next_offset += envelope_size;
3568            _next_ordinal_to_read += 1;
3569            if next_offset >= end_offset {
3570                return Ok(());
3571            }
3572
3573            // Decode unknown envelopes for gaps in ordinals.
3574            while _next_ordinal_to_read < 9 {
3575                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3576                _next_ordinal_to_read += 1;
3577                next_offset += envelope_size;
3578            }
3579
3580            let next_out_of_line = decoder.next_out_of_line();
3581            let handles_before = decoder.remaining_handles();
3582            if let Some((inlined, num_bytes, num_handles)) =
3583                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3584            {
3585                let member_inline_size =
3586                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3587                if inlined != (member_inline_size <= 4) {
3588                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3589                }
3590                let inner_offset;
3591                let mut inner_depth = depth.clone();
3592                if inlined {
3593                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3594                    inner_offset = next_offset;
3595                } else {
3596                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3597                    inner_depth.increment()?;
3598                }
3599                let val_ref =
3600                    self.compressed_page_evictions.get_or_insert_with(|| fidl::new_empty!(u64, D));
3601                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3602                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3603                {
3604                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3605                }
3606                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3607                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3608                }
3609            }
3610
3611            next_offset += envelope_size;
3612            _next_ordinal_to_read += 1;
3613            if next_offset >= end_offset {
3614                return Ok(());
3615            }
3616
3617            // Decode unknown envelopes for gaps in ordinals.
3618            while _next_ordinal_to_read < 10 {
3619                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3620                _next_ordinal_to_read += 1;
3621                next_offset += envelope_size;
3622            }
3623
3624            let next_out_of_line = decoder.next_out_of_line();
3625            let handles_before = decoder.remaining_handles();
3626            if let Some((inlined, num_bytes, num_handles)) =
3627                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3628            {
3629                let member_inline_size =
3630                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3631                if inlined != (member_inline_size <= 4) {
3632                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3633                }
3634                let inner_offset;
3635                let mut inner_depth = depth.clone();
3636                if inlined {
3637                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3638                    inner_offset = next_offset;
3639                } else {
3640                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3641                    inner_depth.increment()?;
3642                }
3643                let val_ref =
3644                    self.eager_page_compressions.get_or_insert_with(|| fidl::new_empty!(u64, D));
3645                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3646                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3647                {
3648                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3649                }
3650                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3651                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3652                }
3653            }
3654
3655            next_offset += envelope_size;
3656            _next_ordinal_to_read += 1;
3657            if next_offset >= end_offset {
3658                return Ok(());
3659            }
3660
3661            // Decode unknown envelopes for gaps in ordinals.
3662            while _next_ordinal_to_read < 11 {
3663                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3664                _next_ordinal_to_read += 1;
3665                next_offset += envelope_size;
3666            }
3667
3668            let next_out_of_line = decoder.next_out_of_line();
3669            let handles_before = decoder.remaining_handles();
3670            if let Some((inlined, num_bytes, num_handles)) =
3671                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3672            {
3673                let member_inline_size =
3674                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3675                if inlined != (member_inline_size <= 4) {
3676                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3677                }
3678                let inner_offset;
3679                let mut inner_depth = depth.clone();
3680                if inlined {
3681                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3682                    inner_offset = next_offset;
3683                } else {
3684                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3685                    inner_depth.increment()?;
3686                }
3687                let val_ref = self
3688                    .memory_pressure_page_compressions
3689                    .get_or_insert_with(|| fidl::new_empty!(u64, D));
3690                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3691                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3692                {
3693                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3694                }
3695                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3696                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3697                }
3698            }
3699
3700            next_offset += envelope_size;
3701            _next_ordinal_to_read += 1;
3702            if next_offset >= end_offset {
3703                return Ok(());
3704            }
3705
3706            // Decode unknown envelopes for gaps in ordinals.
3707            while _next_ordinal_to_read < 12 {
3708                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3709                _next_ordinal_to_read += 1;
3710                next_offset += envelope_size;
3711            }
3712
3713            let next_out_of_line = decoder.next_out_of_line();
3714            let handles_before = decoder.remaining_handles();
3715            if let Some((inlined, num_bytes, num_handles)) =
3716                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3717            {
3718                let member_inline_size =
3719                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3720                if inlined != (member_inline_size <= 4) {
3721                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3722                }
3723                let inner_offset;
3724                let mut inner_depth = depth.clone();
3725                if inlined {
3726                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3727                    inner_offset = next_offset;
3728                } else {
3729                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3730                    inner_depth.increment()?;
3731                }
3732                let val_ref = self
3733                    .critical_memory_page_compressions
3734                    .get_or_insert_with(|| fidl::new_empty!(u64, D));
3735                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3736                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3737                {
3738                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3739                }
3740                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3741                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3742                }
3743            }
3744
3745            next_offset += envelope_size;
3746            _next_ordinal_to_read += 1;
3747            if next_offset >= end_offset {
3748                return Ok(());
3749            }
3750
3751            // Decode unknown envelopes for gaps in ordinals.
3752            while _next_ordinal_to_read < 13 {
3753                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3754                _next_ordinal_to_read += 1;
3755                next_offset += envelope_size;
3756            }
3757
3758            let next_out_of_line = decoder.next_out_of_line();
3759            let handles_before = decoder.remaining_handles();
3760            if let Some((inlined, num_bytes, num_handles)) =
3761                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3762            {
3763                let member_inline_size =
3764                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3765                if inlined != (member_inline_size <= 4) {
3766                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3767                }
3768                let inner_offset;
3769                let mut inner_depth = depth.clone();
3770                if inlined {
3771                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3772                    inner_offset = next_offset;
3773                } else {
3774                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3775                    inner_depth.increment()?;
3776                }
3777                let val_ref =
3778                    self.pages_decompressed_unit_ns.get_or_insert_with(|| fidl::new_empty!(u64, D));
3779                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3780                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3781                {
3782                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3783                }
3784                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3785                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3786                }
3787            }
3788
3789            next_offset += envelope_size;
3790            _next_ordinal_to_read += 1;
3791            if next_offset >= end_offset {
3792                return Ok(());
3793            }
3794
3795            // Decode unknown envelopes for gaps in ordinals.
3796            while _next_ordinal_to_read < 14 {
3797                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3798                _next_ordinal_to_read += 1;
3799                next_offset += envelope_size;
3800            }
3801
3802            let next_out_of_line = decoder.next_out_of_line();
3803            let handles_before = decoder.remaining_handles();
3804            if let Some((inlined, num_bytes, num_handles)) =
3805                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3806            {
3807                let member_inline_size =
3808                    <fidl::encoding::Array<u64, 8> as fidl::encoding::TypeMarker>::inline_size(
3809                        decoder.context,
3810                    );
3811                if inlined != (member_inline_size <= 4) {
3812                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3813                }
3814                let inner_offset;
3815                let mut inner_depth = depth.clone();
3816                if inlined {
3817                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3818                    inner_offset = next_offset;
3819                } else {
3820                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3821                    inner_depth.increment()?;
3822                }
3823                let val_ref = self
3824                    .pages_decompressed_within_log_time
3825                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u64, 8>, D));
3826                fidl::decode!(fidl::encoding::Array<u64, 8>, D, val_ref, decoder, inner_offset, inner_depth)?;
3827                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3828                {
3829                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3830                }
3831                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3832                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3833                }
3834            }
3835
3836            next_offset += envelope_size;
3837
3838            // Decode the remaining unknown envelopes.
3839            while next_offset < end_offset {
3840                _next_ordinal_to_read += 1;
3841                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3842                next_offset += envelope_size;
3843            }
3844
3845            Ok(())
3846        }
3847    }
3848
3849    impl MemoryStatsExtended {
3850        #[inline(always)]
3851        fn max_ordinal_present(&self) -> u64 {
3852            if let Some(_) = self.other_bytes {
3853                return 14;
3854            }
3855            if let Some(_) = self.ipc_bytes {
3856                return 13;
3857            }
3858            if let Some(_) = self.mmu_overhead_bytes {
3859                return 12;
3860            }
3861            if let Some(_) = self.vmo_discardable_unlocked_bytes {
3862                return 11;
3863            }
3864            if let Some(_) = self.vmo_discardable_locked_bytes {
3865                return 10;
3866            }
3867            if let Some(_) = self.vmo_pager_oldest_bytes {
3868                return 9;
3869            }
3870            if let Some(_) = self.vmo_pager_newest_bytes {
3871                return 8;
3872            }
3873            if let Some(_) = self.vmo_pager_total_bytes {
3874                return 7;
3875            }
3876            if let Some(_) = self.vmo_bytes {
3877                return 6;
3878            }
3879            if let Some(_) = self.free_heap_bytes {
3880                return 5;
3881            }
3882            if let Some(_) = self.total_heap_bytes {
3883                return 4;
3884            }
3885            if let Some(_) = self.wired_bytes {
3886                return 3;
3887            }
3888            if let Some(_) = self.free_bytes {
3889                return 2;
3890            }
3891            if let Some(_) = self.total_bytes {
3892                return 1;
3893            }
3894            0
3895        }
3896    }
3897
3898    impl fidl::encoding::ValueTypeMarker for MemoryStatsExtended {
3899        type Borrowed<'a> = &'a Self;
3900        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3901            value
3902        }
3903    }
3904
3905    unsafe impl fidl::encoding::TypeMarker for MemoryStatsExtended {
3906        type Owned = Self;
3907
3908        #[inline(always)]
3909        fn inline_align(_context: fidl::encoding::Context) -> usize {
3910            8
3911        }
3912
3913        #[inline(always)]
3914        fn inline_size(_context: fidl::encoding::Context) -> usize {
3915            16
3916        }
3917    }
3918
3919    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MemoryStatsExtended, D>
3920        for &MemoryStatsExtended
3921    {
3922        unsafe fn encode(
3923            self,
3924            encoder: &mut fidl::encoding::Encoder<'_, D>,
3925            offset: usize,
3926            mut depth: fidl::encoding::Depth,
3927        ) -> fidl::Result<()> {
3928            encoder.debug_check_bounds::<MemoryStatsExtended>(offset);
3929            // Vector header
3930            let max_ordinal: u64 = self.max_ordinal_present();
3931            encoder.write_num(max_ordinal, offset);
3932            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3933            // Calling encoder.out_of_line_offset(0) is not allowed.
3934            if max_ordinal == 0 {
3935                return Ok(());
3936            }
3937            depth.increment()?;
3938            let envelope_size = 8;
3939            let bytes_len = max_ordinal as usize * envelope_size;
3940            #[allow(unused_variables)]
3941            let offset = encoder.out_of_line_offset(bytes_len);
3942            let mut _prev_end_offset: usize = 0;
3943            if 1 > max_ordinal {
3944                return Ok(());
3945            }
3946
3947            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3948            // are envelope_size bytes.
3949            let cur_offset: usize = (1 - 1) * envelope_size;
3950
3951            // Zero reserved fields.
3952            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3953
3954            // Safety:
3955            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3956            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3957            //   envelope_size bytes, there is always sufficient room.
3958            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3959                self.total_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3960                encoder,
3961                offset + cur_offset,
3962                depth,
3963            )?;
3964
3965            _prev_end_offset = cur_offset + envelope_size;
3966            if 2 > max_ordinal {
3967                return Ok(());
3968            }
3969
3970            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3971            // are envelope_size bytes.
3972            let cur_offset: usize = (2 - 1) * envelope_size;
3973
3974            // Zero reserved fields.
3975            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3976
3977            // Safety:
3978            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3979            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3980            //   envelope_size bytes, there is always sufficient room.
3981            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3982                self.free_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3983                encoder,
3984                offset + cur_offset,
3985                depth,
3986            )?;
3987
3988            _prev_end_offset = cur_offset + envelope_size;
3989            if 3 > max_ordinal {
3990                return Ok(());
3991            }
3992
3993            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3994            // are envelope_size bytes.
3995            let cur_offset: usize = (3 - 1) * envelope_size;
3996
3997            // Zero reserved fields.
3998            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3999
4000            // Safety:
4001            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4002            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4003            //   envelope_size bytes, there is always sufficient room.
4004            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4005                self.wired_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4006                encoder,
4007                offset + cur_offset,
4008                depth,
4009            )?;
4010
4011            _prev_end_offset = cur_offset + envelope_size;
4012            if 4 > max_ordinal {
4013                return Ok(());
4014            }
4015
4016            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4017            // are envelope_size bytes.
4018            let cur_offset: usize = (4 - 1) * envelope_size;
4019
4020            // Zero reserved fields.
4021            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4022
4023            // Safety:
4024            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4025            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4026            //   envelope_size bytes, there is always sufficient room.
4027            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4028                self.total_heap_bytes
4029                    .as_ref()
4030                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4031                encoder,
4032                offset + cur_offset,
4033                depth,
4034            )?;
4035
4036            _prev_end_offset = cur_offset + envelope_size;
4037            if 5 > max_ordinal {
4038                return Ok(());
4039            }
4040
4041            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4042            // are envelope_size bytes.
4043            let cur_offset: usize = (5 - 1) * envelope_size;
4044
4045            // Zero reserved fields.
4046            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4047
4048            // Safety:
4049            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4050            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4051            //   envelope_size bytes, there is always sufficient room.
4052            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4053                self.free_heap_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4054                encoder,
4055                offset + cur_offset,
4056                depth,
4057            )?;
4058
4059            _prev_end_offset = cur_offset + envelope_size;
4060            if 6 > max_ordinal {
4061                return Ok(());
4062            }
4063
4064            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4065            // are envelope_size bytes.
4066            let cur_offset: usize = (6 - 1) * envelope_size;
4067
4068            // Zero reserved fields.
4069            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4070
4071            // Safety:
4072            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4073            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4074            //   envelope_size bytes, there is always sufficient room.
4075            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4076                self.vmo_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4077                encoder,
4078                offset + cur_offset,
4079                depth,
4080            )?;
4081
4082            _prev_end_offset = cur_offset + envelope_size;
4083            if 7 > max_ordinal {
4084                return Ok(());
4085            }
4086
4087            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4088            // are envelope_size bytes.
4089            let cur_offset: usize = (7 - 1) * envelope_size;
4090
4091            // Zero reserved fields.
4092            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4093
4094            // Safety:
4095            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4096            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4097            //   envelope_size bytes, there is always sufficient room.
4098            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4099                self.vmo_pager_total_bytes
4100                    .as_ref()
4101                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4102                encoder,
4103                offset + cur_offset,
4104                depth,
4105            )?;
4106
4107            _prev_end_offset = cur_offset + envelope_size;
4108            if 8 > max_ordinal {
4109                return Ok(());
4110            }
4111
4112            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4113            // are envelope_size bytes.
4114            let cur_offset: usize = (8 - 1) * envelope_size;
4115
4116            // Zero reserved fields.
4117            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4118
4119            // Safety:
4120            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4121            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4122            //   envelope_size bytes, there is always sufficient room.
4123            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4124                self.vmo_pager_newest_bytes
4125                    .as_ref()
4126                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4127                encoder,
4128                offset + cur_offset,
4129                depth,
4130            )?;
4131
4132            _prev_end_offset = cur_offset + envelope_size;
4133            if 9 > max_ordinal {
4134                return Ok(());
4135            }
4136
4137            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4138            // are envelope_size bytes.
4139            let cur_offset: usize = (9 - 1) * envelope_size;
4140
4141            // Zero reserved fields.
4142            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4143
4144            // Safety:
4145            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4146            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4147            //   envelope_size bytes, there is always sufficient room.
4148            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4149                self.vmo_pager_oldest_bytes
4150                    .as_ref()
4151                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4152                encoder,
4153                offset + cur_offset,
4154                depth,
4155            )?;
4156
4157            _prev_end_offset = cur_offset + envelope_size;
4158            if 10 > max_ordinal {
4159                return Ok(());
4160            }
4161
4162            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4163            // are envelope_size bytes.
4164            let cur_offset: usize = (10 - 1) * envelope_size;
4165
4166            // Zero reserved fields.
4167            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4168
4169            // Safety:
4170            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4171            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4172            //   envelope_size bytes, there is always sufficient room.
4173            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4174                self.vmo_discardable_locked_bytes
4175                    .as_ref()
4176                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4177                encoder,
4178                offset + cur_offset,
4179                depth,
4180            )?;
4181
4182            _prev_end_offset = cur_offset + envelope_size;
4183            if 11 > max_ordinal {
4184                return Ok(());
4185            }
4186
4187            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4188            // are envelope_size bytes.
4189            let cur_offset: usize = (11 - 1) * envelope_size;
4190
4191            // Zero reserved fields.
4192            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4193
4194            // Safety:
4195            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4196            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4197            //   envelope_size bytes, there is always sufficient room.
4198            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4199                self.vmo_discardable_unlocked_bytes
4200                    .as_ref()
4201                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4202                encoder,
4203                offset + cur_offset,
4204                depth,
4205            )?;
4206
4207            _prev_end_offset = cur_offset + envelope_size;
4208            if 12 > max_ordinal {
4209                return Ok(());
4210            }
4211
4212            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4213            // are envelope_size bytes.
4214            let cur_offset: usize = (12 - 1) * envelope_size;
4215
4216            // Zero reserved fields.
4217            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4218
4219            // Safety:
4220            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4221            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4222            //   envelope_size bytes, there is always sufficient room.
4223            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4224                self.mmu_overhead_bytes
4225                    .as_ref()
4226                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4227                encoder,
4228                offset + cur_offset,
4229                depth,
4230            )?;
4231
4232            _prev_end_offset = cur_offset + envelope_size;
4233            if 13 > max_ordinal {
4234                return Ok(());
4235            }
4236
4237            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4238            // are envelope_size bytes.
4239            let cur_offset: usize = (13 - 1) * envelope_size;
4240
4241            // Zero reserved fields.
4242            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4243
4244            // Safety:
4245            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4246            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4247            //   envelope_size bytes, there is always sufficient room.
4248            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4249                self.ipc_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4250                encoder,
4251                offset + cur_offset,
4252                depth,
4253            )?;
4254
4255            _prev_end_offset = cur_offset + envelope_size;
4256            if 14 > max_ordinal {
4257                return Ok(());
4258            }
4259
4260            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4261            // are envelope_size bytes.
4262            let cur_offset: usize = (14 - 1) * envelope_size;
4263
4264            // Zero reserved fields.
4265            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4266
4267            // Safety:
4268            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4269            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4270            //   envelope_size bytes, there is always sufficient room.
4271            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4272                self.other_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4273                encoder,
4274                offset + cur_offset,
4275                depth,
4276            )?;
4277
4278            _prev_end_offset = cur_offset + envelope_size;
4279
4280            Ok(())
4281        }
4282    }
4283
4284    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MemoryStatsExtended {
4285        #[inline(always)]
4286        fn new_empty() -> Self {
4287            Self::default()
4288        }
4289
4290        unsafe fn decode(
4291            &mut self,
4292            decoder: &mut fidl::encoding::Decoder<'_, D>,
4293            offset: usize,
4294            mut depth: fidl::encoding::Depth,
4295        ) -> fidl::Result<()> {
4296            decoder.debug_check_bounds::<Self>(offset);
4297            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4298                None => return Err(fidl::Error::NotNullable),
4299                Some(len) => len,
4300            };
4301            // Calling decoder.out_of_line_offset(0) is not allowed.
4302            if len == 0 {
4303                return Ok(());
4304            };
4305            depth.increment()?;
4306            let envelope_size = 8;
4307            let bytes_len = len * envelope_size;
4308            let offset = decoder.out_of_line_offset(bytes_len)?;
4309            // Decode the envelope for each type.
4310            let mut _next_ordinal_to_read = 0;
4311            let mut next_offset = offset;
4312            let end_offset = offset + bytes_len;
4313            _next_ordinal_to_read += 1;
4314            if next_offset >= end_offset {
4315                return Ok(());
4316            }
4317
4318            // Decode unknown envelopes for gaps in ordinals.
4319            while _next_ordinal_to_read < 1 {
4320                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4321                _next_ordinal_to_read += 1;
4322                next_offset += envelope_size;
4323            }
4324
4325            let next_out_of_line = decoder.next_out_of_line();
4326            let handles_before = decoder.remaining_handles();
4327            if let Some((inlined, num_bytes, num_handles)) =
4328                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4329            {
4330                let member_inline_size =
4331                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4332                if inlined != (member_inline_size <= 4) {
4333                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4334                }
4335                let inner_offset;
4336                let mut inner_depth = depth.clone();
4337                if inlined {
4338                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4339                    inner_offset = next_offset;
4340                } else {
4341                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4342                    inner_depth.increment()?;
4343                }
4344                let val_ref = self.total_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4345                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4346                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4347                {
4348                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4349                }
4350                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4351                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4352                }
4353            }
4354
4355            next_offset += envelope_size;
4356            _next_ordinal_to_read += 1;
4357            if next_offset >= end_offset {
4358                return Ok(());
4359            }
4360
4361            // Decode unknown envelopes for gaps in ordinals.
4362            while _next_ordinal_to_read < 2 {
4363                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4364                _next_ordinal_to_read += 1;
4365                next_offset += envelope_size;
4366            }
4367
4368            let next_out_of_line = decoder.next_out_of_line();
4369            let handles_before = decoder.remaining_handles();
4370            if let Some((inlined, num_bytes, num_handles)) =
4371                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4372            {
4373                let member_inline_size =
4374                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4375                if inlined != (member_inline_size <= 4) {
4376                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4377                }
4378                let inner_offset;
4379                let mut inner_depth = depth.clone();
4380                if inlined {
4381                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4382                    inner_offset = next_offset;
4383                } else {
4384                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4385                    inner_depth.increment()?;
4386                }
4387                let val_ref = self.free_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4388                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4389                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4390                {
4391                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4392                }
4393                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4394                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4395                }
4396            }
4397
4398            next_offset += envelope_size;
4399            _next_ordinal_to_read += 1;
4400            if next_offset >= end_offset {
4401                return Ok(());
4402            }
4403
4404            // Decode unknown envelopes for gaps in ordinals.
4405            while _next_ordinal_to_read < 3 {
4406                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4407                _next_ordinal_to_read += 1;
4408                next_offset += envelope_size;
4409            }
4410
4411            let next_out_of_line = decoder.next_out_of_line();
4412            let handles_before = decoder.remaining_handles();
4413            if let Some((inlined, num_bytes, num_handles)) =
4414                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4415            {
4416                let member_inline_size =
4417                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4418                if inlined != (member_inline_size <= 4) {
4419                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4420                }
4421                let inner_offset;
4422                let mut inner_depth = depth.clone();
4423                if inlined {
4424                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4425                    inner_offset = next_offset;
4426                } else {
4427                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4428                    inner_depth.increment()?;
4429                }
4430                let val_ref = self.wired_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4431                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4432                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4433                {
4434                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4435                }
4436                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4437                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4438                }
4439            }
4440
4441            next_offset += envelope_size;
4442            _next_ordinal_to_read += 1;
4443            if next_offset >= end_offset {
4444                return Ok(());
4445            }
4446
4447            // Decode unknown envelopes for gaps in ordinals.
4448            while _next_ordinal_to_read < 4 {
4449                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4450                _next_ordinal_to_read += 1;
4451                next_offset += envelope_size;
4452            }
4453
4454            let next_out_of_line = decoder.next_out_of_line();
4455            let handles_before = decoder.remaining_handles();
4456            if let Some((inlined, num_bytes, num_handles)) =
4457                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4458            {
4459                let member_inline_size =
4460                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4461                if inlined != (member_inline_size <= 4) {
4462                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4463                }
4464                let inner_offset;
4465                let mut inner_depth = depth.clone();
4466                if inlined {
4467                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4468                    inner_offset = next_offset;
4469                } else {
4470                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4471                    inner_depth.increment()?;
4472                }
4473                let val_ref = self.total_heap_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4474                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4475                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4476                {
4477                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4478                }
4479                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4480                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4481                }
4482            }
4483
4484            next_offset += envelope_size;
4485            _next_ordinal_to_read += 1;
4486            if next_offset >= end_offset {
4487                return Ok(());
4488            }
4489
4490            // Decode unknown envelopes for gaps in ordinals.
4491            while _next_ordinal_to_read < 5 {
4492                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4493                _next_ordinal_to_read += 1;
4494                next_offset += envelope_size;
4495            }
4496
4497            let next_out_of_line = decoder.next_out_of_line();
4498            let handles_before = decoder.remaining_handles();
4499            if let Some((inlined, num_bytes, num_handles)) =
4500                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4501            {
4502                let member_inline_size =
4503                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4504                if inlined != (member_inline_size <= 4) {
4505                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4506                }
4507                let inner_offset;
4508                let mut inner_depth = depth.clone();
4509                if inlined {
4510                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4511                    inner_offset = next_offset;
4512                } else {
4513                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4514                    inner_depth.increment()?;
4515                }
4516                let val_ref = self.free_heap_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4517                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4518                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4519                {
4520                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4521                }
4522                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4523                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4524                }
4525            }
4526
4527            next_offset += envelope_size;
4528            _next_ordinal_to_read += 1;
4529            if next_offset >= end_offset {
4530                return Ok(());
4531            }
4532
4533            // Decode unknown envelopes for gaps in ordinals.
4534            while _next_ordinal_to_read < 6 {
4535                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4536                _next_ordinal_to_read += 1;
4537                next_offset += envelope_size;
4538            }
4539
4540            let next_out_of_line = decoder.next_out_of_line();
4541            let handles_before = decoder.remaining_handles();
4542            if let Some((inlined, num_bytes, num_handles)) =
4543                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4544            {
4545                let member_inline_size =
4546                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4547                if inlined != (member_inline_size <= 4) {
4548                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4549                }
4550                let inner_offset;
4551                let mut inner_depth = depth.clone();
4552                if inlined {
4553                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4554                    inner_offset = next_offset;
4555                } else {
4556                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4557                    inner_depth.increment()?;
4558                }
4559                let val_ref = self.vmo_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4560                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4561                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4562                {
4563                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4564                }
4565                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4566                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4567                }
4568            }
4569
4570            next_offset += envelope_size;
4571            _next_ordinal_to_read += 1;
4572            if next_offset >= end_offset {
4573                return Ok(());
4574            }
4575
4576            // Decode unknown envelopes for gaps in ordinals.
4577            while _next_ordinal_to_read < 7 {
4578                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4579                _next_ordinal_to_read += 1;
4580                next_offset += envelope_size;
4581            }
4582
4583            let next_out_of_line = decoder.next_out_of_line();
4584            let handles_before = decoder.remaining_handles();
4585            if let Some((inlined, num_bytes, num_handles)) =
4586                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4587            {
4588                let member_inline_size =
4589                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4590                if inlined != (member_inline_size <= 4) {
4591                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4592                }
4593                let inner_offset;
4594                let mut inner_depth = depth.clone();
4595                if inlined {
4596                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4597                    inner_offset = next_offset;
4598                } else {
4599                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4600                    inner_depth.increment()?;
4601                }
4602                let val_ref =
4603                    self.vmo_pager_total_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4604                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4605                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4606                {
4607                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4608                }
4609                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4610                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4611                }
4612            }
4613
4614            next_offset += envelope_size;
4615            _next_ordinal_to_read += 1;
4616            if next_offset >= end_offset {
4617                return Ok(());
4618            }
4619
4620            // Decode unknown envelopes for gaps in ordinals.
4621            while _next_ordinal_to_read < 8 {
4622                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4623                _next_ordinal_to_read += 1;
4624                next_offset += envelope_size;
4625            }
4626
4627            let next_out_of_line = decoder.next_out_of_line();
4628            let handles_before = decoder.remaining_handles();
4629            if let Some((inlined, num_bytes, num_handles)) =
4630                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4631            {
4632                let member_inline_size =
4633                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4634                if inlined != (member_inline_size <= 4) {
4635                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4636                }
4637                let inner_offset;
4638                let mut inner_depth = depth.clone();
4639                if inlined {
4640                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4641                    inner_offset = next_offset;
4642                } else {
4643                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4644                    inner_depth.increment()?;
4645                }
4646                let val_ref =
4647                    self.vmo_pager_newest_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4648                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4649                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4650                {
4651                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4652                }
4653                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4654                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4655                }
4656            }
4657
4658            next_offset += envelope_size;
4659            _next_ordinal_to_read += 1;
4660            if next_offset >= end_offset {
4661                return Ok(());
4662            }
4663
4664            // Decode unknown envelopes for gaps in ordinals.
4665            while _next_ordinal_to_read < 9 {
4666                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4667                _next_ordinal_to_read += 1;
4668                next_offset += envelope_size;
4669            }
4670
4671            let next_out_of_line = decoder.next_out_of_line();
4672            let handles_before = decoder.remaining_handles();
4673            if let Some((inlined, num_bytes, num_handles)) =
4674                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4675            {
4676                let member_inline_size =
4677                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4678                if inlined != (member_inline_size <= 4) {
4679                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4680                }
4681                let inner_offset;
4682                let mut inner_depth = depth.clone();
4683                if inlined {
4684                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4685                    inner_offset = next_offset;
4686                } else {
4687                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4688                    inner_depth.increment()?;
4689                }
4690                let val_ref =
4691                    self.vmo_pager_oldest_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4692                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4693                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4694                {
4695                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4696                }
4697                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4698                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4699                }
4700            }
4701
4702            next_offset += envelope_size;
4703            _next_ordinal_to_read += 1;
4704            if next_offset >= end_offset {
4705                return Ok(());
4706            }
4707
4708            // Decode unknown envelopes for gaps in ordinals.
4709            while _next_ordinal_to_read < 10 {
4710                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4711                _next_ordinal_to_read += 1;
4712                next_offset += envelope_size;
4713            }
4714
4715            let next_out_of_line = decoder.next_out_of_line();
4716            let handles_before = decoder.remaining_handles();
4717            if let Some((inlined, num_bytes, num_handles)) =
4718                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4719            {
4720                let member_inline_size =
4721                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4722                if inlined != (member_inline_size <= 4) {
4723                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4724                }
4725                let inner_offset;
4726                let mut inner_depth = depth.clone();
4727                if inlined {
4728                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4729                    inner_offset = next_offset;
4730                } else {
4731                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4732                    inner_depth.increment()?;
4733                }
4734                let val_ref = self
4735                    .vmo_discardable_locked_bytes
4736                    .get_or_insert_with(|| fidl::new_empty!(u64, D));
4737                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4738                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4739                {
4740                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4741                }
4742                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4743                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4744                }
4745            }
4746
4747            next_offset += envelope_size;
4748            _next_ordinal_to_read += 1;
4749            if next_offset >= end_offset {
4750                return Ok(());
4751            }
4752
4753            // Decode unknown envelopes for gaps in ordinals.
4754            while _next_ordinal_to_read < 11 {
4755                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4756                _next_ordinal_to_read += 1;
4757                next_offset += envelope_size;
4758            }
4759
4760            let next_out_of_line = decoder.next_out_of_line();
4761            let handles_before = decoder.remaining_handles();
4762            if let Some((inlined, num_bytes, num_handles)) =
4763                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4764            {
4765                let member_inline_size =
4766                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4767                if inlined != (member_inline_size <= 4) {
4768                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4769                }
4770                let inner_offset;
4771                let mut inner_depth = depth.clone();
4772                if inlined {
4773                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4774                    inner_offset = next_offset;
4775                } else {
4776                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4777                    inner_depth.increment()?;
4778                }
4779                let val_ref = self
4780                    .vmo_discardable_unlocked_bytes
4781                    .get_or_insert_with(|| fidl::new_empty!(u64, D));
4782                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4783                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4784                {
4785                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4786                }
4787                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4788                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4789                }
4790            }
4791
4792            next_offset += envelope_size;
4793            _next_ordinal_to_read += 1;
4794            if next_offset >= end_offset {
4795                return Ok(());
4796            }
4797
4798            // Decode unknown envelopes for gaps in ordinals.
4799            while _next_ordinal_to_read < 12 {
4800                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4801                _next_ordinal_to_read += 1;
4802                next_offset += envelope_size;
4803            }
4804
4805            let next_out_of_line = decoder.next_out_of_line();
4806            let handles_before = decoder.remaining_handles();
4807            if let Some((inlined, num_bytes, num_handles)) =
4808                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4809            {
4810                let member_inline_size =
4811                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4812                if inlined != (member_inline_size <= 4) {
4813                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4814                }
4815                let inner_offset;
4816                let mut inner_depth = depth.clone();
4817                if inlined {
4818                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4819                    inner_offset = next_offset;
4820                } else {
4821                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4822                    inner_depth.increment()?;
4823                }
4824                let val_ref =
4825                    self.mmu_overhead_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4826                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4827                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4828                {
4829                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4830                }
4831                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4832                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4833                }
4834            }
4835
4836            next_offset += envelope_size;
4837            _next_ordinal_to_read += 1;
4838            if next_offset >= end_offset {
4839                return Ok(());
4840            }
4841
4842            // Decode unknown envelopes for gaps in ordinals.
4843            while _next_ordinal_to_read < 13 {
4844                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4845                _next_ordinal_to_read += 1;
4846                next_offset += envelope_size;
4847            }
4848
4849            let next_out_of_line = decoder.next_out_of_line();
4850            let handles_before = decoder.remaining_handles();
4851            if let Some((inlined, num_bytes, num_handles)) =
4852                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4853            {
4854                let member_inline_size =
4855                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4856                if inlined != (member_inline_size <= 4) {
4857                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4858                }
4859                let inner_offset;
4860                let mut inner_depth = depth.clone();
4861                if inlined {
4862                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4863                    inner_offset = next_offset;
4864                } else {
4865                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4866                    inner_depth.increment()?;
4867                }
4868                let val_ref = self.ipc_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4869                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4870                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4871                {
4872                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4873                }
4874                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4875                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4876                }
4877            }
4878
4879            next_offset += envelope_size;
4880            _next_ordinal_to_read += 1;
4881            if next_offset >= end_offset {
4882                return Ok(());
4883            }
4884
4885            // Decode unknown envelopes for gaps in ordinals.
4886            while _next_ordinal_to_read < 14 {
4887                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4888                _next_ordinal_to_read += 1;
4889                next_offset += envelope_size;
4890            }
4891
4892            let next_out_of_line = decoder.next_out_of_line();
4893            let handles_before = decoder.remaining_handles();
4894            if let Some((inlined, num_bytes, num_handles)) =
4895                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4896            {
4897                let member_inline_size =
4898                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4899                if inlined != (member_inline_size <= 4) {
4900                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4901                }
4902                let inner_offset;
4903                let mut inner_depth = depth.clone();
4904                if inlined {
4905                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4906                    inner_offset = next_offset;
4907                } else {
4908                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4909                    inner_depth.increment()?;
4910                }
4911                let val_ref = self.other_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4912                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4913                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4914                {
4915                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4916                }
4917                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4918                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4919                }
4920            }
4921
4922            next_offset += envelope_size;
4923
4924            // Decode the remaining unknown envelopes.
4925            while next_offset < end_offset {
4926                _next_ordinal_to_read += 1;
4927                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4928                next_offset += envelope_size;
4929            }
4930
4931            Ok(())
4932        }
4933    }
4934
4935    impl PerCpuStats {
4936        #[inline(always)]
4937        fn max_ordinal_present(&self) -> u64 {
4938            if let Some(_) = self.generic_ipis {
4939                return 15;
4940            }
4941            if let Some(_) = self.reschedule_ipis {
4942                return 14;
4943            }
4944            if let Some(_) = self.syscalls {
4945                return 13;
4946            }
4947            if let Some(_) = self.exceptions {
4948                return 12;
4949            }
4950            if let Some(_) = self.page_faults {
4951                return 11;
4952            }
4953            if let Some(_) = self.timers {
4954                return 10;
4955            }
4956            if let Some(_) = self.timer_ints {
4957                return 9;
4958            }
4959            if let Some(_) = self.ints {
4960                return 8;
4961            }
4962            if let Some(_) = self.yields {
4963                return 7;
4964            }
4965            if let Some(_) = self.irq_preempts {
4966                return 6;
4967            }
4968            if let Some(_) = self.context_switches {
4969                return 5;
4970            }
4971            if let Some(_) = self.reschedules {
4972                return 4;
4973            }
4974            if let Some(_) = self.idle_time {
4975                return 3;
4976            }
4977            if let Some(_) = self.flags {
4978                return 2;
4979            }
4980            if let Some(_) = self.cpu_number {
4981                return 1;
4982            }
4983            0
4984        }
4985    }
4986
4987    impl fidl::encoding::ValueTypeMarker for PerCpuStats {
4988        type Borrowed<'a> = &'a Self;
4989        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4990            value
4991        }
4992    }
4993
4994    unsafe impl fidl::encoding::TypeMarker for PerCpuStats {
4995        type Owned = Self;
4996
4997        #[inline(always)]
4998        fn inline_align(_context: fidl::encoding::Context) -> usize {
4999            8
5000        }
5001
5002        #[inline(always)]
5003        fn inline_size(_context: fidl::encoding::Context) -> usize {
5004            16
5005        }
5006    }
5007
5008    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PerCpuStats, D>
5009        for &PerCpuStats
5010    {
5011        unsafe fn encode(
5012            self,
5013            encoder: &mut fidl::encoding::Encoder<'_, D>,
5014            offset: usize,
5015            mut depth: fidl::encoding::Depth,
5016        ) -> fidl::Result<()> {
5017            encoder.debug_check_bounds::<PerCpuStats>(offset);
5018            // Vector header
5019            let max_ordinal: u64 = self.max_ordinal_present();
5020            encoder.write_num(max_ordinal, offset);
5021            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5022            // Calling encoder.out_of_line_offset(0) is not allowed.
5023            if max_ordinal == 0 {
5024                return Ok(());
5025            }
5026            depth.increment()?;
5027            let envelope_size = 8;
5028            let bytes_len = max_ordinal as usize * envelope_size;
5029            #[allow(unused_variables)]
5030            let offset = encoder.out_of_line_offset(bytes_len);
5031            let mut _prev_end_offset: usize = 0;
5032            if 1 > max_ordinal {
5033                return Ok(());
5034            }
5035
5036            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5037            // are envelope_size bytes.
5038            let cur_offset: usize = (1 - 1) * envelope_size;
5039
5040            // Zero reserved fields.
5041            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5042
5043            // Safety:
5044            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5045            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5046            //   envelope_size bytes, there is always sufficient room.
5047            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5048                self.cpu_number.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5049                encoder,
5050                offset + cur_offset,
5051                depth,
5052            )?;
5053
5054            _prev_end_offset = cur_offset + envelope_size;
5055            if 2 > max_ordinal {
5056                return Ok(());
5057            }
5058
5059            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5060            // are envelope_size bytes.
5061            let cur_offset: usize = (2 - 1) * envelope_size;
5062
5063            // Zero reserved fields.
5064            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5065
5066            // Safety:
5067            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5068            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5069            //   envelope_size bytes, there is always sufficient room.
5070            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5071                self.flags.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5072                encoder,
5073                offset + cur_offset,
5074                depth,
5075            )?;
5076
5077            _prev_end_offset = cur_offset + envelope_size;
5078            if 3 > max_ordinal {
5079                return Ok(());
5080            }
5081
5082            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5083            // are envelope_size bytes.
5084            let cur_offset: usize = (3 - 1) * envelope_size;
5085
5086            // Zero reserved fields.
5087            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5088
5089            // Safety:
5090            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5091            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5092            //   envelope_size bytes, there is always sufficient room.
5093            fidl::encoding::encode_in_envelope_optional::<i64, D>(
5094                self.idle_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5095                encoder,
5096                offset + cur_offset,
5097                depth,
5098            )?;
5099
5100            _prev_end_offset = cur_offset + envelope_size;
5101            if 4 > max_ordinal {
5102                return Ok(());
5103            }
5104
5105            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5106            // are envelope_size bytes.
5107            let cur_offset: usize = (4 - 1) * envelope_size;
5108
5109            // Zero reserved fields.
5110            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5111
5112            // Safety:
5113            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5114            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5115            //   envelope_size bytes, there is always sufficient room.
5116            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5117                self.reschedules.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5118                encoder,
5119                offset + cur_offset,
5120                depth,
5121            )?;
5122
5123            _prev_end_offset = cur_offset + envelope_size;
5124            if 5 > max_ordinal {
5125                return Ok(());
5126            }
5127
5128            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5129            // are envelope_size bytes.
5130            let cur_offset: usize = (5 - 1) * envelope_size;
5131
5132            // Zero reserved fields.
5133            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5134
5135            // Safety:
5136            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5137            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5138            //   envelope_size bytes, there is always sufficient room.
5139            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5140                self.context_switches
5141                    .as_ref()
5142                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5143                encoder,
5144                offset + cur_offset,
5145                depth,
5146            )?;
5147
5148            _prev_end_offset = cur_offset + envelope_size;
5149            if 6 > max_ordinal {
5150                return Ok(());
5151            }
5152
5153            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5154            // are envelope_size bytes.
5155            let cur_offset: usize = (6 - 1) * envelope_size;
5156
5157            // Zero reserved fields.
5158            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5159
5160            // Safety:
5161            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5162            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5163            //   envelope_size bytes, there is always sufficient room.
5164            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5165                self.irq_preempts.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5166                encoder,
5167                offset + cur_offset,
5168                depth,
5169            )?;
5170
5171            _prev_end_offset = cur_offset + envelope_size;
5172            if 7 > max_ordinal {
5173                return Ok(());
5174            }
5175
5176            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5177            // are envelope_size bytes.
5178            let cur_offset: usize = (7 - 1) * envelope_size;
5179
5180            // Zero reserved fields.
5181            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5182
5183            // Safety:
5184            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5185            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5186            //   envelope_size bytes, there is always sufficient room.
5187            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5188                self.yields.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5189                encoder,
5190                offset + cur_offset,
5191                depth,
5192            )?;
5193
5194            _prev_end_offset = cur_offset + envelope_size;
5195            if 8 > max_ordinal {
5196                return Ok(());
5197            }
5198
5199            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5200            // are envelope_size bytes.
5201            let cur_offset: usize = (8 - 1) * envelope_size;
5202
5203            // Zero reserved fields.
5204            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5205
5206            // Safety:
5207            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5208            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5209            //   envelope_size bytes, there is always sufficient room.
5210            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5211                self.ints.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5212                encoder,
5213                offset + cur_offset,
5214                depth,
5215            )?;
5216
5217            _prev_end_offset = cur_offset + envelope_size;
5218            if 9 > max_ordinal {
5219                return Ok(());
5220            }
5221
5222            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5223            // are envelope_size bytes.
5224            let cur_offset: usize = (9 - 1) * envelope_size;
5225
5226            // Zero reserved fields.
5227            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5228
5229            // Safety:
5230            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5231            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5232            //   envelope_size bytes, there is always sufficient room.
5233            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5234                self.timer_ints.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5235                encoder,
5236                offset + cur_offset,
5237                depth,
5238            )?;
5239
5240            _prev_end_offset = cur_offset + envelope_size;
5241            if 10 > max_ordinal {
5242                return Ok(());
5243            }
5244
5245            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5246            // are envelope_size bytes.
5247            let cur_offset: usize = (10 - 1) * envelope_size;
5248
5249            // Zero reserved fields.
5250            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5251
5252            // Safety:
5253            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5254            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5255            //   envelope_size bytes, there is always sufficient room.
5256            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5257                self.timers.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5258                encoder,
5259                offset + cur_offset,
5260                depth,
5261            )?;
5262
5263            _prev_end_offset = cur_offset + envelope_size;
5264            if 11 > max_ordinal {
5265                return Ok(());
5266            }
5267
5268            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5269            // are envelope_size bytes.
5270            let cur_offset: usize = (11 - 1) * envelope_size;
5271
5272            // Zero reserved fields.
5273            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5274
5275            // Safety:
5276            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5277            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5278            //   envelope_size bytes, there is always sufficient room.
5279            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5280                self.page_faults.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5281                encoder,
5282                offset + cur_offset,
5283                depth,
5284            )?;
5285
5286            _prev_end_offset = cur_offset + envelope_size;
5287            if 12 > max_ordinal {
5288                return Ok(());
5289            }
5290
5291            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5292            // are envelope_size bytes.
5293            let cur_offset: usize = (12 - 1) * envelope_size;
5294
5295            // Zero reserved fields.
5296            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5297
5298            // Safety:
5299            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5300            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5301            //   envelope_size bytes, there is always sufficient room.
5302            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5303                self.exceptions.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5304                encoder,
5305                offset + cur_offset,
5306                depth,
5307            )?;
5308
5309            _prev_end_offset = cur_offset + envelope_size;
5310            if 13 > max_ordinal {
5311                return Ok(());
5312            }
5313
5314            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5315            // are envelope_size bytes.
5316            let cur_offset: usize = (13 - 1) * envelope_size;
5317
5318            // Zero reserved fields.
5319            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5320
5321            // Safety:
5322            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5323            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5324            //   envelope_size bytes, there is always sufficient room.
5325            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5326                self.syscalls.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5327                encoder,
5328                offset + cur_offset,
5329                depth,
5330            )?;
5331
5332            _prev_end_offset = cur_offset + envelope_size;
5333            if 14 > max_ordinal {
5334                return Ok(());
5335            }
5336
5337            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5338            // are envelope_size bytes.
5339            let cur_offset: usize = (14 - 1) * envelope_size;
5340
5341            // Zero reserved fields.
5342            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5343
5344            // Safety:
5345            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5346            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5347            //   envelope_size bytes, there is always sufficient room.
5348            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5349                self.reschedule_ipis.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5350                encoder,
5351                offset + cur_offset,
5352                depth,
5353            )?;
5354
5355            _prev_end_offset = cur_offset + envelope_size;
5356            if 15 > max_ordinal {
5357                return Ok(());
5358            }
5359
5360            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5361            // are envelope_size bytes.
5362            let cur_offset: usize = (15 - 1) * envelope_size;
5363
5364            // Zero reserved fields.
5365            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5366
5367            // Safety:
5368            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5369            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5370            //   envelope_size bytes, there is always sufficient room.
5371            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5372                self.generic_ipis.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5373                encoder,
5374                offset + cur_offset,
5375                depth,
5376            )?;
5377
5378            _prev_end_offset = cur_offset + envelope_size;
5379
5380            Ok(())
5381        }
5382    }
5383
5384    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PerCpuStats {
5385        #[inline(always)]
5386        fn new_empty() -> Self {
5387            Self::default()
5388        }
5389
5390        unsafe fn decode(
5391            &mut self,
5392            decoder: &mut fidl::encoding::Decoder<'_, D>,
5393            offset: usize,
5394            mut depth: fidl::encoding::Depth,
5395        ) -> fidl::Result<()> {
5396            decoder.debug_check_bounds::<Self>(offset);
5397            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5398                None => return Err(fidl::Error::NotNullable),
5399                Some(len) => len,
5400            };
5401            // Calling decoder.out_of_line_offset(0) is not allowed.
5402            if len == 0 {
5403                return Ok(());
5404            };
5405            depth.increment()?;
5406            let envelope_size = 8;
5407            let bytes_len = len * envelope_size;
5408            let offset = decoder.out_of_line_offset(bytes_len)?;
5409            // Decode the envelope for each type.
5410            let mut _next_ordinal_to_read = 0;
5411            let mut next_offset = offset;
5412            let end_offset = offset + bytes_len;
5413            _next_ordinal_to_read += 1;
5414            if next_offset >= end_offset {
5415                return Ok(());
5416            }
5417
5418            // Decode unknown envelopes for gaps in ordinals.
5419            while _next_ordinal_to_read < 1 {
5420                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5421                _next_ordinal_to_read += 1;
5422                next_offset += envelope_size;
5423            }
5424
5425            let next_out_of_line = decoder.next_out_of_line();
5426            let handles_before = decoder.remaining_handles();
5427            if let Some((inlined, num_bytes, num_handles)) =
5428                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5429            {
5430                let member_inline_size =
5431                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5432                if inlined != (member_inline_size <= 4) {
5433                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5434                }
5435                let inner_offset;
5436                let mut inner_depth = depth.clone();
5437                if inlined {
5438                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5439                    inner_offset = next_offset;
5440                } else {
5441                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5442                    inner_depth.increment()?;
5443                }
5444                let val_ref = self.cpu_number.get_or_insert_with(|| fidl::new_empty!(u32, D));
5445                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5446                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5447                {
5448                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5449                }
5450                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5451                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5452                }
5453            }
5454
5455            next_offset += envelope_size;
5456            _next_ordinal_to_read += 1;
5457            if next_offset >= end_offset {
5458                return Ok(());
5459            }
5460
5461            // Decode unknown envelopes for gaps in ordinals.
5462            while _next_ordinal_to_read < 2 {
5463                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5464                _next_ordinal_to_read += 1;
5465                next_offset += envelope_size;
5466            }
5467
5468            let next_out_of_line = decoder.next_out_of_line();
5469            let handles_before = decoder.remaining_handles();
5470            if let Some((inlined, num_bytes, num_handles)) =
5471                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5472            {
5473                let member_inline_size =
5474                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5475                if inlined != (member_inline_size <= 4) {
5476                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5477                }
5478                let inner_offset;
5479                let mut inner_depth = depth.clone();
5480                if inlined {
5481                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5482                    inner_offset = next_offset;
5483                } else {
5484                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5485                    inner_depth.increment()?;
5486                }
5487                let val_ref = self.flags.get_or_insert_with(|| fidl::new_empty!(u32, D));
5488                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5489                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5490                {
5491                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5492                }
5493                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5494                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5495                }
5496            }
5497
5498            next_offset += envelope_size;
5499            _next_ordinal_to_read += 1;
5500            if next_offset >= end_offset {
5501                return Ok(());
5502            }
5503
5504            // Decode unknown envelopes for gaps in ordinals.
5505            while _next_ordinal_to_read < 3 {
5506                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5507                _next_ordinal_to_read += 1;
5508                next_offset += envelope_size;
5509            }
5510
5511            let next_out_of_line = decoder.next_out_of_line();
5512            let handles_before = decoder.remaining_handles();
5513            if let Some((inlined, num_bytes, num_handles)) =
5514                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5515            {
5516                let member_inline_size =
5517                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5518                if inlined != (member_inline_size <= 4) {
5519                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5520                }
5521                let inner_offset;
5522                let mut inner_depth = depth.clone();
5523                if inlined {
5524                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5525                    inner_offset = next_offset;
5526                } else {
5527                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5528                    inner_depth.increment()?;
5529                }
5530                let val_ref = self.idle_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
5531                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
5532                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5533                {
5534                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5535                }
5536                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5537                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5538                }
5539            }
5540
5541            next_offset += envelope_size;
5542            _next_ordinal_to_read += 1;
5543            if next_offset >= end_offset {
5544                return Ok(());
5545            }
5546
5547            // Decode unknown envelopes for gaps in ordinals.
5548            while _next_ordinal_to_read < 4 {
5549                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5550                _next_ordinal_to_read += 1;
5551                next_offset += envelope_size;
5552            }
5553
5554            let next_out_of_line = decoder.next_out_of_line();
5555            let handles_before = decoder.remaining_handles();
5556            if let Some((inlined, num_bytes, num_handles)) =
5557                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5558            {
5559                let member_inline_size =
5560                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5561                if inlined != (member_inline_size <= 4) {
5562                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5563                }
5564                let inner_offset;
5565                let mut inner_depth = depth.clone();
5566                if inlined {
5567                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5568                    inner_offset = next_offset;
5569                } else {
5570                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5571                    inner_depth.increment()?;
5572                }
5573                let val_ref = self.reschedules.get_or_insert_with(|| fidl::new_empty!(u64, D));
5574                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5575                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5576                {
5577                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5578                }
5579                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5580                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5581                }
5582            }
5583
5584            next_offset += envelope_size;
5585            _next_ordinal_to_read += 1;
5586            if next_offset >= end_offset {
5587                return Ok(());
5588            }
5589
5590            // Decode unknown envelopes for gaps in ordinals.
5591            while _next_ordinal_to_read < 5 {
5592                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5593                _next_ordinal_to_read += 1;
5594                next_offset += envelope_size;
5595            }
5596
5597            let next_out_of_line = decoder.next_out_of_line();
5598            let handles_before = decoder.remaining_handles();
5599            if let Some((inlined, num_bytes, num_handles)) =
5600                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5601            {
5602                let member_inline_size =
5603                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5604                if inlined != (member_inline_size <= 4) {
5605                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5606                }
5607                let inner_offset;
5608                let mut inner_depth = depth.clone();
5609                if inlined {
5610                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5611                    inner_offset = next_offset;
5612                } else {
5613                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5614                    inner_depth.increment()?;
5615                }
5616                let val_ref = self.context_switches.get_or_insert_with(|| fidl::new_empty!(u64, D));
5617                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5618                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5619                {
5620                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5621                }
5622                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5623                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5624                }
5625            }
5626
5627            next_offset += envelope_size;
5628            _next_ordinal_to_read += 1;
5629            if next_offset >= end_offset {
5630                return Ok(());
5631            }
5632
5633            // Decode unknown envelopes for gaps in ordinals.
5634            while _next_ordinal_to_read < 6 {
5635                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5636                _next_ordinal_to_read += 1;
5637                next_offset += envelope_size;
5638            }
5639
5640            let next_out_of_line = decoder.next_out_of_line();
5641            let handles_before = decoder.remaining_handles();
5642            if let Some((inlined, num_bytes, num_handles)) =
5643                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5644            {
5645                let member_inline_size =
5646                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5647                if inlined != (member_inline_size <= 4) {
5648                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5649                }
5650                let inner_offset;
5651                let mut inner_depth = depth.clone();
5652                if inlined {
5653                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5654                    inner_offset = next_offset;
5655                } else {
5656                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5657                    inner_depth.increment()?;
5658                }
5659                let val_ref = self.irq_preempts.get_or_insert_with(|| fidl::new_empty!(u64, D));
5660                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5661                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5662                {
5663                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5664                }
5665                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5666                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5667                }
5668            }
5669
5670            next_offset += envelope_size;
5671            _next_ordinal_to_read += 1;
5672            if next_offset >= end_offset {
5673                return Ok(());
5674            }
5675
5676            // Decode unknown envelopes for gaps in ordinals.
5677            while _next_ordinal_to_read < 7 {
5678                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5679                _next_ordinal_to_read += 1;
5680                next_offset += envelope_size;
5681            }
5682
5683            let next_out_of_line = decoder.next_out_of_line();
5684            let handles_before = decoder.remaining_handles();
5685            if let Some((inlined, num_bytes, num_handles)) =
5686                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5687            {
5688                let member_inline_size =
5689                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5690                if inlined != (member_inline_size <= 4) {
5691                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5692                }
5693                let inner_offset;
5694                let mut inner_depth = depth.clone();
5695                if inlined {
5696                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5697                    inner_offset = next_offset;
5698                } else {
5699                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5700                    inner_depth.increment()?;
5701                }
5702                let val_ref = self.yields.get_or_insert_with(|| fidl::new_empty!(u64, D));
5703                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5704                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5705                {
5706                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5707                }
5708                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5709                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5710                }
5711            }
5712
5713            next_offset += envelope_size;
5714            _next_ordinal_to_read += 1;
5715            if next_offset >= end_offset {
5716                return Ok(());
5717            }
5718
5719            // Decode unknown envelopes for gaps in ordinals.
5720            while _next_ordinal_to_read < 8 {
5721                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5722                _next_ordinal_to_read += 1;
5723                next_offset += envelope_size;
5724            }
5725
5726            let next_out_of_line = decoder.next_out_of_line();
5727            let handles_before = decoder.remaining_handles();
5728            if let Some((inlined, num_bytes, num_handles)) =
5729                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5730            {
5731                let member_inline_size =
5732                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5733                if inlined != (member_inline_size <= 4) {
5734                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5735                }
5736                let inner_offset;
5737                let mut inner_depth = depth.clone();
5738                if inlined {
5739                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5740                    inner_offset = next_offset;
5741                } else {
5742                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5743                    inner_depth.increment()?;
5744                }
5745                let val_ref = self.ints.get_or_insert_with(|| fidl::new_empty!(u64, D));
5746                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5747                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5748                {
5749                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5750                }
5751                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5752                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5753                }
5754            }
5755
5756            next_offset += envelope_size;
5757            _next_ordinal_to_read += 1;
5758            if next_offset >= end_offset {
5759                return Ok(());
5760            }
5761
5762            // Decode unknown envelopes for gaps in ordinals.
5763            while _next_ordinal_to_read < 9 {
5764                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5765                _next_ordinal_to_read += 1;
5766                next_offset += envelope_size;
5767            }
5768
5769            let next_out_of_line = decoder.next_out_of_line();
5770            let handles_before = decoder.remaining_handles();
5771            if let Some((inlined, num_bytes, num_handles)) =
5772                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5773            {
5774                let member_inline_size =
5775                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5776                if inlined != (member_inline_size <= 4) {
5777                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5778                }
5779                let inner_offset;
5780                let mut inner_depth = depth.clone();
5781                if inlined {
5782                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5783                    inner_offset = next_offset;
5784                } else {
5785                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5786                    inner_depth.increment()?;
5787                }
5788                let val_ref = self.timer_ints.get_or_insert_with(|| fidl::new_empty!(u64, D));
5789                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5790                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5791                {
5792                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5793                }
5794                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5795                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5796                }
5797            }
5798
5799            next_offset += envelope_size;
5800            _next_ordinal_to_read += 1;
5801            if next_offset >= end_offset {
5802                return Ok(());
5803            }
5804
5805            // Decode unknown envelopes for gaps in ordinals.
5806            while _next_ordinal_to_read < 10 {
5807                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5808                _next_ordinal_to_read += 1;
5809                next_offset += envelope_size;
5810            }
5811
5812            let next_out_of_line = decoder.next_out_of_line();
5813            let handles_before = decoder.remaining_handles();
5814            if let Some((inlined, num_bytes, num_handles)) =
5815                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5816            {
5817                let member_inline_size =
5818                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5819                if inlined != (member_inline_size <= 4) {
5820                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5821                }
5822                let inner_offset;
5823                let mut inner_depth = depth.clone();
5824                if inlined {
5825                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5826                    inner_offset = next_offset;
5827                } else {
5828                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5829                    inner_depth.increment()?;
5830                }
5831                let val_ref = self.timers.get_or_insert_with(|| fidl::new_empty!(u64, D));
5832                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5833                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5834                {
5835                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5836                }
5837                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5838                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5839                }
5840            }
5841
5842            next_offset += envelope_size;
5843            _next_ordinal_to_read += 1;
5844            if next_offset >= end_offset {
5845                return Ok(());
5846            }
5847
5848            // Decode unknown envelopes for gaps in ordinals.
5849            while _next_ordinal_to_read < 11 {
5850                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5851                _next_ordinal_to_read += 1;
5852                next_offset += envelope_size;
5853            }
5854
5855            let next_out_of_line = decoder.next_out_of_line();
5856            let handles_before = decoder.remaining_handles();
5857            if let Some((inlined, num_bytes, num_handles)) =
5858                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5859            {
5860                let member_inline_size =
5861                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5862                if inlined != (member_inline_size <= 4) {
5863                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5864                }
5865                let inner_offset;
5866                let mut inner_depth = depth.clone();
5867                if inlined {
5868                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5869                    inner_offset = next_offset;
5870                } else {
5871                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5872                    inner_depth.increment()?;
5873                }
5874                let val_ref = self.page_faults.get_or_insert_with(|| fidl::new_empty!(u64, D));
5875                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5876                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5877                {
5878                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5879                }
5880                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5881                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5882                }
5883            }
5884
5885            next_offset += envelope_size;
5886            _next_ordinal_to_read += 1;
5887            if next_offset >= end_offset {
5888                return Ok(());
5889            }
5890
5891            // Decode unknown envelopes for gaps in ordinals.
5892            while _next_ordinal_to_read < 12 {
5893                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5894                _next_ordinal_to_read += 1;
5895                next_offset += envelope_size;
5896            }
5897
5898            let next_out_of_line = decoder.next_out_of_line();
5899            let handles_before = decoder.remaining_handles();
5900            if let Some((inlined, num_bytes, num_handles)) =
5901                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5902            {
5903                let member_inline_size =
5904                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5905                if inlined != (member_inline_size <= 4) {
5906                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5907                }
5908                let inner_offset;
5909                let mut inner_depth = depth.clone();
5910                if inlined {
5911                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5912                    inner_offset = next_offset;
5913                } else {
5914                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5915                    inner_depth.increment()?;
5916                }
5917                let val_ref = self.exceptions.get_or_insert_with(|| fidl::new_empty!(u64, D));
5918                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5919                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5920                {
5921                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5922                }
5923                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5924                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5925                }
5926            }
5927
5928            next_offset += envelope_size;
5929            _next_ordinal_to_read += 1;
5930            if next_offset >= end_offset {
5931                return Ok(());
5932            }
5933
5934            // Decode unknown envelopes for gaps in ordinals.
5935            while _next_ordinal_to_read < 13 {
5936                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5937                _next_ordinal_to_read += 1;
5938                next_offset += envelope_size;
5939            }
5940
5941            let next_out_of_line = decoder.next_out_of_line();
5942            let handles_before = decoder.remaining_handles();
5943            if let Some((inlined, num_bytes, num_handles)) =
5944                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5945            {
5946                let member_inline_size =
5947                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5948                if inlined != (member_inline_size <= 4) {
5949                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5950                }
5951                let inner_offset;
5952                let mut inner_depth = depth.clone();
5953                if inlined {
5954                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5955                    inner_offset = next_offset;
5956                } else {
5957                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5958                    inner_depth.increment()?;
5959                }
5960                let val_ref = self.syscalls.get_or_insert_with(|| fidl::new_empty!(u64, D));
5961                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5962                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5963                {
5964                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5965                }
5966                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5967                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5968                }
5969            }
5970
5971            next_offset += envelope_size;
5972            _next_ordinal_to_read += 1;
5973            if next_offset >= end_offset {
5974                return Ok(());
5975            }
5976
5977            // Decode unknown envelopes for gaps in ordinals.
5978            while _next_ordinal_to_read < 14 {
5979                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5980                _next_ordinal_to_read += 1;
5981                next_offset += envelope_size;
5982            }
5983
5984            let next_out_of_line = decoder.next_out_of_line();
5985            let handles_before = decoder.remaining_handles();
5986            if let Some((inlined, num_bytes, num_handles)) =
5987                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5988            {
5989                let member_inline_size =
5990                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5991                if inlined != (member_inline_size <= 4) {
5992                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5993                }
5994                let inner_offset;
5995                let mut inner_depth = depth.clone();
5996                if inlined {
5997                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5998                    inner_offset = next_offset;
5999                } else {
6000                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6001                    inner_depth.increment()?;
6002                }
6003                let val_ref = self.reschedule_ipis.get_or_insert_with(|| fidl::new_empty!(u64, D));
6004                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
6005                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6006                {
6007                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6008                }
6009                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6010                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6011                }
6012            }
6013
6014            next_offset += envelope_size;
6015            _next_ordinal_to_read += 1;
6016            if next_offset >= end_offset {
6017                return Ok(());
6018            }
6019
6020            // Decode unknown envelopes for gaps in ordinals.
6021            while _next_ordinal_to_read < 15 {
6022                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6023                _next_ordinal_to_read += 1;
6024                next_offset += envelope_size;
6025            }
6026
6027            let next_out_of_line = decoder.next_out_of_line();
6028            let handles_before = decoder.remaining_handles();
6029            if let Some((inlined, num_bytes, num_handles)) =
6030                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6031            {
6032                let member_inline_size =
6033                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6034                if inlined != (member_inline_size <= 4) {
6035                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6036                }
6037                let inner_offset;
6038                let mut inner_depth = depth.clone();
6039                if inlined {
6040                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6041                    inner_offset = next_offset;
6042                } else {
6043                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6044                    inner_depth.increment()?;
6045                }
6046                let val_ref = self.generic_ipis.get_or_insert_with(|| fidl::new_empty!(u64, D));
6047                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
6048                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6049                {
6050                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6051                }
6052                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6053                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6054                }
6055            }
6056
6057            next_offset += envelope_size;
6058
6059            // Decode the remaining unknown envelopes.
6060            while next_offset < end_offset {
6061                _next_ordinal_to_read += 1;
6062                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6063                next_offset += envelope_size;
6064            }
6065
6066            Ok(())
6067        }
6068    }
6069}