fidl_fuchsia_fuzzer__common/
fidl_fuchsia_fuzzer__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/// Marker indicating the last message in a diagnostic output stream.
12///
13/// In addition to an `Artifact`, long-running workflows may also produce the
14/// standard output, standard error, and system logs. These fuzzer output
15/// streams are provided by `fuchsia.test_manager/SuiteRunner` and have no
16/// guaranteed order with respect to FIDL responses. As a result, the streams
17/// need to include an "in-band" signal that indicates when they are complete
18/// for a particular workflow. Clients processing the fuzzer output may use this
19/// marker to synchronize the streams and the FIDL response for `GetArtifact`.
20///
21/// The string is intentionally somewhat long to mitigate the likelihood of it
22/// being emitted by the code under test.
23pub const DONE_MARKER: &str =
24    "DONE: A long-running `fuchsia.fuzzer.Controller` workflow is complete.";
25
26/// Command line flag requesting fuzzing to be performed.
27///
28/// This flag is passed by the `fuzz_manager` to the `test_manager` when
29/// starting fuzzers. Since the fuzzers are run as part of the Test Runner
30/// Framework, they can be started by normal test workflows, e.g. `fx test`. The
31/// presence of this flag indicates the fuzzer is being started to perform
32/// fuzzing; in its absence the fuzzer should simply execute a bounded number of
33/// inputs as a test.
34pub const FUZZ_MODE: &str = "--fuzz";
35
36/// Maximum length of a vector of CoverageData structs.
37///
38/// This value matches the maximum number of LLVM modules libFuzzer can track.
39pub const MAX_COVERAGE_DATA: u64 = 4096;
40
41pub const MAX_PARAMETERS: u16 = 128;
42
43pub const MAX_PARAMETER_LEN: u16 = 256;
44
45/// The maximum number of processes for which stats will be returned via
46/// `Status`.
47pub const MAX_PROCESS_STATS: u16 = 256;
48
49/// Maximum length of a sanitizer options environment variable name.
50///
51/// `sanitizer_options.name` must be something like "...SAN_OPTIONS". The
52/// longest name currently supported on Fuchsia is "UBSAN_OPTIONS". The longest
53/// currently supported on any platform is "HWASAN_OPTIONS".
54pub const MAX_SANITIZER_OPTIONS_NAME_SIZE: u16 = 32;
55
56/// Maximum length of a sanitizer options environment variable value.
57///
58/// `sanitizer_options.value` is a concatenation of "<key>=<value>" pairs
59/// delimited by ':'. AddressSanitizer currently has the most flags, with ~40
60/// sanitizer specific ones and ~70 common ones. Most of these are either
61/// boolean values or short integers. The only long types of flags are paths,
62/// but none these of these are supported on Fuchsia.
63pub const MAX_SANITIZER_OPTIONS_VALUE_SIZE: u16 = 8192;
64
65bitflags! {
66    /// Specifies how a fuzzing engine should configure output streams.
67    ///
68    /// Flags may be combined, e.g. `CLOSE_STDOUT | CLOSE_STDERR`. Support for each
69    /// flag is engine-specific. Specifying an unsupported output mode flag may
70    /// cause `Controller.Configure` to return `ZX_ERR_NOT_SUPPORTED`.
71    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
72    pub struct OutputFlags: u32 {
73        /// Suppress standard output from the engine process. This is analogous to
74        /// libFuzzer's `-close_fd_mask=1`.
75        const CLOSE_STDOUT = 1;
76        /// Suppress standard error from the engine process. Use with care: this may
77        /// remove diagnostic output from the target code (e.g. messages on assert
78        /// failure). This is analogous to libFuzzer's `-close_fd_mask=2`.
79        const CLOSE_STDERR = 2;
80        /// Produce more verbose output from the fuzzer engine. The exact meaning of
81        /// "more verbose" is engine-specific. This is analogous to libFuzzer's
82        /// `-verbosity=2`.
83        const VERBOSE = 4;
84        /// Produce libFuzzer-style output on standard error. This facilitates
85        /// integration with systems like ClusterFuzz.
86        /// See https://llvm.org/docs/LibFuzzer.html#output for example output.
87        const LIBFUZZER = 8;
88    }
89}
90
91impl OutputFlags {}
92
93/// See |Controller.GetCorpusWriter| and |Controller.GetCorpusReader|.
94#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
95pub enum Corpus {
96    /// Indicates a set of fixed, immutable inputs typically provided at
97    /// start-up. These inputs are never discarded when merging.
98    Seed,
99    /// Indicates a set of inputs generated by the fuzzer. These may be modified
100    /// and/or discarded when merging and minimizing the corpus.
101    Live,
102    #[doc(hidden)]
103    __SourceBreaking { unknown_ordinal: u8 },
104}
105
106/// Pattern that matches an unknown `Corpus` member.
107#[macro_export]
108macro_rules! CorpusUnknown {
109    () => {
110        _
111    };
112}
113
114impl Corpus {
115    #[inline]
116    pub fn from_primitive(prim: u8) -> Option<Self> {
117        match prim {
118            1 => Some(Self::Seed),
119            2 => Some(Self::Live),
120            _ => None,
121        }
122    }
123
124    #[inline]
125    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
126        match prim {
127            1 => Self::Seed,
128            2 => Self::Live,
129            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
130        }
131    }
132
133    #[inline]
134    pub fn unknown() -> Self {
135        Self::__SourceBreaking { unknown_ordinal: 0xff }
136    }
137
138    #[inline]
139    pub const fn into_primitive(self) -> u8 {
140        match self {
141            Self::Seed => 1,
142            Self::Live => 2,
143            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
144        }
145    }
146
147    #[inline]
148    pub fn is_unknown(&self) -> bool {
149        match self {
150            Self::__SourceBreaking { unknown_ordinal: _ } => true,
151            _ => false,
152        }
153    }
154}
155
156/// Indicates the result of a long-running fuzzing workflow.
157///
158/// Fuzzers have several "long-running" workflows; that is, the fuzzer may
159/// perform actions for an indefinite period of time. Fuzzing itself is the most
160/// notable example, as the fuzzing engine may continuously generate new inputs
161/// until an error is found. This workflow is represented by the `Fuzz` method
162/// below. Other long-running workflows include `TryOne`, `Cleanse`, `Minimize`
163/// and `Merge`.
164///
165/// These workflows continue executing after their associated call returns. Only
166/// one workflow at a time may be executing. Callers can use `AddMonitor` to
167/// monitor the status of the workflow, and `GetArtifact` to retrieve the
168/// `Result` and optionally associated `Input` when it completes.
169#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
170pub enum Result_ {
171    /// The associated input did not cause any errors to be detected when tried.
172    NoErrors,
173    /// Trying the associated input triggered a memory allocation by an
174    /// instrumented process that exceeded the configured limit.  Some fuzzing
175    /// engines, such as libFuzzer, may not distinguish between this result and
176    /// `OOM`. To differentiate,  examine the fuzzer output.
177    BadMalloc,
178    /// Trying the associated input triggered an exception in an instrumented
179    /// process.
180    Crash,
181    /// Trying the associated input triggered an error in an instrumented
182    /// process that was detected by a sanitizer runtime.
183    Death,
184    /// Trying the associated input caused an instrumented process to exit
185    /// unexpectedly. Some fuzzing engines such as libFuzzer may combine this
186    /// result with `CRASH`. To differentiate, examine the fuzzer output.
187    Exit,
188    /// Trying the associated input triggered a memory leak in an instrumented
189    /// process.
190    Leak,
191    /// Trying the associated input caused an instrumented process's memory
192    /// usage to exceed the configured limit.
193    Oom,
194    /// Trying the associated input took longer than the configured limit.
195    Timeout,
196    /// The associated input was produced by finding the shortest input that
197    /// produces the same error as an original input. See `Minimize`.
198    Minimized,
199    /// The associated input was produced by replacing bytes in an original
200    /// input with PII-free values while preserving the error produced. See
201    /// `Cleanse`.
202    Cleansed,
203    /// The fuzzer corpus has been compacted to only include the shortest inputs
204    /// that preserve overall coverage. This workflow does not have an
205    /// associated input. See `Merge`.
206    Merged,
207    #[doc(hidden)]
208    __SourceBreaking { unknown_ordinal: u32 },
209}
210
211/// Pattern that matches an unknown `Result_` member.
212#[macro_export]
213macro_rules! Result_Unknown {
214    () => {
215        _
216    };
217}
218
219impl Result_ {
220    #[inline]
221    pub fn from_primitive(prim: u32) -> Option<Self> {
222        match prim {
223            1 => Some(Self::NoErrors),
224            2 => Some(Self::BadMalloc),
225            3 => Some(Self::Crash),
226            4 => Some(Self::Death),
227            5 => Some(Self::Exit),
228            6 => Some(Self::Leak),
229            7 => Some(Self::Oom),
230            8 => Some(Self::Timeout),
231            9 => Some(Self::Minimized),
232            10 => Some(Self::Cleansed),
233            11 => Some(Self::Merged),
234            _ => None,
235        }
236    }
237
238    #[inline]
239    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
240        match prim {
241            1 => Self::NoErrors,
242            2 => Self::BadMalloc,
243            3 => Self::Crash,
244            4 => Self::Death,
245            5 => Self::Exit,
246            6 => Self::Leak,
247            7 => Self::Oom,
248            8 => Self::Timeout,
249            9 => Self::Minimized,
250            10 => Self::Cleansed,
251            11 => Self::Merged,
252            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
253        }
254    }
255
256    #[inline]
257    pub fn unknown() -> Self {
258        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
259    }
260
261    #[inline]
262    pub const fn into_primitive(self) -> u32 {
263        match self {
264            Self::NoErrors => 1,
265            Self::BadMalloc => 2,
266            Self::Crash => 3,
267            Self::Death => 4,
268            Self::Exit => 5,
269            Self::Leak => 6,
270            Self::Oom => 7,
271            Self::Timeout => 8,
272            Self::Minimized => 9,
273            Self::Cleansed => 10,
274            Self::Merged => 11,
275            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
276        }
277    }
278
279    #[inline]
280    pub fn is_unknown(&self) -> bool {
281        match self {
282            Self::__SourceBreaking { unknown_ordinal: _ } => true,
283            _ => false,
284        }
285    }
286}
287
288/// Represents types of fuzzer output.
289///
290/// These correspond to the subset of the `fuchsia.test_manager/Artifact`s that
291/// `fuzz_manager` can forward. The name "artifact" is avoided due to its
292/// distinct meaning for fuzzers; namely, `fuchsia.fuzzer.Artifact`.
293#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
294pub enum TestOutput {
295    /// Standard output from fuzzer.
296    Stdout,
297    /// Standard error from fuzzer.
298    Stderr,
299    /// System logs from fuzzer.
300    Syslog,
301    #[doc(hidden)]
302    __SourceBreaking { unknown_ordinal: u32 },
303}
304
305/// Pattern that matches an unknown `TestOutput` member.
306#[macro_export]
307macro_rules! TestOutputUnknown {
308    () => {
309        _
310    };
311}
312
313impl TestOutput {
314    #[inline]
315    pub fn from_primitive(prim: u32) -> Option<Self> {
316        match prim {
317            1 => Some(Self::Stdout),
318            2 => Some(Self::Stderr),
319            3 => Some(Self::Syslog),
320            _ => None,
321        }
322    }
323
324    #[inline]
325    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
326        match prim {
327            1 => Self::Stdout,
328            2 => Self::Stderr,
329            3 => Self::Syslog,
330            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
331        }
332    }
333
334    #[inline]
335    pub fn unknown() -> Self {
336        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
337    }
338
339    #[inline]
340    pub const fn into_primitive(self) -> u32 {
341        match self {
342            Self::Stdout => 1,
343            Self::Stderr => 2,
344            Self::Syslog => 3,
345            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
346        }
347    }
348
349    #[inline]
350    pub fn is_unknown(&self) -> bool {
351        match self {
352            Self::__SourceBreaking { unknown_ordinal: _ } => true,
353            _ => false,
354        }
355    }
356}
357
358/// See `Controller.Monitor`. Used to indicate why an update was sent.
359#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
360pub enum UpdateReason {
361    /// Represents an otherwise unspecified update. Useful when integrating
362    /// other engines as runners, e.g. libFuzzer.
363    Misc,
364    /// A fuzzing action is starting. See, e.g. `Controller.Fuzz`,
365    /// `Controller.Merge`, etc.
366    Init,
367    /// An input produced new feedback.
368    New,
369    /// Periodic status update, configured with `Options.pulse_interval`.
370    Pulse,
371    /// A shorter input for some particular feedback has been found.
372    Reduce,
373    /// A fuzzing action is complete.
374    Done,
375    #[doc(hidden)]
376    __SourceBreaking { unknown_ordinal: u8 },
377}
378
379/// Pattern that matches an unknown `UpdateReason` member.
380#[macro_export]
381macro_rules! UpdateReasonUnknown {
382    () => {
383        _
384    };
385}
386
387impl UpdateReason {
388    #[inline]
389    pub fn from_primitive(prim: u8) -> Option<Self> {
390        match prim {
391            1 => Some(Self::Misc),
392            2 => Some(Self::Init),
393            3 => Some(Self::New),
394            4 => Some(Self::Pulse),
395            5 => Some(Self::Reduce),
396            6 => Some(Self::Done),
397            _ => None,
398        }
399    }
400
401    #[inline]
402    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
403        match prim {
404            1 => Self::Misc,
405            2 => Self::Init,
406            3 => Self::New,
407            4 => Self::Pulse,
408            5 => Self::Reduce,
409            6 => Self::Done,
410            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
411        }
412    }
413
414    #[inline]
415    pub fn unknown() -> Self {
416        Self::__SourceBreaking { unknown_ordinal: 0xff }
417    }
418
419    #[inline]
420    pub const fn into_primitive(self) -> u8 {
421        match self {
422            Self::Misc => 1,
423            Self::Init => 2,
424            Self::New => 3,
425            Self::Pulse => 4,
426            Self::Reduce => 5,
427            Self::Done => 6,
428            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
429        }
430    }
431
432    #[inline]
433    pub fn is_unknown(&self) -> bool {
434        match self {
435            Self::__SourceBreaking { unknown_ordinal: _ } => true,
436            _ => false,
437        }
438    }
439}
440
441#[derive(Clone, Debug, PartialEq)]
442pub struct ControllerConfigureRequest {
443    pub options: Options,
444}
445
446impl fidl::Persistable for ControllerConfigureRequest {}
447
448#[derive(Clone, Debug, PartialEq)]
449pub struct ControllerGetOptionsResponse {
450    pub options: Options,
451}
452
453impl fidl::Persistable for ControllerGetOptionsResponse {}
454
455#[derive(Clone, Debug, PartialEq)]
456pub struct ControllerGetStatusResponse {
457    pub status: Status,
458}
459
460impl fidl::Persistable for ControllerGetStatusResponse {}
461
462#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
463#[repr(C)]
464pub struct CorpusReaderNextResponse {
465    pub result: i32,
466}
467
468impl fidl::Persistable for CorpusReaderNextResponse {}
469
470#[derive(Clone, Debug, PartialEq)]
471pub struct CoverageDataCollectorInitializeResponse {
472    pub options: Options,
473}
474
475impl fidl::Persistable for CoverageDataCollectorInitializeResponse {}
476
477#[derive(Clone, Debug, PartialEq)]
478pub struct CoverageDataProviderSetOptionsRequest {
479    pub options: Options,
480}
481
482impl fidl::Persistable for CoverageDataProviderSetOptionsRequest {}
483
484#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
485pub struct ManagerStopRequest {
486    pub fuzzer_url: String,
487}
488
489impl fidl::Persistable for ManagerStopRequest {}
490
491#[derive(Clone, Debug, PartialEq)]
492pub struct MonitorUpdateRequest {
493    pub reason: UpdateReason,
494    pub status: Status,
495}
496
497impl fidl::Persistable for MonitorUpdateRequest {}
498
499/// Details about an instrumented process.
500///
501/// See also:
502///
503/// * https://fuchsia.dev/fuchsia-src/reference/syscalls/object_get_info#zx_info_task_stats
504/// * https://fuchsia.dev/fuchsia-src/reference/syscalls/object_get_info#zx_info_task_runtime
505#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
506#[repr(C)]
507pub struct ProcessStats {
508    /// The kernel object identifier of the task.
509    pub koid: u64,
510    /// The total size of mapped memory ranges in this process.
511    pub mem_mapped_bytes: u64,
512    /// Committed memory that is only mapped into this process.
513    pub mem_private_bytes: u64,
514    /// Committed memory that is mapped into this and at least one other
515    /// process.
516    pub mem_shared_bytes: u64,
517    /// Estimate of how much of |mem_shared_bytes| that this process owns.
518    pub mem_scaled_shared_bytes: u64,
519    /// The total amount of time this process was running on a CPU and not
520    /// blocked.
521    pub cpu_time: i64,
522    /// The total amount of time this process was ready but not actually using a
523    /// CPU.
524    pub queue_time: i64,
525    /// The total amount of time this process spent handling page faults.
526    pub page_fault_time: i64,
527    /// The total amount of time this process spent waiting on contended kernel
528    /// locks.
529    pub lock_contention_time: i64,
530}
531
532impl fidl::Persistable for ProcessStats {}
533
534#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
535pub struct RegistryDisconnectRequest {
536    pub fuzzer_url: String,
537}
538
539impl fidl::Persistable for RegistryDisconnectRequest {}
540
541/// Corresponds to sanitizer enviroment variables.
542///
543/// The options are ignored unless `name` must end in "...SAN_OPTIONS", e.g.
544/// "ASAN_OPTIONS". `value` should be a ':'-delimited list of options, e.g.
545/// "verbosity=1:malloc_context_size=20".
546///
547/// For more details, see the following:
548///
549/// * https://github.com/google/sanitizers/wiki/SanitizerCommonFlags
550/// * https://github.com/google/sanitizers/wiki/AddressSanitizerFlags
551#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
552pub struct SanitizerOptions {
553    pub name: String,
554    pub value: String,
555}
556
557impl fidl::Persistable for SanitizerOptions {}
558
559#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
560pub struct TargetAdapterGetParametersResponse {
561    pub parameters: Vec<String>,
562}
563
564impl fidl::Persistable for TargetAdapterGetParametersResponse {}
565
566/// See `fuchsia.fuzzer.Controller/Configure`.
567#[derive(Clone, Debug, Default, PartialEq)]
568pub struct Options {
569    /// Perform this many fuzzing runs, then exit normally. If unset (or zero),
570    /// fuzz indefinitely.
571    pub runs: Option<u32>,
572    /// If non-zero, fuzz for this duration and then exit normally. If zero,
573    /// fuzz indefinitely. Defaults to 0.
574    pub max_total_time: Option<i64>,
575    /// PRNG seed to use when generating inputs. The same seed for the same
576    /// target should produce the same inputs. If zero, the current ticks will
577    /// be used. Defaults to 0.
578    pub seed: Option<u32>,
579    /// If non-zero, limit the maximum size of a test input to this size, in
580    /// bytes. Use 0 to disable the limit. Defaults to 1 MB.
581    pub max_input_size: Option<u64>,
582    /// Maximum number of consecutive mutations to apply to an input. Defaults
583    /// to 5.
584    pub mutation_depth: Option<u16>,
585    /// If an AFL-style dictionary is supplied using
586    /// `Controller.WriteDictionary`, include words up to this level. Defaults
587    /// to 0, i.e. words without an explicit level.
588    pub dictionary_level: Option<u16>,
589    /// If true, treat instrumented process exits as fuzzing errors. Defaults to
590    /// false.
591    pub detect_exits: Option<bool>,
592    /// If true, and ASan or LSan are available, try to detect memory leaks.
593    /// Defaults to false. Leak detection can be expensive, so it is recommended
594    /// to first develop a corpus that covers a reasonable amount of the code
595    /// under test before attempting to detect leaks.
596    pub detect_leaks: Option<bool>,
597    /// If non-zero, any run that takes longer than this duration will raise a
598    /// TIMEOUT error. Use 0 to disable the limit. Defaults to 20 minutes.
599    pub run_limit: Option<i64>,
600    /// If non-zero, any allocation over this size in bytes will raise a
601    /// BAD_MALLOC error. Use 0 to disable the limit. Defaults to 2 GB.
602    pub malloc_limit: Option<u64>,
603    /// If non-zero, any process that uses more than this amount of memory in
604    /// bytes will raise an OOM error. Use 0 to disable the limit. Defaults to
605    /// 2 GB.
606    pub oom_limit: Option<u64>,
607    /// If non-zero, purge the sanitizer's allocator quarantine and reclaim
608    /// memory periodically between runs after an interval of this many seconds.
609    /// Use 0 to disable allocator purging. Defaults to 1 second.
610    pub purge_interval: Option<i64>,
611    /// Exit code used by the instrumented process if it encounters a bad
612    /// allocation. Set this if the target already uses the default for another
613    /// reason. Defaults to 2000.
614    pub malloc_exitcode: Option<i32>,
615    /// Exit code used by the instrumented process if it encounters a sanitizer
616    /// error. Set this if the target already uses the default for another
617    /// reason. Defaults to 2001.
618    pub death_exitcode: Option<i32>,
619    /// Exit code used by the instrumented process if it encounters a leak. Set
620    /// this if the target already uses the default for another reason. Defaults
621    /// to 2002.
622    pub leak_exitcode: Option<i32>,
623    /// Exit code used by the instrumented process if it exceeds the OOM limit.
624    /// Set this if the target already uses the default for another reason.
625    /// Defaults to 2003.
626    pub oom_exitcode: Option<i32>,
627    /// If non-zero, the engine will periodically update any added monitors
628    /// after this duration. Defaults to 20 seconds.
629    pub pulse_interval: Option<i64>,
630    /// If true, allow a debugger like `zxdb` to be attached to an instrumented
631    /// process. This may interfere with the engine's ability to detect
632    /// exceptions and is not recommended when fuzzing. It can be useful when
633    /// reproducing an error with a known error-causing input. Defaults to
634    /// false.
635    pub debug: Option<bool>,
636    /// If true, include ClusterFuzz-compatible final statistics in the output
637    /// of a call to `fuchsia.fuzzer.Controller/WatchArtifact`.
638    pub print_final_stats: Option<bool>,
639    /// If true, also use data flow traces as part of the fuzzing coverage data.
640    /// See https://clang.llvm.org/docs/SanitizerCoverage.html#tracing-data-flow
641    /// for more details.
642    pub use_value_profile: Option<bool>,
643    /// Sanitizer options. See `SanitizerOptions`.
644    pub sanitizer_options: Option<SanitizerOptions>,
645    /// Output flags. See `OutputFlags`.
646    pub output_flags: Option<OutputFlags>,
647    #[doc(hidden)]
648    pub __source_breaking: fidl::marker::SourceBreaking,
649}
650
651impl fidl::Persistable for Options {}
652
653/// See `Controller.GetStatus`.
654#[derive(Clone, Debug, Default, PartialEq)]
655pub struct Status {
656    /// True if the fuzzer is working on a commands, e.g. it is fuzzing.
657    pub running: Option<bool>,
658    /// Number of runs performed so far.
659    pub runs: Option<u32>,
660    /// Time spent so far.
661    pub elapsed: Option<i64>,
662    /// Number of program edges covered so far.
663    pub covered_pcs: Option<u64>,
664    /// Number of opaque features encountered so far.
665    pub covered_features: Option<u64>,
666    /// Number of inputs in the "live" corpus.
667    pub corpus_num_inputs: Option<u64>,
668    /// Total size of the inputs in the "live" corpus.
669    pub corpus_total_size: Option<u64>,
670    /// Information about the instrumented processes attached to the engine.
671    pub process_stats: Option<Vec<ProcessStats>>,
672    #[doc(hidden)]
673    pub __source_breaking: fidl::marker::SourceBreaking,
674}
675
676impl fidl::Persistable for Status {}
677
678pub mod controller_ordinals {
679    pub const CONFIGURE: u64 = 0x35c8cba7fa3d32e4;
680    pub const GET_OPTIONS: u64 = 0x683d93332504b9cd;
681    pub const ADD_TO_CORPUS: u64 = 0x7bdf8336ab534cee;
682    pub const READ_CORPUS: u64 = 0x501279b430b34514;
683    pub const WRITE_DICTIONARY: u64 = 0x4ecfc1274fe4a70b;
684    pub const READ_DICTIONARY: u64 = 0x1be6724c87b51c37;
685    pub const ADD_MONITOR: u64 = 0x2efbf7d3dc21438e;
686    pub const FUZZ: u64 = 0x62fe3684ea23af62;
687    pub const TRY_ONE: u64 = 0x368dc762d8e16d46;
688    pub const MINIMIZE: u64 = 0x105a242ee0552794;
689    pub const CLEANSE: u64 = 0x6d7892f62735f3e0;
690    pub const MERGE: u64 = 0x3614e5c39413b5eb;
691    pub const GET_STATUS: u64 = 0x51db4975d93ce768;
692    pub const WATCH_ARTIFACT: u64 = 0x6cfca3730944a414;
693}
694
695pub mod controller_provider_ordinals {
696    pub const CONNECT: u64 = 0xc0325f0732defcb;
697    pub const STOP: u64 = 0x6cd6a98fc38bcbf2;
698}
699
700pub mod corpus_reader_ordinals {
701    pub const NEXT: u64 = 0x68d19e55ea635356;
702}
703
704pub mod coverage_data_collector_ordinals {
705    pub const INITIALIZE: u64 = 0x51d6f91d6f02d9d6;
706    pub const ADD_INLINE8BIT_COUNTERS: u64 = 0x75f87cadfc94d1be;
707}
708
709pub mod coverage_data_provider_ordinals {
710    pub const SET_OPTIONS: u64 = 0x4873c4a5c7683384;
711    pub const WATCH_COVERAGE_DATA: u64 = 0x34a92fc9c73bea5a;
712}
713
714pub mod manager_ordinals {
715    pub const CONNECT: u64 = 0x1620cd742a89f064;
716    pub const GET_OUTPUT: u64 = 0x755c28eecf20a88d;
717    pub const STOP: u64 = 0x27e53d86badd21f3;
718}
719
720pub mod monitor_ordinals {
721    pub const UPDATE: u64 = 0x7c773b93c1e6080f;
722}
723
724pub mod registrar_ordinals {
725    pub const REGISTER: u64 = 0x1716ac38e74b2840;
726}
727
728pub mod registry_ordinals {
729    pub const CONNECT: u64 = 0x5128cb31967a446f;
730    pub const DISCONNECT: u64 = 0x7bb4b7591146d4cb;
731}
732
733pub mod target_adapter_ordinals {
734    pub const GET_PARAMETERS: u64 = 0x5c7e40a47f753e3e;
735    pub const CONNECT: u64 = 0x7ea603a119866618;
736}
737
738mod internal {
739    use super::*;
740    unsafe impl fidl::encoding::TypeMarker for OutputFlags {
741        type Owned = Self;
742
743        #[inline(always)]
744        fn inline_align(_context: fidl::encoding::Context) -> usize {
745            4
746        }
747
748        #[inline(always)]
749        fn inline_size(_context: fidl::encoding::Context) -> usize {
750            4
751        }
752    }
753
754    impl fidl::encoding::ValueTypeMarker for OutputFlags {
755        type Borrowed<'a> = Self;
756        #[inline(always)]
757        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
758            *value
759        }
760    }
761
762    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for OutputFlags {
763        #[inline]
764        unsafe fn encode(
765            self,
766            encoder: &mut fidl::encoding::Encoder<'_, D>,
767            offset: usize,
768            _depth: fidl::encoding::Depth,
769        ) -> fidl::Result<()> {
770            encoder.debug_check_bounds::<Self>(offset);
771            if self.bits() & Self::all().bits() != self.bits() {
772                return Err(fidl::Error::InvalidBitsValue);
773            }
774            encoder.write_num(self.bits(), offset);
775            Ok(())
776        }
777    }
778
779    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OutputFlags {
780        #[inline(always)]
781        fn new_empty() -> Self {
782            Self::empty()
783        }
784
785        #[inline]
786        unsafe fn decode(
787            &mut self,
788            decoder: &mut fidl::encoding::Decoder<'_, D>,
789            offset: usize,
790            _depth: fidl::encoding::Depth,
791        ) -> fidl::Result<()> {
792            decoder.debug_check_bounds::<Self>(offset);
793            let prim = decoder.read_num::<u32>(offset);
794            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
795            Ok(())
796        }
797    }
798    unsafe impl fidl::encoding::TypeMarker for Corpus {
799        type Owned = Self;
800
801        #[inline(always)]
802        fn inline_align(_context: fidl::encoding::Context) -> usize {
803            std::mem::align_of::<u8>()
804        }
805
806        #[inline(always)]
807        fn inline_size(_context: fidl::encoding::Context) -> usize {
808            std::mem::size_of::<u8>()
809        }
810
811        #[inline(always)]
812        fn encode_is_copy() -> bool {
813            false
814        }
815
816        #[inline(always)]
817        fn decode_is_copy() -> bool {
818            false
819        }
820    }
821
822    impl fidl::encoding::ValueTypeMarker for Corpus {
823        type Borrowed<'a> = Self;
824        #[inline(always)]
825        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
826            *value
827        }
828    }
829
830    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Corpus {
831        #[inline]
832        unsafe fn encode(
833            self,
834            encoder: &mut fidl::encoding::Encoder<'_, D>,
835            offset: usize,
836            _depth: fidl::encoding::Depth,
837        ) -> fidl::Result<()> {
838            encoder.debug_check_bounds::<Self>(offset);
839            encoder.write_num(self.into_primitive(), offset);
840            Ok(())
841        }
842    }
843
844    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Corpus {
845        #[inline(always)]
846        fn new_empty() -> Self {
847            Self::unknown()
848        }
849
850        #[inline]
851        unsafe fn decode(
852            &mut self,
853            decoder: &mut fidl::encoding::Decoder<'_, D>,
854            offset: usize,
855            _depth: fidl::encoding::Depth,
856        ) -> fidl::Result<()> {
857            decoder.debug_check_bounds::<Self>(offset);
858            let prim = decoder.read_num::<u8>(offset);
859
860            *self = Self::from_primitive_allow_unknown(prim);
861            Ok(())
862        }
863    }
864    unsafe impl fidl::encoding::TypeMarker for Result_ {
865        type Owned = Self;
866
867        #[inline(always)]
868        fn inline_align(_context: fidl::encoding::Context) -> usize {
869            std::mem::align_of::<u32>()
870        }
871
872        #[inline(always)]
873        fn inline_size(_context: fidl::encoding::Context) -> usize {
874            std::mem::size_of::<u32>()
875        }
876
877        #[inline(always)]
878        fn encode_is_copy() -> bool {
879            false
880        }
881
882        #[inline(always)]
883        fn decode_is_copy() -> bool {
884            false
885        }
886    }
887
888    impl fidl::encoding::ValueTypeMarker for Result_ {
889        type Borrowed<'a> = Self;
890        #[inline(always)]
891        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
892            *value
893        }
894    }
895
896    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Result_ {
897        #[inline]
898        unsafe fn encode(
899            self,
900            encoder: &mut fidl::encoding::Encoder<'_, D>,
901            offset: usize,
902            _depth: fidl::encoding::Depth,
903        ) -> fidl::Result<()> {
904            encoder.debug_check_bounds::<Self>(offset);
905            encoder.write_num(self.into_primitive(), offset);
906            Ok(())
907        }
908    }
909
910    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Result_ {
911        #[inline(always)]
912        fn new_empty() -> Self {
913            Self::unknown()
914        }
915
916        #[inline]
917        unsafe fn decode(
918            &mut self,
919            decoder: &mut fidl::encoding::Decoder<'_, D>,
920            offset: usize,
921            _depth: fidl::encoding::Depth,
922        ) -> fidl::Result<()> {
923            decoder.debug_check_bounds::<Self>(offset);
924            let prim = decoder.read_num::<u32>(offset);
925
926            *self = Self::from_primitive_allow_unknown(prim);
927            Ok(())
928        }
929    }
930    unsafe impl fidl::encoding::TypeMarker for TestOutput {
931        type Owned = Self;
932
933        #[inline(always)]
934        fn inline_align(_context: fidl::encoding::Context) -> usize {
935            std::mem::align_of::<u32>()
936        }
937
938        #[inline(always)]
939        fn inline_size(_context: fidl::encoding::Context) -> usize {
940            std::mem::size_of::<u32>()
941        }
942
943        #[inline(always)]
944        fn encode_is_copy() -> bool {
945            false
946        }
947
948        #[inline(always)]
949        fn decode_is_copy() -> bool {
950            false
951        }
952    }
953
954    impl fidl::encoding::ValueTypeMarker for TestOutput {
955        type Borrowed<'a> = Self;
956        #[inline(always)]
957        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
958            *value
959        }
960    }
961
962    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for TestOutput {
963        #[inline]
964        unsafe fn encode(
965            self,
966            encoder: &mut fidl::encoding::Encoder<'_, D>,
967            offset: usize,
968            _depth: fidl::encoding::Depth,
969        ) -> fidl::Result<()> {
970            encoder.debug_check_bounds::<Self>(offset);
971            encoder.write_num(self.into_primitive(), offset);
972            Ok(())
973        }
974    }
975
976    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TestOutput {
977        #[inline(always)]
978        fn new_empty() -> Self {
979            Self::unknown()
980        }
981
982        #[inline]
983        unsafe fn decode(
984            &mut self,
985            decoder: &mut fidl::encoding::Decoder<'_, D>,
986            offset: usize,
987            _depth: fidl::encoding::Depth,
988        ) -> fidl::Result<()> {
989            decoder.debug_check_bounds::<Self>(offset);
990            let prim = decoder.read_num::<u32>(offset);
991
992            *self = Self::from_primitive_allow_unknown(prim);
993            Ok(())
994        }
995    }
996    unsafe impl fidl::encoding::TypeMarker for UpdateReason {
997        type Owned = Self;
998
999        #[inline(always)]
1000        fn inline_align(_context: fidl::encoding::Context) -> usize {
1001            std::mem::align_of::<u8>()
1002        }
1003
1004        #[inline(always)]
1005        fn inline_size(_context: fidl::encoding::Context) -> usize {
1006            std::mem::size_of::<u8>()
1007        }
1008
1009        #[inline(always)]
1010        fn encode_is_copy() -> bool {
1011            false
1012        }
1013
1014        #[inline(always)]
1015        fn decode_is_copy() -> bool {
1016            false
1017        }
1018    }
1019
1020    impl fidl::encoding::ValueTypeMarker for UpdateReason {
1021        type Borrowed<'a> = Self;
1022        #[inline(always)]
1023        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1024            *value
1025        }
1026    }
1027
1028    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for UpdateReason {
1029        #[inline]
1030        unsafe fn encode(
1031            self,
1032            encoder: &mut fidl::encoding::Encoder<'_, D>,
1033            offset: usize,
1034            _depth: fidl::encoding::Depth,
1035        ) -> fidl::Result<()> {
1036            encoder.debug_check_bounds::<Self>(offset);
1037            encoder.write_num(self.into_primitive(), offset);
1038            Ok(())
1039        }
1040    }
1041
1042    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UpdateReason {
1043        #[inline(always)]
1044        fn new_empty() -> Self {
1045            Self::unknown()
1046        }
1047
1048        #[inline]
1049        unsafe fn decode(
1050            &mut self,
1051            decoder: &mut fidl::encoding::Decoder<'_, D>,
1052            offset: usize,
1053            _depth: fidl::encoding::Depth,
1054        ) -> fidl::Result<()> {
1055            decoder.debug_check_bounds::<Self>(offset);
1056            let prim = decoder.read_num::<u8>(offset);
1057
1058            *self = Self::from_primitive_allow_unknown(prim);
1059            Ok(())
1060        }
1061    }
1062
1063    impl fidl::encoding::ValueTypeMarker for ControllerConfigureRequest {
1064        type Borrowed<'a> = &'a Self;
1065        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1066            value
1067        }
1068    }
1069
1070    unsafe impl fidl::encoding::TypeMarker for ControllerConfigureRequest {
1071        type Owned = Self;
1072
1073        #[inline(always)]
1074        fn inline_align(_context: fidl::encoding::Context) -> usize {
1075            8
1076        }
1077
1078        #[inline(always)]
1079        fn inline_size(_context: fidl::encoding::Context) -> usize {
1080            16
1081        }
1082    }
1083
1084    unsafe impl<D: fidl::encoding::ResourceDialect>
1085        fidl::encoding::Encode<ControllerConfigureRequest, D> for &ControllerConfigureRequest
1086    {
1087        #[inline]
1088        unsafe fn encode(
1089            self,
1090            encoder: &mut fidl::encoding::Encoder<'_, D>,
1091            offset: usize,
1092            _depth: fidl::encoding::Depth,
1093        ) -> fidl::Result<()> {
1094            encoder.debug_check_bounds::<ControllerConfigureRequest>(offset);
1095            // Delegate to tuple encoding.
1096            fidl::encoding::Encode::<ControllerConfigureRequest, D>::encode(
1097                (<Options as fidl::encoding::ValueTypeMarker>::borrow(&self.options),),
1098                encoder,
1099                offset,
1100                _depth,
1101            )
1102        }
1103    }
1104    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Options, D>>
1105        fidl::encoding::Encode<ControllerConfigureRequest, D> for (T0,)
1106    {
1107        #[inline]
1108        unsafe fn encode(
1109            self,
1110            encoder: &mut fidl::encoding::Encoder<'_, D>,
1111            offset: usize,
1112            depth: fidl::encoding::Depth,
1113        ) -> fidl::Result<()> {
1114            encoder.debug_check_bounds::<ControllerConfigureRequest>(offset);
1115            // Zero out padding regions. There's no need to apply masks
1116            // because the unmasked parts will be overwritten by fields.
1117            // Write the fields.
1118            self.0.encode(encoder, offset + 0, depth)?;
1119            Ok(())
1120        }
1121    }
1122
1123    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1124        for ControllerConfigureRequest
1125    {
1126        #[inline(always)]
1127        fn new_empty() -> Self {
1128            Self { options: fidl::new_empty!(Options, D) }
1129        }
1130
1131        #[inline]
1132        unsafe fn decode(
1133            &mut self,
1134            decoder: &mut fidl::encoding::Decoder<'_, D>,
1135            offset: usize,
1136            _depth: fidl::encoding::Depth,
1137        ) -> fidl::Result<()> {
1138            decoder.debug_check_bounds::<Self>(offset);
1139            // Verify that padding bytes are zero.
1140            fidl::decode!(Options, D, &mut self.options, decoder, offset + 0, _depth)?;
1141            Ok(())
1142        }
1143    }
1144
1145    impl fidl::encoding::ValueTypeMarker for ControllerGetOptionsResponse {
1146        type Borrowed<'a> = &'a Self;
1147        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1148            value
1149        }
1150    }
1151
1152    unsafe impl fidl::encoding::TypeMarker for ControllerGetOptionsResponse {
1153        type Owned = Self;
1154
1155        #[inline(always)]
1156        fn inline_align(_context: fidl::encoding::Context) -> usize {
1157            8
1158        }
1159
1160        #[inline(always)]
1161        fn inline_size(_context: fidl::encoding::Context) -> usize {
1162            16
1163        }
1164    }
1165
1166    unsafe impl<D: fidl::encoding::ResourceDialect>
1167        fidl::encoding::Encode<ControllerGetOptionsResponse, D> for &ControllerGetOptionsResponse
1168    {
1169        #[inline]
1170        unsafe fn encode(
1171            self,
1172            encoder: &mut fidl::encoding::Encoder<'_, D>,
1173            offset: usize,
1174            _depth: fidl::encoding::Depth,
1175        ) -> fidl::Result<()> {
1176            encoder.debug_check_bounds::<ControllerGetOptionsResponse>(offset);
1177            // Delegate to tuple encoding.
1178            fidl::encoding::Encode::<ControllerGetOptionsResponse, D>::encode(
1179                (<Options as fidl::encoding::ValueTypeMarker>::borrow(&self.options),),
1180                encoder,
1181                offset,
1182                _depth,
1183            )
1184        }
1185    }
1186    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Options, D>>
1187        fidl::encoding::Encode<ControllerGetOptionsResponse, D> for (T0,)
1188    {
1189        #[inline]
1190        unsafe fn encode(
1191            self,
1192            encoder: &mut fidl::encoding::Encoder<'_, D>,
1193            offset: usize,
1194            depth: fidl::encoding::Depth,
1195        ) -> fidl::Result<()> {
1196            encoder.debug_check_bounds::<ControllerGetOptionsResponse>(offset);
1197            // Zero out padding regions. There's no need to apply masks
1198            // because the unmasked parts will be overwritten by fields.
1199            // Write the fields.
1200            self.0.encode(encoder, offset + 0, depth)?;
1201            Ok(())
1202        }
1203    }
1204
1205    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1206        for ControllerGetOptionsResponse
1207    {
1208        #[inline(always)]
1209        fn new_empty() -> Self {
1210            Self { options: fidl::new_empty!(Options, D) }
1211        }
1212
1213        #[inline]
1214        unsafe fn decode(
1215            &mut self,
1216            decoder: &mut fidl::encoding::Decoder<'_, D>,
1217            offset: usize,
1218            _depth: fidl::encoding::Depth,
1219        ) -> fidl::Result<()> {
1220            decoder.debug_check_bounds::<Self>(offset);
1221            // Verify that padding bytes are zero.
1222            fidl::decode!(Options, D, &mut self.options, decoder, offset + 0, _depth)?;
1223            Ok(())
1224        }
1225    }
1226
1227    impl fidl::encoding::ValueTypeMarker for ControllerGetStatusResponse {
1228        type Borrowed<'a> = &'a Self;
1229        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1230            value
1231        }
1232    }
1233
1234    unsafe impl fidl::encoding::TypeMarker for ControllerGetStatusResponse {
1235        type Owned = Self;
1236
1237        #[inline(always)]
1238        fn inline_align(_context: fidl::encoding::Context) -> usize {
1239            8
1240        }
1241
1242        #[inline(always)]
1243        fn inline_size(_context: fidl::encoding::Context) -> usize {
1244            16
1245        }
1246    }
1247
1248    unsafe impl<D: fidl::encoding::ResourceDialect>
1249        fidl::encoding::Encode<ControllerGetStatusResponse, D> for &ControllerGetStatusResponse
1250    {
1251        #[inline]
1252        unsafe fn encode(
1253            self,
1254            encoder: &mut fidl::encoding::Encoder<'_, D>,
1255            offset: usize,
1256            _depth: fidl::encoding::Depth,
1257        ) -> fidl::Result<()> {
1258            encoder.debug_check_bounds::<ControllerGetStatusResponse>(offset);
1259            // Delegate to tuple encoding.
1260            fidl::encoding::Encode::<ControllerGetStatusResponse, D>::encode(
1261                (<Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),),
1262                encoder,
1263                offset,
1264                _depth,
1265            )
1266        }
1267    }
1268    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Status, D>>
1269        fidl::encoding::Encode<ControllerGetStatusResponse, D> for (T0,)
1270    {
1271        #[inline]
1272        unsafe fn encode(
1273            self,
1274            encoder: &mut fidl::encoding::Encoder<'_, D>,
1275            offset: usize,
1276            depth: fidl::encoding::Depth,
1277        ) -> fidl::Result<()> {
1278            encoder.debug_check_bounds::<ControllerGetStatusResponse>(offset);
1279            // Zero out padding regions. There's no need to apply masks
1280            // because the unmasked parts will be overwritten by fields.
1281            // Write the fields.
1282            self.0.encode(encoder, offset + 0, depth)?;
1283            Ok(())
1284        }
1285    }
1286
1287    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1288        for ControllerGetStatusResponse
1289    {
1290        #[inline(always)]
1291        fn new_empty() -> Self {
1292            Self { status: fidl::new_empty!(Status, D) }
1293        }
1294
1295        #[inline]
1296        unsafe fn decode(
1297            &mut self,
1298            decoder: &mut fidl::encoding::Decoder<'_, D>,
1299            offset: usize,
1300            _depth: fidl::encoding::Depth,
1301        ) -> fidl::Result<()> {
1302            decoder.debug_check_bounds::<Self>(offset);
1303            // Verify that padding bytes are zero.
1304            fidl::decode!(Status, D, &mut self.status, decoder, offset + 0, _depth)?;
1305            Ok(())
1306        }
1307    }
1308
1309    impl fidl::encoding::ValueTypeMarker for CorpusReaderNextResponse {
1310        type Borrowed<'a> = &'a Self;
1311        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1312            value
1313        }
1314    }
1315
1316    unsafe impl fidl::encoding::TypeMarker for CorpusReaderNextResponse {
1317        type Owned = Self;
1318
1319        #[inline(always)]
1320        fn inline_align(_context: fidl::encoding::Context) -> usize {
1321            4
1322        }
1323
1324        #[inline(always)]
1325        fn inline_size(_context: fidl::encoding::Context) -> usize {
1326            4
1327        }
1328        #[inline(always)]
1329        fn encode_is_copy() -> bool {
1330            true
1331        }
1332
1333        #[inline(always)]
1334        fn decode_is_copy() -> bool {
1335            true
1336        }
1337    }
1338
1339    unsafe impl<D: fidl::encoding::ResourceDialect>
1340        fidl::encoding::Encode<CorpusReaderNextResponse, D> for &CorpusReaderNextResponse
1341    {
1342        #[inline]
1343        unsafe fn encode(
1344            self,
1345            encoder: &mut fidl::encoding::Encoder<'_, D>,
1346            offset: usize,
1347            _depth: fidl::encoding::Depth,
1348        ) -> fidl::Result<()> {
1349            encoder.debug_check_bounds::<CorpusReaderNextResponse>(offset);
1350            unsafe {
1351                // Copy the object into the buffer.
1352                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1353                (buf_ptr as *mut CorpusReaderNextResponse)
1354                    .write_unaligned((self as *const CorpusReaderNextResponse).read());
1355                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1356                // done second because the memcpy will write garbage to these bytes.
1357            }
1358            Ok(())
1359        }
1360    }
1361    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
1362        fidl::encoding::Encode<CorpusReaderNextResponse, D> for (T0,)
1363    {
1364        #[inline]
1365        unsafe fn encode(
1366            self,
1367            encoder: &mut fidl::encoding::Encoder<'_, D>,
1368            offset: usize,
1369            depth: fidl::encoding::Depth,
1370        ) -> fidl::Result<()> {
1371            encoder.debug_check_bounds::<CorpusReaderNextResponse>(offset);
1372            // Zero out padding regions. There's no need to apply masks
1373            // because the unmasked parts will be overwritten by fields.
1374            // Write the fields.
1375            self.0.encode(encoder, offset + 0, depth)?;
1376            Ok(())
1377        }
1378    }
1379
1380    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1381        for CorpusReaderNextResponse
1382    {
1383        #[inline(always)]
1384        fn new_empty() -> Self {
1385            Self { result: fidl::new_empty!(i32, D) }
1386        }
1387
1388        #[inline]
1389        unsafe fn decode(
1390            &mut self,
1391            decoder: &mut fidl::encoding::Decoder<'_, D>,
1392            offset: usize,
1393            _depth: fidl::encoding::Depth,
1394        ) -> fidl::Result<()> {
1395            decoder.debug_check_bounds::<Self>(offset);
1396            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1397            // Verify that padding bytes are zero.
1398            // Copy from the buffer into the object.
1399            unsafe {
1400                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
1401            }
1402            Ok(())
1403        }
1404    }
1405
1406    impl fidl::encoding::ValueTypeMarker for CoverageDataCollectorInitializeResponse {
1407        type Borrowed<'a> = &'a Self;
1408        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1409            value
1410        }
1411    }
1412
1413    unsafe impl fidl::encoding::TypeMarker for CoverageDataCollectorInitializeResponse {
1414        type Owned = Self;
1415
1416        #[inline(always)]
1417        fn inline_align(_context: fidl::encoding::Context) -> usize {
1418            8
1419        }
1420
1421        #[inline(always)]
1422        fn inline_size(_context: fidl::encoding::Context) -> usize {
1423            16
1424        }
1425    }
1426
1427    unsafe impl<D: fidl::encoding::ResourceDialect>
1428        fidl::encoding::Encode<CoverageDataCollectorInitializeResponse, D>
1429        for &CoverageDataCollectorInitializeResponse
1430    {
1431        #[inline]
1432        unsafe fn encode(
1433            self,
1434            encoder: &mut fidl::encoding::Encoder<'_, D>,
1435            offset: usize,
1436            _depth: fidl::encoding::Depth,
1437        ) -> fidl::Result<()> {
1438            encoder.debug_check_bounds::<CoverageDataCollectorInitializeResponse>(offset);
1439            // Delegate to tuple encoding.
1440            fidl::encoding::Encode::<CoverageDataCollectorInitializeResponse, D>::encode(
1441                (<Options as fidl::encoding::ValueTypeMarker>::borrow(&self.options),),
1442                encoder,
1443                offset,
1444                _depth,
1445            )
1446        }
1447    }
1448    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Options, D>>
1449        fidl::encoding::Encode<CoverageDataCollectorInitializeResponse, D> for (T0,)
1450    {
1451        #[inline]
1452        unsafe fn encode(
1453            self,
1454            encoder: &mut fidl::encoding::Encoder<'_, D>,
1455            offset: usize,
1456            depth: fidl::encoding::Depth,
1457        ) -> fidl::Result<()> {
1458            encoder.debug_check_bounds::<CoverageDataCollectorInitializeResponse>(offset);
1459            // Zero out padding regions. There's no need to apply masks
1460            // because the unmasked parts will be overwritten by fields.
1461            // Write the fields.
1462            self.0.encode(encoder, offset + 0, depth)?;
1463            Ok(())
1464        }
1465    }
1466
1467    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1468        for CoverageDataCollectorInitializeResponse
1469    {
1470        #[inline(always)]
1471        fn new_empty() -> Self {
1472            Self { options: fidl::new_empty!(Options, D) }
1473        }
1474
1475        #[inline]
1476        unsafe fn decode(
1477            &mut self,
1478            decoder: &mut fidl::encoding::Decoder<'_, D>,
1479            offset: usize,
1480            _depth: fidl::encoding::Depth,
1481        ) -> fidl::Result<()> {
1482            decoder.debug_check_bounds::<Self>(offset);
1483            // Verify that padding bytes are zero.
1484            fidl::decode!(Options, D, &mut self.options, decoder, offset + 0, _depth)?;
1485            Ok(())
1486        }
1487    }
1488
1489    impl fidl::encoding::ValueTypeMarker for CoverageDataProviderSetOptionsRequest {
1490        type Borrowed<'a> = &'a Self;
1491        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1492            value
1493        }
1494    }
1495
1496    unsafe impl fidl::encoding::TypeMarker for CoverageDataProviderSetOptionsRequest {
1497        type Owned = Self;
1498
1499        #[inline(always)]
1500        fn inline_align(_context: fidl::encoding::Context) -> usize {
1501            8
1502        }
1503
1504        #[inline(always)]
1505        fn inline_size(_context: fidl::encoding::Context) -> usize {
1506            16
1507        }
1508    }
1509
1510    unsafe impl<D: fidl::encoding::ResourceDialect>
1511        fidl::encoding::Encode<CoverageDataProviderSetOptionsRequest, D>
1512        for &CoverageDataProviderSetOptionsRequest
1513    {
1514        #[inline]
1515        unsafe fn encode(
1516            self,
1517            encoder: &mut fidl::encoding::Encoder<'_, D>,
1518            offset: usize,
1519            _depth: fidl::encoding::Depth,
1520        ) -> fidl::Result<()> {
1521            encoder.debug_check_bounds::<CoverageDataProviderSetOptionsRequest>(offset);
1522            // Delegate to tuple encoding.
1523            fidl::encoding::Encode::<CoverageDataProviderSetOptionsRequest, D>::encode(
1524                (<Options as fidl::encoding::ValueTypeMarker>::borrow(&self.options),),
1525                encoder,
1526                offset,
1527                _depth,
1528            )
1529        }
1530    }
1531    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Options, D>>
1532        fidl::encoding::Encode<CoverageDataProviderSetOptionsRequest, D> for (T0,)
1533    {
1534        #[inline]
1535        unsafe fn encode(
1536            self,
1537            encoder: &mut fidl::encoding::Encoder<'_, D>,
1538            offset: usize,
1539            depth: fidl::encoding::Depth,
1540        ) -> fidl::Result<()> {
1541            encoder.debug_check_bounds::<CoverageDataProviderSetOptionsRequest>(offset);
1542            // Zero out padding regions. There's no need to apply masks
1543            // because the unmasked parts will be overwritten by fields.
1544            // Write the fields.
1545            self.0.encode(encoder, offset + 0, depth)?;
1546            Ok(())
1547        }
1548    }
1549
1550    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1551        for CoverageDataProviderSetOptionsRequest
1552    {
1553        #[inline(always)]
1554        fn new_empty() -> Self {
1555            Self { options: fidl::new_empty!(Options, D) }
1556        }
1557
1558        #[inline]
1559        unsafe fn decode(
1560            &mut self,
1561            decoder: &mut fidl::encoding::Decoder<'_, D>,
1562            offset: usize,
1563            _depth: fidl::encoding::Depth,
1564        ) -> fidl::Result<()> {
1565            decoder.debug_check_bounds::<Self>(offset);
1566            // Verify that padding bytes are zero.
1567            fidl::decode!(Options, D, &mut self.options, decoder, offset + 0, _depth)?;
1568            Ok(())
1569        }
1570    }
1571
1572    impl fidl::encoding::ValueTypeMarker for ManagerStopRequest {
1573        type Borrowed<'a> = &'a Self;
1574        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1575            value
1576        }
1577    }
1578
1579    unsafe impl fidl::encoding::TypeMarker for ManagerStopRequest {
1580        type Owned = Self;
1581
1582        #[inline(always)]
1583        fn inline_align(_context: fidl::encoding::Context) -> usize {
1584            8
1585        }
1586
1587        #[inline(always)]
1588        fn inline_size(_context: fidl::encoding::Context) -> usize {
1589            16
1590        }
1591    }
1592
1593    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ManagerStopRequest, D>
1594        for &ManagerStopRequest
1595    {
1596        #[inline]
1597        unsafe fn encode(
1598            self,
1599            encoder: &mut fidl::encoding::Encoder<'_, D>,
1600            offset: usize,
1601            _depth: fidl::encoding::Depth,
1602        ) -> fidl::Result<()> {
1603            encoder.debug_check_bounds::<ManagerStopRequest>(offset);
1604            // Delegate to tuple encoding.
1605            fidl::encoding::Encode::<ManagerStopRequest, D>::encode(
1606                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
1607                    &self.fuzzer_url,
1608                ),),
1609                encoder,
1610                offset,
1611                _depth,
1612            )
1613        }
1614    }
1615    unsafe impl<
1616            D: fidl::encoding::ResourceDialect,
1617            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
1618        > fidl::encoding::Encode<ManagerStopRequest, D> for (T0,)
1619    {
1620        #[inline]
1621        unsafe fn encode(
1622            self,
1623            encoder: &mut fidl::encoding::Encoder<'_, D>,
1624            offset: usize,
1625            depth: fidl::encoding::Depth,
1626        ) -> fidl::Result<()> {
1627            encoder.debug_check_bounds::<ManagerStopRequest>(offset);
1628            // Zero out padding regions. There's no need to apply masks
1629            // because the unmasked parts will be overwritten by fields.
1630            // Write the fields.
1631            self.0.encode(encoder, offset + 0, depth)?;
1632            Ok(())
1633        }
1634    }
1635
1636    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ManagerStopRequest {
1637        #[inline(always)]
1638        fn new_empty() -> Self {
1639            Self { fuzzer_url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
1640        }
1641
1642        #[inline]
1643        unsafe fn decode(
1644            &mut self,
1645            decoder: &mut fidl::encoding::Decoder<'_, D>,
1646            offset: usize,
1647            _depth: fidl::encoding::Depth,
1648        ) -> fidl::Result<()> {
1649            decoder.debug_check_bounds::<Self>(offset);
1650            // Verify that padding bytes are zero.
1651            fidl::decode!(
1652                fidl::encoding::BoundedString<4096>,
1653                D,
1654                &mut self.fuzzer_url,
1655                decoder,
1656                offset + 0,
1657                _depth
1658            )?;
1659            Ok(())
1660        }
1661    }
1662
1663    impl fidl::encoding::ValueTypeMarker for MonitorUpdateRequest {
1664        type Borrowed<'a> = &'a Self;
1665        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1666            value
1667        }
1668    }
1669
1670    unsafe impl fidl::encoding::TypeMarker for MonitorUpdateRequest {
1671        type Owned = Self;
1672
1673        #[inline(always)]
1674        fn inline_align(_context: fidl::encoding::Context) -> usize {
1675            8
1676        }
1677
1678        #[inline(always)]
1679        fn inline_size(_context: fidl::encoding::Context) -> usize {
1680            24
1681        }
1682    }
1683
1684    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MonitorUpdateRequest, D>
1685        for &MonitorUpdateRequest
1686    {
1687        #[inline]
1688        unsafe fn encode(
1689            self,
1690            encoder: &mut fidl::encoding::Encoder<'_, D>,
1691            offset: usize,
1692            _depth: fidl::encoding::Depth,
1693        ) -> fidl::Result<()> {
1694            encoder.debug_check_bounds::<MonitorUpdateRequest>(offset);
1695            // Delegate to tuple encoding.
1696            fidl::encoding::Encode::<MonitorUpdateRequest, D>::encode(
1697                (
1698                    <UpdateReason as fidl::encoding::ValueTypeMarker>::borrow(&self.reason),
1699                    <Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
1700                ),
1701                encoder,
1702                offset,
1703                _depth,
1704            )
1705        }
1706    }
1707    unsafe impl<
1708            D: fidl::encoding::ResourceDialect,
1709            T0: fidl::encoding::Encode<UpdateReason, D>,
1710            T1: fidl::encoding::Encode<Status, D>,
1711        > fidl::encoding::Encode<MonitorUpdateRequest, D> for (T0, T1)
1712    {
1713        #[inline]
1714        unsafe fn encode(
1715            self,
1716            encoder: &mut fidl::encoding::Encoder<'_, D>,
1717            offset: usize,
1718            depth: fidl::encoding::Depth,
1719        ) -> fidl::Result<()> {
1720            encoder.debug_check_bounds::<MonitorUpdateRequest>(offset);
1721            // Zero out padding regions. There's no need to apply masks
1722            // because the unmasked parts will be overwritten by fields.
1723            unsafe {
1724                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1725                (ptr as *mut u64).write_unaligned(0);
1726            }
1727            // Write the fields.
1728            self.0.encode(encoder, offset + 0, depth)?;
1729            self.1.encode(encoder, offset + 8, depth)?;
1730            Ok(())
1731        }
1732    }
1733
1734    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MonitorUpdateRequest {
1735        #[inline(always)]
1736        fn new_empty() -> Self {
1737            Self { reason: fidl::new_empty!(UpdateReason, D), status: fidl::new_empty!(Status, D) }
1738        }
1739
1740        #[inline]
1741        unsafe fn decode(
1742            &mut self,
1743            decoder: &mut fidl::encoding::Decoder<'_, D>,
1744            offset: usize,
1745            _depth: fidl::encoding::Depth,
1746        ) -> fidl::Result<()> {
1747            decoder.debug_check_bounds::<Self>(offset);
1748            // Verify that padding bytes are zero.
1749            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1750            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1751            let mask = 0xffffffffffffff00u64;
1752            let maskedval = padval & mask;
1753            if maskedval != 0 {
1754                return Err(fidl::Error::NonZeroPadding {
1755                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1756                });
1757            }
1758            fidl::decode!(UpdateReason, D, &mut self.reason, decoder, offset + 0, _depth)?;
1759            fidl::decode!(Status, D, &mut self.status, decoder, offset + 8, _depth)?;
1760            Ok(())
1761        }
1762    }
1763
1764    impl fidl::encoding::ValueTypeMarker for ProcessStats {
1765        type Borrowed<'a> = &'a Self;
1766        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1767            value
1768        }
1769    }
1770
1771    unsafe impl fidl::encoding::TypeMarker for ProcessStats {
1772        type Owned = Self;
1773
1774        #[inline(always)]
1775        fn inline_align(_context: fidl::encoding::Context) -> usize {
1776            8
1777        }
1778
1779        #[inline(always)]
1780        fn inline_size(_context: fidl::encoding::Context) -> usize {
1781            72
1782        }
1783        #[inline(always)]
1784        fn encode_is_copy() -> bool {
1785            true
1786        }
1787
1788        #[inline(always)]
1789        fn decode_is_copy() -> bool {
1790            true
1791        }
1792    }
1793
1794    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProcessStats, D>
1795        for &ProcessStats
1796    {
1797        #[inline]
1798        unsafe fn encode(
1799            self,
1800            encoder: &mut fidl::encoding::Encoder<'_, D>,
1801            offset: usize,
1802            _depth: fidl::encoding::Depth,
1803        ) -> fidl::Result<()> {
1804            encoder.debug_check_bounds::<ProcessStats>(offset);
1805            unsafe {
1806                // Copy the object into the buffer.
1807                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1808                (buf_ptr as *mut ProcessStats)
1809                    .write_unaligned((self as *const ProcessStats).read());
1810                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1811                // done second because the memcpy will write garbage to these bytes.
1812            }
1813            Ok(())
1814        }
1815    }
1816    unsafe impl<
1817            D: fidl::encoding::ResourceDialect,
1818            T0: fidl::encoding::Encode<u64, D>,
1819            T1: fidl::encoding::Encode<u64, D>,
1820            T2: fidl::encoding::Encode<u64, D>,
1821            T3: fidl::encoding::Encode<u64, D>,
1822            T4: fidl::encoding::Encode<u64, D>,
1823            T5: fidl::encoding::Encode<i64, D>,
1824            T6: fidl::encoding::Encode<i64, D>,
1825            T7: fidl::encoding::Encode<i64, D>,
1826            T8: fidl::encoding::Encode<i64, D>,
1827        > fidl::encoding::Encode<ProcessStats, D> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
1828    {
1829        #[inline]
1830        unsafe fn encode(
1831            self,
1832            encoder: &mut fidl::encoding::Encoder<'_, D>,
1833            offset: usize,
1834            depth: fidl::encoding::Depth,
1835        ) -> fidl::Result<()> {
1836            encoder.debug_check_bounds::<ProcessStats>(offset);
1837            // Zero out padding regions. There's no need to apply masks
1838            // because the unmasked parts will be overwritten by fields.
1839            // Write the fields.
1840            self.0.encode(encoder, offset + 0, depth)?;
1841            self.1.encode(encoder, offset + 8, depth)?;
1842            self.2.encode(encoder, offset + 16, depth)?;
1843            self.3.encode(encoder, offset + 24, depth)?;
1844            self.4.encode(encoder, offset + 32, depth)?;
1845            self.5.encode(encoder, offset + 40, depth)?;
1846            self.6.encode(encoder, offset + 48, depth)?;
1847            self.7.encode(encoder, offset + 56, depth)?;
1848            self.8.encode(encoder, offset + 64, depth)?;
1849            Ok(())
1850        }
1851    }
1852
1853    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProcessStats {
1854        #[inline(always)]
1855        fn new_empty() -> Self {
1856            Self {
1857                koid: fidl::new_empty!(u64, D),
1858                mem_mapped_bytes: fidl::new_empty!(u64, D),
1859                mem_private_bytes: fidl::new_empty!(u64, D),
1860                mem_shared_bytes: fidl::new_empty!(u64, D),
1861                mem_scaled_shared_bytes: fidl::new_empty!(u64, D),
1862                cpu_time: fidl::new_empty!(i64, D),
1863                queue_time: fidl::new_empty!(i64, D),
1864                page_fault_time: fidl::new_empty!(i64, D),
1865                lock_contention_time: fidl::new_empty!(i64, D),
1866            }
1867        }
1868
1869        #[inline]
1870        unsafe fn decode(
1871            &mut self,
1872            decoder: &mut fidl::encoding::Decoder<'_, D>,
1873            offset: usize,
1874            _depth: fidl::encoding::Depth,
1875        ) -> fidl::Result<()> {
1876            decoder.debug_check_bounds::<Self>(offset);
1877            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1878            // Verify that padding bytes are zero.
1879            // Copy from the buffer into the object.
1880            unsafe {
1881                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 72);
1882            }
1883            Ok(())
1884        }
1885    }
1886
1887    impl fidl::encoding::ValueTypeMarker for RegistryDisconnectRequest {
1888        type Borrowed<'a> = &'a Self;
1889        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1890            value
1891        }
1892    }
1893
1894    unsafe impl fidl::encoding::TypeMarker for RegistryDisconnectRequest {
1895        type Owned = Self;
1896
1897        #[inline(always)]
1898        fn inline_align(_context: fidl::encoding::Context) -> usize {
1899            8
1900        }
1901
1902        #[inline(always)]
1903        fn inline_size(_context: fidl::encoding::Context) -> usize {
1904            16
1905        }
1906    }
1907
1908    unsafe impl<D: fidl::encoding::ResourceDialect>
1909        fidl::encoding::Encode<RegistryDisconnectRequest, D> for &RegistryDisconnectRequest
1910    {
1911        #[inline]
1912        unsafe fn encode(
1913            self,
1914            encoder: &mut fidl::encoding::Encoder<'_, D>,
1915            offset: usize,
1916            _depth: fidl::encoding::Depth,
1917        ) -> fidl::Result<()> {
1918            encoder.debug_check_bounds::<RegistryDisconnectRequest>(offset);
1919            // Delegate to tuple encoding.
1920            fidl::encoding::Encode::<RegistryDisconnectRequest, D>::encode(
1921                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
1922                    &self.fuzzer_url,
1923                ),),
1924                encoder,
1925                offset,
1926                _depth,
1927            )
1928        }
1929    }
1930    unsafe impl<
1931            D: fidl::encoding::ResourceDialect,
1932            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
1933        > fidl::encoding::Encode<RegistryDisconnectRequest, D> for (T0,)
1934    {
1935        #[inline]
1936        unsafe fn encode(
1937            self,
1938            encoder: &mut fidl::encoding::Encoder<'_, D>,
1939            offset: usize,
1940            depth: fidl::encoding::Depth,
1941        ) -> fidl::Result<()> {
1942            encoder.debug_check_bounds::<RegistryDisconnectRequest>(offset);
1943            // Zero out padding regions. There's no need to apply masks
1944            // because the unmasked parts will be overwritten by fields.
1945            // Write the fields.
1946            self.0.encode(encoder, offset + 0, depth)?;
1947            Ok(())
1948        }
1949    }
1950
1951    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1952        for RegistryDisconnectRequest
1953    {
1954        #[inline(always)]
1955        fn new_empty() -> Self {
1956            Self { fuzzer_url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
1957        }
1958
1959        #[inline]
1960        unsafe fn decode(
1961            &mut self,
1962            decoder: &mut fidl::encoding::Decoder<'_, D>,
1963            offset: usize,
1964            _depth: fidl::encoding::Depth,
1965        ) -> fidl::Result<()> {
1966            decoder.debug_check_bounds::<Self>(offset);
1967            // Verify that padding bytes are zero.
1968            fidl::decode!(
1969                fidl::encoding::BoundedString<4096>,
1970                D,
1971                &mut self.fuzzer_url,
1972                decoder,
1973                offset + 0,
1974                _depth
1975            )?;
1976            Ok(())
1977        }
1978    }
1979
1980    impl fidl::encoding::ValueTypeMarker for SanitizerOptions {
1981        type Borrowed<'a> = &'a Self;
1982        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1983            value
1984        }
1985    }
1986
1987    unsafe impl fidl::encoding::TypeMarker for SanitizerOptions {
1988        type Owned = Self;
1989
1990        #[inline(always)]
1991        fn inline_align(_context: fidl::encoding::Context) -> usize {
1992            8
1993        }
1994
1995        #[inline(always)]
1996        fn inline_size(_context: fidl::encoding::Context) -> usize {
1997            32
1998        }
1999    }
2000
2001    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SanitizerOptions, D>
2002        for &SanitizerOptions
2003    {
2004        #[inline]
2005        unsafe fn encode(
2006            self,
2007            encoder: &mut fidl::encoding::Encoder<'_, D>,
2008            offset: usize,
2009            _depth: fidl::encoding::Depth,
2010        ) -> fidl::Result<()> {
2011            encoder.debug_check_bounds::<SanitizerOptions>(offset);
2012            // Delegate to tuple encoding.
2013            fidl::encoding::Encode::<SanitizerOptions, D>::encode(
2014                (
2015                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
2016                    <fidl::encoding::BoundedString<8192> as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
2017                ),
2018                encoder, offset, _depth
2019            )
2020        }
2021    }
2022    unsafe impl<
2023            D: fidl::encoding::ResourceDialect,
2024            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<32>, D>,
2025            T1: fidl::encoding::Encode<fidl::encoding::BoundedString<8192>, D>,
2026        > fidl::encoding::Encode<SanitizerOptions, D> for (T0, T1)
2027    {
2028        #[inline]
2029        unsafe fn encode(
2030            self,
2031            encoder: &mut fidl::encoding::Encoder<'_, D>,
2032            offset: usize,
2033            depth: fidl::encoding::Depth,
2034        ) -> fidl::Result<()> {
2035            encoder.debug_check_bounds::<SanitizerOptions>(offset);
2036            // Zero out padding regions. There's no need to apply masks
2037            // because the unmasked parts will be overwritten by fields.
2038            // Write the fields.
2039            self.0.encode(encoder, offset + 0, depth)?;
2040            self.1.encode(encoder, offset + 16, depth)?;
2041            Ok(())
2042        }
2043    }
2044
2045    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SanitizerOptions {
2046        #[inline(always)]
2047        fn new_empty() -> Self {
2048            Self {
2049                name: fidl::new_empty!(fidl::encoding::BoundedString<32>, D),
2050                value: fidl::new_empty!(fidl::encoding::BoundedString<8192>, D),
2051            }
2052        }
2053
2054        #[inline]
2055        unsafe fn decode(
2056            &mut self,
2057            decoder: &mut fidl::encoding::Decoder<'_, D>,
2058            offset: usize,
2059            _depth: fidl::encoding::Depth,
2060        ) -> fidl::Result<()> {
2061            decoder.debug_check_bounds::<Self>(offset);
2062            // Verify that padding bytes are zero.
2063            fidl::decode!(
2064                fidl::encoding::BoundedString<32>,
2065                D,
2066                &mut self.name,
2067                decoder,
2068                offset + 0,
2069                _depth
2070            )?;
2071            fidl::decode!(
2072                fidl::encoding::BoundedString<8192>,
2073                D,
2074                &mut self.value,
2075                decoder,
2076                offset + 16,
2077                _depth
2078            )?;
2079            Ok(())
2080        }
2081    }
2082
2083    impl fidl::encoding::ValueTypeMarker for TargetAdapterGetParametersResponse {
2084        type Borrowed<'a> = &'a Self;
2085        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2086            value
2087        }
2088    }
2089
2090    unsafe impl fidl::encoding::TypeMarker for TargetAdapterGetParametersResponse {
2091        type Owned = Self;
2092
2093        #[inline(always)]
2094        fn inline_align(_context: fidl::encoding::Context) -> usize {
2095            8
2096        }
2097
2098        #[inline(always)]
2099        fn inline_size(_context: fidl::encoding::Context) -> usize {
2100            16
2101        }
2102    }
2103
2104    unsafe impl<D: fidl::encoding::ResourceDialect>
2105        fidl::encoding::Encode<TargetAdapterGetParametersResponse, D>
2106        for &TargetAdapterGetParametersResponse
2107    {
2108        #[inline]
2109        unsafe fn encode(
2110            self,
2111            encoder: &mut fidl::encoding::Encoder<'_, D>,
2112            offset: usize,
2113            _depth: fidl::encoding::Depth,
2114        ) -> fidl::Result<()> {
2115            encoder.debug_check_bounds::<TargetAdapterGetParametersResponse>(offset);
2116            // Delegate to tuple encoding.
2117            fidl::encoding::Encode::<TargetAdapterGetParametersResponse, D>::encode(
2118                (
2119                    <fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 128> as fidl::encoding::ValueTypeMarker>::borrow(&self.parameters),
2120                ),
2121                encoder, offset, _depth
2122            )
2123        }
2124    }
2125    unsafe impl<
2126            D: fidl::encoding::ResourceDialect,
2127            T0: fidl::encoding::Encode<
2128                fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 128>,
2129                D,
2130            >,
2131        > fidl::encoding::Encode<TargetAdapterGetParametersResponse, D> for (T0,)
2132    {
2133        #[inline]
2134        unsafe fn encode(
2135            self,
2136            encoder: &mut fidl::encoding::Encoder<'_, D>,
2137            offset: usize,
2138            depth: fidl::encoding::Depth,
2139        ) -> fidl::Result<()> {
2140            encoder.debug_check_bounds::<TargetAdapterGetParametersResponse>(offset);
2141            // Zero out padding regions. There's no need to apply masks
2142            // because the unmasked parts will be overwritten by fields.
2143            // Write the fields.
2144            self.0.encode(encoder, offset + 0, depth)?;
2145            Ok(())
2146        }
2147    }
2148
2149    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2150        for TargetAdapterGetParametersResponse
2151    {
2152        #[inline(always)]
2153        fn new_empty() -> Self {
2154            Self {
2155                parameters: fidl::new_empty!(
2156                    fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 128>,
2157                    D
2158                ),
2159            }
2160        }
2161
2162        #[inline]
2163        unsafe fn decode(
2164            &mut self,
2165            decoder: &mut fidl::encoding::Decoder<'_, D>,
2166            offset: usize,
2167            _depth: fidl::encoding::Depth,
2168        ) -> fidl::Result<()> {
2169            decoder.debug_check_bounds::<Self>(offset);
2170            // Verify that padding bytes are zero.
2171            fidl::decode!(
2172                fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 128>,
2173                D,
2174                &mut self.parameters,
2175                decoder,
2176                offset + 0,
2177                _depth
2178            )?;
2179            Ok(())
2180        }
2181    }
2182
2183    impl Options {
2184        #[inline(always)]
2185        fn max_ordinal_present(&self) -> u64 {
2186            if let Some(_) = self.output_flags {
2187                return 22;
2188            }
2189            if let Some(_) = self.sanitizer_options {
2190                return 21;
2191            }
2192            if let Some(_) = self.use_value_profile {
2193                return 20;
2194            }
2195            if let Some(_) = self.print_final_stats {
2196                return 19;
2197            }
2198            if let Some(_) = self.debug {
2199                return 18;
2200            }
2201            if let Some(_) = self.pulse_interval {
2202                return 17;
2203            }
2204            if let Some(_) = self.oom_exitcode {
2205                return 16;
2206            }
2207            if let Some(_) = self.leak_exitcode {
2208                return 15;
2209            }
2210            if let Some(_) = self.death_exitcode {
2211                return 14;
2212            }
2213            if let Some(_) = self.malloc_exitcode {
2214                return 13;
2215            }
2216            if let Some(_) = self.purge_interval {
2217                return 12;
2218            }
2219            if let Some(_) = self.oom_limit {
2220                return 11;
2221            }
2222            if let Some(_) = self.malloc_limit {
2223                return 10;
2224            }
2225            if let Some(_) = self.run_limit {
2226                return 9;
2227            }
2228            if let Some(_) = self.detect_leaks {
2229                return 8;
2230            }
2231            if let Some(_) = self.detect_exits {
2232                return 7;
2233            }
2234            if let Some(_) = self.dictionary_level {
2235                return 6;
2236            }
2237            if let Some(_) = self.mutation_depth {
2238                return 5;
2239            }
2240            if let Some(_) = self.max_input_size {
2241                return 4;
2242            }
2243            if let Some(_) = self.seed {
2244                return 3;
2245            }
2246            if let Some(_) = self.max_total_time {
2247                return 2;
2248            }
2249            if let Some(_) = self.runs {
2250                return 1;
2251            }
2252            0
2253        }
2254    }
2255
2256    impl fidl::encoding::ValueTypeMarker for Options {
2257        type Borrowed<'a> = &'a Self;
2258        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2259            value
2260        }
2261    }
2262
2263    unsafe impl fidl::encoding::TypeMarker for Options {
2264        type Owned = Self;
2265
2266        #[inline(always)]
2267        fn inline_align(_context: fidl::encoding::Context) -> usize {
2268            8
2269        }
2270
2271        #[inline(always)]
2272        fn inline_size(_context: fidl::encoding::Context) -> usize {
2273            16
2274        }
2275    }
2276
2277    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Options, D> for &Options {
2278        unsafe fn encode(
2279            self,
2280            encoder: &mut fidl::encoding::Encoder<'_, D>,
2281            offset: usize,
2282            mut depth: fidl::encoding::Depth,
2283        ) -> fidl::Result<()> {
2284            encoder.debug_check_bounds::<Options>(offset);
2285            // Vector header
2286            let max_ordinal: u64 = self.max_ordinal_present();
2287            encoder.write_num(max_ordinal, offset);
2288            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2289            // Calling encoder.out_of_line_offset(0) is not allowed.
2290            if max_ordinal == 0 {
2291                return Ok(());
2292            }
2293            depth.increment()?;
2294            let envelope_size = 8;
2295            let bytes_len = max_ordinal as usize * envelope_size;
2296            #[allow(unused_variables)]
2297            let offset = encoder.out_of_line_offset(bytes_len);
2298            let mut _prev_end_offset: usize = 0;
2299            if 1 > max_ordinal {
2300                return Ok(());
2301            }
2302
2303            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2304            // are envelope_size bytes.
2305            let cur_offset: usize = (1 - 1) * envelope_size;
2306
2307            // Zero reserved fields.
2308            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2309
2310            // Safety:
2311            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2312            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2313            //   envelope_size bytes, there is always sufficient room.
2314            fidl::encoding::encode_in_envelope_optional::<u32, D>(
2315                self.runs.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2316                encoder,
2317                offset + cur_offset,
2318                depth,
2319            )?;
2320
2321            _prev_end_offset = cur_offset + envelope_size;
2322            if 2 > max_ordinal {
2323                return Ok(());
2324            }
2325
2326            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2327            // are envelope_size bytes.
2328            let cur_offset: usize = (2 - 1) * envelope_size;
2329
2330            // Zero reserved fields.
2331            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2332
2333            // Safety:
2334            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2335            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2336            //   envelope_size bytes, there is always sufficient room.
2337            fidl::encoding::encode_in_envelope_optional::<i64, D>(
2338                self.max_total_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2339                encoder,
2340                offset + cur_offset,
2341                depth,
2342            )?;
2343
2344            _prev_end_offset = cur_offset + envelope_size;
2345            if 3 > max_ordinal {
2346                return Ok(());
2347            }
2348
2349            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2350            // are envelope_size bytes.
2351            let cur_offset: usize = (3 - 1) * envelope_size;
2352
2353            // Zero reserved fields.
2354            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2355
2356            // Safety:
2357            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2358            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2359            //   envelope_size bytes, there is always sufficient room.
2360            fidl::encoding::encode_in_envelope_optional::<u32, D>(
2361                self.seed.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2362                encoder,
2363                offset + cur_offset,
2364                depth,
2365            )?;
2366
2367            _prev_end_offset = cur_offset + envelope_size;
2368            if 4 > max_ordinal {
2369                return Ok(());
2370            }
2371
2372            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2373            // are envelope_size bytes.
2374            let cur_offset: usize = (4 - 1) * envelope_size;
2375
2376            // Zero reserved fields.
2377            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2378
2379            // Safety:
2380            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2381            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2382            //   envelope_size bytes, there is always sufficient room.
2383            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2384                self.max_input_size.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2385                encoder,
2386                offset + cur_offset,
2387                depth,
2388            )?;
2389
2390            _prev_end_offset = cur_offset + envelope_size;
2391            if 5 > max_ordinal {
2392                return Ok(());
2393            }
2394
2395            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2396            // are envelope_size bytes.
2397            let cur_offset: usize = (5 - 1) * envelope_size;
2398
2399            // Zero reserved fields.
2400            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2401
2402            // Safety:
2403            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2404            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2405            //   envelope_size bytes, there is always sufficient room.
2406            fidl::encoding::encode_in_envelope_optional::<u16, D>(
2407                self.mutation_depth.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
2408                encoder,
2409                offset + cur_offset,
2410                depth,
2411            )?;
2412
2413            _prev_end_offset = cur_offset + envelope_size;
2414            if 6 > max_ordinal {
2415                return Ok(());
2416            }
2417
2418            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2419            // are envelope_size bytes.
2420            let cur_offset: usize = (6 - 1) * envelope_size;
2421
2422            // Zero reserved fields.
2423            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2424
2425            // Safety:
2426            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2427            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2428            //   envelope_size bytes, there is always sufficient room.
2429            fidl::encoding::encode_in_envelope_optional::<u16, D>(
2430                self.dictionary_level
2431                    .as_ref()
2432                    .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
2433                encoder,
2434                offset + cur_offset,
2435                depth,
2436            )?;
2437
2438            _prev_end_offset = cur_offset + envelope_size;
2439            if 7 > max_ordinal {
2440                return Ok(());
2441            }
2442
2443            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2444            // are envelope_size bytes.
2445            let cur_offset: usize = (7 - 1) * envelope_size;
2446
2447            // Zero reserved fields.
2448            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2449
2450            // Safety:
2451            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2452            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2453            //   envelope_size bytes, there is always sufficient room.
2454            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2455                self.detect_exits.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2456                encoder,
2457                offset + cur_offset,
2458                depth,
2459            )?;
2460
2461            _prev_end_offset = cur_offset + envelope_size;
2462            if 8 > max_ordinal {
2463                return Ok(());
2464            }
2465
2466            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2467            // are envelope_size bytes.
2468            let cur_offset: usize = (8 - 1) * envelope_size;
2469
2470            // Zero reserved fields.
2471            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2472
2473            // Safety:
2474            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2475            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2476            //   envelope_size bytes, there is always sufficient room.
2477            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2478                self.detect_leaks.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2479                encoder,
2480                offset + cur_offset,
2481                depth,
2482            )?;
2483
2484            _prev_end_offset = cur_offset + envelope_size;
2485            if 9 > max_ordinal {
2486                return Ok(());
2487            }
2488
2489            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2490            // are envelope_size bytes.
2491            let cur_offset: usize = (9 - 1) * envelope_size;
2492
2493            // Zero reserved fields.
2494            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2495
2496            // Safety:
2497            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2498            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2499            //   envelope_size bytes, there is always sufficient room.
2500            fidl::encoding::encode_in_envelope_optional::<i64, D>(
2501                self.run_limit.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2502                encoder,
2503                offset + cur_offset,
2504                depth,
2505            )?;
2506
2507            _prev_end_offset = cur_offset + envelope_size;
2508            if 10 > max_ordinal {
2509                return Ok(());
2510            }
2511
2512            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2513            // are envelope_size bytes.
2514            let cur_offset: usize = (10 - 1) * envelope_size;
2515
2516            // Zero reserved fields.
2517            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2518
2519            // Safety:
2520            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2521            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2522            //   envelope_size bytes, there is always sufficient room.
2523            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2524                self.malloc_limit.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2525                encoder,
2526                offset + cur_offset,
2527                depth,
2528            )?;
2529
2530            _prev_end_offset = cur_offset + envelope_size;
2531            if 11 > max_ordinal {
2532                return Ok(());
2533            }
2534
2535            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2536            // are envelope_size bytes.
2537            let cur_offset: usize = (11 - 1) * envelope_size;
2538
2539            // Zero reserved fields.
2540            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2541
2542            // Safety:
2543            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2544            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2545            //   envelope_size bytes, there is always sufficient room.
2546            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2547                self.oom_limit.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2548                encoder,
2549                offset + cur_offset,
2550                depth,
2551            )?;
2552
2553            _prev_end_offset = cur_offset + envelope_size;
2554            if 12 > max_ordinal {
2555                return Ok(());
2556            }
2557
2558            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2559            // are envelope_size bytes.
2560            let cur_offset: usize = (12 - 1) * envelope_size;
2561
2562            // Zero reserved fields.
2563            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2564
2565            // Safety:
2566            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2567            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2568            //   envelope_size bytes, there is always sufficient room.
2569            fidl::encoding::encode_in_envelope_optional::<i64, D>(
2570                self.purge_interval.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2571                encoder,
2572                offset + cur_offset,
2573                depth,
2574            )?;
2575
2576            _prev_end_offset = cur_offset + envelope_size;
2577            if 13 > max_ordinal {
2578                return Ok(());
2579            }
2580
2581            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2582            // are envelope_size bytes.
2583            let cur_offset: usize = (13 - 1) * envelope_size;
2584
2585            // Zero reserved fields.
2586            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2587
2588            // Safety:
2589            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2590            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2591            //   envelope_size bytes, there is always sufficient room.
2592            fidl::encoding::encode_in_envelope_optional::<i32, D>(
2593                self.malloc_exitcode.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
2594                encoder,
2595                offset + cur_offset,
2596                depth,
2597            )?;
2598
2599            _prev_end_offset = cur_offset + envelope_size;
2600            if 14 > max_ordinal {
2601                return Ok(());
2602            }
2603
2604            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2605            // are envelope_size bytes.
2606            let cur_offset: usize = (14 - 1) * envelope_size;
2607
2608            // Zero reserved fields.
2609            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2610
2611            // Safety:
2612            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2613            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2614            //   envelope_size bytes, there is always sufficient room.
2615            fidl::encoding::encode_in_envelope_optional::<i32, D>(
2616                self.death_exitcode.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
2617                encoder,
2618                offset + cur_offset,
2619                depth,
2620            )?;
2621
2622            _prev_end_offset = cur_offset + envelope_size;
2623            if 15 > max_ordinal {
2624                return Ok(());
2625            }
2626
2627            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2628            // are envelope_size bytes.
2629            let cur_offset: usize = (15 - 1) * envelope_size;
2630
2631            // Zero reserved fields.
2632            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2633
2634            // Safety:
2635            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2636            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2637            //   envelope_size bytes, there is always sufficient room.
2638            fidl::encoding::encode_in_envelope_optional::<i32, D>(
2639                self.leak_exitcode.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
2640                encoder,
2641                offset + cur_offset,
2642                depth,
2643            )?;
2644
2645            _prev_end_offset = cur_offset + envelope_size;
2646            if 16 > max_ordinal {
2647                return Ok(());
2648            }
2649
2650            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2651            // are envelope_size bytes.
2652            let cur_offset: usize = (16 - 1) * envelope_size;
2653
2654            // Zero reserved fields.
2655            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2656
2657            // Safety:
2658            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2659            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2660            //   envelope_size bytes, there is always sufficient room.
2661            fidl::encoding::encode_in_envelope_optional::<i32, D>(
2662                self.oom_exitcode.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
2663                encoder,
2664                offset + cur_offset,
2665                depth,
2666            )?;
2667
2668            _prev_end_offset = cur_offset + envelope_size;
2669            if 17 > max_ordinal {
2670                return Ok(());
2671            }
2672
2673            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2674            // are envelope_size bytes.
2675            let cur_offset: usize = (17 - 1) * envelope_size;
2676
2677            // Zero reserved fields.
2678            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2679
2680            // Safety:
2681            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2682            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2683            //   envelope_size bytes, there is always sufficient room.
2684            fidl::encoding::encode_in_envelope_optional::<i64, D>(
2685                self.pulse_interval.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2686                encoder,
2687                offset + cur_offset,
2688                depth,
2689            )?;
2690
2691            _prev_end_offset = cur_offset + envelope_size;
2692            if 18 > max_ordinal {
2693                return Ok(());
2694            }
2695
2696            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2697            // are envelope_size bytes.
2698            let cur_offset: usize = (18 - 1) * envelope_size;
2699
2700            // Zero reserved fields.
2701            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2702
2703            // Safety:
2704            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2705            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2706            //   envelope_size bytes, there is always sufficient room.
2707            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2708                self.debug.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2709                encoder,
2710                offset + cur_offset,
2711                depth,
2712            )?;
2713
2714            _prev_end_offset = cur_offset + envelope_size;
2715            if 19 > max_ordinal {
2716                return Ok(());
2717            }
2718
2719            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2720            // are envelope_size bytes.
2721            let cur_offset: usize = (19 - 1) * envelope_size;
2722
2723            // Zero reserved fields.
2724            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2725
2726            // Safety:
2727            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2728            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2729            //   envelope_size bytes, there is always sufficient room.
2730            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2731                self.print_final_stats
2732                    .as_ref()
2733                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2734                encoder,
2735                offset + cur_offset,
2736                depth,
2737            )?;
2738
2739            _prev_end_offset = cur_offset + envelope_size;
2740            if 20 > max_ordinal {
2741                return Ok(());
2742            }
2743
2744            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2745            // are envelope_size bytes.
2746            let cur_offset: usize = (20 - 1) * envelope_size;
2747
2748            // Zero reserved fields.
2749            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2750
2751            // Safety:
2752            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2753            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2754            //   envelope_size bytes, there is always sufficient room.
2755            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2756                self.use_value_profile
2757                    .as_ref()
2758                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2759                encoder,
2760                offset + cur_offset,
2761                depth,
2762            )?;
2763
2764            _prev_end_offset = cur_offset + envelope_size;
2765            if 21 > max_ordinal {
2766                return Ok(());
2767            }
2768
2769            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2770            // are envelope_size bytes.
2771            let cur_offset: usize = (21 - 1) * envelope_size;
2772
2773            // Zero reserved fields.
2774            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2775
2776            // Safety:
2777            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2778            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2779            //   envelope_size bytes, there is always sufficient room.
2780            fidl::encoding::encode_in_envelope_optional::<SanitizerOptions, D>(
2781                self.sanitizer_options
2782                    .as_ref()
2783                    .map(<SanitizerOptions as fidl::encoding::ValueTypeMarker>::borrow),
2784                encoder,
2785                offset + cur_offset,
2786                depth,
2787            )?;
2788
2789            _prev_end_offset = cur_offset + envelope_size;
2790            if 22 > max_ordinal {
2791                return Ok(());
2792            }
2793
2794            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2795            // are envelope_size bytes.
2796            let cur_offset: usize = (22 - 1) * envelope_size;
2797
2798            // Zero reserved fields.
2799            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2800
2801            // Safety:
2802            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2803            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2804            //   envelope_size bytes, there is always sufficient room.
2805            fidl::encoding::encode_in_envelope_optional::<OutputFlags, D>(
2806                self.output_flags
2807                    .as_ref()
2808                    .map(<OutputFlags as fidl::encoding::ValueTypeMarker>::borrow),
2809                encoder,
2810                offset + cur_offset,
2811                depth,
2812            )?;
2813
2814            _prev_end_offset = cur_offset + envelope_size;
2815
2816            Ok(())
2817        }
2818    }
2819
2820    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Options {
2821        #[inline(always)]
2822        fn new_empty() -> Self {
2823            Self::default()
2824        }
2825
2826        unsafe fn decode(
2827            &mut self,
2828            decoder: &mut fidl::encoding::Decoder<'_, D>,
2829            offset: usize,
2830            mut depth: fidl::encoding::Depth,
2831        ) -> fidl::Result<()> {
2832            decoder.debug_check_bounds::<Self>(offset);
2833            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2834                None => return Err(fidl::Error::NotNullable),
2835                Some(len) => len,
2836            };
2837            // Calling decoder.out_of_line_offset(0) is not allowed.
2838            if len == 0 {
2839                return Ok(());
2840            };
2841            depth.increment()?;
2842            let envelope_size = 8;
2843            let bytes_len = len * envelope_size;
2844            let offset = decoder.out_of_line_offset(bytes_len)?;
2845            // Decode the envelope for each type.
2846            let mut _next_ordinal_to_read = 0;
2847            let mut next_offset = offset;
2848            let end_offset = offset + bytes_len;
2849            _next_ordinal_to_read += 1;
2850            if next_offset >= end_offset {
2851                return Ok(());
2852            }
2853
2854            // Decode unknown envelopes for gaps in ordinals.
2855            while _next_ordinal_to_read < 1 {
2856                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2857                _next_ordinal_to_read += 1;
2858                next_offset += envelope_size;
2859            }
2860
2861            let next_out_of_line = decoder.next_out_of_line();
2862            let handles_before = decoder.remaining_handles();
2863            if let Some((inlined, num_bytes, num_handles)) =
2864                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2865            {
2866                let member_inline_size =
2867                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2868                if inlined != (member_inline_size <= 4) {
2869                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2870                }
2871                let inner_offset;
2872                let mut inner_depth = depth.clone();
2873                if inlined {
2874                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2875                    inner_offset = next_offset;
2876                } else {
2877                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2878                    inner_depth.increment()?;
2879                }
2880                let val_ref = self.runs.get_or_insert_with(|| fidl::new_empty!(u32, D));
2881                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2882                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2883                {
2884                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2885                }
2886                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2887                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2888                }
2889            }
2890
2891            next_offset += envelope_size;
2892            _next_ordinal_to_read += 1;
2893            if next_offset >= end_offset {
2894                return Ok(());
2895            }
2896
2897            // Decode unknown envelopes for gaps in ordinals.
2898            while _next_ordinal_to_read < 2 {
2899                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2900                _next_ordinal_to_read += 1;
2901                next_offset += envelope_size;
2902            }
2903
2904            let next_out_of_line = decoder.next_out_of_line();
2905            let handles_before = decoder.remaining_handles();
2906            if let Some((inlined, num_bytes, num_handles)) =
2907                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2908            {
2909                let member_inline_size =
2910                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2911                if inlined != (member_inline_size <= 4) {
2912                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2913                }
2914                let inner_offset;
2915                let mut inner_depth = depth.clone();
2916                if inlined {
2917                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2918                    inner_offset = next_offset;
2919                } else {
2920                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2921                    inner_depth.increment()?;
2922                }
2923                let val_ref = self.max_total_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
2924                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
2925                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2926                {
2927                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2928                }
2929                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2930                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2931                }
2932            }
2933
2934            next_offset += envelope_size;
2935            _next_ordinal_to_read += 1;
2936            if next_offset >= end_offset {
2937                return Ok(());
2938            }
2939
2940            // Decode unknown envelopes for gaps in ordinals.
2941            while _next_ordinal_to_read < 3 {
2942                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2943                _next_ordinal_to_read += 1;
2944                next_offset += envelope_size;
2945            }
2946
2947            let next_out_of_line = decoder.next_out_of_line();
2948            let handles_before = decoder.remaining_handles();
2949            if let Some((inlined, num_bytes, num_handles)) =
2950                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2951            {
2952                let member_inline_size =
2953                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2954                if inlined != (member_inline_size <= 4) {
2955                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2956                }
2957                let inner_offset;
2958                let mut inner_depth = depth.clone();
2959                if inlined {
2960                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2961                    inner_offset = next_offset;
2962                } else {
2963                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2964                    inner_depth.increment()?;
2965                }
2966                let val_ref = self.seed.get_or_insert_with(|| fidl::new_empty!(u32, D));
2967                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2968                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2969                {
2970                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2971                }
2972                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2973                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2974                }
2975            }
2976
2977            next_offset += envelope_size;
2978            _next_ordinal_to_read += 1;
2979            if next_offset >= end_offset {
2980                return Ok(());
2981            }
2982
2983            // Decode unknown envelopes for gaps in ordinals.
2984            while _next_ordinal_to_read < 4 {
2985                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2986                _next_ordinal_to_read += 1;
2987                next_offset += envelope_size;
2988            }
2989
2990            let next_out_of_line = decoder.next_out_of_line();
2991            let handles_before = decoder.remaining_handles();
2992            if let Some((inlined, num_bytes, num_handles)) =
2993                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2994            {
2995                let member_inline_size =
2996                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2997                if inlined != (member_inline_size <= 4) {
2998                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2999                }
3000                let inner_offset;
3001                let mut inner_depth = depth.clone();
3002                if inlined {
3003                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3004                    inner_offset = next_offset;
3005                } else {
3006                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3007                    inner_depth.increment()?;
3008                }
3009                let val_ref = self.max_input_size.get_or_insert_with(|| fidl::new_empty!(u64, D));
3010                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3011                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3012                {
3013                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3014                }
3015                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3016                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3017                }
3018            }
3019
3020            next_offset += envelope_size;
3021            _next_ordinal_to_read += 1;
3022            if next_offset >= end_offset {
3023                return Ok(());
3024            }
3025
3026            // Decode unknown envelopes for gaps in ordinals.
3027            while _next_ordinal_to_read < 5 {
3028                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3029                _next_ordinal_to_read += 1;
3030                next_offset += envelope_size;
3031            }
3032
3033            let next_out_of_line = decoder.next_out_of_line();
3034            let handles_before = decoder.remaining_handles();
3035            if let Some((inlined, num_bytes, num_handles)) =
3036                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3037            {
3038                let member_inline_size =
3039                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3040                if inlined != (member_inline_size <= 4) {
3041                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3042                }
3043                let inner_offset;
3044                let mut inner_depth = depth.clone();
3045                if inlined {
3046                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3047                    inner_offset = next_offset;
3048                } else {
3049                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3050                    inner_depth.increment()?;
3051                }
3052                let val_ref = self.mutation_depth.get_or_insert_with(|| fidl::new_empty!(u16, D));
3053                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
3054                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3055                {
3056                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3057                }
3058                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3059                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3060                }
3061            }
3062
3063            next_offset += envelope_size;
3064            _next_ordinal_to_read += 1;
3065            if next_offset >= end_offset {
3066                return Ok(());
3067            }
3068
3069            // Decode unknown envelopes for gaps in ordinals.
3070            while _next_ordinal_to_read < 6 {
3071                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3072                _next_ordinal_to_read += 1;
3073                next_offset += envelope_size;
3074            }
3075
3076            let next_out_of_line = decoder.next_out_of_line();
3077            let handles_before = decoder.remaining_handles();
3078            if let Some((inlined, num_bytes, num_handles)) =
3079                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3080            {
3081                let member_inline_size =
3082                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3083                if inlined != (member_inline_size <= 4) {
3084                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3085                }
3086                let inner_offset;
3087                let mut inner_depth = depth.clone();
3088                if inlined {
3089                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3090                    inner_offset = next_offset;
3091                } else {
3092                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3093                    inner_depth.increment()?;
3094                }
3095                let val_ref = self.dictionary_level.get_or_insert_with(|| fidl::new_empty!(u16, D));
3096                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
3097                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3098                {
3099                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3100                }
3101                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3102                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3103                }
3104            }
3105
3106            next_offset += envelope_size;
3107            _next_ordinal_to_read += 1;
3108            if next_offset >= end_offset {
3109                return Ok(());
3110            }
3111
3112            // Decode unknown envelopes for gaps in ordinals.
3113            while _next_ordinal_to_read < 7 {
3114                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3115                _next_ordinal_to_read += 1;
3116                next_offset += envelope_size;
3117            }
3118
3119            let next_out_of_line = decoder.next_out_of_line();
3120            let handles_before = decoder.remaining_handles();
3121            if let Some((inlined, num_bytes, num_handles)) =
3122                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3123            {
3124                let member_inline_size =
3125                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3126                if inlined != (member_inline_size <= 4) {
3127                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3128                }
3129                let inner_offset;
3130                let mut inner_depth = depth.clone();
3131                if inlined {
3132                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3133                    inner_offset = next_offset;
3134                } else {
3135                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3136                    inner_depth.increment()?;
3137                }
3138                let val_ref = self.detect_exits.get_or_insert_with(|| fidl::new_empty!(bool, D));
3139                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3140                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3141                {
3142                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3143                }
3144                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3145                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3146                }
3147            }
3148
3149            next_offset += envelope_size;
3150            _next_ordinal_to_read += 1;
3151            if next_offset >= end_offset {
3152                return Ok(());
3153            }
3154
3155            // Decode unknown envelopes for gaps in ordinals.
3156            while _next_ordinal_to_read < 8 {
3157                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3158                _next_ordinal_to_read += 1;
3159                next_offset += envelope_size;
3160            }
3161
3162            let next_out_of_line = decoder.next_out_of_line();
3163            let handles_before = decoder.remaining_handles();
3164            if let Some((inlined, num_bytes, num_handles)) =
3165                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3166            {
3167                let member_inline_size =
3168                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3169                if inlined != (member_inline_size <= 4) {
3170                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3171                }
3172                let inner_offset;
3173                let mut inner_depth = depth.clone();
3174                if inlined {
3175                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3176                    inner_offset = next_offset;
3177                } else {
3178                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3179                    inner_depth.increment()?;
3180                }
3181                let val_ref = self.detect_leaks.get_or_insert_with(|| fidl::new_empty!(bool, D));
3182                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3183                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3184                {
3185                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3186                }
3187                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3188                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3189                }
3190            }
3191
3192            next_offset += envelope_size;
3193            _next_ordinal_to_read += 1;
3194            if next_offset >= end_offset {
3195                return Ok(());
3196            }
3197
3198            // Decode unknown envelopes for gaps in ordinals.
3199            while _next_ordinal_to_read < 9 {
3200                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3201                _next_ordinal_to_read += 1;
3202                next_offset += envelope_size;
3203            }
3204
3205            let next_out_of_line = decoder.next_out_of_line();
3206            let handles_before = decoder.remaining_handles();
3207            if let Some((inlined, num_bytes, num_handles)) =
3208                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3209            {
3210                let member_inline_size =
3211                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3212                if inlined != (member_inline_size <= 4) {
3213                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3214                }
3215                let inner_offset;
3216                let mut inner_depth = depth.clone();
3217                if inlined {
3218                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3219                    inner_offset = next_offset;
3220                } else {
3221                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3222                    inner_depth.increment()?;
3223                }
3224                let val_ref = self.run_limit.get_or_insert_with(|| fidl::new_empty!(i64, D));
3225                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3226                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3227                {
3228                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3229                }
3230                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3231                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3232                }
3233            }
3234
3235            next_offset += envelope_size;
3236            _next_ordinal_to_read += 1;
3237            if next_offset >= end_offset {
3238                return Ok(());
3239            }
3240
3241            // Decode unknown envelopes for gaps in ordinals.
3242            while _next_ordinal_to_read < 10 {
3243                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3244                _next_ordinal_to_read += 1;
3245                next_offset += envelope_size;
3246            }
3247
3248            let next_out_of_line = decoder.next_out_of_line();
3249            let handles_before = decoder.remaining_handles();
3250            if let Some((inlined, num_bytes, num_handles)) =
3251                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3252            {
3253                let member_inline_size =
3254                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3255                if inlined != (member_inline_size <= 4) {
3256                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3257                }
3258                let inner_offset;
3259                let mut inner_depth = depth.clone();
3260                if inlined {
3261                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3262                    inner_offset = next_offset;
3263                } else {
3264                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3265                    inner_depth.increment()?;
3266                }
3267                let val_ref = self.malloc_limit.get_or_insert_with(|| fidl::new_empty!(u64, D));
3268                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3269                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3270                {
3271                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3272                }
3273                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3274                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3275                }
3276            }
3277
3278            next_offset += envelope_size;
3279            _next_ordinal_to_read += 1;
3280            if next_offset >= end_offset {
3281                return Ok(());
3282            }
3283
3284            // Decode unknown envelopes for gaps in ordinals.
3285            while _next_ordinal_to_read < 11 {
3286                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3287                _next_ordinal_to_read += 1;
3288                next_offset += envelope_size;
3289            }
3290
3291            let next_out_of_line = decoder.next_out_of_line();
3292            let handles_before = decoder.remaining_handles();
3293            if let Some((inlined, num_bytes, num_handles)) =
3294                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3295            {
3296                let member_inline_size =
3297                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3298                if inlined != (member_inline_size <= 4) {
3299                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3300                }
3301                let inner_offset;
3302                let mut inner_depth = depth.clone();
3303                if inlined {
3304                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3305                    inner_offset = next_offset;
3306                } else {
3307                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3308                    inner_depth.increment()?;
3309                }
3310                let val_ref = self.oom_limit.get_or_insert_with(|| fidl::new_empty!(u64, D));
3311                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3312                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3313                {
3314                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3315                }
3316                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3317                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3318                }
3319            }
3320
3321            next_offset += envelope_size;
3322            _next_ordinal_to_read += 1;
3323            if next_offset >= end_offset {
3324                return Ok(());
3325            }
3326
3327            // Decode unknown envelopes for gaps in ordinals.
3328            while _next_ordinal_to_read < 12 {
3329                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3330                _next_ordinal_to_read += 1;
3331                next_offset += envelope_size;
3332            }
3333
3334            let next_out_of_line = decoder.next_out_of_line();
3335            let handles_before = decoder.remaining_handles();
3336            if let Some((inlined, num_bytes, num_handles)) =
3337                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3338            {
3339                let member_inline_size =
3340                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3341                if inlined != (member_inline_size <= 4) {
3342                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3343                }
3344                let inner_offset;
3345                let mut inner_depth = depth.clone();
3346                if inlined {
3347                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3348                    inner_offset = next_offset;
3349                } else {
3350                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3351                    inner_depth.increment()?;
3352                }
3353                let val_ref = self.purge_interval.get_or_insert_with(|| fidl::new_empty!(i64, D));
3354                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3355                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3356                {
3357                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3358                }
3359                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3360                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3361                }
3362            }
3363
3364            next_offset += envelope_size;
3365            _next_ordinal_to_read += 1;
3366            if next_offset >= end_offset {
3367                return Ok(());
3368            }
3369
3370            // Decode unknown envelopes for gaps in ordinals.
3371            while _next_ordinal_to_read < 13 {
3372                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3373                _next_ordinal_to_read += 1;
3374                next_offset += envelope_size;
3375            }
3376
3377            let next_out_of_line = decoder.next_out_of_line();
3378            let handles_before = decoder.remaining_handles();
3379            if let Some((inlined, num_bytes, num_handles)) =
3380                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3381            {
3382                let member_inline_size =
3383                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3384                if inlined != (member_inline_size <= 4) {
3385                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3386                }
3387                let inner_offset;
3388                let mut inner_depth = depth.clone();
3389                if inlined {
3390                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3391                    inner_offset = next_offset;
3392                } else {
3393                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3394                    inner_depth.increment()?;
3395                }
3396                let val_ref = self.malloc_exitcode.get_or_insert_with(|| fidl::new_empty!(i32, D));
3397                fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
3398                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3399                {
3400                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3401                }
3402                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3403                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3404                }
3405            }
3406
3407            next_offset += envelope_size;
3408            _next_ordinal_to_read += 1;
3409            if next_offset >= end_offset {
3410                return Ok(());
3411            }
3412
3413            // Decode unknown envelopes for gaps in ordinals.
3414            while _next_ordinal_to_read < 14 {
3415                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3416                _next_ordinal_to_read += 1;
3417                next_offset += envelope_size;
3418            }
3419
3420            let next_out_of_line = decoder.next_out_of_line();
3421            let handles_before = decoder.remaining_handles();
3422            if let Some((inlined, num_bytes, num_handles)) =
3423                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3424            {
3425                let member_inline_size =
3426                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3427                if inlined != (member_inline_size <= 4) {
3428                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3429                }
3430                let inner_offset;
3431                let mut inner_depth = depth.clone();
3432                if inlined {
3433                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3434                    inner_offset = next_offset;
3435                } else {
3436                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3437                    inner_depth.increment()?;
3438                }
3439                let val_ref = self.death_exitcode.get_or_insert_with(|| fidl::new_empty!(i32, D));
3440                fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
3441                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3442                {
3443                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3444                }
3445                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3446                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3447                }
3448            }
3449
3450            next_offset += envelope_size;
3451            _next_ordinal_to_read += 1;
3452            if next_offset >= end_offset {
3453                return Ok(());
3454            }
3455
3456            // Decode unknown envelopes for gaps in ordinals.
3457            while _next_ordinal_to_read < 15 {
3458                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3459                _next_ordinal_to_read += 1;
3460                next_offset += envelope_size;
3461            }
3462
3463            let next_out_of_line = decoder.next_out_of_line();
3464            let handles_before = decoder.remaining_handles();
3465            if let Some((inlined, num_bytes, num_handles)) =
3466                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3467            {
3468                let member_inline_size =
3469                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3470                if inlined != (member_inline_size <= 4) {
3471                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3472                }
3473                let inner_offset;
3474                let mut inner_depth = depth.clone();
3475                if inlined {
3476                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3477                    inner_offset = next_offset;
3478                } else {
3479                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3480                    inner_depth.increment()?;
3481                }
3482                let val_ref = self.leak_exitcode.get_or_insert_with(|| fidl::new_empty!(i32, D));
3483                fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
3484                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3485                {
3486                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3487                }
3488                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3489                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3490                }
3491            }
3492
3493            next_offset += envelope_size;
3494            _next_ordinal_to_read += 1;
3495            if next_offset >= end_offset {
3496                return Ok(());
3497            }
3498
3499            // Decode unknown envelopes for gaps in ordinals.
3500            while _next_ordinal_to_read < 16 {
3501                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3502                _next_ordinal_to_read += 1;
3503                next_offset += envelope_size;
3504            }
3505
3506            let next_out_of_line = decoder.next_out_of_line();
3507            let handles_before = decoder.remaining_handles();
3508            if let Some((inlined, num_bytes, num_handles)) =
3509                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3510            {
3511                let member_inline_size =
3512                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3513                if inlined != (member_inline_size <= 4) {
3514                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3515                }
3516                let inner_offset;
3517                let mut inner_depth = depth.clone();
3518                if inlined {
3519                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3520                    inner_offset = next_offset;
3521                } else {
3522                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3523                    inner_depth.increment()?;
3524                }
3525                let val_ref = self.oom_exitcode.get_or_insert_with(|| fidl::new_empty!(i32, D));
3526                fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
3527                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3528                {
3529                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3530                }
3531                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3532                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3533                }
3534            }
3535
3536            next_offset += envelope_size;
3537            _next_ordinal_to_read += 1;
3538            if next_offset >= end_offset {
3539                return Ok(());
3540            }
3541
3542            // Decode unknown envelopes for gaps in ordinals.
3543            while _next_ordinal_to_read < 17 {
3544                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3545                _next_ordinal_to_read += 1;
3546                next_offset += envelope_size;
3547            }
3548
3549            let next_out_of_line = decoder.next_out_of_line();
3550            let handles_before = decoder.remaining_handles();
3551            if let Some((inlined, num_bytes, num_handles)) =
3552                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3553            {
3554                let member_inline_size =
3555                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3556                if inlined != (member_inline_size <= 4) {
3557                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3558                }
3559                let inner_offset;
3560                let mut inner_depth = depth.clone();
3561                if inlined {
3562                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3563                    inner_offset = next_offset;
3564                } else {
3565                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3566                    inner_depth.increment()?;
3567                }
3568                let val_ref = self.pulse_interval.get_or_insert_with(|| fidl::new_empty!(i64, D));
3569                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3570                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3571                {
3572                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3573                }
3574                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3575                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3576                }
3577            }
3578
3579            next_offset += envelope_size;
3580            _next_ordinal_to_read += 1;
3581            if next_offset >= end_offset {
3582                return Ok(());
3583            }
3584
3585            // Decode unknown envelopes for gaps in ordinals.
3586            while _next_ordinal_to_read < 18 {
3587                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3588                _next_ordinal_to_read += 1;
3589                next_offset += envelope_size;
3590            }
3591
3592            let next_out_of_line = decoder.next_out_of_line();
3593            let handles_before = decoder.remaining_handles();
3594            if let Some((inlined, num_bytes, num_handles)) =
3595                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3596            {
3597                let member_inline_size =
3598                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3599                if inlined != (member_inline_size <= 4) {
3600                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3601                }
3602                let inner_offset;
3603                let mut inner_depth = depth.clone();
3604                if inlined {
3605                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3606                    inner_offset = next_offset;
3607                } else {
3608                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3609                    inner_depth.increment()?;
3610                }
3611                let val_ref = self.debug.get_or_insert_with(|| fidl::new_empty!(bool, D));
3612                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3613                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3614                {
3615                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3616                }
3617                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3618                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3619                }
3620            }
3621
3622            next_offset += envelope_size;
3623            _next_ordinal_to_read += 1;
3624            if next_offset >= end_offset {
3625                return Ok(());
3626            }
3627
3628            // Decode unknown envelopes for gaps in ordinals.
3629            while _next_ordinal_to_read < 19 {
3630                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3631                _next_ordinal_to_read += 1;
3632                next_offset += envelope_size;
3633            }
3634
3635            let next_out_of_line = decoder.next_out_of_line();
3636            let handles_before = decoder.remaining_handles();
3637            if let Some((inlined, num_bytes, num_handles)) =
3638                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3639            {
3640                let member_inline_size =
3641                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3642                if inlined != (member_inline_size <= 4) {
3643                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3644                }
3645                let inner_offset;
3646                let mut inner_depth = depth.clone();
3647                if inlined {
3648                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3649                    inner_offset = next_offset;
3650                } else {
3651                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3652                    inner_depth.increment()?;
3653                }
3654                let val_ref =
3655                    self.print_final_stats.get_or_insert_with(|| fidl::new_empty!(bool, D));
3656                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3657                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3658                {
3659                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3660                }
3661                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3662                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3663                }
3664            }
3665
3666            next_offset += envelope_size;
3667            _next_ordinal_to_read += 1;
3668            if next_offset >= end_offset {
3669                return Ok(());
3670            }
3671
3672            // Decode unknown envelopes for gaps in ordinals.
3673            while _next_ordinal_to_read < 20 {
3674                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3675                _next_ordinal_to_read += 1;
3676                next_offset += envelope_size;
3677            }
3678
3679            let next_out_of_line = decoder.next_out_of_line();
3680            let handles_before = decoder.remaining_handles();
3681            if let Some((inlined, num_bytes, num_handles)) =
3682                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3683            {
3684                let member_inline_size =
3685                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3686                if inlined != (member_inline_size <= 4) {
3687                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3688                }
3689                let inner_offset;
3690                let mut inner_depth = depth.clone();
3691                if inlined {
3692                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3693                    inner_offset = next_offset;
3694                } else {
3695                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3696                    inner_depth.increment()?;
3697                }
3698                let val_ref =
3699                    self.use_value_profile.get_or_insert_with(|| fidl::new_empty!(bool, D));
3700                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3701                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3702                {
3703                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3704                }
3705                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3706                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3707                }
3708            }
3709
3710            next_offset += envelope_size;
3711            _next_ordinal_to_read += 1;
3712            if next_offset >= end_offset {
3713                return Ok(());
3714            }
3715
3716            // Decode unknown envelopes for gaps in ordinals.
3717            while _next_ordinal_to_read < 21 {
3718                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3719                _next_ordinal_to_read += 1;
3720                next_offset += envelope_size;
3721            }
3722
3723            let next_out_of_line = decoder.next_out_of_line();
3724            let handles_before = decoder.remaining_handles();
3725            if let Some((inlined, num_bytes, num_handles)) =
3726                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3727            {
3728                let member_inline_size =
3729                    <SanitizerOptions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3730                if inlined != (member_inline_size <= 4) {
3731                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3732                }
3733                let inner_offset;
3734                let mut inner_depth = depth.clone();
3735                if inlined {
3736                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3737                    inner_offset = next_offset;
3738                } else {
3739                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3740                    inner_depth.increment()?;
3741                }
3742                let val_ref = self
3743                    .sanitizer_options
3744                    .get_or_insert_with(|| fidl::new_empty!(SanitizerOptions, D));
3745                fidl::decode!(SanitizerOptions, D, val_ref, decoder, inner_offset, inner_depth)?;
3746                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3747                {
3748                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3749                }
3750                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3751                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3752                }
3753            }
3754
3755            next_offset += envelope_size;
3756            _next_ordinal_to_read += 1;
3757            if next_offset >= end_offset {
3758                return Ok(());
3759            }
3760
3761            // Decode unknown envelopes for gaps in ordinals.
3762            while _next_ordinal_to_read < 22 {
3763                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3764                _next_ordinal_to_read += 1;
3765                next_offset += envelope_size;
3766            }
3767
3768            let next_out_of_line = decoder.next_out_of_line();
3769            let handles_before = decoder.remaining_handles();
3770            if let Some((inlined, num_bytes, num_handles)) =
3771                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3772            {
3773                let member_inline_size =
3774                    <OutputFlags as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3775                if inlined != (member_inline_size <= 4) {
3776                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3777                }
3778                let inner_offset;
3779                let mut inner_depth = depth.clone();
3780                if inlined {
3781                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3782                    inner_offset = next_offset;
3783                } else {
3784                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3785                    inner_depth.increment()?;
3786                }
3787                let val_ref =
3788                    self.output_flags.get_or_insert_with(|| fidl::new_empty!(OutputFlags, D));
3789                fidl::decode!(OutputFlags, D, val_ref, decoder, inner_offset, inner_depth)?;
3790                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3791                {
3792                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3793                }
3794                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3795                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3796                }
3797            }
3798
3799            next_offset += envelope_size;
3800
3801            // Decode the remaining unknown envelopes.
3802            while next_offset < end_offset {
3803                _next_ordinal_to_read += 1;
3804                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3805                next_offset += envelope_size;
3806            }
3807
3808            Ok(())
3809        }
3810    }
3811
3812    impl Status {
3813        #[inline(always)]
3814        fn max_ordinal_present(&self) -> u64 {
3815            if let Some(_) = self.process_stats {
3816                return 8;
3817            }
3818            if let Some(_) = self.corpus_total_size {
3819                return 7;
3820            }
3821            if let Some(_) = self.corpus_num_inputs {
3822                return 6;
3823            }
3824            if let Some(_) = self.covered_features {
3825                return 5;
3826            }
3827            if let Some(_) = self.covered_pcs {
3828                return 4;
3829            }
3830            if let Some(_) = self.elapsed {
3831                return 3;
3832            }
3833            if let Some(_) = self.runs {
3834                return 2;
3835            }
3836            if let Some(_) = self.running {
3837                return 1;
3838            }
3839            0
3840        }
3841    }
3842
3843    impl fidl::encoding::ValueTypeMarker for Status {
3844        type Borrowed<'a> = &'a Self;
3845        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3846            value
3847        }
3848    }
3849
3850    unsafe impl fidl::encoding::TypeMarker for Status {
3851        type Owned = Self;
3852
3853        #[inline(always)]
3854        fn inline_align(_context: fidl::encoding::Context) -> usize {
3855            8
3856        }
3857
3858        #[inline(always)]
3859        fn inline_size(_context: fidl::encoding::Context) -> usize {
3860            16
3861        }
3862    }
3863
3864    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Status, D> for &Status {
3865        unsafe fn encode(
3866            self,
3867            encoder: &mut fidl::encoding::Encoder<'_, D>,
3868            offset: usize,
3869            mut depth: fidl::encoding::Depth,
3870        ) -> fidl::Result<()> {
3871            encoder.debug_check_bounds::<Status>(offset);
3872            // Vector header
3873            let max_ordinal: u64 = self.max_ordinal_present();
3874            encoder.write_num(max_ordinal, offset);
3875            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3876            // Calling encoder.out_of_line_offset(0) is not allowed.
3877            if max_ordinal == 0 {
3878                return Ok(());
3879            }
3880            depth.increment()?;
3881            let envelope_size = 8;
3882            let bytes_len = max_ordinal as usize * envelope_size;
3883            #[allow(unused_variables)]
3884            let offset = encoder.out_of_line_offset(bytes_len);
3885            let mut _prev_end_offset: usize = 0;
3886            if 1 > max_ordinal {
3887                return Ok(());
3888            }
3889
3890            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3891            // are envelope_size bytes.
3892            let cur_offset: usize = (1 - 1) * envelope_size;
3893
3894            // Zero reserved fields.
3895            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3896
3897            // Safety:
3898            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3899            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3900            //   envelope_size bytes, there is always sufficient room.
3901            fidl::encoding::encode_in_envelope_optional::<bool, D>(
3902                self.running.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3903                encoder,
3904                offset + cur_offset,
3905                depth,
3906            )?;
3907
3908            _prev_end_offset = cur_offset + envelope_size;
3909            if 2 > max_ordinal {
3910                return Ok(());
3911            }
3912
3913            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3914            // are envelope_size bytes.
3915            let cur_offset: usize = (2 - 1) * envelope_size;
3916
3917            // Zero reserved fields.
3918            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3919
3920            // Safety:
3921            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3922            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3923            //   envelope_size bytes, there is always sufficient room.
3924            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3925                self.runs.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3926                encoder,
3927                offset + cur_offset,
3928                depth,
3929            )?;
3930
3931            _prev_end_offset = cur_offset + envelope_size;
3932            if 3 > max_ordinal {
3933                return Ok(());
3934            }
3935
3936            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3937            // are envelope_size bytes.
3938            let cur_offset: usize = (3 - 1) * envelope_size;
3939
3940            // Zero reserved fields.
3941            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3942
3943            // Safety:
3944            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3945            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3946            //   envelope_size bytes, there is always sufficient room.
3947            fidl::encoding::encode_in_envelope_optional::<i64, D>(
3948                self.elapsed.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
3949                encoder,
3950                offset + cur_offset,
3951                depth,
3952            )?;
3953
3954            _prev_end_offset = cur_offset + envelope_size;
3955            if 4 > max_ordinal {
3956                return Ok(());
3957            }
3958
3959            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3960            // are envelope_size bytes.
3961            let cur_offset: usize = (4 - 1) * envelope_size;
3962
3963            // Zero reserved fields.
3964            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3965
3966            // Safety:
3967            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3968            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3969            //   envelope_size bytes, there is always sufficient room.
3970            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3971                self.covered_pcs.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3972                encoder,
3973                offset + cur_offset,
3974                depth,
3975            )?;
3976
3977            _prev_end_offset = cur_offset + envelope_size;
3978            if 5 > max_ordinal {
3979                return Ok(());
3980            }
3981
3982            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3983            // are envelope_size bytes.
3984            let cur_offset: usize = (5 - 1) * envelope_size;
3985
3986            // Zero reserved fields.
3987            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3988
3989            // Safety:
3990            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3991            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3992            //   envelope_size bytes, there is always sufficient room.
3993            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3994                self.covered_features
3995                    .as_ref()
3996                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3997                encoder,
3998                offset + cur_offset,
3999                depth,
4000            )?;
4001
4002            _prev_end_offset = cur_offset + envelope_size;
4003            if 6 > max_ordinal {
4004                return Ok(());
4005            }
4006
4007            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4008            // are envelope_size bytes.
4009            let cur_offset: usize = (6 - 1) * envelope_size;
4010
4011            // Zero reserved fields.
4012            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4013
4014            // Safety:
4015            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4016            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4017            //   envelope_size bytes, there is always sufficient room.
4018            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4019                self.corpus_num_inputs
4020                    .as_ref()
4021                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4022                encoder,
4023                offset + cur_offset,
4024                depth,
4025            )?;
4026
4027            _prev_end_offset = cur_offset + envelope_size;
4028            if 7 > max_ordinal {
4029                return Ok(());
4030            }
4031
4032            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4033            // are envelope_size bytes.
4034            let cur_offset: usize = (7 - 1) * envelope_size;
4035
4036            // Zero reserved fields.
4037            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4038
4039            // Safety:
4040            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4041            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4042            //   envelope_size bytes, there is always sufficient room.
4043            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4044                self.corpus_total_size
4045                    .as_ref()
4046                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4047                encoder,
4048                offset + cur_offset,
4049                depth,
4050            )?;
4051
4052            _prev_end_offset = cur_offset + envelope_size;
4053            if 8 > max_ordinal {
4054                return Ok(());
4055            }
4056
4057            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4058            // are envelope_size bytes.
4059            let cur_offset: usize = (8 - 1) * envelope_size;
4060
4061            // Zero reserved fields.
4062            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4063
4064            // Safety:
4065            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4066            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4067            //   envelope_size bytes, there is always sufficient room.
4068            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ProcessStats, 256>, D>(
4069            self.process_stats.as_ref().map(<fidl::encoding::Vector<ProcessStats, 256> as fidl::encoding::ValueTypeMarker>::borrow),
4070            encoder, offset + cur_offset, depth
4071        )?;
4072
4073            _prev_end_offset = cur_offset + envelope_size;
4074
4075            Ok(())
4076        }
4077    }
4078
4079    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Status {
4080        #[inline(always)]
4081        fn new_empty() -> Self {
4082            Self::default()
4083        }
4084
4085        unsafe fn decode(
4086            &mut self,
4087            decoder: &mut fidl::encoding::Decoder<'_, D>,
4088            offset: usize,
4089            mut depth: fidl::encoding::Depth,
4090        ) -> fidl::Result<()> {
4091            decoder.debug_check_bounds::<Self>(offset);
4092            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4093                None => return Err(fidl::Error::NotNullable),
4094                Some(len) => len,
4095            };
4096            // Calling decoder.out_of_line_offset(0) is not allowed.
4097            if len == 0 {
4098                return Ok(());
4099            };
4100            depth.increment()?;
4101            let envelope_size = 8;
4102            let bytes_len = len * envelope_size;
4103            let offset = decoder.out_of_line_offset(bytes_len)?;
4104            // Decode the envelope for each type.
4105            let mut _next_ordinal_to_read = 0;
4106            let mut next_offset = offset;
4107            let end_offset = offset + bytes_len;
4108            _next_ordinal_to_read += 1;
4109            if next_offset >= end_offset {
4110                return Ok(());
4111            }
4112
4113            // Decode unknown envelopes for gaps in ordinals.
4114            while _next_ordinal_to_read < 1 {
4115                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4116                _next_ordinal_to_read += 1;
4117                next_offset += envelope_size;
4118            }
4119
4120            let next_out_of_line = decoder.next_out_of_line();
4121            let handles_before = decoder.remaining_handles();
4122            if let Some((inlined, num_bytes, num_handles)) =
4123                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4124            {
4125                let member_inline_size =
4126                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4127                if inlined != (member_inline_size <= 4) {
4128                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4129                }
4130                let inner_offset;
4131                let mut inner_depth = depth.clone();
4132                if inlined {
4133                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4134                    inner_offset = next_offset;
4135                } else {
4136                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4137                    inner_depth.increment()?;
4138                }
4139                let val_ref = self.running.get_or_insert_with(|| fidl::new_empty!(bool, D));
4140                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4141                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4142                {
4143                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4144                }
4145                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4146                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4147                }
4148            }
4149
4150            next_offset += envelope_size;
4151            _next_ordinal_to_read += 1;
4152            if next_offset >= end_offset {
4153                return Ok(());
4154            }
4155
4156            // Decode unknown envelopes for gaps in ordinals.
4157            while _next_ordinal_to_read < 2 {
4158                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4159                _next_ordinal_to_read += 1;
4160                next_offset += envelope_size;
4161            }
4162
4163            let next_out_of_line = decoder.next_out_of_line();
4164            let handles_before = decoder.remaining_handles();
4165            if let Some((inlined, num_bytes, num_handles)) =
4166                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4167            {
4168                let member_inline_size =
4169                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4170                if inlined != (member_inline_size <= 4) {
4171                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4172                }
4173                let inner_offset;
4174                let mut inner_depth = depth.clone();
4175                if inlined {
4176                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4177                    inner_offset = next_offset;
4178                } else {
4179                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4180                    inner_depth.increment()?;
4181                }
4182                let val_ref = self.runs.get_or_insert_with(|| fidl::new_empty!(u32, D));
4183                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4184                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4185                {
4186                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4187                }
4188                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4189                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4190                }
4191            }
4192
4193            next_offset += envelope_size;
4194            _next_ordinal_to_read += 1;
4195            if next_offset >= end_offset {
4196                return Ok(());
4197            }
4198
4199            // Decode unknown envelopes for gaps in ordinals.
4200            while _next_ordinal_to_read < 3 {
4201                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4202                _next_ordinal_to_read += 1;
4203                next_offset += envelope_size;
4204            }
4205
4206            let next_out_of_line = decoder.next_out_of_line();
4207            let handles_before = decoder.remaining_handles();
4208            if let Some((inlined, num_bytes, num_handles)) =
4209                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4210            {
4211                let member_inline_size =
4212                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4213                if inlined != (member_inline_size <= 4) {
4214                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4215                }
4216                let inner_offset;
4217                let mut inner_depth = depth.clone();
4218                if inlined {
4219                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4220                    inner_offset = next_offset;
4221                } else {
4222                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4223                    inner_depth.increment()?;
4224                }
4225                let val_ref = self.elapsed.get_or_insert_with(|| fidl::new_empty!(i64, D));
4226                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4227                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4228                {
4229                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4230                }
4231                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4232                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4233                }
4234            }
4235
4236            next_offset += envelope_size;
4237            _next_ordinal_to_read += 1;
4238            if next_offset >= end_offset {
4239                return Ok(());
4240            }
4241
4242            // Decode unknown envelopes for gaps in ordinals.
4243            while _next_ordinal_to_read < 4 {
4244                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4245                _next_ordinal_to_read += 1;
4246                next_offset += envelope_size;
4247            }
4248
4249            let next_out_of_line = decoder.next_out_of_line();
4250            let handles_before = decoder.remaining_handles();
4251            if let Some((inlined, num_bytes, num_handles)) =
4252                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4253            {
4254                let member_inline_size =
4255                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4256                if inlined != (member_inline_size <= 4) {
4257                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4258                }
4259                let inner_offset;
4260                let mut inner_depth = depth.clone();
4261                if inlined {
4262                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4263                    inner_offset = next_offset;
4264                } else {
4265                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4266                    inner_depth.increment()?;
4267                }
4268                let val_ref = self.covered_pcs.get_or_insert_with(|| fidl::new_empty!(u64, D));
4269                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4270                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4271                {
4272                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4273                }
4274                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4275                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4276                }
4277            }
4278
4279            next_offset += envelope_size;
4280            _next_ordinal_to_read += 1;
4281            if next_offset >= end_offset {
4282                return Ok(());
4283            }
4284
4285            // Decode unknown envelopes for gaps in ordinals.
4286            while _next_ordinal_to_read < 5 {
4287                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4288                _next_ordinal_to_read += 1;
4289                next_offset += envelope_size;
4290            }
4291
4292            let next_out_of_line = decoder.next_out_of_line();
4293            let handles_before = decoder.remaining_handles();
4294            if let Some((inlined, num_bytes, num_handles)) =
4295                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4296            {
4297                let member_inline_size =
4298                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4299                if inlined != (member_inline_size <= 4) {
4300                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4301                }
4302                let inner_offset;
4303                let mut inner_depth = depth.clone();
4304                if inlined {
4305                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4306                    inner_offset = next_offset;
4307                } else {
4308                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4309                    inner_depth.increment()?;
4310                }
4311                let val_ref = self.covered_features.get_or_insert_with(|| fidl::new_empty!(u64, D));
4312                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4313                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4314                {
4315                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4316                }
4317                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4318                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4319                }
4320            }
4321
4322            next_offset += envelope_size;
4323            _next_ordinal_to_read += 1;
4324            if next_offset >= end_offset {
4325                return Ok(());
4326            }
4327
4328            // Decode unknown envelopes for gaps in ordinals.
4329            while _next_ordinal_to_read < 6 {
4330                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4331                _next_ordinal_to_read += 1;
4332                next_offset += envelope_size;
4333            }
4334
4335            let next_out_of_line = decoder.next_out_of_line();
4336            let handles_before = decoder.remaining_handles();
4337            if let Some((inlined, num_bytes, num_handles)) =
4338                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4339            {
4340                let member_inline_size =
4341                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4342                if inlined != (member_inline_size <= 4) {
4343                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4344                }
4345                let inner_offset;
4346                let mut inner_depth = depth.clone();
4347                if inlined {
4348                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4349                    inner_offset = next_offset;
4350                } else {
4351                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4352                    inner_depth.increment()?;
4353                }
4354                let val_ref =
4355                    self.corpus_num_inputs.get_or_insert_with(|| fidl::new_empty!(u64, D));
4356                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4357                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4358                {
4359                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4360                }
4361                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4362                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4363                }
4364            }
4365
4366            next_offset += envelope_size;
4367            _next_ordinal_to_read += 1;
4368            if next_offset >= end_offset {
4369                return Ok(());
4370            }
4371
4372            // Decode unknown envelopes for gaps in ordinals.
4373            while _next_ordinal_to_read < 7 {
4374                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4375                _next_ordinal_to_read += 1;
4376                next_offset += envelope_size;
4377            }
4378
4379            let next_out_of_line = decoder.next_out_of_line();
4380            let handles_before = decoder.remaining_handles();
4381            if let Some((inlined, num_bytes, num_handles)) =
4382                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4383            {
4384                let member_inline_size =
4385                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4386                if inlined != (member_inline_size <= 4) {
4387                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4388                }
4389                let inner_offset;
4390                let mut inner_depth = depth.clone();
4391                if inlined {
4392                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4393                    inner_offset = next_offset;
4394                } else {
4395                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4396                    inner_depth.increment()?;
4397                }
4398                let val_ref =
4399                    self.corpus_total_size.get_or_insert_with(|| fidl::new_empty!(u64, D));
4400                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4401                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4402                {
4403                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4404                }
4405                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4406                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4407                }
4408            }
4409
4410            next_offset += envelope_size;
4411            _next_ordinal_to_read += 1;
4412            if next_offset >= end_offset {
4413                return Ok(());
4414            }
4415
4416            // Decode unknown envelopes for gaps in ordinals.
4417            while _next_ordinal_to_read < 8 {
4418                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4419                _next_ordinal_to_read += 1;
4420                next_offset += envelope_size;
4421            }
4422
4423            let next_out_of_line = decoder.next_out_of_line();
4424            let handles_before = decoder.remaining_handles();
4425            if let Some((inlined, num_bytes, num_handles)) =
4426                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4427            {
4428                let member_inline_size = <fidl::encoding::Vector<ProcessStats, 256> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4429                if inlined != (member_inline_size <= 4) {
4430                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4431                }
4432                let inner_offset;
4433                let mut inner_depth = depth.clone();
4434                if inlined {
4435                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4436                    inner_offset = next_offset;
4437                } else {
4438                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4439                    inner_depth.increment()?;
4440                }
4441                let val_ref = self.process_stats.get_or_insert_with(
4442                    || fidl::new_empty!(fidl::encoding::Vector<ProcessStats, 256>, D),
4443                );
4444                fidl::decode!(fidl::encoding::Vector<ProcessStats, 256>, D, val_ref, decoder, inner_offset, inner_depth)?;
4445                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4446                {
4447                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4448                }
4449                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4450                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4451                }
4452            }
4453
4454            next_offset += envelope_size;
4455
4456            // Decode the remaining unknown envelopes.
4457            while next_offset < end_offset {
4458                _next_ordinal_to_read += 1;
4459                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4460                next_offset += envelope_size;
4461            }
4462
4463            Ok(())
4464        }
4465    }
4466}