eigenlayer_contract_deployer/bindings/core/
registrycoordinator.rs

1#![allow(clippy::all, clippy::pedantic, clippy::nursery, warnings, unknown_lints, rustdoc::all, elided_lifetimes_in_paths)]
2use RegistryCoordinator::*;
3
4///Module containing a contract's types and functions.
5/**
6
7```solidity
8library BN254 {
9    struct G1Point { uint256 X; uint256 Y; }
10    struct G2Point { uint256[2] X; uint256[2] Y; }
11}
12```*/
13#[allow(
14    non_camel_case_types,
15    non_snake_case,
16    clippy::pub_underscore_fields,
17    clippy::style,
18    clippy::empty_structs_with_brackets
19)]
20pub mod BN254 {
21    use super::*;
22    use alloy::sol_types as alloy_sol_types;
23    #[derive(Default, Debug, PartialEq, Eq, Hash)]
24    /**```solidity
25struct G1Point { uint256 X; uint256 Y; }
26```*/
27    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
28    #[derive(Clone)]
29    pub struct G1Point {
30        #[allow(missing_docs)]
31        pub X: alloy::sol_types::private::primitives::aliases::U256,
32        #[allow(missing_docs)]
33        pub Y: alloy::sol_types::private::primitives::aliases::U256,
34    }
35    #[allow(
36        non_camel_case_types,
37        non_snake_case,
38        clippy::pub_underscore_fields,
39        clippy::style
40    )]
41    const _: () = {
42        use alloy::sol_types as alloy_sol_types;
43        #[doc(hidden)]
44        type UnderlyingSolTuple<'a> = (
45            alloy::sol_types::sol_data::Uint<256>,
46            alloy::sol_types::sol_data::Uint<256>,
47        );
48        #[doc(hidden)]
49        type UnderlyingRustTuple<'a> = (
50            alloy::sol_types::private::primitives::aliases::U256,
51            alloy::sol_types::private::primitives::aliases::U256,
52        );
53        #[cfg(test)]
54        #[allow(dead_code, unreachable_patterns)]
55        fn _type_assertion(
56            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
57        ) {
58            match _t {
59                alloy_sol_types::private::AssertTypeEq::<
60                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
61                >(_) => {}
62            }
63        }
64        #[automatically_derived]
65        #[doc(hidden)]
66        impl ::core::convert::From<G1Point> for UnderlyingRustTuple<'_> {
67            fn from(value: G1Point) -> Self {
68                (value.X, value.Y)
69            }
70        }
71        #[automatically_derived]
72        #[doc(hidden)]
73        impl ::core::convert::From<UnderlyingRustTuple<'_>> for G1Point {
74            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
75                Self { X: tuple.0, Y: tuple.1 }
76            }
77        }
78        #[automatically_derived]
79        impl alloy_sol_types::SolValue for G1Point {
80            type SolType = Self;
81        }
82        #[automatically_derived]
83        impl alloy_sol_types::private::SolTypeValue<Self> for G1Point {
84            #[inline]
85            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
86                (
87                    <alloy::sol_types::sol_data::Uint<
88                        256,
89                    > as alloy_sol_types::SolType>::tokenize(&self.X),
90                    <alloy::sol_types::sol_data::Uint<
91                        256,
92                    > as alloy_sol_types::SolType>::tokenize(&self.Y),
93                )
94            }
95            #[inline]
96            fn stv_abi_encoded_size(&self) -> usize {
97                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
98                    return size;
99                }
100                let tuple = <UnderlyingRustTuple<
101                    '_,
102                > as ::core::convert::From<Self>>::from(self.clone());
103                <UnderlyingSolTuple<
104                    '_,
105                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
106            }
107            #[inline]
108            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
109                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
110            }
111            #[inline]
112            fn stv_abi_encode_packed_to(
113                &self,
114                out: &mut alloy_sol_types::private::Vec<u8>,
115            ) {
116                let tuple = <UnderlyingRustTuple<
117                    '_,
118                > as ::core::convert::From<Self>>::from(self.clone());
119                <UnderlyingSolTuple<
120                    '_,
121                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
122            }
123            #[inline]
124            fn stv_abi_packed_encoded_size(&self) -> usize {
125                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
126                    return size;
127                }
128                let tuple = <UnderlyingRustTuple<
129                    '_,
130                > as ::core::convert::From<Self>>::from(self.clone());
131                <UnderlyingSolTuple<
132                    '_,
133                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
134            }
135        }
136        #[automatically_derived]
137        impl alloy_sol_types::SolType for G1Point {
138            type RustType = Self;
139            type Token<'a> = <UnderlyingSolTuple<
140                'a,
141            > as alloy_sol_types::SolType>::Token<'a>;
142            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
143            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
144                '_,
145            > as alloy_sol_types::SolType>::ENCODED_SIZE;
146            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
147                '_,
148            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
149            #[inline]
150            fn valid_token(token: &Self::Token<'_>) -> bool {
151                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
152            }
153            #[inline]
154            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
155                let tuple = <UnderlyingSolTuple<
156                    '_,
157                > as alloy_sol_types::SolType>::detokenize(token);
158                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
159            }
160        }
161        #[automatically_derived]
162        impl alloy_sol_types::SolStruct for G1Point {
163            const NAME: &'static str = "G1Point";
164            #[inline]
165            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
166                alloy_sol_types::private::Cow::Borrowed("G1Point(uint256 X,uint256 Y)")
167            }
168            #[inline]
169            fn eip712_components() -> alloy_sol_types::private::Vec<
170                alloy_sol_types::private::Cow<'static, str>,
171            > {
172                alloy_sol_types::private::Vec::new()
173            }
174            #[inline]
175            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
176                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
177            }
178            #[inline]
179            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
180                [
181                    <alloy::sol_types::sol_data::Uint<
182                        256,
183                    > as alloy_sol_types::SolType>::eip712_data_word(&self.X)
184                        .0,
185                    <alloy::sol_types::sol_data::Uint<
186                        256,
187                    > as alloy_sol_types::SolType>::eip712_data_word(&self.Y)
188                        .0,
189                ]
190                    .concat()
191            }
192        }
193        #[automatically_derived]
194        impl alloy_sol_types::EventTopic for G1Point {
195            #[inline]
196            fn topic_preimage_length(rust: &Self::RustType) -> usize {
197                0usize
198                    + <alloy::sol_types::sol_data::Uint<
199                        256,
200                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.X)
201                    + <alloy::sol_types::sol_data::Uint<
202                        256,
203                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.Y)
204            }
205            #[inline]
206            fn encode_topic_preimage(
207                rust: &Self::RustType,
208                out: &mut alloy_sol_types::private::Vec<u8>,
209            ) {
210                out.reserve(
211                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
212                );
213                <alloy::sol_types::sol_data::Uint<
214                    256,
215                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.X, out);
216                <alloy::sol_types::sol_data::Uint<
217                    256,
218                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.Y, out);
219            }
220            #[inline]
221            fn encode_topic(
222                rust: &Self::RustType,
223            ) -> alloy_sol_types::abi::token::WordToken {
224                let mut out = alloy_sol_types::private::Vec::new();
225                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
226                    rust,
227                    &mut out,
228                );
229                alloy_sol_types::abi::token::WordToken(
230                    alloy_sol_types::private::keccak256(out),
231                )
232            }
233        }
234    };
235    #[derive(Default, Debug, PartialEq, Eq, Hash)]
236    /**```solidity
237struct G2Point { uint256[2] X; uint256[2] Y; }
238```*/
239    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
240    #[derive(Clone)]
241    pub struct G2Point {
242        #[allow(missing_docs)]
243        pub X: [alloy::sol_types::private::primitives::aliases::U256; 2usize],
244        #[allow(missing_docs)]
245        pub Y: [alloy::sol_types::private::primitives::aliases::U256; 2usize],
246    }
247    #[allow(
248        non_camel_case_types,
249        non_snake_case,
250        clippy::pub_underscore_fields,
251        clippy::style
252    )]
253    const _: () = {
254        use alloy::sol_types as alloy_sol_types;
255        #[doc(hidden)]
256        type UnderlyingSolTuple<'a> = (
257            alloy::sol_types::sol_data::FixedArray<
258                alloy::sol_types::sol_data::Uint<256>,
259                2usize,
260            >,
261            alloy::sol_types::sol_data::FixedArray<
262                alloy::sol_types::sol_data::Uint<256>,
263                2usize,
264            >,
265        );
266        #[doc(hidden)]
267        type UnderlyingRustTuple<'a> = (
268            [alloy::sol_types::private::primitives::aliases::U256; 2usize],
269            [alloy::sol_types::private::primitives::aliases::U256; 2usize],
270        );
271        #[cfg(test)]
272        #[allow(dead_code, unreachable_patterns)]
273        fn _type_assertion(
274            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
275        ) {
276            match _t {
277                alloy_sol_types::private::AssertTypeEq::<
278                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
279                >(_) => {}
280            }
281        }
282        #[automatically_derived]
283        #[doc(hidden)]
284        impl ::core::convert::From<G2Point> for UnderlyingRustTuple<'_> {
285            fn from(value: G2Point) -> Self {
286                (value.X, value.Y)
287            }
288        }
289        #[automatically_derived]
290        #[doc(hidden)]
291        impl ::core::convert::From<UnderlyingRustTuple<'_>> for G2Point {
292            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
293                Self { X: tuple.0, Y: tuple.1 }
294            }
295        }
296        #[automatically_derived]
297        impl alloy_sol_types::SolValue for G2Point {
298            type SolType = Self;
299        }
300        #[automatically_derived]
301        impl alloy_sol_types::private::SolTypeValue<Self> for G2Point {
302            #[inline]
303            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
304                (
305                    <alloy::sol_types::sol_data::FixedArray<
306                        alloy::sol_types::sol_data::Uint<256>,
307                        2usize,
308                    > as alloy_sol_types::SolType>::tokenize(&self.X),
309                    <alloy::sol_types::sol_data::FixedArray<
310                        alloy::sol_types::sol_data::Uint<256>,
311                        2usize,
312                    > as alloy_sol_types::SolType>::tokenize(&self.Y),
313                )
314            }
315            #[inline]
316            fn stv_abi_encoded_size(&self) -> usize {
317                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
318                    return size;
319                }
320                let tuple = <UnderlyingRustTuple<
321                    '_,
322                > as ::core::convert::From<Self>>::from(self.clone());
323                <UnderlyingSolTuple<
324                    '_,
325                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
326            }
327            #[inline]
328            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
329                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
330            }
331            #[inline]
332            fn stv_abi_encode_packed_to(
333                &self,
334                out: &mut alloy_sol_types::private::Vec<u8>,
335            ) {
336                let tuple = <UnderlyingRustTuple<
337                    '_,
338                > as ::core::convert::From<Self>>::from(self.clone());
339                <UnderlyingSolTuple<
340                    '_,
341                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
342            }
343            #[inline]
344            fn stv_abi_packed_encoded_size(&self) -> usize {
345                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
346                    return size;
347                }
348                let tuple = <UnderlyingRustTuple<
349                    '_,
350                > as ::core::convert::From<Self>>::from(self.clone());
351                <UnderlyingSolTuple<
352                    '_,
353                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
354            }
355        }
356        #[automatically_derived]
357        impl alloy_sol_types::SolType for G2Point {
358            type RustType = Self;
359            type Token<'a> = <UnderlyingSolTuple<
360                'a,
361            > as alloy_sol_types::SolType>::Token<'a>;
362            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
363            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
364                '_,
365            > as alloy_sol_types::SolType>::ENCODED_SIZE;
366            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
367                '_,
368            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
369            #[inline]
370            fn valid_token(token: &Self::Token<'_>) -> bool {
371                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
372            }
373            #[inline]
374            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
375                let tuple = <UnderlyingSolTuple<
376                    '_,
377                > as alloy_sol_types::SolType>::detokenize(token);
378                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
379            }
380        }
381        #[automatically_derived]
382        impl alloy_sol_types::SolStruct for G2Point {
383            const NAME: &'static str = "G2Point";
384            #[inline]
385            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
386                alloy_sol_types::private::Cow::Borrowed(
387                    "G2Point(uint256[2] X,uint256[2] Y)",
388                )
389            }
390            #[inline]
391            fn eip712_components() -> alloy_sol_types::private::Vec<
392                alloy_sol_types::private::Cow<'static, str>,
393            > {
394                alloy_sol_types::private::Vec::new()
395            }
396            #[inline]
397            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
398                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
399            }
400            #[inline]
401            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
402                [
403                    <alloy::sol_types::sol_data::FixedArray<
404                        alloy::sol_types::sol_data::Uint<256>,
405                        2usize,
406                    > as alloy_sol_types::SolType>::eip712_data_word(&self.X)
407                        .0,
408                    <alloy::sol_types::sol_data::FixedArray<
409                        alloy::sol_types::sol_data::Uint<256>,
410                        2usize,
411                    > as alloy_sol_types::SolType>::eip712_data_word(&self.Y)
412                        .0,
413                ]
414                    .concat()
415            }
416        }
417        #[automatically_derived]
418        impl alloy_sol_types::EventTopic for G2Point {
419            #[inline]
420            fn topic_preimage_length(rust: &Self::RustType) -> usize {
421                0usize
422                    + <alloy::sol_types::sol_data::FixedArray<
423                        alloy::sol_types::sol_data::Uint<256>,
424                        2usize,
425                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.X)
426                    + <alloy::sol_types::sol_data::FixedArray<
427                        alloy::sol_types::sol_data::Uint<256>,
428                        2usize,
429                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.Y)
430            }
431            #[inline]
432            fn encode_topic_preimage(
433                rust: &Self::RustType,
434                out: &mut alloy_sol_types::private::Vec<u8>,
435            ) {
436                out.reserve(
437                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
438                );
439                <alloy::sol_types::sol_data::FixedArray<
440                    alloy::sol_types::sol_data::Uint<256>,
441                    2usize,
442                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.X, out);
443                <alloy::sol_types::sol_data::FixedArray<
444                    alloy::sol_types::sol_data::Uint<256>,
445                    2usize,
446                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.Y, out);
447            }
448            #[inline]
449            fn encode_topic(
450                rust: &Self::RustType,
451            ) -> alloy_sol_types::abi::token::WordToken {
452                let mut out = alloy_sol_types::private::Vec::new();
453                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
454                    rust,
455                    &mut out,
456                );
457                alloy_sol_types::abi::token::WordToken(
458                    alloy_sol_types::private::keccak256(out),
459                )
460            }
461        }
462    };
463    use alloy::contract as alloy_contract;
464    /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance.
465
466See the [wrapper's documentation](`BN254Instance`) for more details.*/
467    #[inline]
468    pub const fn new<
469        T: alloy_contract::private::Transport + ::core::clone::Clone,
470        P: alloy_contract::private::Provider<T, N>,
471        N: alloy_contract::private::Network,
472    >(
473        address: alloy_sol_types::private::Address,
474        provider: P,
475    ) -> BN254Instance<T, P, N> {
476        BN254Instance::<T, P, N>::new(address, provider)
477    }
478    /**A [`BN254`](self) instance.
479
480Contains type-safe methods for interacting with an on-chain instance of the
481[`BN254`](self) contract located at a given `address`, using a given
482provider `P`.
483
484If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
485documentation on how to provide it), the `deploy` and `deploy_builder` methods can
486be used to deploy a new instance of the contract.
487
488See the [module-level documentation](self) for all the available methods.*/
489    #[derive(Clone)]
490    pub struct BN254Instance<T, P, N = alloy_contract::private::Ethereum> {
491        address: alloy_sol_types::private::Address,
492        provider: P,
493        _network_transport: ::core::marker::PhantomData<(N, T)>,
494    }
495    #[automatically_derived]
496    impl<T, P, N> ::core::fmt::Debug for BN254Instance<T, P, N> {
497        #[inline]
498        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
499            f.debug_tuple("BN254Instance").field(&self.address).finish()
500        }
501    }
502    /// Instantiation and getters/setters.
503    #[automatically_derived]
504    impl<
505        T: alloy_contract::private::Transport + ::core::clone::Clone,
506        P: alloy_contract::private::Provider<T, N>,
507        N: alloy_contract::private::Network,
508    > BN254Instance<T, P, N> {
509        /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance.
510
511See the [wrapper's documentation](`BN254Instance`) for more details.*/
512        #[inline]
513        pub const fn new(
514            address: alloy_sol_types::private::Address,
515            provider: P,
516        ) -> Self {
517            Self {
518                address,
519                provider,
520                _network_transport: ::core::marker::PhantomData,
521            }
522        }
523        /// Returns a reference to the address.
524        #[inline]
525        pub const fn address(&self) -> &alloy_sol_types::private::Address {
526            &self.address
527        }
528        /// Sets the address.
529        #[inline]
530        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
531            self.address = address;
532        }
533        /// Sets the address and returns `self`.
534        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
535            self.set_address(address);
536            self
537        }
538        /// Returns a reference to the provider.
539        #[inline]
540        pub const fn provider(&self) -> &P {
541            &self.provider
542        }
543    }
544    impl<T, P: ::core::clone::Clone, N> BN254Instance<T, &P, N> {
545        /// Clones the provider and returns a new instance with the cloned provider.
546        #[inline]
547        pub fn with_cloned_provider(self) -> BN254Instance<T, P, N> {
548            BN254Instance {
549                address: self.address,
550                provider: ::core::clone::Clone::clone(&self.provider),
551                _network_transport: ::core::marker::PhantomData,
552            }
553        }
554    }
555    /// Function calls.
556    #[automatically_derived]
557    impl<
558        T: alloy_contract::private::Transport + ::core::clone::Clone,
559        P: alloy_contract::private::Provider<T, N>,
560        N: alloy_contract::private::Network,
561    > BN254Instance<T, P, N> {
562        /// Creates a new call builder using this contract instance's provider and address.
563        ///
564        /// Note that the call can be any function call, not just those defined in this
565        /// contract. Prefer using the other methods for building type-safe contract calls.
566        pub fn call_builder<C: alloy_sol_types::SolCall>(
567            &self,
568            call: &C,
569        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
570            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
571        }
572    }
573    /// Event filters.
574    #[automatically_derived]
575    impl<
576        T: alloy_contract::private::Transport + ::core::clone::Clone,
577        P: alloy_contract::private::Provider<T, N>,
578        N: alloy_contract::private::Network,
579    > BN254Instance<T, P, N> {
580        /// Creates a new event filter using this contract instance's provider and address.
581        ///
582        /// Note that the type can be any event, not just those defined in this contract.
583        /// Prefer using the other methods for building type-safe event filters.
584        pub fn event_filter<E: alloy_sol_types::SolEvent>(
585            &self,
586        ) -> alloy_contract::Event<T, &P, E, N> {
587            alloy_contract::Event::new_sol(&self.provider, &self.address)
588        }
589    }
590}
591///Module containing a contract's types and functions.
592/**
593
594```solidity
595library IBLSApkRegistryTypes {
596    struct PubkeyRegistrationParams { BN254.G1Point pubkeyRegistrationSignature; BN254.G1Point pubkeyG1; BN254.G2Point pubkeyG2; }
597}
598```*/
599#[allow(
600    non_camel_case_types,
601    non_snake_case,
602    clippy::pub_underscore_fields,
603    clippy::style,
604    clippy::empty_structs_with_brackets
605)]
606pub mod IBLSApkRegistryTypes {
607    use super::*;
608    use alloy::sol_types as alloy_sol_types;
609    #[derive(Default, Debug, PartialEq, Eq, Hash)]
610    /**```solidity
611struct PubkeyRegistrationParams { BN254.G1Point pubkeyRegistrationSignature; BN254.G1Point pubkeyG1; BN254.G2Point pubkeyG2; }
612```*/
613    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
614    #[derive(Clone)]
615    pub struct PubkeyRegistrationParams {
616        #[allow(missing_docs)]
617        pub pubkeyRegistrationSignature: <BN254::G1Point as alloy::sol_types::SolType>::RustType,
618        #[allow(missing_docs)]
619        pub pubkeyG1: <BN254::G1Point as alloy::sol_types::SolType>::RustType,
620        #[allow(missing_docs)]
621        pub pubkeyG2: <BN254::G2Point as alloy::sol_types::SolType>::RustType,
622    }
623    #[allow(
624        non_camel_case_types,
625        non_snake_case,
626        clippy::pub_underscore_fields,
627        clippy::style
628    )]
629    const _: () = {
630        use alloy::sol_types as alloy_sol_types;
631        #[doc(hidden)]
632        type UnderlyingSolTuple<'a> = (BN254::G1Point, BN254::G1Point, BN254::G2Point);
633        #[doc(hidden)]
634        type UnderlyingRustTuple<'a> = (
635            <BN254::G1Point as alloy::sol_types::SolType>::RustType,
636            <BN254::G1Point as alloy::sol_types::SolType>::RustType,
637            <BN254::G2Point as alloy::sol_types::SolType>::RustType,
638        );
639        #[cfg(test)]
640        #[allow(dead_code, unreachable_patterns)]
641        fn _type_assertion(
642            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
643        ) {
644            match _t {
645                alloy_sol_types::private::AssertTypeEq::<
646                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
647                >(_) => {}
648            }
649        }
650        #[automatically_derived]
651        #[doc(hidden)]
652        impl ::core::convert::From<PubkeyRegistrationParams>
653        for UnderlyingRustTuple<'_> {
654            fn from(value: PubkeyRegistrationParams) -> Self {
655                (value.pubkeyRegistrationSignature, value.pubkeyG1, value.pubkeyG2)
656            }
657        }
658        #[automatically_derived]
659        #[doc(hidden)]
660        impl ::core::convert::From<UnderlyingRustTuple<'_>>
661        for PubkeyRegistrationParams {
662            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
663                Self {
664                    pubkeyRegistrationSignature: tuple.0,
665                    pubkeyG1: tuple.1,
666                    pubkeyG2: tuple.2,
667                }
668            }
669        }
670        #[automatically_derived]
671        impl alloy_sol_types::SolValue for PubkeyRegistrationParams {
672            type SolType = Self;
673        }
674        #[automatically_derived]
675        impl alloy_sol_types::private::SolTypeValue<Self> for PubkeyRegistrationParams {
676            #[inline]
677            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
678                (
679                    <BN254::G1Point as alloy_sol_types::SolType>::tokenize(
680                        &self.pubkeyRegistrationSignature,
681                    ),
682                    <BN254::G1Point as alloy_sol_types::SolType>::tokenize(
683                        &self.pubkeyG1,
684                    ),
685                    <BN254::G2Point as alloy_sol_types::SolType>::tokenize(
686                        &self.pubkeyG2,
687                    ),
688                )
689            }
690            #[inline]
691            fn stv_abi_encoded_size(&self) -> usize {
692                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
693                    return size;
694                }
695                let tuple = <UnderlyingRustTuple<
696                    '_,
697                > as ::core::convert::From<Self>>::from(self.clone());
698                <UnderlyingSolTuple<
699                    '_,
700                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
701            }
702            #[inline]
703            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
704                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
705            }
706            #[inline]
707            fn stv_abi_encode_packed_to(
708                &self,
709                out: &mut alloy_sol_types::private::Vec<u8>,
710            ) {
711                let tuple = <UnderlyingRustTuple<
712                    '_,
713                > as ::core::convert::From<Self>>::from(self.clone());
714                <UnderlyingSolTuple<
715                    '_,
716                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
717            }
718            #[inline]
719            fn stv_abi_packed_encoded_size(&self) -> usize {
720                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
721                    return size;
722                }
723                let tuple = <UnderlyingRustTuple<
724                    '_,
725                > as ::core::convert::From<Self>>::from(self.clone());
726                <UnderlyingSolTuple<
727                    '_,
728                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
729            }
730        }
731        #[automatically_derived]
732        impl alloy_sol_types::SolType for PubkeyRegistrationParams {
733            type RustType = Self;
734            type Token<'a> = <UnderlyingSolTuple<
735                'a,
736            > as alloy_sol_types::SolType>::Token<'a>;
737            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
738            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
739                '_,
740            > as alloy_sol_types::SolType>::ENCODED_SIZE;
741            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
742                '_,
743            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
744            #[inline]
745            fn valid_token(token: &Self::Token<'_>) -> bool {
746                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
747            }
748            #[inline]
749            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
750                let tuple = <UnderlyingSolTuple<
751                    '_,
752                > as alloy_sol_types::SolType>::detokenize(token);
753                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
754            }
755        }
756        #[automatically_derived]
757        impl alloy_sol_types::SolStruct for PubkeyRegistrationParams {
758            const NAME: &'static str = "PubkeyRegistrationParams";
759            #[inline]
760            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
761                alloy_sol_types::private::Cow::Borrowed(
762                    "PubkeyRegistrationParams(BN254.G1Point pubkeyRegistrationSignature,BN254.G1Point pubkeyG1,BN254.G2Point pubkeyG2)",
763                )
764            }
765            #[inline]
766            fn eip712_components() -> alloy_sol_types::private::Vec<
767                alloy_sol_types::private::Cow<'static, str>,
768            > {
769                let mut components = alloy_sol_types::private::Vec::with_capacity(3);
770                components
771                    .push(
772                        <BN254::G1Point as alloy_sol_types::SolStruct>::eip712_root_type(),
773                    );
774                components
775                    .extend(
776                        <BN254::G1Point as alloy_sol_types::SolStruct>::eip712_components(),
777                    );
778                components
779                    .push(
780                        <BN254::G1Point as alloy_sol_types::SolStruct>::eip712_root_type(),
781                    );
782                components
783                    .extend(
784                        <BN254::G1Point as alloy_sol_types::SolStruct>::eip712_components(),
785                    );
786                components
787                    .push(
788                        <BN254::G2Point as alloy_sol_types::SolStruct>::eip712_root_type(),
789                    );
790                components
791                    .extend(
792                        <BN254::G2Point as alloy_sol_types::SolStruct>::eip712_components(),
793                    );
794                components
795            }
796            #[inline]
797            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
798                [
799                    <BN254::G1Point as alloy_sol_types::SolType>::eip712_data_word(
800                            &self.pubkeyRegistrationSignature,
801                        )
802                        .0,
803                    <BN254::G1Point as alloy_sol_types::SolType>::eip712_data_word(
804                            &self.pubkeyG1,
805                        )
806                        .0,
807                    <BN254::G2Point as alloy_sol_types::SolType>::eip712_data_word(
808                            &self.pubkeyG2,
809                        )
810                        .0,
811                ]
812                    .concat()
813            }
814        }
815        #[automatically_derived]
816        impl alloy_sol_types::EventTopic for PubkeyRegistrationParams {
817            #[inline]
818            fn topic_preimage_length(rust: &Self::RustType) -> usize {
819                0usize
820                    + <BN254::G1Point as alloy_sol_types::EventTopic>::topic_preimage_length(
821                        &rust.pubkeyRegistrationSignature,
822                    )
823                    + <BN254::G1Point as alloy_sol_types::EventTopic>::topic_preimage_length(
824                        &rust.pubkeyG1,
825                    )
826                    + <BN254::G2Point as alloy_sol_types::EventTopic>::topic_preimage_length(
827                        &rust.pubkeyG2,
828                    )
829            }
830            #[inline]
831            fn encode_topic_preimage(
832                rust: &Self::RustType,
833                out: &mut alloy_sol_types::private::Vec<u8>,
834            ) {
835                out.reserve(
836                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
837                );
838                <BN254::G1Point as alloy_sol_types::EventTopic>::encode_topic_preimage(
839                    &rust.pubkeyRegistrationSignature,
840                    out,
841                );
842                <BN254::G1Point as alloy_sol_types::EventTopic>::encode_topic_preimage(
843                    &rust.pubkeyG1,
844                    out,
845                );
846                <BN254::G2Point as alloy_sol_types::EventTopic>::encode_topic_preimage(
847                    &rust.pubkeyG2,
848                    out,
849                );
850            }
851            #[inline]
852            fn encode_topic(
853                rust: &Self::RustType,
854            ) -> alloy_sol_types::abi::token::WordToken {
855                let mut out = alloy_sol_types::private::Vec::new();
856                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
857                    rust,
858                    &mut out,
859                );
860                alloy_sol_types::abi::token::WordToken(
861                    alloy_sol_types::private::keccak256(out),
862                )
863            }
864        }
865    };
866    use alloy::contract as alloy_contract;
867    /**Creates a new wrapper around an on-chain [`IBLSApkRegistryTypes`](self) contract instance.
868
869See the [wrapper's documentation](`IBLSApkRegistryTypesInstance`) for more details.*/
870    #[inline]
871    pub const fn new<
872        T: alloy_contract::private::Transport + ::core::clone::Clone,
873        P: alloy_contract::private::Provider<T, N>,
874        N: alloy_contract::private::Network,
875    >(
876        address: alloy_sol_types::private::Address,
877        provider: P,
878    ) -> IBLSApkRegistryTypesInstance<T, P, N> {
879        IBLSApkRegistryTypesInstance::<T, P, N>::new(address, provider)
880    }
881    /**A [`IBLSApkRegistryTypes`](self) instance.
882
883Contains type-safe methods for interacting with an on-chain instance of the
884[`IBLSApkRegistryTypes`](self) contract located at a given `address`, using a given
885provider `P`.
886
887If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
888documentation on how to provide it), the `deploy` and `deploy_builder` methods can
889be used to deploy a new instance of the contract.
890
891See the [module-level documentation](self) for all the available methods.*/
892    #[derive(Clone)]
893    pub struct IBLSApkRegistryTypesInstance<
894        T,
895        P,
896        N = alloy_contract::private::Ethereum,
897    > {
898        address: alloy_sol_types::private::Address,
899        provider: P,
900        _network_transport: ::core::marker::PhantomData<(N, T)>,
901    }
902    #[automatically_derived]
903    impl<T, P, N> ::core::fmt::Debug for IBLSApkRegistryTypesInstance<T, P, N> {
904        #[inline]
905        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
906            f.debug_tuple("IBLSApkRegistryTypesInstance").field(&self.address).finish()
907        }
908    }
909    /// Instantiation and getters/setters.
910    #[automatically_derived]
911    impl<
912        T: alloy_contract::private::Transport + ::core::clone::Clone,
913        P: alloy_contract::private::Provider<T, N>,
914        N: alloy_contract::private::Network,
915    > IBLSApkRegistryTypesInstance<T, P, N> {
916        /**Creates a new wrapper around an on-chain [`IBLSApkRegistryTypes`](self) contract instance.
917
918See the [wrapper's documentation](`IBLSApkRegistryTypesInstance`) for more details.*/
919        #[inline]
920        pub const fn new(
921            address: alloy_sol_types::private::Address,
922            provider: P,
923        ) -> Self {
924            Self {
925                address,
926                provider,
927                _network_transport: ::core::marker::PhantomData,
928            }
929        }
930        /// Returns a reference to the address.
931        #[inline]
932        pub const fn address(&self) -> &alloy_sol_types::private::Address {
933            &self.address
934        }
935        /// Sets the address.
936        #[inline]
937        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
938            self.address = address;
939        }
940        /// Sets the address and returns `self`.
941        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
942            self.set_address(address);
943            self
944        }
945        /// Returns a reference to the provider.
946        #[inline]
947        pub const fn provider(&self) -> &P {
948            &self.provider
949        }
950    }
951    impl<T, P: ::core::clone::Clone, N> IBLSApkRegistryTypesInstance<T, &P, N> {
952        /// Clones the provider and returns a new instance with the cloned provider.
953        #[inline]
954        pub fn with_cloned_provider(self) -> IBLSApkRegistryTypesInstance<T, P, N> {
955            IBLSApkRegistryTypesInstance {
956                address: self.address,
957                provider: ::core::clone::Clone::clone(&self.provider),
958                _network_transport: ::core::marker::PhantomData,
959            }
960        }
961    }
962    /// Function calls.
963    #[automatically_derived]
964    impl<
965        T: alloy_contract::private::Transport + ::core::clone::Clone,
966        P: alloy_contract::private::Provider<T, N>,
967        N: alloy_contract::private::Network,
968    > IBLSApkRegistryTypesInstance<T, P, N> {
969        /// Creates a new call builder using this contract instance's provider and address.
970        ///
971        /// Note that the call can be any function call, not just those defined in this
972        /// contract. Prefer using the other methods for building type-safe contract calls.
973        pub fn call_builder<C: alloy_sol_types::SolCall>(
974            &self,
975            call: &C,
976        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
977            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
978        }
979    }
980    /// Event filters.
981    #[automatically_derived]
982    impl<
983        T: alloy_contract::private::Transport + ::core::clone::Clone,
984        P: alloy_contract::private::Provider<T, N>,
985        N: alloy_contract::private::Network,
986    > IBLSApkRegistryTypesInstance<T, P, N> {
987        /// Creates a new event filter using this contract instance's provider and address.
988        ///
989        /// Note that the type can be any event, not just those defined in this contract.
990        /// Prefer using the other methods for building type-safe event filters.
991        pub fn event_filter<E: alloy_sol_types::SolEvent>(
992            &self,
993        ) -> alloy_contract::Event<T, &P, E, N> {
994            alloy_contract::Event::new_sol(&self.provider, &self.address)
995        }
996    }
997}
998///Module containing a contract's types and functions.
999/**
1000
1001```solidity
1002library IRegistryCoordinatorTypes {
1003    struct RegistryCoordinatorParams { address serviceManager; SlashingRegistryParams slashingParams; }
1004    struct SlashingRegistryParams { address stakeRegistry; address blsApkRegistry; address indexRegistry; address socketRegistry; address allocationManager; address pauserRegistry; }
1005}
1006```*/
1007#[allow(
1008    non_camel_case_types,
1009    non_snake_case,
1010    clippy::pub_underscore_fields,
1011    clippy::style,
1012    clippy::empty_structs_with_brackets
1013)]
1014pub mod IRegistryCoordinatorTypes {
1015    use super::*;
1016    use alloy::sol_types as alloy_sol_types;
1017    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1018    /**```solidity
1019struct RegistryCoordinatorParams { address serviceManager; SlashingRegistryParams slashingParams; }
1020```*/
1021    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1022    #[derive(Clone)]
1023    pub struct RegistryCoordinatorParams {
1024        #[allow(missing_docs)]
1025        pub serviceManager: alloy::sol_types::private::Address,
1026        #[allow(missing_docs)]
1027        pub slashingParams: <SlashingRegistryParams as alloy::sol_types::SolType>::RustType,
1028    }
1029    #[allow(
1030        non_camel_case_types,
1031        non_snake_case,
1032        clippy::pub_underscore_fields,
1033        clippy::style
1034    )]
1035    const _: () = {
1036        use alloy::sol_types as alloy_sol_types;
1037        #[doc(hidden)]
1038        type UnderlyingSolTuple<'a> = (
1039            alloy::sol_types::sol_data::Address,
1040            SlashingRegistryParams,
1041        );
1042        #[doc(hidden)]
1043        type UnderlyingRustTuple<'a> = (
1044            alloy::sol_types::private::Address,
1045            <SlashingRegistryParams as alloy::sol_types::SolType>::RustType,
1046        );
1047        #[cfg(test)]
1048        #[allow(dead_code, unreachable_patterns)]
1049        fn _type_assertion(
1050            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1051        ) {
1052            match _t {
1053                alloy_sol_types::private::AssertTypeEq::<
1054                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1055                >(_) => {}
1056            }
1057        }
1058        #[automatically_derived]
1059        #[doc(hidden)]
1060        impl ::core::convert::From<RegistryCoordinatorParams>
1061        for UnderlyingRustTuple<'_> {
1062            fn from(value: RegistryCoordinatorParams) -> Self {
1063                (value.serviceManager, value.slashingParams)
1064            }
1065        }
1066        #[automatically_derived]
1067        #[doc(hidden)]
1068        impl ::core::convert::From<UnderlyingRustTuple<'_>>
1069        for RegistryCoordinatorParams {
1070            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1071                Self {
1072                    serviceManager: tuple.0,
1073                    slashingParams: tuple.1,
1074                }
1075            }
1076        }
1077        #[automatically_derived]
1078        impl alloy_sol_types::SolValue for RegistryCoordinatorParams {
1079            type SolType = Self;
1080        }
1081        #[automatically_derived]
1082        impl alloy_sol_types::private::SolTypeValue<Self> for RegistryCoordinatorParams {
1083            #[inline]
1084            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
1085                (
1086                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1087                        &self.serviceManager,
1088                    ),
1089                    <SlashingRegistryParams as alloy_sol_types::SolType>::tokenize(
1090                        &self.slashingParams,
1091                    ),
1092                )
1093            }
1094            #[inline]
1095            fn stv_abi_encoded_size(&self) -> usize {
1096                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
1097                    return size;
1098                }
1099                let tuple = <UnderlyingRustTuple<
1100                    '_,
1101                > as ::core::convert::From<Self>>::from(self.clone());
1102                <UnderlyingSolTuple<
1103                    '_,
1104                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
1105            }
1106            #[inline]
1107            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
1108                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
1109            }
1110            #[inline]
1111            fn stv_abi_encode_packed_to(
1112                &self,
1113                out: &mut alloy_sol_types::private::Vec<u8>,
1114            ) {
1115                let tuple = <UnderlyingRustTuple<
1116                    '_,
1117                > as ::core::convert::From<Self>>::from(self.clone());
1118                <UnderlyingSolTuple<
1119                    '_,
1120                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
1121            }
1122            #[inline]
1123            fn stv_abi_packed_encoded_size(&self) -> usize {
1124                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
1125                    return size;
1126                }
1127                let tuple = <UnderlyingRustTuple<
1128                    '_,
1129                > as ::core::convert::From<Self>>::from(self.clone());
1130                <UnderlyingSolTuple<
1131                    '_,
1132                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
1133            }
1134        }
1135        #[automatically_derived]
1136        impl alloy_sol_types::SolType for RegistryCoordinatorParams {
1137            type RustType = Self;
1138            type Token<'a> = <UnderlyingSolTuple<
1139                'a,
1140            > as alloy_sol_types::SolType>::Token<'a>;
1141            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
1142            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1143                '_,
1144            > as alloy_sol_types::SolType>::ENCODED_SIZE;
1145            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1146                '_,
1147            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
1148            #[inline]
1149            fn valid_token(token: &Self::Token<'_>) -> bool {
1150                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
1151            }
1152            #[inline]
1153            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
1154                let tuple = <UnderlyingSolTuple<
1155                    '_,
1156                > as alloy_sol_types::SolType>::detokenize(token);
1157                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
1158            }
1159        }
1160        #[automatically_derived]
1161        impl alloy_sol_types::SolStruct for RegistryCoordinatorParams {
1162            const NAME: &'static str = "RegistryCoordinatorParams";
1163            #[inline]
1164            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
1165                alloy_sol_types::private::Cow::Borrowed(
1166                    "RegistryCoordinatorParams(address serviceManager,SlashingRegistryParams slashingParams)",
1167                )
1168            }
1169            #[inline]
1170            fn eip712_components() -> alloy_sol_types::private::Vec<
1171                alloy_sol_types::private::Cow<'static, str>,
1172            > {
1173                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
1174                components
1175                    .push(
1176                        <SlashingRegistryParams as alloy_sol_types::SolStruct>::eip712_root_type(),
1177                    );
1178                components
1179                    .extend(
1180                        <SlashingRegistryParams as alloy_sol_types::SolStruct>::eip712_components(),
1181                    );
1182                components
1183            }
1184            #[inline]
1185            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
1186                [
1187                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
1188                            &self.serviceManager,
1189                        )
1190                        .0,
1191                    <SlashingRegistryParams as alloy_sol_types::SolType>::eip712_data_word(
1192                            &self.slashingParams,
1193                        )
1194                        .0,
1195                ]
1196                    .concat()
1197            }
1198        }
1199        #[automatically_derived]
1200        impl alloy_sol_types::EventTopic for RegistryCoordinatorParams {
1201            #[inline]
1202            fn topic_preimage_length(rust: &Self::RustType) -> usize {
1203                0usize
1204                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
1205                        &rust.serviceManager,
1206                    )
1207                    + <SlashingRegistryParams as alloy_sol_types::EventTopic>::topic_preimage_length(
1208                        &rust.slashingParams,
1209                    )
1210            }
1211            #[inline]
1212            fn encode_topic_preimage(
1213                rust: &Self::RustType,
1214                out: &mut alloy_sol_types::private::Vec<u8>,
1215            ) {
1216                out.reserve(
1217                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
1218                );
1219                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
1220                    &rust.serviceManager,
1221                    out,
1222                );
1223                <SlashingRegistryParams as alloy_sol_types::EventTopic>::encode_topic_preimage(
1224                    &rust.slashingParams,
1225                    out,
1226                );
1227            }
1228            #[inline]
1229            fn encode_topic(
1230                rust: &Self::RustType,
1231            ) -> alloy_sol_types::abi::token::WordToken {
1232                let mut out = alloy_sol_types::private::Vec::new();
1233                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
1234                    rust,
1235                    &mut out,
1236                );
1237                alloy_sol_types::abi::token::WordToken(
1238                    alloy_sol_types::private::keccak256(out),
1239                )
1240            }
1241        }
1242    };
1243    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1244    /**```solidity
1245struct SlashingRegistryParams { address stakeRegistry; address blsApkRegistry; address indexRegistry; address socketRegistry; address allocationManager; address pauserRegistry; }
1246```*/
1247    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1248    #[derive(Clone)]
1249    pub struct SlashingRegistryParams {
1250        #[allow(missing_docs)]
1251        pub stakeRegistry: alloy::sol_types::private::Address,
1252        #[allow(missing_docs)]
1253        pub blsApkRegistry: alloy::sol_types::private::Address,
1254        #[allow(missing_docs)]
1255        pub indexRegistry: alloy::sol_types::private::Address,
1256        #[allow(missing_docs)]
1257        pub socketRegistry: alloy::sol_types::private::Address,
1258        #[allow(missing_docs)]
1259        pub allocationManager: alloy::sol_types::private::Address,
1260        #[allow(missing_docs)]
1261        pub pauserRegistry: alloy::sol_types::private::Address,
1262    }
1263    #[allow(
1264        non_camel_case_types,
1265        non_snake_case,
1266        clippy::pub_underscore_fields,
1267        clippy::style
1268    )]
1269    const _: () = {
1270        use alloy::sol_types as alloy_sol_types;
1271        #[doc(hidden)]
1272        type UnderlyingSolTuple<'a> = (
1273            alloy::sol_types::sol_data::Address,
1274            alloy::sol_types::sol_data::Address,
1275            alloy::sol_types::sol_data::Address,
1276            alloy::sol_types::sol_data::Address,
1277            alloy::sol_types::sol_data::Address,
1278            alloy::sol_types::sol_data::Address,
1279        );
1280        #[doc(hidden)]
1281        type UnderlyingRustTuple<'a> = (
1282            alloy::sol_types::private::Address,
1283            alloy::sol_types::private::Address,
1284            alloy::sol_types::private::Address,
1285            alloy::sol_types::private::Address,
1286            alloy::sol_types::private::Address,
1287            alloy::sol_types::private::Address,
1288        );
1289        #[cfg(test)]
1290        #[allow(dead_code, unreachable_patterns)]
1291        fn _type_assertion(
1292            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1293        ) {
1294            match _t {
1295                alloy_sol_types::private::AssertTypeEq::<
1296                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1297                >(_) => {}
1298            }
1299        }
1300        #[automatically_derived]
1301        #[doc(hidden)]
1302        impl ::core::convert::From<SlashingRegistryParams> for UnderlyingRustTuple<'_> {
1303            fn from(value: SlashingRegistryParams) -> Self {
1304                (
1305                    value.stakeRegistry,
1306                    value.blsApkRegistry,
1307                    value.indexRegistry,
1308                    value.socketRegistry,
1309                    value.allocationManager,
1310                    value.pauserRegistry,
1311                )
1312            }
1313        }
1314        #[automatically_derived]
1315        #[doc(hidden)]
1316        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SlashingRegistryParams {
1317            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1318                Self {
1319                    stakeRegistry: tuple.0,
1320                    blsApkRegistry: tuple.1,
1321                    indexRegistry: tuple.2,
1322                    socketRegistry: tuple.3,
1323                    allocationManager: tuple.4,
1324                    pauserRegistry: tuple.5,
1325                }
1326            }
1327        }
1328        #[automatically_derived]
1329        impl alloy_sol_types::SolValue for SlashingRegistryParams {
1330            type SolType = Self;
1331        }
1332        #[automatically_derived]
1333        impl alloy_sol_types::private::SolTypeValue<Self> for SlashingRegistryParams {
1334            #[inline]
1335            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
1336                (
1337                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1338                        &self.stakeRegistry,
1339                    ),
1340                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1341                        &self.blsApkRegistry,
1342                    ),
1343                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1344                        &self.indexRegistry,
1345                    ),
1346                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1347                        &self.socketRegistry,
1348                    ),
1349                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1350                        &self.allocationManager,
1351                    ),
1352                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1353                        &self.pauserRegistry,
1354                    ),
1355                )
1356            }
1357            #[inline]
1358            fn stv_abi_encoded_size(&self) -> usize {
1359                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
1360                    return size;
1361                }
1362                let tuple = <UnderlyingRustTuple<
1363                    '_,
1364                > as ::core::convert::From<Self>>::from(self.clone());
1365                <UnderlyingSolTuple<
1366                    '_,
1367                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
1368            }
1369            #[inline]
1370            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
1371                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
1372            }
1373            #[inline]
1374            fn stv_abi_encode_packed_to(
1375                &self,
1376                out: &mut alloy_sol_types::private::Vec<u8>,
1377            ) {
1378                let tuple = <UnderlyingRustTuple<
1379                    '_,
1380                > as ::core::convert::From<Self>>::from(self.clone());
1381                <UnderlyingSolTuple<
1382                    '_,
1383                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
1384            }
1385            #[inline]
1386            fn stv_abi_packed_encoded_size(&self) -> usize {
1387                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
1388                    return size;
1389                }
1390                let tuple = <UnderlyingRustTuple<
1391                    '_,
1392                > as ::core::convert::From<Self>>::from(self.clone());
1393                <UnderlyingSolTuple<
1394                    '_,
1395                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
1396            }
1397        }
1398        #[automatically_derived]
1399        impl alloy_sol_types::SolType for SlashingRegistryParams {
1400            type RustType = Self;
1401            type Token<'a> = <UnderlyingSolTuple<
1402                'a,
1403            > as alloy_sol_types::SolType>::Token<'a>;
1404            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
1405            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1406                '_,
1407            > as alloy_sol_types::SolType>::ENCODED_SIZE;
1408            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1409                '_,
1410            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
1411            #[inline]
1412            fn valid_token(token: &Self::Token<'_>) -> bool {
1413                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
1414            }
1415            #[inline]
1416            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
1417                let tuple = <UnderlyingSolTuple<
1418                    '_,
1419                > as alloy_sol_types::SolType>::detokenize(token);
1420                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
1421            }
1422        }
1423        #[automatically_derived]
1424        impl alloy_sol_types::SolStruct for SlashingRegistryParams {
1425            const NAME: &'static str = "SlashingRegistryParams";
1426            #[inline]
1427            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
1428                alloy_sol_types::private::Cow::Borrowed(
1429                    "SlashingRegistryParams(address stakeRegistry,address blsApkRegistry,address indexRegistry,address socketRegistry,address allocationManager,address pauserRegistry)",
1430                )
1431            }
1432            #[inline]
1433            fn eip712_components() -> alloy_sol_types::private::Vec<
1434                alloy_sol_types::private::Cow<'static, str>,
1435            > {
1436                alloy_sol_types::private::Vec::new()
1437            }
1438            #[inline]
1439            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
1440                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
1441            }
1442            #[inline]
1443            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
1444                [
1445                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
1446                            &self.stakeRegistry,
1447                        )
1448                        .0,
1449                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
1450                            &self.blsApkRegistry,
1451                        )
1452                        .0,
1453                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
1454                            &self.indexRegistry,
1455                        )
1456                        .0,
1457                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
1458                            &self.socketRegistry,
1459                        )
1460                        .0,
1461                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
1462                            &self.allocationManager,
1463                        )
1464                        .0,
1465                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
1466                            &self.pauserRegistry,
1467                        )
1468                        .0,
1469                ]
1470                    .concat()
1471            }
1472        }
1473        #[automatically_derived]
1474        impl alloy_sol_types::EventTopic for SlashingRegistryParams {
1475            #[inline]
1476            fn topic_preimage_length(rust: &Self::RustType) -> usize {
1477                0usize
1478                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
1479                        &rust.stakeRegistry,
1480                    )
1481                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
1482                        &rust.blsApkRegistry,
1483                    )
1484                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
1485                        &rust.indexRegistry,
1486                    )
1487                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
1488                        &rust.socketRegistry,
1489                    )
1490                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
1491                        &rust.allocationManager,
1492                    )
1493                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
1494                        &rust.pauserRegistry,
1495                    )
1496            }
1497            #[inline]
1498            fn encode_topic_preimage(
1499                rust: &Self::RustType,
1500                out: &mut alloy_sol_types::private::Vec<u8>,
1501            ) {
1502                out.reserve(
1503                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
1504                );
1505                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
1506                    &rust.stakeRegistry,
1507                    out,
1508                );
1509                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
1510                    &rust.blsApkRegistry,
1511                    out,
1512                );
1513                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
1514                    &rust.indexRegistry,
1515                    out,
1516                );
1517                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
1518                    &rust.socketRegistry,
1519                    out,
1520                );
1521                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
1522                    &rust.allocationManager,
1523                    out,
1524                );
1525                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
1526                    &rust.pauserRegistry,
1527                    out,
1528                );
1529            }
1530            #[inline]
1531            fn encode_topic(
1532                rust: &Self::RustType,
1533            ) -> alloy_sol_types::abi::token::WordToken {
1534                let mut out = alloy_sol_types::private::Vec::new();
1535                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
1536                    rust,
1537                    &mut out,
1538                );
1539                alloy_sol_types::abi::token::WordToken(
1540                    alloy_sol_types::private::keccak256(out),
1541                )
1542            }
1543        }
1544    };
1545    use alloy::contract as alloy_contract;
1546    /**Creates a new wrapper around an on-chain [`IRegistryCoordinatorTypes`](self) contract instance.
1547
1548See the [wrapper's documentation](`IRegistryCoordinatorTypesInstance`) for more details.*/
1549    #[inline]
1550    pub const fn new<
1551        T: alloy_contract::private::Transport + ::core::clone::Clone,
1552        P: alloy_contract::private::Provider<T, N>,
1553        N: alloy_contract::private::Network,
1554    >(
1555        address: alloy_sol_types::private::Address,
1556        provider: P,
1557    ) -> IRegistryCoordinatorTypesInstance<T, P, N> {
1558        IRegistryCoordinatorTypesInstance::<T, P, N>::new(address, provider)
1559    }
1560    /**A [`IRegistryCoordinatorTypes`](self) instance.
1561
1562Contains type-safe methods for interacting with an on-chain instance of the
1563[`IRegistryCoordinatorTypes`](self) contract located at a given `address`, using a given
1564provider `P`.
1565
1566If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
1567documentation on how to provide it), the `deploy` and `deploy_builder` methods can
1568be used to deploy a new instance of the contract.
1569
1570See the [module-level documentation](self) for all the available methods.*/
1571    #[derive(Clone)]
1572    pub struct IRegistryCoordinatorTypesInstance<
1573        T,
1574        P,
1575        N = alloy_contract::private::Ethereum,
1576    > {
1577        address: alloy_sol_types::private::Address,
1578        provider: P,
1579        _network_transport: ::core::marker::PhantomData<(N, T)>,
1580    }
1581    #[automatically_derived]
1582    impl<T, P, N> ::core::fmt::Debug for IRegistryCoordinatorTypesInstance<T, P, N> {
1583        #[inline]
1584        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1585            f.debug_tuple("IRegistryCoordinatorTypesInstance")
1586                .field(&self.address)
1587                .finish()
1588        }
1589    }
1590    /// Instantiation and getters/setters.
1591    #[automatically_derived]
1592    impl<
1593        T: alloy_contract::private::Transport + ::core::clone::Clone,
1594        P: alloy_contract::private::Provider<T, N>,
1595        N: alloy_contract::private::Network,
1596    > IRegistryCoordinatorTypesInstance<T, P, N> {
1597        /**Creates a new wrapper around an on-chain [`IRegistryCoordinatorTypes`](self) contract instance.
1598
1599See the [wrapper's documentation](`IRegistryCoordinatorTypesInstance`) for more details.*/
1600        #[inline]
1601        pub const fn new(
1602            address: alloy_sol_types::private::Address,
1603            provider: P,
1604        ) -> Self {
1605            Self {
1606                address,
1607                provider,
1608                _network_transport: ::core::marker::PhantomData,
1609            }
1610        }
1611        /// Returns a reference to the address.
1612        #[inline]
1613        pub const fn address(&self) -> &alloy_sol_types::private::Address {
1614            &self.address
1615        }
1616        /// Sets the address.
1617        #[inline]
1618        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
1619            self.address = address;
1620        }
1621        /// Sets the address and returns `self`.
1622        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
1623            self.set_address(address);
1624            self
1625        }
1626        /// Returns a reference to the provider.
1627        #[inline]
1628        pub const fn provider(&self) -> &P {
1629            &self.provider
1630        }
1631    }
1632    impl<T, P: ::core::clone::Clone, N> IRegistryCoordinatorTypesInstance<T, &P, N> {
1633        /// Clones the provider and returns a new instance with the cloned provider.
1634        #[inline]
1635        pub fn with_cloned_provider(self) -> IRegistryCoordinatorTypesInstance<T, P, N> {
1636            IRegistryCoordinatorTypesInstance {
1637                address: self.address,
1638                provider: ::core::clone::Clone::clone(&self.provider),
1639                _network_transport: ::core::marker::PhantomData,
1640            }
1641        }
1642    }
1643    /// Function calls.
1644    #[automatically_derived]
1645    impl<
1646        T: alloy_contract::private::Transport + ::core::clone::Clone,
1647        P: alloy_contract::private::Provider<T, N>,
1648        N: alloy_contract::private::Network,
1649    > IRegistryCoordinatorTypesInstance<T, P, N> {
1650        /// Creates a new call builder using this contract instance's provider and address.
1651        ///
1652        /// Note that the call can be any function call, not just those defined in this
1653        /// contract. Prefer using the other methods for building type-safe contract calls.
1654        pub fn call_builder<C: alloy_sol_types::SolCall>(
1655            &self,
1656            call: &C,
1657        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
1658            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
1659        }
1660    }
1661    /// Event filters.
1662    #[automatically_derived]
1663    impl<
1664        T: alloy_contract::private::Transport + ::core::clone::Clone,
1665        P: alloy_contract::private::Provider<T, N>,
1666        N: alloy_contract::private::Network,
1667    > IRegistryCoordinatorTypesInstance<T, P, N> {
1668        /// Creates a new event filter using this contract instance's provider and address.
1669        ///
1670        /// Note that the type can be any event, not just those defined in this contract.
1671        /// Prefer using the other methods for building type-safe event filters.
1672        pub fn event_filter<E: alloy_sol_types::SolEvent>(
1673            &self,
1674        ) -> alloy_contract::Event<T, &P, E, N> {
1675            alloy_contract::Event::new_sol(&self.provider, &self.address)
1676        }
1677    }
1678}
1679///Module containing a contract's types and functions.
1680/**
1681
1682```solidity
1683library ISignatureUtilsMixinTypes {
1684    struct SignatureWithSaltAndExpiry { bytes signature; bytes32 salt; uint256 expiry; }
1685}
1686```*/
1687#[allow(
1688    non_camel_case_types,
1689    non_snake_case,
1690    clippy::pub_underscore_fields,
1691    clippy::style,
1692    clippy::empty_structs_with_brackets
1693)]
1694pub mod ISignatureUtilsMixinTypes {
1695    use super::*;
1696    use alloy::sol_types as alloy_sol_types;
1697    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1698    /**```solidity
1699struct SignatureWithSaltAndExpiry { bytes signature; bytes32 salt; uint256 expiry; }
1700```*/
1701    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1702    #[derive(Clone)]
1703    pub struct SignatureWithSaltAndExpiry {
1704        #[allow(missing_docs)]
1705        pub signature: alloy::sol_types::private::Bytes,
1706        #[allow(missing_docs)]
1707        pub salt: alloy::sol_types::private::FixedBytes<32>,
1708        #[allow(missing_docs)]
1709        pub expiry: alloy::sol_types::private::primitives::aliases::U256,
1710    }
1711    #[allow(
1712        non_camel_case_types,
1713        non_snake_case,
1714        clippy::pub_underscore_fields,
1715        clippy::style
1716    )]
1717    const _: () = {
1718        use alloy::sol_types as alloy_sol_types;
1719        #[doc(hidden)]
1720        type UnderlyingSolTuple<'a> = (
1721            alloy::sol_types::sol_data::Bytes,
1722            alloy::sol_types::sol_data::FixedBytes<32>,
1723            alloy::sol_types::sol_data::Uint<256>,
1724        );
1725        #[doc(hidden)]
1726        type UnderlyingRustTuple<'a> = (
1727            alloy::sol_types::private::Bytes,
1728            alloy::sol_types::private::FixedBytes<32>,
1729            alloy::sol_types::private::primitives::aliases::U256,
1730        );
1731        #[cfg(test)]
1732        #[allow(dead_code, unreachable_patterns)]
1733        fn _type_assertion(
1734            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1735        ) {
1736            match _t {
1737                alloy_sol_types::private::AssertTypeEq::<
1738                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1739                >(_) => {}
1740            }
1741        }
1742        #[automatically_derived]
1743        #[doc(hidden)]
1744        impl ::core::convert::From<SignatureWithSaltAndExpiry>
1745        for UnderlyingRustTuple<'_> {
1746            fn from(value: SignatureWithSaltAndExpiry) -> Self {
1747                (value.signature, value.salt, value.expiry)
1748            }
1749        }
1750        #[automatically_derived]
1751        #[doc(hidden)]
1752        impl ::core::convert::From<UnderlyingRustTuple<'_>>
1753        for SignatureWithSaltAndExpiry {
1754            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1755                Self {
1756                    signature: tuple.0,
1757                    salt: tuple.1,
1758                    expiry: tuple.2,
1759                }
1760            }
1761        }
1762        #[automatically_derived]
1763        impl alloy_sol_types::SolValue for SignatureWithSaltAndExpiry {
1764            type SolType = Self;
1765        }
1766        #[automatically_derived]
1767        impl alloy_sol_types::private::SolTypeValue<Self>
1768        for SignatureWithSaltAndExpiry {
1769            #[inline]
1770            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
1771                (
1772                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
1773                        &self.signature,
1774                    ),
1775                    <alloy::sol_types::sol_data::FixedBytes<
1776                        32,
1777                    > as alloy_sol_types::SolType>::tokenize(&self.salt),
1778                    <alloy::sol_types::sol_data::Uint<
1779                        256,
1780                    > as alloy_sol_types::SolType>::tokenize(&self.expiry),
1781                )
1782            }
1783            #[inline]
1784            fn stv_abi_encoded_size(&self) -> usize {
1785                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
1786                    return size;
1787                }
1788                let tuple = <UnderlyingRustTuple<
1789                    '_,
1790                > as ::core::convert::From<Self>>::from(self.clone());
1791                <UnderlyingSolTuple<
1792                    '_,
1793                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
1794            }
1795            #[inline]
1796            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
1797                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
1798            }
1799            #[inline]
1800            fn stv_abi_encode_packed_to(
1801                &self,
1802                out: &mut alloy_sol_types::private::Vec<u8>,
1803            ) {
1804                let tuple = <UnderlyingRustTuple<
1805                    '_,
1806                > as ::core::convert::From<Self>>::from(self.clone());
1807                <UnderlyingSolTuple<
1808                    '_,
1809                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
1810            }
1811            #[inline]
1812            fn stv_abi_packed_encoded_size(&self) -> usize {
1813                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
1814                    return size;
1815                }
1816                let tuple = <UnderlyingRustTuple<
1817                    '_,
1818                > as ::core::convert::From<Self>>::from(self.clone());
1819                <UnderlyingSolTuple<
1820                    '_,
1821                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
1822            }
1823        }
1824        #[automatically_derived]
1825        impl alloy_sol_types::SolType for SignatureWithSaltAndExpiry {
1826            type RustType = Self;
1827            type Token<'a> = <UnderlyingSolTuple<
1828                'a,
1829            > as alloy_sol_types::SolType>::Token<'a>;
1830            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
1831            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1832                '_,
1833            > as alloy_sol_types::SolType>::ENCODED_SIZE;
1834            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1835                '_,
1836            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
1837            #[inline]
1838            fn valid_token(token: &Self::Token<'_>) -> bool {
1839                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
1840            }
1841            #[inline]
1842            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
1843                let tuple = <UnderlyingSolTuple<
1844                    '_,
1845                > as alloy_sol_types::SolType>::detokenize(token);
1846                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
1847            }
1848        }
1849        #[automatically_derived]
1850        impl alloy_sol_types::SolStruct for SignatureWithSaltAndExpiry {
1851            const NAME: &'static str = "SignatureWithSaltAndExpiry";
1852            #[inline]
1853            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
1854                alloy_sol_types::private::Cow::Borrowed(
1855                    "SignatureWithSaltAndExpiry(bytes signature,bytes32 salt,uint256 expiry)",
1856                )
1857            }
1858            #[inline]
1859            fn eip712_components() -> alloy_sol_types::private::Vec<
1860                alloy_sol_types::private::Cow<'static, str>,
1861            > {
1862                alloy_sol_types::private::Vec::new()
1863            }
1864            #[inline]
1865            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
1866                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
1867            }
1868            #[inline]
1869            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
1870                [
1871                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
1872                            &self.signature,
1873                        )
1874                        .0,
1875                    <alloy::sol_types::sol_data::FixedBytes<
1876                        32,
1877                    > as alloy_sol_types::SolType>::eip712_data_word(&self.salt)
1878                        .0,
1879                    <alloy::sol_types::sol_data::Uint<
1880                        256,
1881                    > as alloy_sol_types::SolType>::eip712_data_word(&self.expiry)
1882                        .0,
1883                ]
1884                    .concat()
1885            }
1886        }
1887        #[automatically_derived]
1888        impl alloy_sol_types::EventTopic for SignatureWithSaltAndExpiry {
1889            #[inline]
1890            fn topic_preimage_length(rust: &Self::RustType) -> usize {
1891                0usize
1892                    + <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
1893                        &rust.signature,
1894                    )
1895                    + <alloy::sol_types::sol_data::FixedBytes<
1896                        32,
1897                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.salt)
1898                    + <alloy::sol_types::sol_data::Uint<
1899                        256,
1900                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
1901                        &rust.expiry,
1902                    )
1903            }
1904            #[inline]
1905            fn encode_topic_preimage(
1906                rust: &Self::RustType,
1907                out: &mut alloy_sol_types::private::Vec<u8>,
1908            ) {
1909                out.reserve(
1910                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
1911                );
1912                <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
1913                    &rust.signature,
1914                    out,
1915                );
1916                <alloy::sol_types::sol_data::FixedBytes<
1917                    32,
1918                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1919                    &rust.salt,
1920                    out,
1921                );
1922                <alloy::sol_types::sol_data::Uint<
1923                    256,
1924                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1925                    &rust.expiry,
1926                    out,
1927                );
1928            }
1929            #[inline]
1930            fn encode_topic(
1931                rust: &Self::RustType,
1932            ) -> alloy_sol_types::abi::token::WordToken {
1933                let mut out = alloy_sol_types::private::Vec::new();
1934                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
1935                    rust,
1936                    &mut out,
1937                );
1938                alloy_sol_types::abi::token::WordToken(
1939                    alloy_sol_types::private::keccak256(out),
1940                )
1941            }
1942        }
1943    };
1944    use alloy::contract as alloy_contract;
1945    /**Creates a new wrapper around an on-chain [`ISignatureUtilsMixinTypes`](self) contract instance.
1946
1947See the [wrapper's documentation](`ISignatureUtilsMixinTypesInstance`) for more details.*/
1948    #[inline]
1949    pub const fn new<
1950        T: alloy_contract::private::Transport + ::core::clone::Clone,
1951        P: alloy_contract::private::Provider<T, N>,
1952        N: alloy_contract::private::Network,
1953    >(
1954        address: alloy_sol_types::private::Address,
1955        provider: P,
1956    ) -> ISignatureUtilsMixinTypesInstance<T, P, N> {
1957        ISignatureUtilsMixinTypesInstance::<T, P, N>::new(address, provider)
1958    }
1959    /**A [`ISignatureUtilsMixinTypes`](self) instance.
1960
1961Contains type-safe methods for interacting with an on-chain instance of the
1962[`ISignatureUtilsMixinTypes`](self) contract located at a given `address`, using a given
1963provider `P`.
1964
1965If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
1966documentation on how to provide it), the `deploy` and `deploy_builder` methods can
1967be used to deploy a new instance of the contract.
1968
1969See the [module-level documentation](self) for all the available methods.*/
1970    #[derive(Clone)]
1971    pub struct ISignatureUtilsMixinTypesInstance<
1972        T,
1973        P,
1974        N = alloy_contract::private::Ethereum,
1975    > {
1976        address: alloy_sol_types::private::Address,
1977        provider: P,
1978        _network_transport: ::core::marker::PhantomData<(N, T)>,
1979    }
1980    #[automatically_derived]
1981    impl<T, P, N> ::core::fmt::Debug for ISignatureUtilsMixinTypesInstance<T, P, N> {
1982        #[inline]
1983        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1984            f.debug_tuple("ISignatureUtilsMixinTypesInstance")
1985                .field(&self.address)
1986                .finish()
1987        }
1988    }
1989    /// Instantiation and getters/setters.
1990    #[automatically_derived]
1991    impl<
1992        T: alloy_contract::private::Transport + ::core::clone::Clone,
1993        P: alloy_contract::private::Provider<T, N>,
1994        N: alloy_contract::private::Network,
1995    > ISignatureUtilsMixinTypesInstance<T, P, N> {
1996        /**Creates a new wrapper around an on-chain [`ISignatureUtilsMixinTypes`](self) contract instance.
1997
1998See the [wrapper's documentation](`ISignatureUtilsMixinTypesInstance`) for more details.*/
1999        #[inline]
2000        pub const fn new(
2001            address: alloy_sol_types::private::Address,
2002            provider: P,
2003        ) -> Self {
2004            Self {
2005                address,
2006                provider,
2007                _network_transport: ::core::marker::PhantomData,
2008            }
2009        }
2010        /// Returns a reference to the address.
2011        #[inline]
2012        pub const fn address(&self) -> &alloy_sol_types::private::Address {
2013            &self.address
2014        }
2015        /// Sets the address.
2016        #[inline]
2017        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
2018            self.address = address;
2019        }
2020        /// Sets the address and returns `self`.
2021        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
2022            self.set_address(address);
2023            self
2024        }
2025        /// Returns a reference to the provider.
2026        #[inline]
2027        pub const fn provider(&self) -> &P {
2028            &self.provider
2029        }
2030    }
2031    impl<T, P: ::core::clone::Clone, N> ISignatureUtilsMixinTypesInstance<T, &P, N> {
2032        /// Clones the provider and returns a new instance with the cloned provider.
2033        #[inline]
2034        pub fn with_cloned_provider(self) -> ISignatureUtilsMixinTypesInstance<T, P, N> {
2035            ISignatureUtilsMixinTypesInstance {
2036                address: self.address,
2037                provider: ::core::clone::Clone::clone(&self.provider),
2038                _network_transport: ::core::marker::PhantomData,
2039            }
2040        }
2041    }
2042    /// Function calls.
2043    #[automatically_derived]
2044    impl<
2045        T: alloy_contract::private::Transport + ::core::clone::Clone,
2046        P: alloy_contract::private::Provider<T, N>,
2047        N: alloy_contract::private::Network,
2048    > ISignatureUtilsMixinTypesInstance<T, P, N> {
2049        /// Creates a new call builder using this contract instance's provider and address.
2050        ///
2051        /// Note that the call can be any function call, not just those defined in this
2052        /// contract. Prefer using the other methods for building type-safe contract calls.
2053        pub fn call_builder<C: alloy_sol_types::SolCall>(
2054            &self,
2055            call: &C,
2056        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
2057            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
2058        }
2059    }
2060    /// Event filters.
2061    #[automatically_derived]
2062    impl<
2063        T: alloy_contract::private::Transport + ::core::clone::Clone,
2064        P: alloy_contract::private::Provider<T, N>,
2065        N: alloy_contract::private::Network,
2066    > ISignatureUtilsMixinTypesInstance<T, P, N> {
2067        /// Creates a new event filter using this contract instance's provider and address.
2068        ///
2069        /// Note that the type can be any event, not just those defined in this contract.
2070        /// Prefer using the other methods for building type-safe event filters.
2071        pub fn event_filter<E: alloy_sol_types::SolEvent>(
2072            &self,
2073        ) -> alloy_contract::Event<T, &P, E, N> {
2074            alloy_contract::Event::new_sol(&self.provider, &self.address)
2075        }
2076    }
2077}
2078///Module containing a contract's types and functions.
2079/**
2080
2081```solidity
2082library ISlashingRegistryCoordinatorTypes {
2083    type OperatorStatus is uint8;
2084    struct OperatorInfo { bytes32 operatorId; OperatorStatus status; }
2085    struct OperatorKickParam { uint8 quorumNumber; address operator; }
2086    struct OperatorSetParam { uint32 maxOperatorCount; uint16 kickBIPsOfOperatorStake; uint16 kickBIPsOfTotalStake; }
2087    struct QuorumBitmapUpdate { uint32 updateBlockNumber; uint32 nextUpdateBlockNumber; uint192 quorumBitmap; }
2088}
2089```*/
2090#[allow(
2091    non_camel_case_types,
2092    non_snake_case,
2093    clippy::pub_underscore_fields,
2094    clippy::style,
2095    clippy::empty_structs_with_brackets
2096)]
2097pub mod ISlashingRegistryCoordinatorTypes {
2098    use super::*;
2099    use alloy::sol_types as alloy_sol_types;
2100    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2101    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2102    #[derive(Clone)]
2103    pub struct OperatorStatus(u8);
2104    const _: () = {
2105        use alloy::sol_types as alloy_sol_types;
2106        #[automatically_derived]
2107        impl alloy_sol_types::private::SolTypeValue<OperatorStatus> for u8 {
2108            #[inline]
2109            fn stv_to_tokens(
2110                &self,
2111            ) -> <alloy::sol_types::sol_data::Uint<
2112                8,
2113            > as alloy_sol_types::SolType>::Token<'_> {
2114                alloy_sol_types::private::SolTypeValue::<
2115                    alloy::sol_types::sol_data::Uint<8>,
2116                >::stv_to_tokens(self)
2117            }
2118            #[inline]
2119            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
2120                <alloy::sol_types::sol_data::Uint<
2121                    8,
2122                > as alloy_sol_types::SolType>::tokenize(self)
2123                    .0
2124            }
2125            #[inline]
2126            fn stv_abi_encode_packed_to(
2127                &self,
2128                out: &mut alloy_sol_types::private::Vec<u8>,
2129            ) {
2130                <alloy::sol_types::sol_data::Uint<
2131                    8,
2132                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
2133            }
2134            #[inline]
2135            fn stv_abi_packed_encoded_size(&self) -> usize {
2136                <alloy::sol_types::sol_data::Uint<
2137                    8,
2138                > as alloy_sol_types::SolType>::abi_encoded_size(self)
2139            }
2140        }
2141        #[automatically_derived]
2142        impl OperatorStatus {
2143            /// The Solidity type name.
2144            pub const NAME: &'static str = stringify!(@ name);
2145            /// Convert from the underlying value type.
2146            #[inline]
2147            pub const fn from(value: u8) -> Self {
2148                Self(value)
2149            }
2150            /// Return the underlying value.
2151            #[inline]
2152            pub const fn into(self) -> u8 {
2153                self.0
2154            }
2155            /// Return the single encoding of this value, delegating to the
2156            /// underlying type.
2157            #[inline]
2158            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
2159                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
2160            }
2161            /// Return the packed encoding of this value, delegating to the
2162            /// underlying type.
2163            #[inline]
2164            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
2165                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
2166            }
2167        }
2168        #[automatically_derived]
2169        impl alloy_sol_types::SolType for OperatorStatus {
2170            type RustType = u8;
2171            type Token<'a> = <alloy::sol_types::sol_data::Uint<
2172                8,
2173            > as alloy_sol_types::SolType>::Token<'a>;
2174            const SOL_NAME: &'static str = Self::NAME;
2175            const ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
2176                8,
2177            > as alloy_sol_types::SolType>::ENCODED_SIZE;
2178            const PACKED_ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
2179                8,
2180            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
2181            #[inline]
2182            fn valid_token(token: &Self::Token<'_>) -> bool {
2183                Self::type_check(token).is_ok()
2184            }
2185            #[inline]
2186            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
2187                <alloy::sol_types::sol_data::Uint<
2188                    8,
2189                > as alloy_sol_types::SolType>::type_check(token)
2190            }
2191            #[inline]
2192            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
2193                <alloy::sol_types::sol_data::Uint<
2194                    8,
2195                > as alloy_sol_types::SolType>::detokenize(token)
2196            }
2197        }
2198        #[automatically_derived]
2199        impl alloy_sol_types::EventTopic for OperatorStatus {
2200            #[inline]
2201            fn topic_preimage_length(rust: &Self::RustType) -> usize {
2202                <alloy::sol_types::sol_data::Uint<
2203                    8,
2204                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
2205            }
2206            #[inline]
2207            fn encode_topic_preimage(
2208                rust: &Self::RustType,
2209                out: &mut alloy_sol_types::private::Vec<u8>,
2210            ) {
2211                <alloy::sol_types::sol_data::Uint<
2212                    8,
2213                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
2214            }
2215            #[inline]
2216            fn encode_topic(
2217                rust: &Self::RustType,
2218            ) -> alloy_sol_types::abi::token::WordToken {
2219                <alloy::sol_types::sol_data::Uint<
2220                    8,
2221                > as alloy_sol_types::EventTopic>::encode_topic(rust)
2222            }
2223        }
2224    };
2225    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2226    /**```solidity
2227struct OperatorInfo { bytes32 operatorId; OperatorStatus status; }
2228```*/
2229    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2230    #[derive(Clone)]
2231    pub struct OperatorInfo {
2232        #[allow(missing_docs)]
2233        pub operatorId: alloy::sol_types::private::FixedBytes<32>,
2234        #[allow(missing_docs)]
2235        pub status: <OperatorStatus as alloy::sol_types::SolType>::RustType,
2236    }
2237    #[allow(
2238        non_camel_case_types,
2239        non_snake_case,
2240        clippy::pub_underscore_fields,
2241        clippy::style
2242    )]
2243    const _: () = {
2244        use alloy::sol_types as alloy_sol_types;
2245        #[doc(hidden)]
2246        type UnderlyingSolTuple<'a> = (
2247            alloy::sol_types::sol_data::FixedBytes<32>,
2248            OperatorStatus,
2249        );
2250        #[doc(hidden)]
2251        type UnderlyingRustTuple<'a> = (
2252            alloy::sol_types::private::FixedBytes<32>,
2253            <OperatorStatus as alloy::sol_types::SolType>::RustType,
2254        );
2255        #[cfg(test)]
2256        #[allow(dead_code, unreachable_patterns)]
2257        fn _type_assertion(
2258            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2259        ) {
2260            match _t {
2261                alloy_sol_types::private::AssertTypeEq::<
2262                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2263                >(_) => {}
2264            }
2265        }
2266        #[automatically_derived]
2267        #[doc(hidden)]
2268        impl ::core::convert::From<OperatorInfo> for UnderlyingRustTuple<'_> {
2269            fn from(value: OperatorInfo) -> Self {
2270                (value.operatorId, value.status)
2271            }
2272        }
2273        #[automatically_derived]
2274        #[doc(hidden)]
2275        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorInfo {
2276            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2277                Self {
2278                    operatorId: tuple.0,
2279                    status: tuple.1,
2280                }
2281            }
2282        }
2283        #[automatically_derived]
2284        impl alloy_sol_types::SolValue for OperatorInfo {
2285            type SolType = Self;
2286        }
2287        #[automatically_derived]
2288        impl alloy_sol_types::private::SolTypeValue<Self> for OperatorInfo {
2289            #[inline]
2290            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
2291                (
2292                    <alloy::sol_types::sol_data::FixedBytes<
2293                        32,
2294                    > as alloy_sol_types::SolType>::tokenize(&self.operatorId),
2295                    <OperatorStatus as alloy_sol_types::SolType>::tokenize(&self.status),
2296                )
2297            }
2298            #[inline]
2299            fn stv_abi_encoded_size(&self) -> usize {
2300                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
2301                    return size;
2302                }
2303                let tuple = <UnderlyingRustTuple<
2304                    '_,
2305                > as ::core::convert::From<Self>>::from(self.clone());
2306                <UnderlyingSolTuple<
2307                    '_,
2308                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
2309            }
2310            #[inline]
2311            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
2312                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
2313            }
2314            #[inline]
2315            fn stv_abi_encode_packed_to(
2316                &self,
2317                out: &mut alloy_sol_types::private::Vec<u8>,
2318            ) {
2319                let tuple = <UnderlyingRustTuple<
2320                    '_,
2321                > as ::core::convert::From<Self>>::from(self.clone());
2322                <UnderlyingSolTuple<
2323                    '_,
2324                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
2325            }
2326            #[inline]
2327            fn stv_abi_packed_encoded_size(&self) -> usize {
2328                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
2329                    return size;
2330                }
2331                let tuple = <UnderlyingRustTuple<
2332                    '_,
2333                > as ::core::convert::From<Self>>::from(self.clone());
2334                <UnderlyingSolTuple<
2335                    '_,
2336                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
2337            }
2338        }
2339        #[automatically_derived]
2340        impl alloy_sol_types::SolType for OperatorInfo {
2341            type RustType = Self;
2342            type Token<'a> = <UnderlyingSolTuple<
2343                'a,
2344            > as alloy_sol_types::SolType>::Token<'a>;
2345            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
2346            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
2347                '_,
2348            > as alloy_sol_types::SolType>::ENCODED_SIZE;
2349            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
2350                '_,
2351            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
2352            #[inline]
2353            fn valid_token(token: &Self::Token<'_>) -> bool {
2354                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
2355            }
2356            #[inline]
2357            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
2358                let tuple = <UnderlyingSolTuple<
2359                    '_,
2360                > as alloy_sol_types::SolType>::detokenize(token);
2361                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
2362            }
2363        }
2364        #[automatically_derived]
2365        impl alloy_sol_types::SolStruct for OperatorInfo {
2366            const NAME: &'static str = "OperatorInfo";
2367            #[inline]
2368            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
2369                alloy_sol_types::private::Cow::Borrowed(
2370                    "OperatorInfo(bytes32 operatorId,uint8 status)",
2371                )
2372            }
2373            #[inline]
2374            fn eip712_components() -> alloy_sol_types::private::Vec<
2375                alloy_sol_types::private::Cow<'static, str>,
2376            > {
2377                alloy_sol_types::private::Vec::new()
2378            }
2379            #[inline]
2380            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
2381                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
2382            }
2383            #[inline]
2384            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
2385                [
2386                    <alloy::sol_types::sol_data::FixedBytes<
2387                        32,
2388                    > as alloy_sol_types::SolType>::eip712_data_word(&self.operatorId)
2389                        .0,
2390                    <OperatorStatus as alloy_sol_types::SolType>::eip712_data_word(
2391                            &self.status,
2392                        )
2393                        .0,
2394                ]
2395                    .concat()
2396            }
2397        }
2398        #[automatically_derived]
2399        impl alloy_sol_types::EventTopic for OperatorInfo {
2400            #[inline]
2401            fn topic_preimage_length(rust: &Self::RustType) -> usize {
2402                0usize
2403                    + <alloy::sol_types::sol_data::FixedBytes<
2404                        32,
2405                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
2406                        &rust.operatorId,
2407                    )
2408                    + <OperatorStatus as alloy_sol_types::EventTopic>::topic_preimage_length(
2409                        &rust.status,
2410                    )
2411            }
2412            #[inline]
2413            fn encode_topic_preimage(
2414                rust: &Self::RustType,
2415                out: &mut alloy_sol_types::private::Vec<u8>,
2416            ) {
2417                out.reserve(
2418                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
2419                );
2420                <alloy::sol_types::sol_data::FixedBytes<
2421                    32,
2422                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2423                    &rust.operatorId,
2424                    out,
2425                );
2426                <OperatorStatus as alloy_sol_types::EventTopic>::encode_topic_preimage(
2427                    &rust.status,
2428                    out,
2429                );
2430            }
2431            #[inline]
2432            fn encode_topic(
2433                rust: &Self::RustType,
2434            ) -> alloy_sol_types::abi::token::WordToken {
2435                let mut out = alloy_sol_types::private::Vec::new();
2436                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
2437                    rust,
2438                    &mut out,
2439                );
2440                alloy_sol_types::abi::token::WordToken(
2441                    alloy_sol_types::private::keccak256(out),
2442                )
2443            }
2444        }
2445    };
2446    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2447    /**```solidity
2448struct OperatorKickParam { uint8 quorumNumber; address operator; }
2449```*/
2450    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2451    #[derive(Clone)]
2452    pub struct OperatorKickParam {
2453        #[allow(missing_docs)]
2454        pub quorumNumber: u8,
2455        #[allow(missing_docs)]
2456        pub operator: alloy::sol_types::private::Address,
2457    }
2458    #[allow(
2459        non_camel_case_types,
2460        non_snake_case,
2461        clippy::pub_underscore_fields,
2462        clippy::style
2463    )]
2464    const _: () = {
2465        use alloy::sol_types as alloy_sol_types;
2466        #[doc(hidden)]
2467        type UnderlyingSolTuple<'a> = (
2468            alloy::sol_types::sol_data::Uint<8>,
2469            alloy::sol_types::sol_data::Address,
2470        );
2471        #[doc(hidden)]
2472        type UnderlyingRustTuple<'a> = (u8, alloy::sol_types::private::Address);
2473        #[cfg(test)]
2474        #[allow(dead_code, unreachable_patterns)]
2475        fn _type_assertion(
2476            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2477        ) {
2478            match _t {
2479                alloy_sol_types::private::AssertTypeEq::<
2480                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2481                >(_) => {}
2482            }
2483        }
2484        #[automatically_derived]
2485        #[doc(hidden)]
2486        impl ::core::convert::From<OperatorKickParam> for UnderlyingRustTuple<'_> {
2487            fn from(value: OperatorKickParam) -> Self {
2488                (value.quorumNumber, value.operator)
2489            }
2490        }
2491        #[automatically_derived]
2492        #[doc(hidden)]
2493        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorKickParam {
2494            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2495                Self {
2496                    quorumNumber: tuple.0,
2497                    operator: tuple.1,
2498                }
2499            }
2500        }
2501        #[automatically_derived]
2502        impl alloy_sol_types::SolValue for OperatorKickParam {
2503            type SolType = Self;
2504        }
2505        #[automatically_derived]
2506        impl alloy_sol_types::private::SolTypeValue<Self> for OperatorKickParam {
2507            #[inline]
2508            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
2509                (
2510                    <alloy::sol_types::sol_data::Uint<
2511                        8,
2512                    > as alloy_sol_types::SolType>::tokenize(&self.quorumNumber),
2513                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2514                        &self.operator,
2515                    ),
2516                )
2517            }
2518            #[inline]
2519            fn stv_abi_encoded_size(&self) -> usize {
2520                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
2521                    return size;
2522                }
2523                let tuple = <UnderlyingRustTuple<
2524                    '_,
2525                > as ::core::convert::From<Self>>::from(self.clone());
2526                <UnderlyingSolTuple<
2527                    '_,
2528                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
2529            }
2530            #[inline]
2531            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
2532                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
2533            }
2534            #[inline]
2535            fn stv_abi_encode_packed_to(
2536                &self,
2537                out: &mut alloy_sol_types::private::Vec<u8>,
2538            ) {
2539                let tuple = <UnderlyingRustTuple<
2540                    '_,
2541                > as ::core::convert::From<Self>>::from(self.clone());
2542                <UnderlyingSolTuple<
2543                    '_,
2544                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
2545            }
2546            #[inline]
2547            fn stv_abi_packed_encoded_size(&self) -> usize {
2548                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
2549                    return size;
2550                }
2551                let tuple = <UnderlyingRustTuple<
2552                    '_,
2553                > as ::core::convert::From<Self>>::from(self.clone());
2554                <UnderlyingSolTuple<
2555                    '_,
2556                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
2557            }
2558        }
2559        #[automatically_derived]
2560        impl alloy_sol_types::SolType for OperatorKickParam {
2561            type RustType = Self;
2562            type Token<'a> = <UnderlyingSolTuple<
2563                'a,
2564            > as alloy_sol_types::SolType>::Token<'a>;
2565            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
2566            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
2567                '_,
2568            > as alloy_sol_types::SolType>::ENCODED_SIZE;
2569            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
2570                '_,
2571            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
2572            #[inline]
2573            fn valid_token(token: &Self::Token<'_>) -> bool {
2574                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
2575            }
2576            #[inline]
2577            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
2578                let tuple = <UnderlyingSolTuple<
2579                    '_,
2580                > as alloy_sol_types::SolType>::detokenize(token);
2581                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
2582            }
2583        }
2584        #[automatically_derived]
2585        impl alloy_sol_types::SolStruct for OperatorKickParam {
2586            const NAME: &'static str = "OperatorKickParam";
2587            #[inline]
2588            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
2589                alloy_sol_types::private::Cow::Borrowed(
2590                    "OperatorKickParam(uint8 quorumNumber,address operator)",
2591                )
2592            }
2593            #[inline]
2594            fn eip712_components() -> alloy_sol_types::private::Vec<
2595                alloy_sol_types::private::Cow<'static, str>,
2596            > {
2597                alloy_sol_types::private::Vec::new()
2598            }
2599            #[inline]
2600            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
2601                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
2602            }
2603            #[inline]
2604            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
2605                [
2606                    <alloy::sol_types::sol_data::Uint<
2607                        8,
2608                    > as alloy_sol_types::SolType>::eip712_data_word(&self.quorumNumber)
2609                        .0,
2610                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
2611                            &self.operator,
2612                        )
2613                        .0,
2614                ]
2615                    .concat()
2616            }
2617        }
2618        #[automatically_derived]
2619        impl alloy_sol_types::EventTopic for OperatorKickParam {
2620            #[inline]
2621            fn topic_preimage_length(rust: &Self::RustType) -> usize {
2622                0usize
2623                    + <alloy::sol_types::sol_data::Uint<
2624                        8,
2625                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
2626                        &rust.quorumNumber,
2627                    )
2628                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
2629                        &rust.operator,
2630                    )
2631            }
2632            #[inline]
2633            fn encode_topic_preimage(
2634                rust: &Self::RustType,
2635                out: &mut alloy_sol_types::private::Vec<u8>,
2636            ) {
2637                out.reserve(
2638                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
2639                );
2640                <alloy::sol_types::sol_data::Uint<
2641                    8,
2642                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2643                    &rust.quorumNumber,
2644                    out,
2645                );
2646                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
2647                    &rust.operator,
2648                    out,
2649                );
2650            }
2651            #[inline]
2652            fn encode_topic(
2653                rust: &Self::RustType,
2654            ) -> alloy_sol_types::abi::token::WordToken {
2655                let mut out = alloy_sol_types::private::Vec::new();
2656                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
2657                    rust,
2658                    &mut out,
2659                );
2660                alloy_sol_types::abi::token::WordToken(
2661                    alloy_sol_types::private::keccak256(out),
2662                )
2663            }
2664        }
2665    };
2666    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2667    /**```solidity
2668struct OperatorSetParam { uint32 maxOperatorCount; uint16 kickBIPsOfOperatorStake; uint16 kickBIPsOfTotalStake; }
2669```*/
2670    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2671    #[derive(Clone)]
2672    pub struct OperatorSetParam {
2673        #[allow(missing_docs)]
2674        pub maxOperatorCount: u32,
2675        #[allow(missing_docs)]
2676        pub kickBIPsOfOperatorStake: u16,
2677        #[allow(missing_docs)]
2678        pub kickBIPsOfTotalStake: u16,
2679    }
2680    #[allow(
2681        non_camel_case_types,
2682        non_snake_case,
2683        clippy::pub_underscore_fields,
2684        clippy::style
2685    )]
2686    const _: () = {
2687        use alloy::sol_types as alloy_sol_types;
2688        #[doc(hidden)]
2689        type UnderlyingSolTuple<'a> = (
2690            alloy::sol_types::sol_data::Uint<32>,
2691            alloy::sol_types::sol_data::Uint<16>,
2692            alloy::sol_types::sol_data::Uint<16>,
2693        );
2694        #[doc(hidden)]
2695        type UnderlyingRustTuple<'a> = (u32, u16, u16);
2696        #[cfg(test)]
2697        #[allow(dead_code, unreachable_patterns)]
2698        fn _type_assertion(
2699            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2700        ) {
2701            match _t {
2702                alloy_sol_types::private::AssertTypeEq::<
2703                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2704                >(_) => {}
2705            }
2706        }
2707        #[automatically_derived]
2708        #[doc(hidden)]
2709        impl ::core::convert::From<OperatorSetParam> for UnderlyingRustTuple<'_> {
2710            fn from(value: OperatorSetParam) -> Self {
2711                (
2712                    value.maxOperatorCount,
2713                    value.kickBIPsOfOperatorStake,
2714                    value.kickBIPsOfTotalStake,
2715                )
2716            }
2717        }
2718        #[automatically_derived]
2719        #[doc(hidden)]
2720        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorSetParam {
2721            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2722                Self {
2723                    maxOperatorCount: tuple.0,
2724                    kickBIPsOfOperatorStake: tuple.1,
2725                    kickBIPsOfTotalStake: tuple.2,
2726                }
2727            }
2728        }
2729        #[automatically_derived]
2730        impl alloy_sol_types::SolValue for OperatorSetParam {
2731            type SolType = Self;
2732        }
2733        #[automatically_derived]
2734        impl alloy_sol_types::private::SolTypeValue<Self> for OperatorSetParam {
2735            #[inline]
2736            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
2737                (
2738                    <alloy::sol_types::sol_data::Uint<
2739                        32,
2740                    > as alloy_sol_types::SolType>::tokenize(&self.maxOperatorCount),
2741                    <alloy::sol_types::sol_data::Uint<
2742                        16,
2743                    > as alloy_sol_types::SolType>::tokenize(
2744                        &self.kickBIPsOfOperatorStake,
2745                    ),
2746                    <alloy::sol_types::sol_data::Uint<
2747                        16,
2748                    > as alloy_sol_types::SolType>::tokenize(&self.kickBIPsOfTotalStake),
2749                )
2750            }
2751            #[inline]
2752            fn stv_abi_encoded_size(&self) -> usize {
2753                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
2754                    return size;
2755                }
2756                let tuple = <UnderlyingRustTuple<
2757                    '_,
2758                > as ::core::convert::From<Self>>::from(self.clone());
2759                <UnderlyingSolTuple<
2760                    '_,
2761                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
2762            }
2763            #[inline]
2764            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
2765                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
2766            }
2767            #[inline]
2768            fn stv_abi_encode_packed_to(
2769                &self,
2770                out: &mut alloy_sol_types::private::Vec<u8>,
2771            ) {
2772                let tuple = <UnderlyingRustTuple<
2773                    '_,
2774                > as ::core::convert::From<Self>>::from(self.clone());
2775                <UnderlyingSolTuple<
2776                    '_,
2777                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
2778            }
2779            #[inline]
2780            fn stv_abi_packed_encoded_size(&self) -> usize {
2781                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
2782                    return size;
2783                }
2784                let tuple = <UnderlyingRustTuple<
2785                    '_,
2786                > as ::core::convert::From<Self>>::from(self.clone());
2787                <UnderlyingSolTuple<
2788                    '_,
2789                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
2790            }
2791        }
2792        #[automatically_derived]
2793        impl alloy_sol_types::SolType for OperatorSetParam {
2794            type RustType = Self;
2795            type Token<'a> = <UnderlyingSolTuple<
2796                'a,
2797            > as alloy_sol_types::SolType>::Token<'a>;
2798            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
2799            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
2800                '_,
2801            > as alloy_sol_types::SolType>::ENCODED_SIZE;
2802            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
2803                '_,
2804            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
2805            #[inline]
2806            fn valid_token(token: &Self::Token<'_>) -> bool {
2807                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
2808            }
2809            #[inline]
2810            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
2811                let tuple = <UnderlyingSolTuple<
2812                    '_,
2813                > as alloy_sol_types::SolType>::detokenize(token);
2814                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
2815            }
2816        }
2817        #[automatically_derived]
2818        impl alloy_sol_types::SolStruct for OperatorSetParam {
2819            const NAME: &'static str = "OperatorSetParam";
2820            #[inline]
2821            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
2822                alloy_sol_types::private::Cow::Borrowed(
2823                    "OperatorSetParam(uint32 maxOperatorCount,uint16 kickBIPsOfOperatorStake,uint16 kickBIPsOfTotalStake)",
2824                )
2825            }
2826            #[inline]
2827            fn eip712_components() -> alloy_sol_types::private::Vec<
2828                alloy_sol_types::private::Cow<'static, str>,
2829            > {
2830                alloy_sol_types::private::Vec::new()
2831            }
2832            #[inline]
2833            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
2834                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
2835            }
2836            #[inline]
2837            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
2838                [
2839                    <alloy::sol_types::sol_data::Uint<
2840                        32,
2841                    > as alloy_sol_types::SolType>::eip712_data_word(
2842                            &self.maxOperatorCount,
2843                        )
2844                        .0,
2845                    <alloy::sol_types::sol_data::Uint<
2846                        16,
2847                    > as alloy_sol_types::SolType>::eip712_data_word(
2848                            &self.kickBIPsOfOperatorStake,
2849                        )
2850                        .0,
2851                    <alloy::sol_types::sol_data::Uint<
2852                        16,
2853                    > as alloy_sol_types::SolType>::eip712_data_word(
2854                            &self.kickBIPsOfTotalStake,
2855                        )
2856                        .0,
2857                ]
2858                    .concat()
2859            }
2860        }
2861        #[automatically_derived]
2862        impl alloy_sol_types::EventTopic for OperatorSetParam {
2863            #[inline]
2864            fn topic_preimage_length(rust: &Self::RustType) -> usize {
2865                0usize
2866                    + <alloy::sol_types::sol_data::Uint<
2867                        32,
2868                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
2869                        &rust.maxOperatorCount,
2870                    )
2871                    + <alloy::sol_types::sol_data::Uint<
2872                        16,
2873                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
2874                        &rust.kickBIPsOfOperatorStake,
2875                    )
2876                    + <alloy::sol_types::sol_data::Uint<
2877                        16,
2878                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
2879                        &rust.kickBIPsOfTotalStake,
2880                    )
2881            }
2882            #[inline]
2883            fn encode_topic_preimage(
2884                rust: &Self::RustType,
2885                out: &mut alloy_sol_types::private::Vec<u8>,
2886            ) {
2887                out.reserve(
2888                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
2889                );
2890                <alloy::sol_types::sol_data::Uint<
2891                    32,
2892                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2893                    &rust.maxOperatorCount,
2894                    out,
2895                );
2896                <alloy::sol_types::sol_data::Uint<
2897                    16,
2898                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2899                    &rust.kickBIPsOfOperatorStake,
2900                    out,
2901                );
2902                <alloy::sol_types::sol_data::Uint<
2903                    16,
2904                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2905                    &rust.kickBIPsOfTotalStake,
2906                    out,
2907                );
2908            }
2909            #[inline]
2910            fn encode_topic(
2911                rust: &Self::RustType,
2912            ) -> alloy_sol_types::abi::token::WordToken {
2913                let mut out = alloy_sol_types::private::Vec::new();
2914                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
2915                    rust,
2916                    &mut out,
2917                );
2918                alloy_sol_types::abi::token::WordToken(
2919                    alloy_sol_types::private::keccak256(out),
2920                )
2921            }
2922        }
2923    };
2924    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2925    /**```solidity
2926struct QuorumBitmapUpdate { uint32 updateBlockNumber; uint32 nextUpdateBlockNumber; uint192 quorumBitmap; }
2927```*/
2928    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2929    #[derive(Clone)]
2930    pub struct QuorumBitmapUpdate {
2931        #[allow(missing_docs)]
2932        pub updateBlockNumber: u32,
2933        #[allow(missing_docs)]
2934        pub nextUpdateBlockNumber: u32,
2935        #[allow(missing_docs)]
2936        pub quorumBitmap: alloy::sol_types::private::primitives::aliases::U192,
2937    }
2938    #[allow(
2939        non_camel_case_types,
2940        non_snake_case,
2941        clippy::pub_underscore_fields,
2942        clippy::style
2943    )]
2944    const _: () = {
2945        use alloy::sol_types as alloy_sol_types;
2946        #[doc(hidden)]
2947        type UnderlyingSolTuple<'a> = (
2948            alloy::sol_types::sol_data::Uint<32>,
2949            alloy::sol_types::sol_data::Uint<32>,
2950            alloy::sol_types::sol_data::Uint<192>,
2951        );
2952        #[doc(hidden)]
2953        type UnderlyingRustTuple<'a> = (
2954            u32,
2955            u32,
2956            alloy::sol_types::private::primitives::aliases::U192,
2957        );
2958        #[cfg(test)]
2959        #[allow(dead_code, unreachable_patterns)]
2960        fn _type_assertion(
2961            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2962        ) {
2963            match _t {
2964                alloy_sol_types::private::AssertTypeEq::<
2965                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2966                >(_) => {}
2967            }
2968        }
2969        #[automatically_derived]
2970        #[doc(hidden)]
2971        impl ::core::convert::From<QuorumBitmapUpdate> for UnderlyingRustTuple<'_> {
2972            fn from(value: QuorumBitmapUpdate) -> Self {
2973                (
2974                    value.updateBlockNumber,
2975                    value.nextUpdateBlockNumber,
2976                    value.quorumBitmap,
2977                )
2978            }
2979        }
2980        #[automatically_derived]
2981        #[doc(hidden)]
2982        impl ::core::convert::From<UnderlyingRustTuple<'_>> for QuorumBitmapUpdate {
2983            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2984                Self {
2985                    updateBlockNumber: tuple.0,
2986                    nextUpdateBlockNumber: tuple.1,
2987                    quorumBitmap: tuple.2,
2988                }
2989            }
2990        }
2991        #[automatically_derived]
2992        impl alloy_sol_types::SolValue for QuorumBitmapUpdate {
2993            type SolType = Self;
2994        }
2995        #[automatically_derived]
2996        impl alloy_sol_types::private::SolTypeValue<Self> for QuorumBitmapUpdate {
2997            #[inline]
2998            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
2999                (
3000                    <alloy::sol_types::sol_data::Uint<
3001                        32,
3002                    > as alloy_sol_types::SolType>::tokenize(&self.updateBlockNumber),
3003                    <alloy::sol_types::sol_data::Uint<
3004                        32,
3005                    > as alloy_sol_types::SolType>::tokenize(
3006                        &self.nextUpdateBlockNumber,
3007                    ),
3008                    <alloy::sol_types::sol_data::Uint<
3009                        192,
3010                    > as alloy_sol_types::SolType>::tokenize(&self.quorumBitmap),
3011                )
3012            }
3013            #[inline]
3014            fn stv_abi_encoded_size(&self) -> usize {
3015                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
3016                    return size;
3017                }
3018                let tuple = <UnderlyingRustTuple<
3019                    '_,
3020                > as ::core::convert::From<Self>>::from(self.clone());
3021                <UnderlyingSolTuple<
3022                    '_,
3023                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
3024            }
3025            #[inline]
3026            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
3027                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
3028            }
3029            #[inline]
3030            fn stv_abi_encode_packed_to(
3031                &self,
3032                out: &mut alloy_sol_types::private::Vec<u8>,
3033            ) {
3034                let tuple = <UnderlyingRustTuple<
3035                    '_,
3036                > as ::core::convert::From<Self>>::from(self.clone());
3037                <UnderlyingSolTuple<
3038                    '_,
3039                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
3040            }
3041            #[inline]
3042            fn stv_abi_packed_encoded_size(&self) -> usize {
3043                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
3044                    return size;
3045                }
3046                let tuple = <UnderlyingRustTuple<
3047                    '_,
3048                > as ::core::convert::From<Self>>::from(self.clone());
3049                <UnderlyingSolTuple<
3050                    '_,
3051                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
3052            }
3053        }
3054        #[automatically_derived]
3055        impl alloy_sol_types::SolType for QuorumBitmapUpdate {
3056            type RustType = Self;
3057            type Token<'a> = <UnderlyingSolTuple<
3058                'a,
3059            > as alloy_sol_types::SolType>::Token<'a>;
3060            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
3061            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
3062                '_,
3063            > as alloy_sol_types::SolType>::ENCODED_SIZE;
3064            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
3065                '_,
3066            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
3067            #[inline]
3068            fn valid_token(token: &Self::Token<'_>) -> bool {
3069                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
3070            }
3071            #[inline]
3072            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
3073                let tuple = <UnderlyingSolTuple<
3074                    '_,
3075                > as alloy_sol_types::SolType>::detokenize(token);
3076                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
3077            }
3078        }
3079        #[automatically_derived]
3080        impl alloy_sol_types::SolStruct for QuorumBitmapUpdate {
3081            const NAME: &'static str = "QuorumBitmapUpdate";
3082            #[inline]
3083            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
3084                alloy_sol_types::private::Cow::Borrowed(
3085                    "QuorumBitmapUpdate(uint32 updateBlockNumber,uint32 nextUpdateBlockNumber,uint192 quorumBitmap)",
3086                )
3087            }
3088            #[inline]
3089            fn eip712_components() -> alloy_sol_types::private::Vec<
3090                alloy_sol_types::private::Cow<'static, str>,
3091            > {
3092                alloy_sol_types::private::Vec::new()
3093            }
3094            #[inline]
3095            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
3096                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
3097            }
3098            #[inline]
3099            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
3100                [
3101                    <alloy::sol_types::sol_data::Uint<
3102                        32,
3103                    > as alloy_sol_types::SolType>::eip712_data_word(
3104                            &self.updateBlockNumber,
3105                        )
3106                        .0,
3107                    <alloy::sol_types::sol_data::Uint<
3108                        32,
3109                    > as alloy_sol_types::SolType>::eip712_data_word(
3110                            &self.nextUpdateBlockNumber,
3111                        )
3112                        .0,
3113                    <alloy::sol_types::sol_data::Uint<
3114                        192,
3115                    > as alloy_sol_types::SolType>::eip712_data_word(&self.quorumBitmap)
3116                        .0,
3117                ]
3118                    .concat()
3119            }
3120        }
3121        #[automatically_derived]
3122        impl alloy_sol_types::EventTopic for QuorumBitmapUpdate {
3123            #[inline]
3124            fn topic_preimage_length(rust: &Self::RustType) -> usize {
3125                0usize
3126                    + <alloy::sol_types::sol_data::Uint<
3127                        32,
3128                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
3129                        &rust.updateBlockNumber,
3130                    )
3131                    + <alloy::sol_types::sol_data::Uint<
3132                        32,
3133                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
3134                        &rust.nextUpdateBlockNumber,
3135                    )
3136                    + <alloy::sol_types::sol_data::Uint<
3137                        192,
3138                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
3139                        &rust.quorumBitmap,
3140                    )
3141            }
3142            #[inline]
3143            fn encode_topic_preimage(
3144                rust: &Self::RustType,
3145                out: &mut alloy_sol_types::private::Vec<u8>,
3146            ) {
3147                out.reserve(
3148                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
3149                );
3150                <alloy::sol_types::sol_data::Uint<
3151                    32,
3152                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
3153                    &rust.updateBlockNumber,
3154                    out,
3155                );
3156                <alloy::sol_types::sol_data::Uint<
3157                    32,
3158                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
3159                    &rust.nextUpdateBlockNumber,
3160                    out,
3161                );
3162                <alloy::sol_types::sol_data::Uint<
3163                    192,
3164                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
3165                    &rust.quorumBitmap,
3166                    out,
3167                );
3168            }
3169            #[inline]
3170            fn encode_topic(
3171                rust: &Self::RustType,
3172            ) -> alloy_sol_types::abi::token::WordToken {
3173                let mut out = alloy_sol_types::private::Vec::new();
3174                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
3175                    rust,
3176                    &mut out,
3177                );
3178                alloy_sol_types::abi::token::WordToken(
3179                    alloy_sol_types::private::keccak256(out),
3180                )
3181            }
3182        }
3183    };
3184    use alloy::contract as alloy_contract;
3185    /**Creates a new wrapper around an on-chain [`ISlashingRegistryCoordinatorTypes`](self) contract instance.
3186
3187See the [wrapper's documentation](`ISlashingRegistryCoordinatorTypesInstance`) for more details.*/
3188    #[inline]
3189    pub const fn new<
3190        T: alloy_contract::private::Transport + ::core::clone::Clone,
3191        P: alloy_contract::private::Provider<T, N>,
3192        N: alloy_contract::private::Network,
3193    >(
3194        address: alloy_sol_types::private::Address,
3195        provider: P,
3196    ) -> ISlashingRegistryCoordinatorTypesInstance<T, P, N> {
3197        ISlashingRegistryCoordinatorTypesInstance::<T, P, N>::new(address, provider)
3198    }
3199    /**A [`ISlashingRegistryCoordinatorTypes`](self) instance.
3200
3201Contains type-safe methods for interacting with an on-chain instance of the
3202[`ISlashingRegistryCoordinatorTypes`](self) contract located at a given `address`, using a given
3203provider `P`.
3204
3205If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
3206documentation on how to provide it), the `deploy` and `deploy_builder` methods can
3207be used to deploy a new instance of the contract.
3208
3209See the [module-level documentation](self) for all the available methods.*/
3210    #[derive(Clone)]
3211    pub struct ISlashingRegistryCoordinatorTypesInstance<
3212        T,
3213        P,
3214        N = alloy_contract::private::Ethereum,
3215    > {
3216        address: alloy_sol_types::private::Address,
3217        provider: P,
3218        _network_transport: ::core::marker::PhantomData<(N, T)>,
3219    }
3220    #[automatically_derived]
3221    impl<T, P, N> ::core::fmt::Debug
3222    for ISlashingRegistryCoordinatorTypesInstance<T, P, N> {
3223        #[inline]
3224        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3225            f.debug_tuple("ISlashingRegistryCoordinatorTypesInstance")
3226                .field(&self.address)
3227                .finish()
3228        }
3229    }
3230    /// Instantiation and getters/setters.
3231    #[automatically_derived]
3232    impl<
3233        T: alloy_contract::private::Transport + ::core::clone::Clone,
3234        P: alloy_contract::private::Provider<T, N>,
3235        N: alloy_contract::private::Network,
3236    > ISlashingRegistryCoordinatorTypesInstance<T, P, N> {
3237        /**Creates a new wrapper around an on-chain [`ISlashingRegistryCoordinatorTypes`](self) contract instance.
3238
3239See the [wrapper's documentation](`ISlashingRegistryCoordinatorTypesInstance`) for more details.*/
3240        #[inline]
3241        pub const fn new(
3242            address: alloy_sol_types::private::Address,
3243            provider: P,
3244        ) -> Self {
3245            Self {
3246                address,
3247                provider,
3248                _network_transport: ::core::marker::PhantomData,
3249            }
3250        }
3251        /// Returns a reference to the address.
3252        #[inline]
3253        pub const fn address(&self) -> &alloy_sol_types::private::Address {
3254            &self.address
3255        }
3256        /// Sets the address.
3257        #[inline]
3258        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
3259            self.address = address;
3260        }
3261        /// Sets the address and returns `self`.
3262        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
3263            self.set_address(address);
3264            self
3265        }
3266        /// Returns a reference to the provider.
3267        #[inline]
3268        pub const fn provider(&self) -> &P {
3269            &self.provider
3270        }
3271    }
3272    impl<
3273        T,
3274        P: ::core::clone::Clone,
3275        N,
3276    > ISlashingRegistryCoordinatorTypesInstance<T, &P, N> {
3277        /// Clones the provider and returns a new instance with the cloned provider.
3278        #[inline]
3279        pub fn with_cloned_provider(
3280            self,
3281        ) -> ISlashingRegistryCoordinatorTypesInstance<T, P, N> {
3282            ISlashingRegistryCoordinatorTypesInstance {
3283                address: self.address,
3284                provider: ::core::clone::Clone::clone(&self.provider),
3285                _network_transport: ::core::marker::PhantomData,
3286            }
3287        }
3288    }
3289    /// Function calls.
3290    #[automatically_derived]
3291    impl<
3292        T: alloy_contract::private::Transport + ::core::clone::Clone,
3293        P: alloy_contract::private::Provider<T, N>,
3294        N: alloy_contract::private::Network,
3295    > ISlashingRegistryCoordinatorTypesInstance<T, P, N> {
3296        /// Creates a new call builder using this contract instance's provider and address.
3297        ///
3298        /// Note that the call can be any function call, not just those defined in this
3299        /// contract. Prefer using the other methods for building type-safe contract calls.
3300        pub fn call_builder<C: alloy_sol_types::SolCall>(
3301            &self,
3302            call: &C,
3303        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
3304            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
3305        }
3306    }
3307    /// Event filters.
3308    #[automatically_derived]
3309    impl<
3310        T: alloy_contract::private::Transport + ::core::clone::Clone,
3311        P: alloy_contract::private::Provider<T, N>,
3312        N: alloy_contract::private::Network,
3313    > ISlashingRegistryCoordinatorTypesInstance<T, P, N> {
3314        /// Creates a new event filter using this contract instance's provider and address.
3315        ///
3316        /// Note that the type can be any event, not just those defined in this contract.
3317        /// Prefer using the other methods for building type-safe event filters.
3318        pub fn event_filter<E: alloy_sol_types::SolEvent>(
3319            &self,
3320        ) -> alloy_contract::Event<T, &P, E, N> {
3321            alloy_contract::Event::new_sol(&self.provider, &self.address)
3322        }
3323    }
3324}
3325///Module containing a contract's types and functions.
3326/**
3327
3328```solidity
3329library IStakeRegistryTypes {
3330    type StakeType is uint8;
3331    struct StrategyParams { address strategy; uint96 multiplier; }
3332}
3333```*/
3334#[allow(
3335    non_camel_case_types,
3336    non_snake_case,
3337    clippy::pub_underscore_fields,
3338    clippy::style,
3339    clippy::empty_structs_with_brackets
3340)]
3341pub mod IStakeRegistryTypes {
3342    use super::*;
3343    use alloy::sol_types as alloy_sol_types;
3344    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3345    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3346    #[derive(Clone)]
3347    pub struct StakeType(u8);
3348    const _: () = {
3349        use alloy::sol_types as alloy_sol_types;
3350        #[automatically_derived]
3351        impl alloy_sol_types::private::SolTypeValue<StakeType> for u8 {
3352            #[inline]
3353            fn stv_to_tokens(
3354                &self,
3355            ) -> <alloy::sol_types::sol_data::Uint<
3356                8,
3357            > as alloy_sol_types::SolType>::Token<'_> {
3358                alloy_sol_types::private::SolTypeValue::<
3359                    alloy::sol_types::sol_data::Uint<8>,
3360                >::stv_to_tokens(self)
3361            }
3362            #[inline]
3363            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
3364                <alloy::sol_types::sol_data::Uint<
3365                    8,
3366                > as alloy_sol_types::SolType>::tokenize(self)
3367                    .0
3368            }
3369            #[inline]
3370            fn stv_abi_encode_packed_to(
3371                &self,
3372                out: &mut alloy_sol_types::private::Vec<u8>,
3373            ) {
3374                <alloy::sol_types::sol_data::Uint<
3375                    8,
3376                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
3377            }
3378            #[inline]
3379            fn stv_abi_packed_encoded_size(&self) -> usize {
3380                <alloy::sol_types::sol_data::Uint<
3381                    8,
3382                > as alloy_sol_types::SolType>::abi_encoded_size(self)
3383            }
3384        }
3385        #[automatically_derived]
3386        impl StakeType {
3387            /// The Solidity type name.
3388            pub const NAME: &'static str = stringify!(@ name);
3389            /// Convert from the underlying value type.
3390            #[inline]
3391            pub const fn from(value: u8) -> Self {
3392                Self(value)
3393            }
3394            /// Return the underlying value.
3395            #[inline]
3396            pub const fn into(self) -> u8 {
3397                self.0
3398            }
3399            /// Return the single encoding of this value, delegating to the
3400            /// underlying type.
3401            #[inline]
3402            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
3403                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
3404            }
3405            /// Return the packed encoding of this value, delegating to the
3406            /// underlying type.
3407            #[inline]
3408            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
3409                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
3410            }
3411        }
3412        #[automatically_derived]
3413        impl alloy_sol_types::SolType for StakeType {
3414            type RustType = u8;
3415            type Token<'a> = <alloy::sol_types::sol_data::Uint<
3416                8,
3417            > as alloy_sol_types::SolType>::Token<'a>;
3418            const SOL_NAME: &'static str = Self::NAME;
3419            const ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
3420                8,
3421            > as alloy_sol_types::SolType>::ENCODED_SIZE;
3422            const PACKED_ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
3423                8,
3424            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
3425            #[inline]
3426            fn valid_token(token: &Self::Token<'_>) -> bool {
3427                Self::type_check(token).is_ok()
3428            }
3429            #[inline]
3430            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
3431                <alloy::sol_types::sol_data::Uint<
3432                    8,
3433                > as alloy_sol_types::SolType>::type_check(token)
3434            }
3435            #[inline]
3436            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
3437                <alloy::sol_types::sol_data::Uint<
3438                    8,
3439                > as alloy_sol_types::SolType>::detokenize(token)
3440            }
3441        }
3442        #[automatically_derived]
3443        impl alloy_sol_types::EventTopic for StakeType {
3444            #[inline]
3445            fn topic_preimage_length(rust: &Self::RustType) -> usize {
3446                <alloy::sol_types::sol_data::Uint<
3447                    8,
3448                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
3449            }
3450            #[inline]
3451            fn encode_topic_preimage(
3452                rust: &Self::RustType,
3453                out: &mut alloy_sol_types::private::Vec<u8>,
3454            ) {
3455                <alloy::sol_types::sol_data::Uint<
3456                    8,
3457                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
3458            }
3459            #[inline]
3460            fn encode_topic(
3461                rust: &Self::RustType,
3462            ) -> alloy_sol_types::abi::token::WordToken {
3463                <alloy::sol_types::sol_data::Uint<
3464                    8,
3465                > as alloy_sol_types::EventTopic>::encode_topic(rust)
3466            }
3467        }
3468    };
3469    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3470    /**```solidity
3471struct StrategyParams { address strategy; uint96 multiplier; }
3472```*/
3473    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3474    #[derive(Clone)]
3475    pub struct StrategyParams {
3476        #[allow(missing_docs)]
3477        pub strategy: alloy::sol_types::private::Address,
3478        #[allow(missing_docs)]
3479        pub multiplier: alloy::sol_types::private::primitives::aliases::U96,
3480    }
3481    #[allow(
3482        non_camel_case_types,
3483        non_snake_case,
3484        clippy::pub_underscore_fields,
3485        clippy::style
3486    )]
3487    const _: () = {
3488        use alloy::sol_types as alloy_sol_types;
3489        #[doc(hidden)]
3490        type UnderlyingSolTuple<'a> = (
3491            alloy::sol_types::sol_data::Address,
3492            alloy::sol_types::sol_data::Uint<96>,
3493        );
3494        #[doc(hidden)]
3495        type UnderlyingRustTuple<'a> = (
3496            alloy::sol_types::private::Address,
3497            alloy::sol_types::private::primitives::aliases::U96,
3498        );
3499        #[cfg(test)]
3500        #[allow(dead_code, unreachable_patterns)]
3501        fn _type_assertion(
3502            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3503        ) {
3504            match _t {
3505                alloy_sol_types::private::AssertTypeEq::<
3506                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3507                >(_) => {}
3508            }
3509        }
3510        #[automatically_derived]
3511        #[doc(hidden)]
3512        impl ::core::convert::From<StrategyParams> for UnderlyingRustTuple<'_> {
3513            fn from(value: StrategyParams) -> Self {
3514                (value.strategy, value.multiplier)
3515            }
3516        }
3517        #[automatically_derived]
3518        #[doc(hidden)]
3519        impl ::core::convert::From<UnderlyingRustTuple<'_>> for StrategyParams {
3520            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3521                Self {
3522                    strategy: tuple.0,
3523                    multiplier: tuple.1,
3524                }
3525            }
3526        }
3527        #[automatically_derived]
3528        impl alloy_sol_types::SolValue for StrategyParams {
3529            type SolType = Self;
3530        }
3531        #[automatically_derived]
3532        impl alloy_sol_types::private::SolTypeValue<Self> for StrategyParams {
3533            #[inline]
3534            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
3535                (
3536                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3537                        &self.strategy,
3538                    ),
3539                    <alloy::sol_types::sol_data::Uint<
3540                        96,
3541                    > as alloy_sol_types::SolType>::tokenize(&self.multiplier),
3542                )
3543            }
3544            #[inline]
3545            fn stv_abi_encoded_size(&self) -> usize {
3546                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
3547                    return size;
3548                }
3549                let tuple = <UnderlyingRustTuple<
3550                    '_,
3551                > as ::core::convert::From<Self>>::from(self.clone());
3552                <UnderlyingSolTuple<
3553                    '_,
3554                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
3555            }
3556            #[inline]
3557            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
3558                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
3559            }
3560            #[inline]
3561            fn stv_abi_encode_packed_to(
3562                &self,
3563                out: &mut alloy_sol_types::private::Vec<u8>,
3564            ) {
3565                let tuple = <UnderlyingRustTuple<
3566                    '_,
3567                > as ::core::convert::From<Self>>::from(self.clone());
3568                <UnderlyingSolTuple<
3569                    '_,
3570                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
3571            }
3572            #[inline]
3573            fn stv_abi_packed_encoded_size(&self) -> usize {
3574                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
3575                    return size;
3576                }
3577                let tuple = <UnderlyingRustTuple<
3578                    '_,
3579                > as ::core::convert::From<Self>>::from(self.clone());
3580                <UnderlyingSolTuple<
3581                    '_,
3582                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
3583            }
3584        }
3585        #[automatically_derived]
3586        impl alloy_sol_types::SolType for StrategyParams {
3587            type RustType = Self;
3588            type Token<'a> = <UnderlyingSolTuple<
3589                'a,
3590            > as alloy_sol_types::SolType>::Token<'a>;
3591            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
3592            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
3593                '_,
3594            > as alloy_sol_types::SolType>::ENCODED_SIZE;
3595            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
3596                '_,
3597            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
3598            #[inline]
3599            fn valid_token(token: &Self::Token<'_>) -> bool {
3600                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
3601            }
3602            #[inline]
3603            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
3604                let tuple = <UnderlyingSolTuple<
3605                    '_,
3606                > as alloy_sol_types::SolType>::detokenize(token);
3607                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
3608            }
3609        }
3610        #[automatically_derived]
3611        impl alloy_sol_types::SolStruct for StrategyParams {
3612            const NAME: &'static str = "StrategyParams";
3613            #[inline]
3614            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
3615                alloy_sol_types::private::Cow::Borrowed(
3616                    "StrategyParams(address strategy,uint96 multiplier)",
3617                )
3618            }
3619            #[inline]
3620            fn eip712_components() -> alloy_sol_types::private::Vec<
3621                alloy_sol_types::private::Cow<'static, str>,
3622            > {
3623                alloy_sol_types::private::Vec::new()
3624            }
3625            #[inline]
3626            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
3627                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
3628            }
3629            #[inline]
3630            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
3631                [
3632                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
3633                            &self.strategy,
3634                        )
3635                        .0,
3636                    <alloy::sol_types::sol_data::Uint<
3637                        96,
3638                    > as alloy_sol_types::SolType>::eip712_data_word(&self.multiplier)
3639                        .0,
3640                ]
3641                    .concat()
3642            }
3643        }
3644        #[automatically_derived]
3645        impl alloy_sol_types::EventTopic for StrategyParams {
3646            #[inline]
3647            fn topic_preimage_length(rust: &Self::RustType) -> usize {
3648                0usize
3649                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
3650                        &rust.strategy,
3651                    )
3652                    + <alloy::sol_types::sol_data::Uint<
3653                        96,
3654                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
3655                        &rust.multiplier,
3656                    )
3657            }
3658            #[inline]
3659            fn encode_topic_preimage(
3660                rust: &Self::RustType,
3661                out: &mut alloy_sol_types::private::Vec<u8>,
3662            ) {
3663                out.reserve(
3664                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
3665                );
3666                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
3667                    &rust.strategy,
3668                    out,
3669                );
3670                <alloy::sol_types::sol_data::Uint<
3671                    96,
3672                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
3673                    &rust.multiplier,
3674                    out,
3675                );
3676            }
3677            #[inline]
3678            fn encode_topic(
3679                rust: &Self::RustType,
3680            ) -> alloy_sol_types::abi::token::WordToken {
3681                let mut out = alloy_sol_types::private::Vec::new();
3682                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
3683                    rust,
3684                    &mut out,
3685                );
3686                alloy_sol_types::abi::token::WordToken(
3687                    alloy_sol_types::private::keccak256(out),
3688                )
3689            }
3690        }
3691    };
3692    use alloy::contract as alloy_contract;
3693    /**Creates a new wrapper around an on-chain [`IStakeRegistryTypes`](self) contract instance.
3694
3695See the [wrapper's documentation](`IStakeRegistryTypesInstance`) for more details.*/
3696    #[inline]
3697    pub const fn new<
3698        T: alloy_contract::private::Transport + ::core::clone::Clone,
3699        P: alloy_contract::private::Provider<T, N>,
3700        N: alloy_contract::private::Network,
3701    >(
3702        address: alloy_sol_types::private::Address,
3703        provider: P,
3704    ) -> IStakeRegistryTypesInstance<T, P, N> {
3705        IStakeRegistryTypesInstance::<T, P, N>::new(address, provider)
3706    }
3707    /**A [`IStakeRegistryTypes`](self) instance.
3708
3709Contains type-safe methods for interacting with an on-chain instance of the
3710[`IStakeRegistryTypes`](self) contract located at a given `address`, using a given
3711provider `P`.
3712
3713If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
3714documentation on how to provide it), the `deploy` and `deploy_builder` methods can
3715be used to deploy a new instance of the contract.
3716
3717See the [module-level documentation](self) for all the available methods.*/
3718    #[derive(Clone)]
3719    pub struct IStakeRegistryTypesInstance<T, P, N = alloy_contract::private::Ethereum> {
3720        address: alloy_sol_types::private::Address,
3721        provider: P,
3722        _network_transport: ::core::marker::PhantomData<(N, T)>,
3723    }
3724    #[automatically_derived]
3725    impl<T, P, N> ::core::fmt::Debug for IStakeRegistryTypesInstance<T, P, N> {
3726        #[inline]
3727        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3728            f.debug_tuple("IStakeRegistryTypesInstance").field(&self.address).finish()
3729        }
3730    }
3731    /// Instantiation and getters/setters.
3732    #[automatically_derived]
3733    impl<
3734        T: alloy_contract::private::Transport + ::core::clone::Clone,
3735        P: alloy_contract::private::Provider<T, N>,
3736        N: alloy_contract::private::Network,
3737    > IStakeRegistryTypesInstance<T, P, N> {
3738        /**Creates a new wrapper around an on-chain [`IStakeRegistryTypes`](self) contract instance.
3739
3740See the [wrapper's documentation](`IStakeRegistryTypesInstance`) for more details.*/
3741        #[inline]
3742        pub const fn new(
3743            address: alloy_sol_types::private::Address,
3744            provider: P,
3745        ) -> Self {
3746            Self {
3747                address,
3748                provider,
3749                _network_transport: ::core::marker::PhantomData,
3750            }
3751        }
3752        /// Returns a reference to the address.
3753        #[inline]
3754        pub const fn address(&self) -> &alloy_sol_types::private::Address {
3755            &self.address
3756        }
3757        /// Sets the address.
3758        #[inline]
3759        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
3760            self.address = address;
3761        }
3762        /// Sets the address and returns `self`.
3763        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
3764            self.set_address(address);
3765            self
3766        }
3767        /// Returns a reference to the provider.
3768        #[inline]
3769        pub const fn provider(&self) -> &P {
3770            &self.provider
3771        }
3772    }
3773    impl<T, P: ::core::clone::Clone, N> IStakeRegistryTypesInstance<T, &P, N> {
3774        /// Clones the provider and returns a new instance with the cloned provider.
3775        #[inline]
3776        pub fn with_cloned_provider(self) -> IStakeRegistryTypesInstance<T, P, N> {
3777            IStakeRegistryTypesInstance {
3778                address: self.address,
3779                provider: ::core::clone::Clone::clone(&self.provider),
3780                _network_transport: ::core::marker::PhantomData,
3781            }
3782        }
3783    }
3784    /// Function calls.
3785    #[automatically_derived]
3786    impl<
3787        T: alloy_contract::private::Transport + ::core::clone::Clone,
3788        P: alloy_contract::private::Provider<T, N>,
3789        N: alloy_contract::private::Network,
3790    > IStakeRegistryTypesInstance<T, P, N> {
3791        /// Creates a new call builder using this contract instance's provider and address.
3792        ///
3793        /// Note that the call can be any function call, not just those defined in this
3794        /// contract. Prefer using the other methods for building type-safe contract calls.
3795        pub fn call_builder<C: alloy_sol_types::SolCall>(
3796            &self,
3797            call: &C,
3798        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
3799            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
3800        }
3801    }
3802    /// Event filters.
3803    #[automatically_derived]
3804    impl<
3805        T: alloy_contract::private::Transport + ::core::clone::Clone,
3806        P: alloy_contract::private::Provider<T, N>,
3807        N: alloy_contract::private::Network,
3808    > IStakeRegistryTypesInstance<T, P, N> {
3809        /// Creates a new event filter using this contract instance's provider and address.
3810        ///
3811        /// Note that the type can be any event, not just those defined in this contract.
3812        /// Prefer using the other methods for building type-safe event filters.
3813        pub fn event_filter<E: alloy_sol_types::SolEvent>(
3814            &self,
3815        ) -> alloy_contract::Event<T, &P, E, N> {
3816            alloy_contract::Event::new_sol(&self.provider, &self.address)
3817        }
3818    }
3819}
3820/**
3821
3822Generated by the following Solidity interface...
3823```solidity
3824library BN254 {
3825    struct G1Point {
3826        uint256 X;
3827        uint256 Y;
3828    }
3829    struct G2Point {
3830        uint256[2] X;
3831        uint256[2] Y;
3832    }
3833}
3834
3835library IBLSApkRegistryTypes {
3836    struct PubkeyRegistrationParams {
3837        BN254.G1Point pubkeyRegistrationSignature;
3838        BN254.G1Point pubkeyG1;
3839        BN254.G2Point pubkeyG2;
3840    }
3841}
3842
3843library IRegistryCoordinatorTypes {
3844    struct RegistryCoordinatorParams {
3845        address serviceManager;
3846        SlashingRegistryParams slashingParams;
3847    }
3848    struct SlashingRegistryParams {
3849        address stakeRegistry;
3850        address blsApkRegistry;
3851        address indexRegistry;
3852        address socketRegistry;
3853        address allocationManager;
3854        address pauserRegistry;
3855    }
3856}
3857
3858library ISignatureUtilsMixinTypes {
3859    struct SignatureWithSaltAndExpiry {
3860        bytes signature;
3861        bytes32 salt;
3862        uint256 expiry;
3863    }
3864}
3865
3866library ISlashingRegistryCoordinatorTypes {
3867    type OperatorStatus is uint8;
3868    struct OperatorInfo {
3869        bytes32 operatorId;
3870        OperatorStatus status;
3871    }
3872    struct OperatorKickParam {
3873        uint8 quorumNumber;
3874        address operator;
3875    }
3876    struct OperatorSetParam {
3877        uint32 maxOperatorCount;
3878        uint16 kickBIPsOfOperatorStake;
3879        uint16 kickBIPsOfTotalStake;
3880    }
3881    struct QuorumBitmapUpdate {
3882        uint32 updateBlockNumber;
3883        uint32 nextUpdateBlockNumber;
3884        uint192 quorumBitmap;
3885    }
3886}
3887
3888library IStakeRegistryTypes {
3889    type StakeType is uint8;
3890    struct StrategyParams {
3891        address strategy;
3892        uint96 multiplier;
3893    }
3894}
3895
3896interface RegistryCoordinator {
3897    error AlreadyRegisteredForQuorums();
3898    error BitmapCannotBeZero();
3899    error BitmapEmpty();
3900    error BitmapUpdateIsAfterBlockNumber();
3901    error BitmapValueTooLarge();
3902    error BytesArrayLengthTooLong();
3903    error BytesArrayNotOrdered();
3904    error CannotChurnSelf();
3905    error CannotKickOperatorAboveThreshold();
3906    error CannotReregisterYet();
3907    error ChurnApproverSaltUsed();
3908    error CurrentlyPaused();
3909    error ExpModFailed();
3910    error InputAddressZero();
3911    error InputLengthMismatch();
3912    error InsufficientStakeForChurn();
3913    error InvalidAVS();
3914    error InvalidNewPausedStatus();
3915    error InvalidRegistrationType();
3916    error InvalidSignature();
3917    error LookAheadPeriodTooLong();
3918    error M2QuorumRegistrationIsDisabled();
3919    error MaxOperatorCountReached();
3920    error MaxQuorumsReached();
3921    error NextBitmapUpdateIsBeforeBlockNumber();
3922    error NotRegistered();
3923    error NotRegisteredForQuorum();
3924    error NotSorted();
3925    error OnlyAllocationManager();
3926    error OnlyEjector();
3927    error OnlyM2QuorumsAllowed();
3928    error OnlyPauser();
3929    error OnlyUnpauser();
3930    error OperatorNotRegistered();
3931    error OperatorSetQuorum();
3932    error OperatorSetsAlreadyEnabled();
3933    error OperatorSetsNotEnabled();
3934    error QuorumDoesNotExist();
3935    error QuorumOperatorCountMismatch();
3936    error SignatureExpired();
3937    error StringTooLong(string str);
3938
3939    event AVSUpdated(address prevAVS, address newAVS);
3940    event ChurnApproverUpdated(address prevChurnApprover, address newChurnApprover);
3941    event EIP712DomainChanged();
3942    event EjectionCooldownUpdated(uint256 prevEjectionCooldown, uint256 newEjectionCooldown);
3943    event EjectorUpdated(address prevEjector, address newEjector);
3944    event Initialized(uint8 version);
3945    event M2QuorumRegistrationDisabled();
3946    event OperatorDeregistered(address indexed operator, bytes32 indexed operatorId);
3947    event OperatorRegistered(address indexed operator, bytes32 indexed operatorId);
3948    event OperatorSetParamsUpdated(uint8 indexed quorumNumber, ISlashingRegistryCoordinatorTypes.OperatorSetParam operatorSetParams);
3949    event OperatorSetsEnabled();
3950    event OperatorSocketUpdate(bytes32 indexed operatorId, string socket);
3951    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
3952    event Paused(address indexed account, uint256 newPausedStatus);
3953    event QuorumBlockNumberUpdated(uint8 indexed quorumNumber, uint256 blocknumber);
3954    event QuorumCreated(uint8 indexed quorumNumber, ISlashingRegistryCoordinatorTypes.OperatorSetParam operatorSetParams, uint96 minimumStake, IStakeRegistryTypes.StrategyParams[] strategyParams, IStakeRegistryTypes.StakeType stakeType, uint32 lookAheadPeriod);
3955    event Unpaused(address indexed account, uint256 newPausedStatus);
3956
3957    constructor(IRegistryCoordinatorTypes.RegistryCoordinatorParams params);
3958
3959    function OPERATOR_CHURN_APPROVAL_TYPEHASH() external view returns (bytes32);
3960    function PUBKEY_REGISTRATION_TYPEHASH() external view returns (bytes32);
3961    function allocationManager() external view returns (address);
3962    function avs() external view returns (address);
3963    function blsApkRegistry() external view returns (address);
3964    function calculateOperatorChurnApprovalDigestHash(address registeringOperator, bytes32 registeringOperatorId, ISlashingRegistryCoordinatorTypes.OperatorKickParam[] memory operatorKickParams, bytes32 salt, uint256 expiry) external view returns (bytes32);
3965    function calculatePubkeyRegistrationMessageHash(address operator) external view returns (bytes32);
3966    function churnApprover() external view returns (address);
3967    function createSlashableStakeQuorum(ISlashingRegistryCoordinatorTypes.OperatorSetParam memory operatorSetParams, uint96 minimumStake, IStakeRegistryTypes.StrategyParams[] memory strategyParams, uint32 lookAheadPeriod) external;
3968    function createTotalDelegatedStakeQuorum(ISlashingRegistryCoordinatorTypes.OperatorSetParam memory operatorSetParams, uint96 minimumStake, IStakeRegistryTypes.StrategyParams[] memory strategyParams) external;
3969    function deregisterOperator(address operator, address avs, uint32[] memory operatorSetIds) external;
3970    function deregisterOperator(bytes memory quorumNumbers) external;
3971    function disableM2QuorumRegistration() external;
3972    function domainSeparator() external view returns (bytes32);
3973    function eip712Domain() external view returns (bytes1 fields, string memory name, string memory version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] memory extensions);
3974    function ejectOperator(address operator, bytes memory quorumNumbers) external;
3975    function ejectionCooldown() external view returns (uint256);
3976    function ejector() external view returns (address);
3977    function getCurrentQuorumBitmap(bytes32 operatorId) external view returns (uint192);
3978    function getOperator(address operator) external view returns (ISlashingRegistryCoordinatorTypes.OperatorInfo memory);
3979    function getOperatorFromId(bytes32 operatorId) external view returns (address);
3980    function getOperatorId(address operator) external view returns (bytes32);
3981    function getOperatorSetParams(uint8 quorumNumber) external view returns (ISlashingRegistryCoordinatorTypes.OperatorSetParam memory);
3982    function getOperatorStatus(address operator) external view returns (ISlashingRegistryCoordinatorTypes.OperatorStatus);
3983    function getQuorumBitmapAtBlockNumberByIndex(bytes32 operatorId, uint32 blockNumber, uint256 index) external view returns (uint192);
3984    function getQuorumBitmapHistoryLength(bytes32 operatorId) external view returns (uint256);
3985    function getQuorumBitmapIndicesAtBlockNumber(uint32 blockNumber, bytes32[] memory operatorIds) external view returns (uint32[] memory);
3986    function getQuorumBitmapUpdateByIndex(bytes32 operatorId, uint256 index) external view returns (ISlashingRegistryCoordinatorTypes.QuorumBitmapUpdate memory);
3987    function indexRegistry() external view returns (address);
3988    function initialize(address initialOwner, address churnApprover, address ejector, uint256 initialPausedStatus, address avs) external;
3989    function isChurnApproverSaltUsed(bytes32) external view returns (bool);
3990    function isM2Quorum(uint8 quorumNumber) external view returns (bool);
3991    function isM2QuorumRegistrationDisabled() external view returns (bool);
3992    function lastEjectionTimestamp(address) external view returns (uint256);
3993    function m2QuorumBitmap() external view returns (uint256);
3994    function operatorSetsEnabled() external view returns (bool);
3995    function owner() external view returns (address);
3996    function pause(uint256 newPausedStatus) external;
3997    function pauseAll() external;
3998    function paused(uint8 index) external view returns (bool);
3999    function paused() external view returns (uint256);
4000    function pauserRegistry() external view returns (address);
4001    function pubkeyRegistrationMessageHash(address operator) external view returns (BN254.G1Point memory);
4002    function quorumCount() external view returns (uint8);
4003    function quorumUpdateBlockNumber(uint8) external view returns (uint256);
4004    function registerOperator(bytes memory quorumNumbers, string memory socket, IBLSApkRegistryTypes.PubkeyRegistrationParams memory params, ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry memory operatorSignature) external;
4005    function registerOperator(address operator, address avs, uint32[] memory operatorSetIds, bytes memory data) external;
4006    function registerOperatorWithChurn(bytes memory quorumNumbers, string memory socket, IBLSApkRegistryTypes.PubkeyRegistrationParams memory params, ISlashingRegistryCoordinatorTypes.OperatorKickParam[] memory operatorKickParams, ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry memory churnApproverSignature, ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry memory operatorSignature) external;
4007    function renounceOwnership() external;
4008    function serviceManager() external view returns (address);
4009    function setAVS(address _avs) external;
4010    function setChurnApprover(address _churnApprover) external;
4011    function setEjectionCooldown(uint256 _ejectionCooldown) external;
4012    function setEjector(address _ejector) external;
4013    function setOperatorSetParams(uint8 quorumNumber, ISlashingRegistryCoordinatorTypes.OperatorSetParam memory operatorSetParams) external;
4014    function socketRegistry() external view returns (address);
4015    function stakeRegistry() external view returns (address);
4016    function supportsAVS(address _avs) external view returns (bool);
4017    function transferOwnership(address newOwner) external;
4018    function unpause(uint256 newPausedStatus) external;
4019    function updateOperators(address[] memory operators) external;
4020    function updateOperatorsForQuorum(address[][] memory operatorsPerQuorum, bytes memory quorumNumbers) external;
4021    function updateSocket(string memory socket) external;
4022    function version() external view returns (string memory);
4023}
4024```
4025
4026...which was generated by the following JSON ABI:
4027```json
4028[
4029  {
4030    "type": "constructor",
4031    "inputs": [
4032      {
4033        "name": "params",
4034        "type": "tuple",
4035        "internalType": "struct IRegistryCoordinatorTypes.RegistryCoordinatorParams",
4036        "components": [
4037          {
4038            "name": "serviceManager",
4039            "type": "address",
4040            "internalType": "contract IServiceManager"
4041          },
4042          {
4043            "name": "slashingParams",
4044            "type": "tuple",
4045            "internalType": "struct IRegistryCoordinatorTypes.SlashingRegistryParams",
4046            "components": [
4047              {
4048                "name": "stakeRegistry",
4049                "type": "address",
4050                "internalType": "contract IStakeRegistry"
4051              },
4052              {
4053                "name": "blsApkRegistry",
4054                "type": "address",
4055                "internalType": "contract IBLSApkRegistry"
4056              },
4057              {
4058                "name": "indexRegistry",
4059                "type": "address",
4060                "internalType": "contract IIndexRegistry"
4061              },
4062              {
4063                "name": "socketRegistry",
4064                "type": "address",
4065                "internalType": "contract ISocketRegistry"
4066              },
4067              {
4068                "name": "allocationManager",
4069                "type": "address",
4070                "internalType": "contract IAllocationManager"
4071              },
4072              {
4073                "name": "pauserRegistry",
4074                "type": "address",
4075                "internalType": "contract IPauserRegistry"
4076              }
4077            ]
4078          }
4079        ]
4080      }
4081    ],
4082    "stateMutability": "nonpayable"
4083  },
4084  {
4085    "type": "function",
4086    "name": "OPERATOR_CHURN_APPROVAL_TYPEHASH",
4087    "inputs": [],
4088    "outputs": [
4089      {
4090        "name": "",
4091        "type": "bytes32",
4092        "internalType": "bytes32"
4093      }
4094    ],
4095    "stateMutability": "view"
4096  },
4097  {
4098    "type": "function",
4099    "name": "PUBKEY_REGISTRATION_TYPEHASH",
4100    "inputs": [],
4101    "outputs": [
4102      {
4103        "name": "",
4104        "type": "bytes32",
4105        "internalType": "bytes32"
4106      }
4107    ],
4108    "stateMutability": "view"
4109  },
4110  {
4111    "type": "function",
4112    "name": "allocationManager",
4113    "inputs": [],
4114    "outputs": [
4115      {
4116        "name": "",
4117        "type": "address",
4118        "internalType": "contract IAllocationManager"
4119      }
4120    ],
4121    "stateMutability": "view"
4122  },
4123  {
4124    "type": "function",
4125    "name": "avs",
4126    "inputs": [],
4127    "outputs": [
4128      {
4129        "name": "",
4130        "type": "address",
4131        "internalType": "address"
4132      }
4133    ],
4134    "stateMutability": "view"
4135  },
4136  {
4137    "type": "function",
4138    "name": "blsApkRegistry",
4139    "inputs": [],
4140    "outputs": [
4141      {
4142        "name": "",
4143        "type": "address",
4144        "internalType": "contract IBLSApkRegistry"
4145      }
4146    ],
4147    "stateMutability": "view"
4148  },
4149  {
4150    "type": "function",
4151    "name": "calculateOperatorChurnApprovalDigestHash",
4152    "inputs": [
4153      {
4154        "name": "registeringOperator",
4155        "type": "address",
4156        "internalType": "address"
4157      },
4158      {
4159        "name": "registeringOperatorId",
4160        "type": "bytes32",
4161        "internalType": "bytes32"
4162      },
4163      {
4164        "name": "operatorKickParams",
4165        "type": "tuple[]",
4166        "internalType": "struct ISlashingRegistryCoordinatorTypes.OperatorKickParam[]",
4167        "components": [
4168          {
4169            "name": "quorumNumber",
4170            "type": "uint8",
4171            "internalType": "uint8"
4172          },
4173          {
4174            "name": "operator",
4175            "type": "address",
4176            "internalType": "address"
4177          }
4178        ]
4179      },
4180      {
4181        "name": "salt",
4182        "type": "bytes32",
4183        "internalType": "bytes32"
4184      },
4185      {
4186        "name": "expiry",
4187        "type": "uint256",
4188        "internalType": "uint256"
4189      }
4190    ],
4191    "outputs": [
4192      {
4193        "name": "",
4194        "type": "bytes32",
4195        "internalType": "bytes32"
4196      }
4197    ],
4198    "stateMutability": "view"
4199  },
4200  {
4201    "type": "function",
4202    "name": "calculatePubkeyRegistrationMessageHash",
4203    "inputs": [
4204      {
4205        "name": "operator",
4206        "type": "address",
4207        "internalType": "address"
4208      }
4209    ],
4210    "outputs": [
4211      {
4212        "name": "",
4213        "type": "bytes32",
4214        "internalType": "bytes32"
4215      }
4216    ],
4217    "stateMutability": "view"
4218  },
4219  {
4220    "type": "function",
4221    "name": "churnApprover",
4222    "inputs": [],
4223    "outputs": [
4224      {
4225        "name": "",
4226        "type": "address",
4227        "internalType": "address"
4228      }
4229    ],
4230    "stateMutability": "view"
4231  },
4232  {
4233    "type": "function",
4234    "name": "createSlashableStakeQuorum",
4235    "inputs": [
4236      {
4237        "name": "operatorSetParams",
4238        "type": "tuple",
4239        "internalType": "struct ISlashingRegistryCoordinatorTypes.OperatorSetParam",
4240        "components": [
4241          {
4242            "name": "maxOperatorCount",
4243            "type": "uint32",
4244            "internalType": "uint32"
4245          },
4246          {
4247            "name": "kickBIPsOfOperatorStake",
4248            "type": "uint16",
4249            "internalType": "uint16"
4250          },
4251          {
4252            "name": "kickBIPsOfTotalStake",
4253            "type": "uint16",
4254            "internalType": "uint16"
4255          }
4256        ]
4257      },
4258      {
4259        "name": "minimumStake",
4260        "type": "uint96",
4261        "internalType": "uint96"
4262      },
4263      {
4264        "name": "strategyParams",
4265        "type": "tuple[]",
4266        "internalType": "struct IStakeRegistryTypes.StrategyParams[]",
4267        "components": [
4268          {
4269            "name": "strategy",
4270            "type": "address",
4271            "internalType": "contract IStrategy"
4272          },
4273          {
4274            "name": "multiplier",
4275            "type": "uint96",
4276            "internalType": "uint96"
4277          }
4278        ]
4279      },
4280      {
4281        "name": "lookAheadPeriod",
4282        "type": "uint32",
4283        "internalType": "uint32"
4284      }
4285    ],
4286    "outputs": [],
4287    "stateMutability": "nonpayable"
4288  },
4289  {
4290    "type": "function",
4291    "name": "createTotalDelegatedStakeQuorum",
4292    "inputs": [
4293      {
4294        "name": "operatorSetParams",
4295        "type": "tuple",
4296        "internalType": "struct ISlashingRegistryCoordinatorTypes.OperatorSetParam",
4297        "components": [
4298          {
4299            "name": "maxOperatorCount",
4300            "type": "uint32",
4301            "internalType": "uint32"
4302          },
4303          {
4304            "name": "kickBIPsOfOperatorStake",
4305            "type": "uint16",
4306            "internalType": "uint16"
4307          },
4308          {
4309            "name": "kickBIPsOfTotalStake",
4310            "type": "uint16",
4311            "internalType": "uint16"
4312          }
4313        ]
4314      },
4315      {
4316        "name": "minimumStake",
4317        "type": "uint96",
4318        "internalType": "uint96"
4319      },
4320      {
4321        "name": "strategyParams",
4322        "type": "tuple[]",
4323        "internalType": "struct IStakeRegistryTypes.StrategyParams[]",
4324        "components": [
4325          {
4326            "name": "strategy",
4327            "type": "address",
4328            "internalType": "contract IStrategy"
4329          },
4330          {
4331            "name": "multiplier",
4332            "type": "uint96",
4333            "internalType": "uint96"
4334          }
4335        ]
4336      }
4337    ],
4338    "outputs": [],
4339    "stateMutability": "nonpayable"
4340  },
4341  {
4342    "type": "function",
4343    "name": "deregisterOperator",
4344    "inputs": [
4345      {
4346        "name": "operator",
4347        "type": "address",
4348        "internalType": "address"
4349      },
4350      {
4351        "name": "avs",
4352        "type": "address",
4353        "internalType": "address"
4354      },
4355      {
4356        "name": "operatorSetIds",
4357        "type": "uint32[]",
4358        "internalType": "uint32[]"
4359      }
4360    ],
4361    "outputs": [],
4362    "stateMutability": "nonpayable"
4363  },
4364  {
4365    "type": "function",
4366    "name": "deregisterOperator",
4367    "inputs": [
4368      {
4369        "name": "quorumNumbers",
4370        "type": "bytes",
4371        "internalType": "bytes"
4372      }
4373    ],
4374    "outputs": [],
4375    "stateMutability": "nonpayable"
4376  },
4377  {
4378    "type": "function",
4379    "name": "disableM2QuorumRegistration",
4380    "inputs": [],
4381    "outputs": [],
4382    "stateMutability": "nonpayable"
4383  },
4384  {
4385    "type": "function",
4386    "name": "domainSeparator",
4387    "inputs": [],
4388    "outputs": [
4389      {
4390        "name": "",
4391        "type": "bytes32",
4392        "internalType": "bytes32"
4393      }
4394    ],
4395    "stateMutability": "view"
4396  },
4397  {
4398    "type": "function",
4399    "name": "eip712Domain",
4400    "inputs": [],
4401    "outputs": [
4402      {
4403        "name": "fields",
4404        "type": "bytes1",
4405        "internalType": "bytes1"
4406      },
4407      {
4408        "name": "name",
4409        "type": "string",
4410        "internalType": "string"
4411      },
4412      {
4413        "name": "version",
4414        "type": "string",
4415        "internalType": "string"
4416      },
4417      {
4418        "name": "chainId",
4419        "type": "uint256",
4420        "internalType": "uint256"
4421      },
4422      {
4423        "name": "verifyingContract",
4424        "type": "address",
4425        "internalType": "address"
4426      },
4427      {
4428        "name": "salt",
4429        "type": "bytes32",
4430        "internalType": "bytes32"
4431      },
4432      {
4433        "name": "extensions",
4434        "type": "uint256[]",
4435        "internalType": "uint256[]"
4436      }
4437    ],
4438    "stateMutability": "view"
4439  },
4440  {
4441    "type": "function",
4442    "name": "ejectOperator",
4443    "inputs": [
4444      {
4445        "name": "operator",
4446        "type": "address",
4447        "internalType": "address"
4448      },
4449      {
4450        "name": "quorumNumbers",
4451        "type": "bytes",
4452        "internalType": "bytes"
4453      }
4454    ],
4455    "outputs": [],
4456    "stateMutability": "nonpayable"
4457  },
4458  {
4459    "type": "function",
4460    "name": "ejectionCooldown",
4461    "inputs": [],
4462    "outputs": [
4463      {
4464        "name": "",
4465        "type": "uint256",
4466        "internalType": "uint256"
4467      }
4468    ],
4469    "stateMutability": "view"
4470  },
4471  {
4472    "type": "function",
4473    "name": "ejector",
4474    "inputs": [],
4475    "outputs": [
4476      {
4477        "name": "",
4478        "type": "address",
4479        "internalType": "address"
4480      }
4481    ],
4482    "stateMutability": "view"
4483  },
4484  {
4485    "type": "function",
4486    "name": "getCurrentQuorumBitmap",
4487    "inputs": [
4488      {
4489        "name": "operatorId",
4490        "type": "bytes32",
4491        "internalType": "bytes32"
4492      }
4493    ],
4494    "outputs": [
4495      {
4496        "name": "",
4497        "type": "uint192",
4498        "internalType": "uint192"
4499      }
4500    ],
4501    "stateMutability": "view"
4502  },
4503  {
4504    "type": "function",
4505    "name": "getOperator",
4506    "inputs": [
4507      {
4508        "name": "operator",
4509        "type": "address",
4510        "internalType": "address"
4511      }
4512    ],
4513    "outputs": [
4514      {
4515        "name": "",
4516        "type": "tuple",
4517        "internalType": "struct ISlashingRegistryCoordinatorTypes.OperatorInfo",
4518        "components": [
4519          {
4520            "name": "operatorId",
4521            "type": "bytes32",
4522            "internalType": "bytes32"
4523          },
4524          {
4525            "name": "status",
4526            "type": "uint8",
4527            "internalType": "enum ISlashingRegistryCoordinatorTypes.OperatorStatus"
4528          }
4529        ]
4530      }
4531    ],
4532    "stateMutability": "view"
4533  },
4534  {
4535    "type": "function",
4536    "name": "getOperatorFromId",
4537    "inputs": [
4538      {
4539        "name": "operatorId",
4540        "type": "bytes32",
4541        "internalType": "bytes32"
4542      }
4543    ],
4544    "outputs": [
4545      {
4546        "name": "",
4547        "type": "address",
4548        "internalType": "address"
4549      }
4550    ],
4551    "stateMutability": "view"
4552  },
4553  {
4554    "type": "function",
4555    "name": "getOperatorId",
4556    "inputs": [
4557      {
4558        "name": "operator",
4559        "type": "address",
4560        "internalType": "address"
4561      }
4562    ],
4563    "outputs": [
4564      {
4565        "name": "",
4566        "type": "bytes32",
4567        "internalType": "bytes32"
4568      }
4569    ],
4570    "stateMutability": "view"
4571  },
4572  {
4573    "type": "function",
4574    "name": "getOperatorSetParams",
4575    "inputs": [
4576      {
4577        "name": "quorumNumber",
4578        "type": "uint8",
4579        "internalType": "uint8"
4580      }
4581    ],
4582    "outputs": [
4583      {
4584        "name": "",
4585        "type": "tuple",
4586        "internalType": "struct ISlashingRegistryCoordinatorTypes.OperatorSetParam",
4587        "components": [
4588          {
4589            "name": "maxOperatorCount",
4590            "type": "uint32",
4591            "internalType": "uint32"
4592          },
4593          {
4594            "name": "kickBIPsOfOperatorStake",
4595            "type": "uint16",
4596            "internalType": "uint16"
4597          },
4598          {
4599            "name": "kickBIPsOfTotalStake",
4600            "type": "uint16",
4601            "internalType": "uint16"
4602          }
4603        ]
4604      }
4605    ],
4606    "stateMutability": "view"
4607  },
4608  {
4609    "type": "function",
4610    "name": "getOperatorStatus",
4611    "inputs": [
4612      {
4613        "name": "operator",
4614        "type": "address",
4615        "internalType": "address"
4616      }
4617    ],
4618    "outputs": [
4619      {
4620        "name": "",
4621        "type": "uint8",
4622        "internalType": "enum ISlashingRegistryCoordinatorTypes.OperatorStatus"
4623      }
4624    ],
4625    "stateMutability": "view"
4626  },
4627  {
4628    "type": "function",
4629    "name": "getQuorumBitmapAtBlockNumberByIndex",
4630    "inputs": [
4631      {
4632        "name": "operatorId",
4633        "type": "bytes32",
4634        "internalType": "bytes32"
4635      },
4636      {
4637        "name": "blockNumber",
4638        "type": "uint32",
4639        "internalType": "uint32"
4640      },
4641      {
4642        "name": "index",
4643        "type": "uint256",
4644        "internalType": "uint256"
4645      }
4646    ],
4647    "outputs": [
4648      {
4649        "name": "",
4650        "type": "uint192",
4651        "internalType": "uint192"
4652      }
4653    ],
4654    "stateMutability": "view"
4655  },
4656  {
4657    "type": "function",
4658    "name": "getQuorumBitmapHistoryLength",
4659    "inputs": [
4660      {
4661        "name": "operatorId",
4662        "type": "bytes32",
4663        "internalType": "bytes32"
4664      }
4665    ],
4666    "outputs": [
4667      {
4668        "name": "",
4669        "type": "uint256",
4670        "internalType": "uint256"
4671      }
4672    ],
4673    "stateMutability": "view"
4674  },
4675  {
4676    "type": "function",
4677    "name": "getQuorumBitmapIndicesAtBlockNumber",
4678    "inputs": [
4679      {
4680        "name": "blockNumber",
4681        "type": "uint32",
4682        "internalType": "uint32"
4683      },
4684      {
4685        "name": "operatorIds",
4686        "type": "bytes32[]",
4687        "internalType": "bytes32[]"
4688      }
4689    ],
4690    "outputs": [
4691      {
4692        "name": "",
4693        "type": "uint32[]",
4694        "internalType": "uint32[]"
4695      }
4696    ],
4697    "stateMutability": "view"
4698  },
4699  {
4700    "type": "function",
4701    "name": "getQuorumBitmapUpdateByIndex",
4702    "inputs": [
4703      {
4704        "name": "operatorId",
4705        "type": "bytes32",
4706        "internalType": "bytes32"
4707      },
4708      {
4709        "name": "index",
4710        "type": "uint256",
4711        "internalType": "uint256"
4712      }
4713    ],
4714    "outputs": [
4715      {
4716        "name": "",
4717        "type": "tuple",
4718        "internalType": "struct ISlashingRegistryCoordinatorTypes.QuorumBitmapUpdate",
4719        "components": [
4720          {
4721            "name": "updateBlockNumber",
4722            "type": "uint32",
4723            "internalType": "uint32"
4724          },
4725          {
4726            "name": "nextUpdateBlockNumber",
4727            "type": "uint32",
4728            "internalType": "uint32"
4729          },
4730          {
4731            "name": "quorumBitmap",
4732            "type": "uint192",
4733            "internalType": "uint192"
4734          }
4735        ]
4736      }
4737    ],
4738    "stateMutability": "view"
4739  },
4740  {
4741    "type": "function",
4742    "name": "indexRegistry",
4743    "inputs": [],
4744    "outputs": [
4745      {
4746        "name": "",
4747        "type": "address",
4748        "internalType": "contract IIndexRegistry"
4749      }
4750    ],
4751    "stateMutability": "view"
4752  },
4753  {
4754    "type": "function",
4755    "name": "initialize",
4756    "inputs": [
4757      {
4758        "name": "initialOwner",
4759        "type": "address",
4760        "internalType": "address"
4761      },
4762      {
4763        "name": "churnApprover",
4764        "type": "address",
4765        "internalType": "address"
4766      },
4767      {
4768        "name": "ejector",
4769        "type": "address",
4770        "internalType": "address"
4771      },
4772      {
4773        "name": "initialPausedStatus",
4774        "type": "uint256",
4775        "internalType": "uint256"
4776      },
4777      {
4778        "name": "avs",
4779        "type": "address",
4780        "internalType": "address"
4781      }
4782    ],
4783    "outputs": [],
4784    "stateMutability": "nonpayable"
4785  },
4786  {
4787    "type": "function",
4788    "name": "isChurnApproverSaltUsed",
4789    "inputs": [
4790      {
4791        "name": "",
4792        "type": "bytes32",
4793        "internalType": "bytes32"
4794      }
4795    ],
4796    "outputs": [
4797      {
4798        "name": "",
4799        "type": "bool",
4800        "internalType": "bool"
4801      }
4802    ],
4803    "stateMutability": "view"
4804  },
4805  {
4806    "type": "function",
4807    "name": "isM2Quorum",
4808    "inputs": [
4809      {
4810        "name": "quorumNumber",
4811        "type": "uint8",
4812        "internalType": "uint8"
4813      }
4814    ],
4815    "outputs": [
4816      {
4817        "name": "",
4818        "type": "bool",
4819        "internalType": "bool"
4820      }
4821    ],
4822    "stateMutability": "view"
4823  },
4824  {
4825    "type": "function",
4826    "name": "isM2QuorumRegistrationDisabled",
4827    "inputs": [],
4828    "outputs": [
4829      {
4830        "name": "",
4831        "type": "bool",
4832        "internalType": "bool"
4833      }
4834    ],
4835    "stateMutability": "view"
4836  },
4837  {
4838    "type": "function",
4839    "name": "lastEjectionTimestamp",
4840    "inputs": [
4841      {
4842        "name": "",
4843        "type": "address",
4844        "internalType": "address"
4845      }
4846    ],
4847    "outputs": [
4848      {
4849        "name": "",
4850        "type": "uint256",
4851        "internalType": "uint256"
4852      }
4853    ],
4854    "stateMutability": "view"
4855  },
4856  {
4857    "type": "function",
4858    "name": "m2QuorumBitmap",
4859    "inputs": [],
4860    "outputs": [
4861      {
4862        "name": "",
4863        "type": "uint256",
4864        "internalType": "uint256"
4865      }
4866    ],
4867    "stateMutability": "view"
4868  },
4869  {
4870    "type": "function",
4871    "name": "operatorSetsEnabled",
4872    "inputs": [],
4873    "outputs": [
4874      {
4875        "name": "",
4876        "type": "bool",
4877        "internalType": "bool"
4878      }
4879    ],
4880    "stateMutability": "view"
4881  },
4882  {
4883    "type": "function",
4884    "name": "owner",
4885    "inputs": [],
4886    "outputs": [
4887      {
4888        "name": "",
4889        "type": "address",
4890        "internalType": "address"
4891      }
4892    ],
4893    "stateMutability": "view"
4894  },
4895  {
4896    "type": "function",
4897    "name": "pause",
4898    "inputs": [
4899      {
4900        "name": "newPausedStatus",
4901        "type": "uint256",
4902        "internalType": "uint256"
4903      }
4904    ],
4905    "outputs": [],
4906    "stateMutability": "nonpayable"
4907  },
4908  {
4909    "type": "function",
4910    "name": "pauseAll",
4911    "inputs": [],
4912    "outputs": [],
4913    "stateMutability": "nonpayable"
4914  },
4915  {
4916    "type": "function",
4917    "name": "paused",
4918    "inputs": [
4919      {
4920        "name": "index",
4921        "type": "uint8",
4922        "internalType": "uint8"
4923      }
4924    ],
4925    "outputs": [
4926      {
4927        "name": "",
4928        "type": "bool",
4929        "internalType": "bool"
4930      }
4931    ],
4932    "stateMutability": "view"
4933  },
4934  {
4935    "type": "function",
4936    "name": "paused",
4937    "inputs": [],
4938    "outputs": [
4939      {
4940        "name": "",
4941        "type": "uint256",
4942        "internalType": "uint256"
4943      }
4944    ],
4945    "stateMutability": "view"
4946  },
4947  {
4948    "type": "function",
4949    "name": "pauserRegistry",
4950    "inputs": [],
4951    "outputs": [
4952      {
4953        "name": "",
4954        "type": "address",
4955        "internalType": "contract IPauserRegistry"
4956      }
4957    ],
4958    "stateMutability": "view"
4959  },
4960  {
4961    "type": "function",
4962    "name": "pubkeyRegistrationMessageHash",
4963    "inputs": [
4964      {
4965        "name": "operator",
4966        "type": "address",
4967        "internalType": "address"
4968      }
4969    ],
4970    "outputs": [
4971      {
4972        "name": "",
4973        "type": "tuple",
4974        "internalType": "struct BN254.G1Point",
4975        "components": [
4976          {
4977            "name": "X",
4978            "type": "uint256",
4979            "internalType": "uint256"
4980          },
4981          {
4982            "name": "Y",
4983            "type": "uint256",
4984            "internalType": "uint256"
4985          }
4986        ]
4987      }
4988    ],
4989    "stateMutability": "view"
4990  },
4991  {
4992    "type": "function",
4993    "name": "quorumCount",
4994    "inputs": [],
4995    "outputs": [
4996      {
4997        "name": "",
4998        "type": "uint8",
4999        "internalType": "uint8"
5000      }
5001    ],
5002    "stateMutability": "view"
5003  },
5004  {
5005    "type": "function",
5006    "name": "quorumUpdateBlockNumber",
5007    "inputs": [
5008      {
5009        "name": "",
5010        "type": "uint8",
5011        "internalType": "uint8"
5012      }
5013    ],
5014    "outputs": [
5015      {
5016        "name": "",
5017        "type": "uint256",
5018        "internalType": "uint256"
5019      }
5020    ],
5021    "stateMutability": "view"
5022  },
5023  {
5024    "type": "function",
5025    "name": "registerOperator",
5026    "inputs": [
5027      {
5028        "name": "quorumNumbers",
5029        "type": "bytes",
5030        "internalType": "bytes"
5031      },
5032      {
5033        "name": "socket",
5034        "type": "string",
5035        "internalType": "string"
5036      },
5037      {
5038        "name": "params",
5039        "type": "tuple",
5040        "internalType": "struct IBLSApkRegistryTypes.PubkeyRegistrationParams",
5041        "components": [
5042          {
5043            "name": "pubkeyRegistrationSignature",
5044            "type": "tuple",
5045            "internalType": "struct BN254.G1Point",
5046            "components": [
5047              {
5048                "name": "X",
5049                "type": "uint256",
5050                "internalType": "uint256"
5051              },
5052              {
5053                "name": "Y",
5054                "type": "uint256",
5055                "internalType": "uint256"
5056              }
5057            ]
5058          },
5059          {
5060            "name": "pubkeyG1",
5061            "type": "tuple",
5062            "internalType": "struct BN254.G1Point",
5063            "components": [
5064              {
5065                "name": "X",
5066                "type": "uint256",
5067                "internalType": "uint256"
5068              },
5069              {
5070                "name": "Y",
5071                "type": "uint256",
5072                "internalType": "uint256"
5073              }
5074            ]
5075          },
5076          {
5077            "name": "pubkeyG2",
5078            "type": "tuple",
5079            "internalType": "struct BN254.G2Point",
5080            "components": [
5081              {
5082                "name": "X",
5083                "type": "uint256[2]",
5084                "internalType": "uint256[2]"
5085              },
5086              {
5087                "name": "Y",
5088                "type": "uint256[2]",
5089                "internalType": "uint256[2]"
5090              }
5091            ]
5092          }
5093        ]
5094      },
5095      {
5096        "name": "operatorSignature",
5097        "type": "tuple",
5098        "internalType": "struct ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry",
5099        "components": [
5100          {
5101            "name": "signature",
5102            "type": "bytes",
5103            "internalType": "bytes"
5104          },
5105          {
5106            "name": "salt",
5107            "type": "bytes32",
5108            "internalType": "bytes32"
5109          },
5110          {
5111            "name": "expiry",
5112            "type": "uint256",
5113            "internalType": "uint256"
5114          }
5115        ]
5116      }
5117    ],
5118    "outputs": [],
5119    "stateMutability": "nonpayable"
5120  },
5121  {
5122    "type": "function",
5123    "name": "registerOperator",
5124    "inputs": [
5125      {
5126        "name": "operator",
5127        "type": "address",
5128        "internalType": "address"
5129      },
5130      {
5131        "name": "avs",
5132        "type": "address",
5133        "internalType": "address"
5134      },
5135      {
5136        "name": "operatorSetIds",
5137        "type": "uint32[]",
5138        "internalType": "uint32[]"
5139      },
5140      {
5141        "name": "data",
5142        "type": "bytes",
5143        "internalType": "bytes"
5144      }
5145    ],
5146    "outputs": [],
5147    "stateMutability": "nonpayable"
5148  },
5149  {
5150    "type": "function",
5151    "name": "registerOperatorWithChurn",
5152    "inputs": [
5153      {
5154        "name": "quorumNumbers",
5155        "type": "bytes",
5156        "internalType": "bytes"
5157      },
5158      {
5159        "name": "socket",
5160        "type": "string",
5161        "internalType": "string"
5162      },
5163      {
5164        "name": "params",
5165        "type": "tuple",
5166        "internalType": "struct IBLSApkRegistryTypes.PubkeyRegistrationParams",
5167        "components": [
5168          {
5169            "name": "pubkeyRegistrationSignature",
5170            "type": "tuple",
5171            "internalType": "struct BN254.G1Point",
5172            "components": [
5173              {
5174                "name": "X",
5175                "type": "uint256",
5176                "internalType": "uint256"
5177              },
5178              {
5179                "name": "Y",
5180                "type": "uint256",
5181                "internalType": "uint256"
5182              }
5183            ]
5184          },
5185          {
5186            "name": "pubkeyG1",
5187            "type": "tuple",
5188            "internalType": "struct BN254.G1Point",
5189            "components": [
5190              {
5191                "name": "X",
5192                "type": "uint256",
5193                "internalType": "uint256"
5194              },
5195              {
5196                "name": "Y",
5197                "type": "uint256",
5198                "internalType": "uint256"
5199              }
5200            ]
5201          },
5202          {
5203            "name": "pubkeyG2",
5204            "type": "tuple",
5205            "internalType": "struct BN254.G2Point",
5206            "components": [
5207              {
5208                "name": "X",
5209                "type": "uint256[2]",
5210                "internalType": "uint256[2]"
5211              },
5212              {
5213                "name": "Y",
5214                "type": "uint256[2]",
5215                "internalType": "uint256[2]"
5216              }
5217            ]
5218          }
5219        ]
5220      },
5221      {
5222        "name": "operatorKickParams",
5223        "type": "tuple[]",
5224        "internalType": "struct ISlashingRegistryCoordinatorTypes.OperatorKickParam[]",
5225        "components": [
5226          {
5227            "name": "quorumNumber",
5228            "type": "uint8",
5229            "internalType": "uint8"
5230          },
5231          {
5232            "name": "operator",
5233            "type": "address",
5234            "internalType": "address"
5235          }
5236        ]
5237      },
5238      {
5239        "name": "churnApproverSignature",
5240        "type": "tuple",
5241        "internalType": "struct ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry",
5242        "components": [
5243          {
5244            "name": "signature",
5245            "type": "bytes",
5246            "internalType": "bytes"
5247          },
5248          {
5249            "name": "salt",
5250            "type": "bytes32",
5251            "internalType": "bytes32"
5252          },
5253          {
5254            "name": "expiry",
5255            "type": "uint256",
5256            "internalType": "uint256"
5257          }
5258        ]
5259      },
5260      {
5261        "name": "operatorSignature",
5262        "type": "tuple",
5263        "internalType": "struct ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry",
5264        "components": [
5265          {
5266            "name": "signature",
5267            "type": "bytes",
5268            "internalType": "bytes"
5269          },
5270          {
5271            "name": "salt",
5272            "type": "bytes32",
5273            "internalType": "bytes32"
5274          },
5275          {
5276            "name": "expiry",
5277            "type": "uint256",
5278            "internalType": "uint256"
5279          }
5280        ]
5281      }
5282    ],
5283    "outputs": [],
5284    "stateMutability": "nonpayable"
5285  },
5286  {
5287    "type": "function",
5288    "name": "renounceOwnership",
5289    "inputs": [],
5290    "outputs": [],
5291    "stateMutability": "nonpayable"
5292  },
5293  {
5294    "type": "function",
5295    "name": "serviceManager",
5296    "inputs": [],
5297    "outputs": [
5298      {
5299        "name": "",
5300        "type": "address",
5301        "internalType": "contract IServiceManager"
5302      }
5303    ],
5304    "stateMutability": "view"
5305  },
5306  {
5307    "type": "function",
5308    "name": "setAVS",
5309    "inputs": [
5310      {
5311        "name": "_avs",
5312        "type": "address",
5313        "internalType": "address"
5314      }
5315    ],
5316    "outputs": [],
5317    "stateMutability": "nonpayable"
5318  },
5319  {
5320    "type": "function",
5321    "name": "setChurnApprover",
5322    "inputs": [
5323      {
5324        "name": "_churnApprover",
5325        "type": "address",
5326        "internalType": "address"
5327      }
5328    ],
5329    "outputs": [],
5330    "stateMutability": "nonpayable"
5331  },
5332  {
5333    "type": "function",
5334    "name": "setEjectionCooldown",
5335    "inputs": [
5336      {
5337        "name": "_ejectionCooldown",
5338        "type": "uint256",
5339        "internalType": "uint256"
5340      }
5341    ],
5342    "outputs": [],
5343    "stateMutability": "nonpayable"
5344  },
5345  {
5346    "type": "function",
5347    "name": "setEjector",
5348    "inputs": [
5349      {
5350        "name": "_ejector",
5351        "type": "address",
5352        "internalType": "address"
5353      }
5354    ],
5355    "outputs": [],
5356    "stateMutability": "nonpayable"
5357  },
5358  {
5359    "type": "function",
5360    "name": "setOperatorSetParams",
5361    "inputs": [
5362      {
5363        "name": "quorumNumber",
5364        "type": "uint8",
5365        "internalType": "uint8"
5366      },
5367      {
5368        "name": "operatorSetParams",
5369        "type": "tuple",
5370        "internalType": "struct ISlashingRegistryCoordinatorTypes.OperatorSetParam",
5371        "components": [
5372          {
5373            "name": "maxOperatorCount",
5374            "type": "uint32",
5375            "internalType": "uint32"
5376          },
5377          {
5378            "name": "kickBIPsOfOperatorStake",
5379            "type": "uint16",
5380            "internalType": "uint16"
5381          },
5382          {
5383            "name": "kickBIPsOfTotalStake",
5384            "type": "uint16",
5385            "internalType": "uint16"
5386          }
5387        ]
5388      }
5389    ],
5390    "outputs": [],
5391    "stateMutability": "nonpayable"
5392  },
5393  {
5394    "type": "function",
5395    "name": "socketRegistry",
5396    "inputs": [],
5397    "outputs": [
5398      {
5399        "name": "",
5400        "type": "address",
5401        "internalType": "contract ISocketRegistry"
5402      }
5403    ],
5404    "stateMutability": "view"
5405  },
5406  {
5407    "type": "function",
5408    "name": "stakeRegistry",
5409    "inputs": [],
5410    "outputs": [
5411      {
5412        "name": "",
5413        "type": "address",
5414        "internalType": "contract IStakeRegistry"
5415      }
5416    ],
5417    "stateMutability": "view"
5418  },
5419  {
5420    "type": "function",
5421    "name": "supportsAVS",
5422    "inputs": [
5423      {
5424        "name": "_avs",
5425        "type": "address",
5426        "internalType": "address"
5427      }
5428    ],
5429    "outputs": [
5430      {
5431        "name": "",
5432        "type": "bool",
5433        "internalType": "bool"
5434      }
5435    ],
5436    "stateMutability": "view"
5437  },
5438  {
5439    "type": "function",
5440    "name": "transferOwnership",
5441    "inputs": [
5442      {
5443        "name": "newOwner",
5444        "type": "address",
5445        "internalType": "address"
5446      }
5447    ],
5448    "outputs": [],
5449    "stateMutability": "nonpayable"
5450  },
5451  {
5452    "type": "function",
5453    "name": "unpause",
5454    "inputs": [
5455      {
5456        "name": "newPausedStatus",
5457        "type": "uint256",
5458        "internalType": "uint256"
5459      }
5460    ],
5461    "outputs": [],
5462    "stateMutability": "nonpayable"
5463  },
5464  {
5465    "type": "function",
5466    "name": "updateOperators",
5467    "inputs": [
5468      {
5469        "name": "operators",
5470        "type": "address[]",
5471        "internalType": "address[]"
5472      }
5473    ],
5474    "outputs": [],
5475    "stateMutability": "nonpayable"
5476  },
5477  {
5478    "type": "function",
5479    "name": "updateOperatorsForQuorum",
5480    "inputs": [
5481      {
5482        "name": "operatorsPerQuorum",
5483        "type": "address[][]",
5484        "internalType": "address[][]"
5485      },
5486      {
5487        "name": "quorumNumbers",
5488        "type": "bytes",
5489        "internalType": "bytes"
5490      }
5491    ],
5492    "outputs": [],
5493    "stateMutability": "nonpayable"
5494  },
5495  {
5496    "type": "function",
5497    "name": "updateSocket",
5498    "inputs": [
5499      {
5500        "name": "socket",
5501        "type": "string",
5502        "internalType": "string"
5503      }
5504    ],
5505    "outputs": [],
5506    "stateMutability": "nonpayable"
5507  },
5508  {
5509    "type": "function",
5510    "name": "version",
5511    "inputs": [],
5512    "outputs": [
5513      {
5514        "name": "",
5515        "type": "string",
5516        "internalType": "string"
5517      }
5518    ],
5519    "stateMutability": "view"
5520  },
5521  {
5522    "type": "event",
5523    "name": "AVSUpdated",
5524    "inputs": [
5525      {
5526        "name": "prevAVS",
5527        "type": "address",
5528        "indexed": false,
5529        "internalType": "address"
5530      },
5531      {
5532        "name": "newAVS",
5533        "type": "address",
5534        "indexed": false,
5535        "internalType": "address"
5536      }
5537    ],
5538    "anonymous": false
5539  },
5540  {
5541    "type": "event",
5542    "name": "ChurnApproverUpdated",
5543    "inputs": [
5544      {
5545        "name": "prevChurnApprover",
5546        "type": "address",
5547        "indexed": false,
5548        "internalType": "address"
5549      },
5550      {
5551        "name": "newChurnApprover",
5552        "type": "address",
5553        "indexed": false,
5554        "internalType": "address"
5555      }
5556    ],
5557    "anonymous": false
5558  },
5559  {
5560    "type": "event",
5561    "name": "EIP712DomainChanged",
5562    "inputs": [],
5563    "anonymous": false
5564  },
5565  {
5566    "type": "event",
5567    "name": "EjectionCooldownUpdated",
5568    "inputs": [
5569      {
5570        "name": "prevEjectionCooldown",
5571        "type": "uint256",
5572        "indexed": false,
5573        "internalType": "uint256"
5574      },
5575      {
5576        "name": "newEjectionCooldown",
5577        "type": "uint256",
5578        "indexed": false,
5579        "internalType": "uint256"
5580      }
5581    ],
5582    "anonymous": false
5583  },
5584  {
5585    "type": "event",
5586    "name": "EjectorUpdated",
5587    "inputs": [
5588      {
5589        "name": "prevEjector",
5590        "type": "address",
5591        "indexed": false,
5592        "internalType": "address"
5593      },
5594      {
5595        "name": "newEjector",
5596        "type": "address",
5597        "indexed": false,
5598        "internalType": "address"
5599      }
5600    ],
5601    "anonymous": false
5602  },
5603  {
5604    "type": "event",
5605    "name": "Initialized",
5606    "inputs": [
5607      {
5608        "name": "version",
5609        "type": "uint8",
5610        "indexed": false,
5611        "internalType": "uint8"
5612      }
5613    ],
5614    "anonymous": false
5615  },
5616  {
5617    "type": "event",
5618    "name": "M2QuorumRegistrationDisabled",
5619    "inputs": [],
5620    "anonymous": false
5621  },
5622  {
5623    "type": "event",
5624    "name": "OperatorDeregistered",
5625    "inputs": [
5626      {
5627        "name": "operator",
5628        "type": "address",
5629        "indexed": true,
5630        "internalType": "address"
5631      },
5632      {
5633        "name": "operatorId",
5634        "type": "bytes32",
5635        "indexed": true,
5636        "internalType": "bytes32"
5637      }
5638    ],
5639    "anonymous": false
5640  },
5641  {
5642    "type": "event",
5643    "name": "OperatorRegistered",
5644    "inputs": [
5645      {
5646        "name": "operator",
5647        "type": "address",
5648        "indexed": true,
5649        "internalType": "address"
5650      },
5651      {
5652        "name": "operatorId",
5653        "type": "bytes32",
5654        "indexed": true,
5655        "internalType": "bytes32"
5656      }
5657    ],
5658    "anonymous": false
5659  },
5660  {
5661    "type": "event",
5662    "name": "OperatorSetParamsUpdated",
5663    "inputs": [
5664      {
5665        "name": "quorumNumber",
5666        "type": "uint8",
5667        "indexed": true,
5668        "internalType": "uint8"
5669      },
5670      {
5671        "name": "operatorSetParams",
5672        "type": "tuple",
5673        "indexed": false,
5674        "internalType": "struct ISlashingRegistryCoordinatorTypes.OperatorSetParam",
5675        "components": [
5676          {
5677            "name": "maxOperatorCount",
5678            "type": "uint32",
5679            "internalType": "uint32"
5680          },
5681          {
5682            "name": "kickBIPsOfOperatorStake",
5683            "type": "uint16",
5684            "internalType": "uint16"
5685          },
5686          {
5687            "name": "kickBIPsOfTotalStake",
5688            "type": "uint16",
5689            "internalType": "uint16"
5690          }
5691        ]
5692      }
5693    ],
5694    "anonymous": false
5695  },
5696  {
5697    "type": "event",
5698    "name": "OperatorSetsEnabled",
5699    "inputs": [],
5700    "anonymous": false
5701  },
5702  {
5703    "type": "event",
5704    "name": "OperatorSocketUpdate",
5705    "inputs": [
5706      {
5707        "name": "operatorId",
5708        "type": "bytes32",
5709        "indexed": true,
5710        "internalType": "bytes32"
5711      },
5712      {
5713        "name": "socket",
5714        "type": "string",
5715        "indexed": false,
5716        "internalType": "string"
5717      }
5718    ],
5719    "anonymous": false
5720  },
5721  {
5722    "type": "event",
5723    "name": "OwnershipTransferred",
5724    "inputs": [
5725      {
5726        "name": "previousOwner",
5727        "type": "address",
5728        "indexed": true,
5729        "internalType": "address"
5730      },
5731      {
5732        "name": "newOwner",
5733        "type": "address",
5734        "indexed": true,
5735        "internalType": "address"
5736      }
5737    ],
5738    "anonymous": false
5739  },
5740  {
5741    "type": "event",
5742    "name": "Paused",
5743    "inputs": [
5744      {
5745        "name": "account",
5746        "type": "address",
5747        "indexed": true,
5748        "internalType": "address"
5749      },
5750      {
5751        "name": "newPausedStatus",
5752        "type": "uint256",
5753        "indexed": false,
5754        "internalType": "uint256"
5755      }
5756    ],
5757    "anonymous": false
5758  },
5759  {
5760    "type": "event",
5761    "name": "QuorumBlockNumberUpdated",
5762    "inputs": [
5763      {
5764        "name": "quorumNumber",
5765        "type": "uint8",
5766        "indexed": true,
5767        "internalType": "uint8"
5768      },
5769      {
5770        "name": "blocknumber",
5771        "type": "uint256",
5772        "indexed": false,
5773        "internalType": "uint256"
5774      }
5775    ],
5776    "anonymous": false
5777  },
5778  {
5779    "type": "event",
5780    "name": "QuorumCreated",
5781    "inputs": [
5782      {
5783        "name": "quorumNumber",
5784        "type": "uint8",
5785        "indexed": true,
5786        "internalType": "uint8"
5787      },
5788      {
5789        "name": "operatorSetParams",
5790        "type": "tuple",
5791        "indexed": false,
5792        "internalType": "struct ISlashingRegistryCoordinatorTypes.OperatorSetParam",
5793        "components": [
5794          {
5795            "name": "maxOperatorCount",
5796            "type": "uint32",
5797            "internalType": "uint32"
5798          },
5799          {
5800            "name": "kickBIPsOfOperatorStake",
5801            "type": "uint16",
5802            "internalType": "uint16"
5803          },
5804          {
5805            "name": "kickBIPsOfTotalStake",
5806            "type": "uint16",
5807            "internalType": "uint16"
5808          }
5809        ]
5810      },
5811      {
5812        "name": "minimumStake",
5813        "type": "uint96",
5814        "indexed": false,
5815        "internalType": "uint96"
5816      },
5817      {
5818        "name": "strategyParams",
5819        "type": "tuple[]",
5820        "indexed": false,
5821        "internalType": "struct IStakeRegistryTypes.StrategyParams[]",
5822        "components": [
5823          {
5824            "name": "strategy",
5825            "type": "address",
5826            "internalType": "contract IStrategy"
5827          },
5828          {
5829            "name": "multiplier",
5830            "type": "uint96",
5831            "internalType": "uint96"
5832          }
5833        ]
5834      },
5835      {
5836        "name": "stakeType",
5837        "type": "uint8",
5838        "indexed": false,
5839        "internalType": "enum IStakeRegistryTypes.StakeType"
5840      },
5841      {
5842        "name": "lookAheadPeriod",
5843        "type": "uint32",
5844        "indexed": false,
5845        "internalType": "uint32"
5846      }
5847    ],
5848    "anonymous": false
5849  },
5850  {
5851    "type": "event",
5852    "name": "Unpaused",
5853    "inputs": [
5854      {
5855        "name": "account",
5856        "type": "address",
5857        "indexed": true,
5858        "internalType": "address"
5859      },
5860      {
5861        "name": "newPausedStatus",
5862        "type": "uint256",
5863        "indexed": false,
5864        "internalType": "uint256"
5865      }
5866    ],
5867    "anonymous": false
5868  },
5869  {
5870    "type": "error",
5871    "name": "AlreadyRegisteredForQuorums",
5872    "inputs": []
5873  },
5874  {
5875    "type": "error",
5876    "name": "BitmapCannotBeZero",
5877    "inputs": []
5878  },
5879  {
5880    "type": "error",
5881    "name": "BitmapEmpty",
5882    "inputs": []
5883  },
5884  {
5885    "type": "error",
5886    "name": "BitmapUpdateIsAfterBlockNumber",
5887    "inputs": []
5888  },
5889  {
5890    "type": "error",
5891    "name": "BitmapValueTooLarge",
5892    "inputs": []
5893  },
5894  {
5895    "type": "error",
5896    "name": "BytesArrayLengthTooLong",
5897    "inputs": []
5898  },
5899  {
5900    "type": "error",
5901    "name": "BytesArrayNotOrdered",
5902    "inputs": []
5903  },
5904  {
5905    "type": "error",
5906    "name": "CannotChurnSelf",
5907    "inputs": []
5908  },
5909  {
5910    "type": "error",
5911    "name": "CannotKickOperatorAboveThreshold",
5912    "inputs": []
5913  },
5914  {
5915    "type": "error",
5916    "name": "CannotReregisterYet",
5917    "inputs": []
5918  },
5919  {
5920    "type": "error",
5921    "name": "ChurnApproverSaltUsed",
5922    "inputs": []
5923  },
5924  {
5925    "type": "error",
5926    "name": "CurrentlyPaused",
5927    "inputs": []
5928  },
5929  {
5930    "type": "error",
5931    "name": "ExpModFailed",
5932    "inputs": []
5933  },
5934  {
5935    "type": "error",
5936    "name": "InputAddressZero",
5937    "inputs": []
5938  },
5939  {
5940    "type": "error",
5941    "name": "InputLengthMismatch",
5942    "inputs": []
5943  },
5944  {
5945    "type": "error",
5946    "name": "InsufficientStakeForChurn",
5947    "inputs": []
5948  },
5949  {
5950    "type": "error",
5951    "name": "InvalidAVS",
5952    "inputs": []
5953  },
5954  {
5955    "type": "error",
5956    "name": "InvalidNewPausedStatus",
5957    "inputs": []
5958  },
5959  {
5960    "type": "error",
5961    "name": "InvalidRegistrationType",
5962    "inputs": []
5963  },
5964  {
5965    "type": "error",
5966    "name": "InvalidSignature",
5967    "inputs": []
5968  },
5969  {
5970    "type": "error",
5971    "name": "LookAheadPeriodTooLong",
5972    "inputs": []
5973  },
5974  {
5975    "type": "error",
5976    "name": "M2QuorumRegistrationIsDisabled",
5977    "inputs": []
5978  },
5979  {
5980    "type": "error",
5981    "name": "MaxOperatorCountReached",
5982    "inputs": []
5983  },
5984  {
5985    "type": "error",
5986    "name": "MaxQuorumsReached",
5987    "inputs": []
5988  },
5989  {
5990    "type": "error",
5991    "name": "NextBitmapUpdateIsBeforeBlockNumber",
5992    "inputs": []
5993  },
5994  {
5995    "type": "error",
5996    "name": "NotRegistered",
5997    "inputs": []
5998  },
5999  {
6000    "type": "error",
6001    "name": "NotRegisteredForQuorum",
6002    "inputs": []
6003  },
6004  {
6005    "type": "error",
6006    "name": "NotSorted",
6007    "inputs": []
6008  },
6009  {
6010    "type": "error",
6011    "name": "OnlyAllocationManager",
6012    "inputs": []
6013  },
6014  {
6015    "type": "error",
6016    "name": "OnlyEjector",
6017    "inputs": []
6018  },
6019  {
6020    "type": "error",
6021    "name": "OnlyM2QuorumsAllowed",
6022    "inputs": []
6023  },
6024  {
6025    "type": "error",
6026    "name": "OnlyPauser",
6027    "inputs": []
6028  },
6029  {
6030    "type": "error",
6031    "name": "OnlyUnpauser",
6032    "inputs": []
6033  },
6034  {
6035    "type": "error",
6036    "name": "OperatorNotRegistered",
6037    "inputs": []
6038  },
6039  {
6040    "type": "error",
6041    "name": "OperatorSetQuorum",
6042    "inputs": []
6043  },
6044  {
6045    "type": "error",
6046    "name": "OperatorSetsAlreadyEnabled",
6047    "inputs": []
6048  },
6049  {
6050    "type": "error",
6051    "name": "OperatorSetsNotEnabled",
6052    "inputs": []
6053  },
6054  {
6055    "type": "error",
6056    "name": "QuorumDoesNotExist",
6057    "inputs": []
6058  },
6059  {
6060    "type": "error",
6061    "name": "QuorumOperatorCountMismatch",
6062    "inputs": []
6063  },
6064  {
6065    "type": "error",
6066    "name": "SignatureExpired",
6067    "inputs": []
6068  },
6069  {
6070    "type": "error",
6071    "name": "StringTooLong",
6072    "inputs": [
6073      {
6074        "name": "str",
6075        "type": "string",
6076        "internalType": "string"
6077      }
6078    ]
6079  }
6080]
6081```*/
6082#[allow(
6083    non_camel_case_types,
6084    non_snake_case,
6085    clippy::pub_underscore_fields,
6086    clippy::style,
6087    clippy::empty_structs_with_brackets
6088)]
6089pub mod RegistryCoordinator {
6090    use super::*;
6091    use alloy::sol_types as alloy_sol_types;
6092    /// The creation / init bytecode of the contract.
6093    ///
6094    /// ```text
6095    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
6096    /// ```
6097    #[rustfmt::skip]
6098    #[allow(clippy::all)]
6099    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
6100        b"a\x01\x80`@R4\x80\x15a\0\x10W__\xFD[P`@Qad\xDD8\x03\x80ad\xDD\x839\x81\x01`@\x81\x90Ra\0/\x91a\x02zV[` \x80\x82\x01Q\x80Q\x81\x83\x01Q`@\x80\x84\x01Q``\x85\x01Q`\x80\x80\x87\x01Q`\xA0\x97\x88\x01Q\x85Q\x80\x87\x01\x90\x96R`\x06\x86Rev0.0.1`\xD0\x1B\x99\x86\x01\x99\x90\x99R\x89Q`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x90\x92R\x81\x87\x16`\xE0R\x81\x86\x16`\xC0R\x81\x84\x16a\x01\0R\x81\x83\x16\x90\x97R\x86\x16a\x01 R\x93\x95\x92\x94\x90\x93\x92\x90\x91\x81\x81a\0\xB2\x81a\x01\0V[a\x01@RP`\x01`\x01`\xA0\x1B\x03\x81\x16a\0\xDEW`@Qc9\xB1\x90\xBB`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x16a\x01`Ra\0\xF3a\x01FV[PPPPPPPPa\x03\xACV[__\x82\x90P`\x1F\x81Q\x11\x15a\x013W\x82`@Qc0Z'\xA9`\xE0\x1B\x81R`\x04\x01a\x01*\x91\x90a\x03;V[`@Q\x80\x91\x03\x90\xFD[\x80Qa\x01>\x82a\x03\x86V[\x17\x93\x92PPPV[`dTa\x01\0\x90\x04`\xFF\x16\x15a\x01\xAEW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FInitializable: contract is initi`D\x82\x01Rfalizing`\xC8\x1B`d\x82\x01R`\x84\x01a\x01*V[`dT`\xFF\x90\x81\x16\x14a\x01\xFFW`d\x80T`\xFF\x19\x16`\xFF\x90\x81\x17\x90\x91U`@Q\x90\x81R\x7F\x7F&\xB8?\xF9n\x1F+jh/\x138R\xF6y\x8A\t\xC4e\xDA\x95\x92\x14`\xCE\xFB8G@$\x98\x90` \x01`@Q\x80\x91\x03\x90\xA1[V[`@\x80Q\x90\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x02/WcNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@R\x90V[`@Q`\xC0\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x02/WcNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x02wW__\xFD[PV[_\x81\x83\x03`\xE0\x81\x12\x80\x15a\x02\x8CW__\xFD[Pa\x02\x95a\x02\x01V[\x83Qa\x02\xA0\x81a\x02cV[\x81R`\xC0`\x1F\x19\x83\x01\x12\x15a\x02\xB3W__\xFD[a\x02\xBBa\x025V[\x91P` \x84\x01Qa\x02\xCB\x81a\x02cV[\x82R`@\x84\x01Qa\x02\xDB\x81a\x02cV[` \x83\x01R``\x84\x01Qa\x02\xEE\x81a\x02cV[`@\x83\x01R`\x80\x84\x01Qa\x03\x01\x81a\x02cV[``\x83\x01R`\xA0\x84\x01Qa\x03\x14\x81a\x02cV[`\x80\x83\x01R`\xC0\x84\x01Qa\x03'\x81a\x02cV[`\xA0\x83\x01R` \x81\x01\x91\x90\x91R\x93\x92PPPV[` \x81R_\x82Q\x80` \x84\x01R_[\x81\x81\x10\x15a\x03gW` \x81\x86\x01\x81\x01Q`@\x86\x84\x01\x01R\x01a\x03JV[P_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[\x80Q` \x80\x83\x01Q\x91\x90\x81\x10\x15a\x03\xA6W_\x19\x81` \x03`\x03\x1B\x1B\x82\x16\x91P[P\x91\x90PV[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\x01@Qa\x01`Qa`#a\x04\xBA_9_\x81\x81a\x07L\x01R\x81\x81a\x0C\x9E\x01R\x81\x81a\x14\x94\x01Ra\x1DZ\x01R_PP_\x81\x81a\x08\xC6\x01R\x81\x81a#~\x01R\x81\x81a)Y\x01R\x81\x81a*\x84\x01RaA\xEA\x01R_\x81\x81a\x07\xB6\x01R\x81\x81a\x10H\x01R\x81\x81a&\xB2\x01R\x81\x81a+\xBE\x01Ra7\x0F\x01R_\x81\x81a\x06\x8F\x01R\x81\x81a\x1F\xA9\x01R\x81\x81a&7\x01R\x81\x81a)\xF7\x01R\x81\x81a+=\x01R\x81\x81a6m\x01Ra<\xBC\x01R_\x81\x81a\x06h\x01R\x81\x81a\x0E\x07\x01R\x81\x81a%\xBE\x01R\x81\x81a,3\x01R\x81\x81a1\x8B\x01Ra5\xF4\x01R_\x81\x81a\t\x8C\x01Ra!v\x01R_\x81\x81a\x05Z\x01R\x81\x81a\x18\xA9\x01R\x81\x81a\x1A\x15\x01Ra:\x16\x01Ra`#_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x03FW_5`\xE0\x1C\x80cs;u\x07\x11a\x01\xB9W\x80c\xA9ox>\x11a\0\xF6W\x80c\xE6W\x97\xAD\x11a\0\x9AW\x80c\xE6W\x97\xAD\x14a\x08\xFBW\x80c\xE8\x14\xCA\x9D\x14a\tvW\x80c\xEA2\xAF\xAE\x14a\t\x87W\x80c\xEC\x8C:\x1E\x14a\t\xAEW\x80c\xF2\xFD\xE3\x8B\x14a\t\xB6W\x80c\xF6\x98\xDA%\x14a\t\xC9W\x80c\xFA\xBC\x1C\xBC\x14a\t\xD1W\x80c\xFD9\x10Z\x14a\t\xE4W__\xFD[\x80c\xA9ox>\x14a\x088W\x80c\xB5&W\x87\x14a\x08AW\x80c\xC3\x91B^\x14a\x08TW\x80c\xC6?\xD5\x02\x14a\x08tW\x80c\xCA\r\xE8\x82\x14a\x08\x87W\x80c\xCAO-\x97\x14a\x08\xAEW\x80c\xCA\x8A\xA7\xC7\x14a\x08\xC1W\x80c\xDE\x11d\xBB\x14a\x08\xE8W__\xFD[\x80c\x8D\xA5\xCB[\x11a\x01]W\x80c\x8D\xA5\xCB[\x14a\x07nW\x80c\x9A\xA1e=\x14a\x07\x7FW\x80c\x9B]\x17{\x14a\x07\x9EW\x80c\x9E\x99#\xC2\x14a\x07\xB1W\x80c\x9F\xEA\xB8Y\x14a\x07\xD8W\x80c\xA4\xD7\x87\x1F\x14a\x07\xFFW\x80c\xA5\x08W\xBF\x14a\x08\x12W\x80c\xA6T\x97\xC6\x14a\x08%W__\xFD[\x80cs;u\x07\x14a\x06\xCCW\x80csDy\x92\x14a\x06\xD4W\x80c\x81\xF96\xD2\x14a\x06\xE7W\x80c\x82\x81\xABu\x14a\x06\xF3W\x80c\x84\xB0\x19n\x14a\x07\x06W\x80c\x84\xCAR\x13\x14a\x07!W\x80c\x87\x1E\xF0I\x14a\x074W\x80c\x88o\x11\x95\x14a\x07GW__\xFD[\x80c0<\xA9V\x11a\x02\x87W\x80cY\\jg\x11a\x02+W\x80cY\\jg\x14a\x06\x1DW\x80cZ\xC8j\xB7\x14a\x06%W\x80c[\x0B\x82\x9F\x14a\x06HW\x80c\\\x97Z\xBB\x14a\x06[W\x80c]\xF4YF\x14a\x06cW\x80ch0H5\x14a\x06\x8AW\x80cn;\x17\xDB\x14a\x06\xB1W\x80cqP\x18\xA6\x14a\x06\xC4W__\xFD[\x80c0<\xA9V\x14a\x05BW\x80c9\x98\xFD\xD3\x14a\x05UW\x80c<*\x7FL\x14a\x05|W\x80c>\xEF:Q\x14a\x05\x9CW\x80cQ@\xA5H\x14a\x05\xAFW\x80cS\x0B\x97\xA4\x14a\x05\xC2W\x80cT\xFDMP\x14a\x05\xD5W\x80cXe\xC6\x0C\x14a\x05\xFDW__\xFD[\x80c\x13d9\xDD\x11a\x02\xEEW\x80c\x13d9\xDD\x14a\x04IW\x80c\x14x\x85\x1F\x14a\x04\\W\x80c\x1E\xB8\x12\xDA\x14a\x04\x8EW\x80c$\x9A\x0CB\x14a\x04\xD7W\x80c(\xF6\x1B1\x14a\x04\xF6W\x80c)k\xB0d\x14a\x05\tW\x80c)\xD1\xE0\xC3\x14a\x05\x1CW\x80c,\xDD\x1E\x86\x14a\x05/W__\xFD[\x80b\xCF*\xB5\x14a\x03JW\x80c\x03\xFD4\x92\x14a\x03_W\x80c\x04\xECcQ\x14a\x03\x91W\x80c\x05C\x10\xE6\x14a\x03\xBCW\x80c\x0C\xF4\xB7g\x14a\x03\xDCW\x80c\r?!4\x14a\x03\xEFW\x80c\x12^\x05\x84\x14a\x04\x02W\x80c\x13T*N\x14a\x04!W[__\xFD[a\x03]a\x03X6`\x04aG\x99V[a\n\x1FV[\0[a\x03~a\x03m6`\x04aG\xCAV[_\x90\x81R`4` R`@\x90 T\x90V[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\x03\xA4a\x03\x9F6`\x04aG\xF2V[a\x0B\xC0V[`@Q`\x01`\x01`\xC0\x1B\x03\x90\x91\x16\x81R` \x01a\x03\x88V[`9Ta\x03\xCF\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Qa\x03\x88\x91\x90aH'V[a\x03]a\x03\xEA6`\x04aH\xACV[a\x0B\xD8V[a\x03]a\x03\xFD6`\x04aG\xCAV[a\x0C:V[a\x03~a\x04\x106`\x04aH\xDDV[`;` R_\x90\x81R`@\x90 T\x81V[a\x03~a\x04/6`\x04aH\xDDV[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R`5` R`@\x90 T\x90V[a\x03]a\x04W6`\x04aG\xCAV[a\x0C\x87V[a\x04~a\x04j6`\x04aG\xCAV[`6` R_\x90\x81R`@\x90 T`\xFF\x16\x81V[`@Q\x90\x15\x15\x81R` \x01a\x03\x88V[a\x04\xA1a\x04\x9C6`\x04aH\xF8V[a\raV[`@\x80Q\x82Qc\xFF\xFF\xFF\xFF\x90\x81\x16\x82R` \x80\x85\x01Q\x90\x91\x16\x90\x82\x01R\x91\x81\x01Q`\x01`\x01`\xC0\x1B\x03\x16\x90\x82\x01R``\x01a\x03\x88V[a\x03~a\x04\xE56`\x04aI-V[`7` R_\x90\x81R`@\x90 T\x81V[`:Ta\x03\xCF\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[a\x03\xCFa\x05\x176`\x04aG\xCAV[a\r\xEFV[a\x03]a\x05*6`\x04aH\xDDV[a\x0ExV[a\x03]a\x05=6`\x04aH\xDDV[a\x0E\x89V[a\x03]a\x05P6`\x04aI\xAAV[a\x0E\x9AV[a\x03\xCF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x05\x8Fa\x05\x8A6`\x04aH\xDDV[a\x0F\x0EV[`@Qa\x03\x88\x91\x90aJ\x07V[a\x03]a\x05\xAA6`\x04aK(V[a\x0F2V[a\x03]a\x05\xBD6`\x04aK\xD4V[a\x0FNV[a\x03]a\x05\xD06`\x04aL\xB1V[a\x12uV[`@\x80Q\x80\x82\x01\x82R`\x06\x81Rev0.0.1`\xD0\x1B` \x82\x01R\x90Qa\x03\x88\x91\x90aMbV[a\x06\x10a\x06\x0B6`\x04aH\xDDV[a\x14\x0BV[`@Qa\x03\x88\x91\x90aM\x9CV[a\x03]a\x14}V[a\x04~a\x0636`\x04aI-V[`eT`\x01`\xFF\x90\x92\x16\x91\x90\x91\x1B\x90\x81\x16\x14\x90V[a\x03]a\x06V6`\x04aM\xB7V[a\x151V[`eTa\x03~V[a\x03\xCF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x03\xCF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x03]a\x06\xBF6`\x04aM\xE9V[a\x15MV[a\x03]a\x15yV[a\x03]a\x15\x8AV[a\x03~a\x06\xE26`\x04aH\xDDV[a\x15\xF1V[_Ta\x04~\x90`\xFF\x16\x81V[a\x03]a\x07\x016`\x04aN5V[a\x16UV[a\x07\x0Ea\x16jV[`@Qa\x03\x88\x97\x96\x95\x94\x93\x92\x91\x90aN\x87V[a\x03~a\x07/6`\x04aO\xB1V[a\x17\x03V[a\x03\xA4a\x07B6`\x04aG\xCAV[a\x17LV[a\x03\xCF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`\xC8T`\x01`\x01`\xA0\x1B\x03\x16a\x03\xCFV[`2Ta\x07\x8C\x90`\xFF\x16\x81V[`@Q`\xFF\x90\x91\x16\x81R` \x01a\x03\x88V[a\x03]a\x07\xAC6`\x04aQlV[a\x17VV[a\x03\xCF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x03~\x7F+\xD8!$\x05\x7F\t\x13\xBC;w,\xE7\xB8>\x80W\xC1\xAD\x1F5\x10\xFC\x83w\x8B\xE2\x0F\x10\xEC]\xE6\x81V[a\x04~a\x08\r6`\x04aI-V[a\x19\x19V[a\x03]a\x08 6`\x04aRdV[a\x194V[a\x03]a\x0836`\x04aH\xDDV[a\x1A\x81V[a\x03~`<T\x81V[a\x04~a\x08O6`\x04aH\xDDV[a\x1A\x92V[a\x08ga\x08b6`\x04aS\x03V[a\x1A\xA6V[`@Qa\x03\x88\x91\x90aS\xA8V[a\x03]a\x08\x826`\x04aS\xE5V[a\x1A\xB4V[a\x03~\x7FM@N2v\xE7\xAC!c\xD8\xEEGj\xFAjA\xD1\xF6\x8F\xB7\x1F-\x8BeF\xB2NU\xCE\x01\xB7*\x81V[a\x03]a\x08\xBC6`\x04aH\xACV[a\x1CVV[a\x03\xCF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`=Ta\x03\xCF\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[a\tia\t\t6`\x04aI-V[`@\x80Q``\x80\x82\x01\x83R_\x80\x83R` \x80\x84\x01\x82\x90R\x92\x84\x01\x81\x90R`\xFF\x94\x90\x94\x16\x84R`3\x82R\x92\x82\x90 \x82Q\x93\x84\x01\x83RTc\xFF\xFF\xFF\xFF\x81\x16\x84Ra\xFF\xFF`\x01` \x1B\x82\x04\x81\x16\x92\x85\x01\x92\x90\x92R`\x01`0\x1B\x90\x04\x16\x90\x82\x01R\x90V[`@Qa\x03\x88\x91\x90aTrV[_Ta\x04~\x90a\x01\0\x90\x04`\xFF\x16\x81V[a\x03\xCF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x03~a\x1C\xBAV[a\x03]a\t\xC46`\x04aH\xDDV[a\x1C\xD9V[a\x03~a\x1DOV[a\x03]a\t\xDF6`\x04aG\xCAV[a\x1DXV[a\n\x12a\t\xF26`\x04aH\xDDV[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R`5` R`@\x90 `\x01\x01T`\xFF\x16\x90V[`@Qa\x03\x88\x91\x90aT\xA5V[`eT`\x02\x90`\x04\x90\x81\x16\x03a\nHW`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_[\x82Q\x81\x10\x15a\x0B\xBBW`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x80\x83\x01\x90\x806\x837\x01\x90PP\x90P\x83\x82\x81Q\x81\x10a\n\x86Wa\n\x86aT\xB3V[` \x02` \x01\x01Q\x81_\x81Q\x81\x10a\n\xA0Wa\n\xA0aT\xB3V[`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91\x81` \x01` \x82\x02\x806\x837\x01\x90PP\x90P`5_\x86\x85\x81Q\x81\x10a\n\xF1Wa\n\xF1aT\xB3V[` \x02` \x01\x01Q`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x90\x81R` \x01_ _\x01T\x81_\x81Q\x81\x10a\x0B-Wa\x0B-aT\xB3V[` \x02` \x01\x01\x81\x81RPP_a\x0B\\\x82_\x81Q\x81\x10a\x0BOWa\x0BOaT\xB3V[` \x02` \x01\x01Qa\x1EoV[\x90P_a\x0Bq\x82`\x01`\x01`\xC0\x1B\x03\x16a\x1E{V[\x90P_[\x81Q\x81\x10\x15a\x0B\xAAWa\x0B\xA2\x85\x85\x84\x84\x81Q\x81\x10a\x0B\x95Wa\x0B\x95aT\xB3V[\x01` \x01Q`\xF8\x1Ca\x1FDV[`\x01\x01a\x0BuV[PP`\x01\x90\x93\x01\x92Pa\nJ\x91PPV[PPPV[_a\x0B\xCE`4\x85\x85\x85a {V[\x90P[\x93\x92PPPV[`\x013_\x90\x81R`5` R`@\x90 `\x01\x01T`\xFF\x16`\x02\x81\x11\x15a\x0C\0Wa\x0C\0aMtV[\x14a\x0C\x1EW`@Qc\xAB\xA4s9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3_\x90\x81R`5` R`@\x90 Ta\x0C7\x90\x82a!_V[PV[a\x0CBa\"\nV[`<\x80T\x90\x82\x90U`@\x80Q\x82\x81R` \x81\x01\x84\x90R\x7F\xA7z\x91\xBE\xA7\xB6\xD9Z\x8E\xB5\xA5Hx\xA1\xD9\xE3\xC8u\xE2l\x86\xA9\xB7\x0E4 \xC5\xC5\xDB\x19;b\x91\x01`@Q\x80\x91\x03\x90\xA1PPV[`@Qc#}\xFBG`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90cF\xFB\xF6\x8E\x90a\x0C\xD3\x903\x90`\x04\x01aH'V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0C\xEEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\x12\x91\x90aT\xD6V[a\r/W`@Qc\x1Dw\xD4w`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`eT\x81\x81\x16\x81\x14a\rTW`@Qc\xC6\x1D\xCA]`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\r]\x82a\"dV[PPV[`@\x80Q``\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x91\x90\x91R_\x83\x81R`4` R`@\x90 \x80T\x83\x90\x81\x10a\r\x9CWa\r\x9CaT\xB3V[_\x91\x82R` \x91\x82\x90 `@\x80Q``\x81\x01\x82R\x91\x90\x92\x01Tc\xFF\xFF\xFF\xFF\x80\x82\x16\x83R`\x01` \x1B\x82\x04\x16\x93\x82\x01\x93\x90\x93R`\x01`\x01`\xC0\x1B\x03`\x01`@\x1B\x90\x93\x04\x92\x90\x92\x16\x90\x82\x01R\x90P[\x92\x91PPV[`@Qc\x08\xF6b\x9D`\xE3\x1B\x81R`\x04\x81\x01\x82\x90R_\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x90cG\xB3\x14\xE8\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0ETW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\xE9\x91\x90aT\xEFV[a\x0E\x80a\"\nV[a\x0C7\x81a\"\xA1V[a\x0E\x91a\"\nV[a\x0C7\x81a#\nV[a\x0E\xA2a#sV[`eT`\x01\x90`\x02\x90\x81\x16\x03a\x0E\xCBW`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x0E\xD4\x83a\x1A\x92V[a\x0E\xF1W`@Qcf\xE5e\xDF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x0E\xFB\x83a#\xBCV[\x90Pa\x0F\x07\x85\x82a$dV[PPPPPV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01Ra\r\xE9a\x0F-\x83a\x15\xF1V[a'-V[a\x0F:a\"\nV[a\x0FH\x84\x84\x84`\x01\x85a'\xB7V[PPPPV[`eT`\x02\x90`\x04\x90\x81\x16\x03a\x0FwW`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x0F\xBC\x83\x83\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPP`2T`\xFF\x16\x91Pa,\xE2\x90PV[P\x83Q\x82\x14a\x0F\xDEW`@Qc\xAA\xAD\x13\xF7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_[\x82\x81\x10\x15a\x0F\x07W_\x84\x84\x83\x81\x81\x10a\x0F\xFBWa\x0F\xFBaT\xB3V[\x88Q\x92\x015`\xF8\x1C\x92P_\x91\x88\x91P\x84\x90\x81\x10a\x10\x1AWa\x10\x1AaT\xB3V[` \x90\x81\x02\x91\x90\x91\x01\x01Q`@Qcy\xA0\x84\x91`\xE1\x1B\x81R`\xFF\x84\x16`\x04\x82\x01R\x90\x91P`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xF3A\t\"\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\x8DW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xB1\x91\x90aU\nV[c\xFF\xFF\xFF\xFF\x16\x81Q\x14a\x10\xD7W`@Qc\x8EZ\xEE\xE7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x10\xF1Wa\x10\xF1aFbV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x11\x1AW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[\x83Q\x81\x10\x15a\x12\x10W_\x84\x82\x81Q\x81\x10a\x11<Wa\x11<aT\xB3V[` \x02` \x01\x01Q\x90P`5_\x82`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x90\x81R` \x01_ _\x01T\x84\x83\x81Q\x81\x10a\x11~Wa\x11~aT\xB3V[` \x02` \x01\x01\x81\x81RPP_a\x11\xA0\x85\x84\x81Q\x81\x10a\x0BOWa\x0BOaT\xB3V[\x90P`\x01`\x01`\x01`\xC0\x1B\x03\x82\x16`\xFF\x89\x16\x1C\x81\x16\x14a\x11\xD3W`@Qc\xD0S\xAA!`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x83`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x11a\x12\x05W`@Qc\xBAP\xF9\x11`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P\x91P`\x01\x01a\x11 V[Pa\x12\x1C\x83\x83\x86a\x1FDV[`\xFF\x84\x16_\x81\x81R`7` \x90\x81R`@\x91\x82\x90 C\x90\x81\x90U\x91Q\x91\x82R\x7FF\x07}U3\x07c\xF1bi\xFDu\xE5v\x16c\xF4\x19-'\x91t|\x01\x89\xB1j\xD3\x1D\xB0}\xB4\x91\x01`@Q\x80\x91\x03\x90\xA2PPPP\x80`\x01\x01\x90Pa\x0F\xE0V[`dTa\x01\0\x90\x04`\xFF\x16\x15\x80\x80\x15a\x12\x95WP`dT`\x01`\xFF\x90\x91\x16\x10[\x80a\x12\xAFWP0;\x15\x80\x15a\x12\xAFWP`dT`\xFF\x16`\x01\x14[a\x13\x17W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`.`$\x82\x01R\x7FInitializable: contract is alrea`D\x82\x01Rm\x19\x1EH\x1A[\x9A]\x1AX[\x1A^\x99Y`\x92\x1B`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[`d\x80T`\xFF\x19\x16`\x01\x17\x90U\x80\x15a\x13:W`d\x80Ta\xFF\0\x19\x16a\x01\0\x17\x90U[a\x13\x90`@Q\x80`@\x01`@R\x80`\x16\x81R` \x01u \xAB)\xA92\xB3\xB4\xB9\xBA9<\xA1\xB7\xB7\xB924\xB70\xBA7\xB9`Q\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01ev0.0.1`\xD0\x1B\x81RPa-\x16V[a\x13\x99\x86a-GV[a\x13\xA2\x85a\"\xA1V[a\x13\xAB\x83a\"dV[a\x13\xB4\x84a#\nV[a\x13\xBD\x82a-\x98V[\x80\x15a\x14\x03W`d\x80Ta\xFF\0\x19\x16\x90U`@Q`\x01\x81R\x7F\x7F&\xB8?\xF9n\x1F+jh/\x138R\xF6y\x8A\t\xC4e\xDA\x95\x92\x14`\xCE\xFB8G@$\x98\x90` \x01`@Q\x80\x91\x03\x90\xA1[PPPPPPV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`5` \x90\x81R`@\x91\x82\x90 \x82Q\x80\x84\x01\x90\x93R\x80T\x83R`\x01\x81\x01T\x90\x91\x83\x01\x90`\xFF\x16`\x02\x81\x11\x15a\x14cWa\x14caMtV[`\x02\x81\x11\x15a\x14tWa\x14taMtV[\x90RP\x92\x91PPV[`@Qc#}\xFBG`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90cF\xFB\xF6\x8E\x90a\x14\xC9\x903\x90`\x04\x01aH'V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x14\xE4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15\x08\x91\x90aT\xD6V[a\x15%W`@Qc\x1Dw\xD4w`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x15/_\x19a\"dV[V[a\x159a\"\nV[\x81a\x15C\x81a.\x04V[a\x0B\xBB\x83\x83a.-V[a\x15Ua.\xBEV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`;` R`@\x90 B\x90Ua\r]\x82\x82a.\xE9V[a\x15\x81a\"\nV[a\x15/_a-GV[a\x15\x92a\"\nV[_Ta\x01\0\x90\x04`\xFF\x16\x15a\x15\xBAW`@Qc!\xFA\x91\xF3`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80Ta\xFF\0\x19\x16a\x01\0\x17\x81U`@Q\x7F\x0F\xC3\xC0\xE6\xF8\xB4y_7\x1E\x19\xDE\x7FLW3\xDD\x9ET\x9F\xA8\xC3\x9EXB\xEBf\xC3\x15r\xD9\x9E\x91\x90\xA1V[_a\r\xE9\x7F+\xD8!$\x05\x7F\t\x13\xBC;w,\xE7\xB8>\x80W\xC1\xAD\x1F5\x10\xFC\x83w\x8B\xE2\x0F\x10\xEC]\xE6\x83`@Q` \x01a\x16:\x92\x91\x90\x91\x82R`\x01`\x01`\xA0\x1B\x03\x16` \x82\x01R`@\x01\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 a0\x02V[a\x16]a\"\nV[a\x0B\xBB\x83\x83\x83__a'\xB7V[_``\x80___```\xFAT__\x1B\x14\x80\x15a\x16\x86WP`\xFBT\x15[a\x16\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x15`$\x82\x01Rt\x11RT\r\xCCL\x8E\x88\x15[\x9A[\x9A]\x1AX[\x1A^\x99Y`Z\x1B`D\x82\x01R`d\x01a\x13\x0EV[a\x16\xD2a0.V[a\x16\xDAa0\xBEV[`@\x80Q_\x80\x82R` \x82\x01\x90\x92R`\x0F`\xF8\x1B\x9B\x93\x9AP\x91\x98PF\x97P0\x96P\x94P\x92P\x90PV[_a\x17B\x7FM@N2v\xE7\xAC!c\xD8\xEEGj\xFAjA\xD1\xF6\x8F\xB7\x1F-\x8BeF\xB2NU\xCE\x01\xB7*\x87\x87\x87\x87\x87`@Q` \x01a\x16:\x96\x95\x94\x93\x92\x91\x90aU%V[\x96\x95PPPPPPV[_a\r\xE9\x82a\x1EoV[`eT_\x90`\x01\x90\x81\x16\x03a\x17~W`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_Ta\x01\0\x90\x04`\xFF\x16\x15a\x17\xA6W`@Qc!\xFA\x91\xF3`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x17\xF6a\x17\xB1a\x1C\xBAV[a\x17\xEF\x8A\x8A\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPa0\xCD\x92PPPV[\x90\x81\x16\x14\x90V[a\x18\x13W`@Qc\xAF\xAAp\xEF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_`\x013_\x90\x81R`5` R`@\x90 `\x01\x01T`\xFF\x16`\x02\x81\x11\x15a\x18<Wa\x18<aMtV[\x14\x90Pa\x18\x8D3a\x18M3\x89a1\x88V[\x8B\x8B\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RP\x8D\x92P\x8B\x91P\x8A\x90Pa2!V[\x80a\x19\x0EW`@Qc\x99&\xEE}`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\x99&\xEE}\x90a\x18\xE0\x903\x90\x87\x90`\x04\x01aU\xAAV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x18\xF7W__\xFD[PZ\xF1\x15\x80\x15a\x19\tW=__>=_\xFD[PPPP[PPPPPPPPPV[_a\r\xE9\x82a\x19&a\x1C\xBAV[\x90`\xFF\x16\x1C`\x01\x90\x81\x16\x14\x90V[`eT_\x90`\x01\x90\x81\x16\x03a\x19\\W`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_Ta\x01\0\x90\x04`\xFF\x16\x15a\x19\x84W`@Qc!\xFA\x91\xF3`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x19\x98a\x19\x8Fa\x1C\xBAV[a\x17\xEF\x87a0\xCDV[a\x19\xB5W`@Qc\xAF\xAAp\xEF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_`\x013_\x90\x81R`5` R`@\x90 `\x01\x01T`\xFF\x16`\x02\x81\x11\x15a\x19\xDEWa\x19\xDEaMtV[\x14\x90Pa\x19\xF83a\x19\xEF3\x87a1\x88V[\x88\x88`\x01a4\x16V[P\x80a\x14\x03W`@Qc\x99&\xEE}`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\x99&\xEE}\x90a\x1AL\x903\x90\x87\x90`\x04\x01aU\xAAV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1AcW__\xFD[PZ\xF1\x15\x80\x15a\x1AuW=__>=_\xFD[PPPPPPPPPPV[a\x1A\x89a\"\nV[a\x0C7\x81a-\x98V[`=T`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x91\x16\x14\x90V[``a\x0B\xD1`4\x84\x84a8_V[a\x1A\xBCa#sV[`eT_\x90`\x01\x90\x81\x16\x03a\x1A\xE4W`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1A\xED\x85a\x1A\x92V[a\x1B\nW`@Qcf\xE5e\xDF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x1B\x14\x85a#\xBCV[\x90P_\x80\x80a\x1B%\x86\x88\x01\x88aV\x02V[\x92P\x92P\x92P_a\x1B6\x8B\x83a1\x88V[\x90P_\x84`\x01\x81\x11\x15a\x1BKWa\x1BKaMtV[\x03a\x1B\xF4W_a\x1B_\x8C\x83\x88\x87`\x01a4\x16V[Q\x90P_[\x86Q\x81\x10\x15a\x1B\xEDW_\x87\x82\x81Q\x81\x10a\x1B\x80Wa\x1B\x80aT\xB3V[\x01` \x90\x81\x01Q`\xF8\x1C_\x81\x81R`3\x90\x92R`@\x90\x91 T\x84Q\x91\x92Pc\xFF\xFF\xFF\xFF\x16\x90\x84\x90\x84\x90\x81\x10a\x1B\xB7Wa\x1B\xB7aT\xB3V[` \x02` \x01\x01Qc\xFF\xFF\xFF\xFF\x16\x11\x15a\x1B\xE4W`@Qc\xC6\xB9\xE7g`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P`\x01\x01a\x1BdV[PPa\x1CIV[`\x01\x84`\x01\x81\x11\x15a\x1C\x08Wa\x1C\x08aMtV[\x03a\x1C0W_\x80a\x1C\x1B\x89\x8B\x01\x8BaV]V[\x94P\x94PPPPa\x1B\xED\x8D\x84\x89\x88\x86\x86a2!V[`@Qc5K\xB8\xAB`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPPPPPPPPPV[`eT`\x01\x90`\x02\x90\x81\x16\x03a\x1C\x7FW`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1C\x93a\x1C\x8Aa\x1C\xBAV[a\x17\xEF\x84a0\xCDV[a\x1C\xB0W`@Qc\xAF\xAAp\xEF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\r]3\x83a$dV[_\x80T`\xFF\x16\x15a\x1C\xCCWP`\x01T\x90V[a\x1C\xD4a9\x0EV[\x90P\x90V[a\x1C\xE1a\"\nV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x1DFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01Reddress`\xD0\x1B`d\x82\x01R`\x84\x01a\x13\x0EV[a\x0C7\x81a-GV[_a\x1C\xD4a9%V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xEA\xB6mz`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1D\xB4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1D\xD8\x91\x90aT\xEFV[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\x1E\tW`@QcyH!\xFF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`eT\x80\x19\x82\x19\x81\x16\x14a\x1E0W`@Qc\xC6\x1D\xCA]`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`e\x82\x90U`@Q\x82\x81R3\x90\x7F5\x82\xD1\x82\x8E&\xBFV\xBD\x80\x15\x02\xBC\x02\x1A\xC0\xBC\x8A\xFBW\xC8&\xE4\x98kEY<\x8F\xAD8\x9C\x90` \x01[`@Q\x80\x91\x03\x90\xA2PPV[_a\r\xE9`4\x83a9.V[``__a\x1E\x88\x84a9\x98V[a\xFF\xFF\x16`\x01`\x01`@\x1B\x03\x81\x11\x15a\x1E\xA3Wa\x1E\xA3aFbV[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x1E\xCDW` \x82\x01\x81\x806\x837\x01\x90P[P\x90P_\x80[\x82Q\x82\x10\x80\x15a\x1E\xE4WPa\x01\0\x81\x10[\x15a\x1F:W`\x01\x81\x1B\x93P\x85\x84\x16\x15a\x1F*W\x80`\xF8\x1B\x83\x83\x81Q\x81\x10a\x1F\rWa\x1F\raT\xB3V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SP\x81`\x01\x01\x91P[a\x1F3\x81aW!V[\x90Pa\x1E\xD3V[P\x90\x94\x93PPPPV[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x82\x01\x81\x806\x837\x01\x90PP\x90P\x81`\xF8\x1B\x81_\x81Q\x81\x10a\x1FzWa\x1FzaT\xB3V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SP`@Qcl?\xB4\xBF`\xE0\x1B\x81R_\x90`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90cl?\xB4\xBF\x90a\x1F\xE2\x90\x88\x90\x88\x90\x88\x90`\x04\x01aW9V[_`@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x1F\xFDW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra $\x91\x90\x81\x01\x90aW\xC9V[\x90P_[\x85Q\x81\x10\x15a\x14\x03W\x81\x81\x81Q\x81\x10a CWa CaT\xB3V[` \x02` \x01\x01Q\x15a sWa s\x86\x82\x81Q\x81\x10a eWa eaT\xB3V[` \x02` \x01\x01Q\x84a.\xE9V[`\x01\x01a (V[_\x83\x81R` \x85\x90R`@\x81 \x80T\x82\x91\x90\x84\x90\x81\x10a \x9DWa \x9DaT\xB3V[_\x91\x82R` \x91\x82\x90 `@\x80Q``\x81\x01\x82R\x92\x90\x91\x01Tc\xFF\xFF\xFF\xFF\x80\x82\x16\x80\x85R`\x01` \x1B\x83\x04\x82\x16\x95\x85\x01\x95\x90\x95R`\x01`@\x1B\x90\x91\x04`\x01`\x01`\xC0\x1B\x03\x16\x91\x83\x01\x91\x90\x91R\x90\x92P\x85\x16\x10\x15a!\rW`@Qcl\xB1\x9A\xFF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[` \x81\x01Qc\xFF\xFF\xFF\xFF\x16\x15\x80a!3WP\x80` \x01Qc\xFF\xFF\xFF\xFF\x16\x84c\xFF\xFF\xFF\xFF\x16\x10[a!PW`@Qc\xBB\xBA`\xCB`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x01Q\x90P[\x94\x93PPPPV[`@Qcx!\x9B?`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xF0C6~\x90a!\xAD\x90\x85\x90\x85\x90`\x04\x01aXVV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a!\xC4W__\xFD[PZ\xF1\x15\x80\x15a!\xD6W=__>=_\xFD[PPPP\x81\x7F\xEC)c\xAB!\xC1\xE5\x0E\x1EX*\xA5B\xAF.K\xF7\xBF8\xE6\xE1@<'\xB4.\x1C]nb\x1E\xAA\x82`@Qa\x1Ec\x91\x90aMbV[`\xC8T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x15/W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x13\x0EV[`e\x81\x90U`@Q\x81\x81R3\x90\x7F\xAB@\xA3t\xBCQ\xDE7\"\0\xA8\xBC\x98\x1A\xF8\xC9\xEC\xDC\x08\xDF\xDA\xEF\x0B\xB6\xE0\x9F\x88\xF3\xC6\x16\xEF=\x90` \x01`@Q\x80\x91\x03\x90\xA2PV[`9T`@Q\x7F1TW\xD8\xA8\xFE`\xF0J\xF1|\x16\xE2\xF5\xA5\xE1\xDBa+1d\x8EX\x03\x03`u\x9E\xF8\xF3R\x8C\x91a\"\xE0\x91`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90\x84\x90aXnV[`@Q\x80\x91\x03\x90\xA1`9\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[`:T`@Q\x7F\x8F0\xAB\t\xF4:l\x15}\x7F\xCE~\n\x13\xC0\x03\x04,\x1C\x95\xE8\xA7.z\x14j!\xC0\xCA\xA2M\xC9\x91a#I\x91`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90\x84\x90aXnV[`@Q\x80\x91\x03\x90\xA1`:\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[3`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x15/W`@Qc#\xD8q\xA5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[``_\x82Q`\x01`\x01`@\x1B\x03\x81\x11\x15a#\xD8Wa#\xD8aFbV[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a$\x02W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P_[\x83Q\x81\x10\x15a$]W\x83\x81\x81Q\x81\x10a$\"Wa$\"aT\xB3V[` \x02` \x01\x01Q`\xF8\x1B\x82\x82\x81Q\x81\x10a$?Wa$?aT\xB3V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SP`\x01\x01a$\x07V[P\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`5` R`@\x81 \x80T\x90\x91a$\x88\x82a\x1EoV[\x90P`\x01\x80\x84\x01T`\xFF\x16`\x02\x81\x11\x15a$\xA4Wa$\xA4aMtV[\x14a$\xC2W`@Qc\xAB\xA4s9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`2T_\x90a$\xD5\x90\x86\x90`\xFF\x16a,\xE2V[\x90P`\x01`\x01`\xC0\x1B\x03\x81\x16a$\xFEW`@Qch\xB6\xA8u`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a%\x15`\x01`\x01`\xC0\x1B\x03\x82\x81\x16\x90\x84\x16\x81\x16\x14\x90V[a%2W`@Qc\xD0S\xAA!`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xC0\x1B\x03\x81\x81\x16\x19\x83\x16\x16a%K\x84\x82a9\xC2V[`\x01`\x01`\xC0\x1B\x03\x81\x16a%\xA7W`\x01`\x01`\xA0\x1B\x03\x87\x16_\x81\x81R`5` R`@\x80\x82 `\x01\x01\x80T`\xFF\x19\x16`\x02\x17\x90UQ\x86\x92\x91\x7F9o\xDC\xB1\x80\xCB\x0F\xEA&\x92\x81\x13\xFB\x0F\xD1\xC3T\x98c\xF9\xCDV>j\x18O\x1DW\x81\x16\xC8\xE4\x91\xA3[`@Qc\xF4\xE2O\xE5`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xF4\xE2O\xE5\x90a%\xF5\x90\x8A\x90\x8A\x90`\x04\x01aX\x88V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a&\x0CW__\xFD[PZ\xF1\x15\x80\x15a&\x1EW=__>=_\xFD[PP`@Qc\xBD)\xB8\xCD`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x92Pc\xBD)\xB8\xCD\x91Pa&p\x90\x87\x90\x8A\x90`\x04\x01aXVV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a&\x87W__\xFD[PZ\xF1\x15\x80\x15a&\x99W=__>=_\xFD[PP`@Qc\xBD)\xB8\xCD`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x92Pc\xBD)\xB8\xCD\x91Pa&\xEB\x90\x87\x90\x8A\x90`\x04\x01aXVV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a'\x02W__\xFD[PZ\xF1\x15\x80\x15a'\x14W=__>=_\xFD[PPPPa'$\x87\x85\x88\x84a9\xCEV[PPPPPPPV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R_\x80\x80a'Z_Q` a_\xCE_9_Q\x90_R\x86aX\xBFV[\x90P[a'f\x81a:tV[\x90\x93P\x91P_Q` a_\xCE_9_Q\x90_R\x82\x83\t\x83\x03a'\x9EW`@\x80Q\x80\x82\x01\x90\x91R\x90\x81R` \x81\x01\x91\x90\x91R\x93\x92PPPV[_Q` a_\xCE_9_Q\x90_R`\x01\x82\x08\x90Pa']V[`2T`\xFF\x16a'\xC6\x81a:\xF0V[`\xC0`\xFF\x82\x16\x10a'\xEAW`@Qc<\xB8\x9C\x97`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`2\x80T`\x01\x91\x90_\x90a(\x02\x90\x84\x90`\xFF\x16aX\xD2V[\x92Pa\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\xFF\x16\x02\x17\x90UPa($\x81\x87a.-V[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91\x81` \x01[`@\x80Q\x80\x82\x01\x90\x91R_\x81R``` \x82\x01R\x81R` \x01\x90`\x01\x90\x03\x90\x81a(:W\x90PP\x90P_\x85Q`\x01`\x01`@\x1B\x03\x81\x11\x15a(}Wa(}aFbV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a(\xA6W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x86Q\x81\x10\x15a)\x03W\x86\x81\x81Q\x81\x10a(\xC6Wa(\xC6aT\xB3V[` \x02` \x01\x01Q_\x01Q\x82\x82\x81Q\x81\x10a(\xE3Wa(\xE3aT\xB3V[`\x01`\x01`\xA0\x1B\x03\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`\x01\x01a(\xABV[P`@Q\x80`@\x01`@R\x80\x84`\xFF\x16c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81RP\x82_\x81Q\x81\x10a)4Wa)4aT\xB3V[` \x90\x81\x02\x91\x90\x91\x01\x01R`=T`@Qc\x010\xFC'`\xE5\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16\x92c&\x1F\x84\xE0\x92a)\x94\x92\x91\x90\x91\x16\x90\x86\x90`\x04\x01aX\xEBV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a)\xABW__\xFD[PZ\xF1\x15\x80\x15a)\xBDW=__>=_\xFD[P_\x92Pa)\xC9\x91PPV[\x85`\x01\x81\x11\x15a)\xDBWa)\xDBaMtV[\x03a*bW`@Qc:\xEA\x0B\x9D`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90cu\xD4\x17:\x90a*0\x90\x86\x90\x8B\x90\x8B\x90`\x04\x01aZ\x05V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a*GW__\xFD[PZ\xF1\x15\x80\x15a*YW=__>=_\xFD[PPPPa+\xA6V[`\x01\x85`\x01\x81\x11\x15a*vWa*vaMtV[\x03a+\xA6W\x83c\xFF\xFF\xFF\xFF\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c)\x81\xEBw`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a*\xDEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a+\x02\x91\x90aU\nV[c\xFF\xFF\xFF\xFF\x16\x11a+&W`@Qc\x0B\xD4A\xB9`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Qc\x06b\xD3\xE1`\xE5\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xCCZ| \x90a+x\x90\x86\x90\x8B\x90\x89\x90\x8C\x90`\x04\x01aZ8V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a+\x8FW__\xFD[PZ\xF1\x15\x80\x15a+\xA1W=__>=_\xFD[PPPP[`@Qc\x13l\xA0\xF9`\xE1\x1B\x81R`\xFF\x84\x16`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x90c&\xD9A\xF2\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a,\x07W__\xFD[PZ\xF1\x15\x80\x15a,\x19W=__>=_\xFD[PP`@Qc\x13l\xA0\xF9`\xE1\x1B\x81R`\xFF\x86\x16`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x92Pc&\xD9A\xF2\x91P`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a,~W__\xFD[PZ\xF1\x15\x80\x15a,\x90W=__>=_\xFD[PPPP\x82`\xFF\x16\x7F\xA3H5\xBC+g>\xC3\x7F\xCF\x15\x91\xA9\x12\x95\xB1c\xFC.\x18\x1EN\xA4\xE73\xBE\xB2}\xE1\xCE\xACL\x89\x89\x89\x89\x89`@Qa,\xCF\x95\x94\x93\x92\x91\x90aZnV[`@Q\x80\x91\x03\x90\xA2[PPPPPPPPV[__a,\xED\x84a0\xCDV[\x90P\x80\x83`\xFF\x16`\x01\x90\x1B\x11a\x0B\xD1W`@Qc\xCA\x95s3`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`dTa\x01\0\x90\x04`\xFF\x16a-=W`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x13\x0E\x90aZ\xEFV[a\r]\x82\x82a;\x01V[`\xC8\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x01`\x01`\xA0\x1B\x03\x19\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[`=T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90\x7F\x97p\xF3\xCA\xDF\xDC\xBBo\x93\xAF\x93^\x86\x04q\x11Y\x0C7h'\x1D#~J+\xC0\xB8t\xBE\xD6\x93\x90a-\xD9\x90\x83\x90\x85\x90aXnV[`@Q\x80\x91\x03\x90\xA1P`=\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[`2T`\xFF\x90\x81\x16\x90\x82\x16\x10a\x0C7W`@Qcs\x10\xCF\xF5`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\xFF\x82\x16_\x81\x81R`3` \x90\x81R`@\x91\x82\x90 \x84Q\x81T\x92\x86\x01Q\x84\x87\x01Qa\xFF\xFF\x90\x81\x16`\x01`0\x1B\x02g\xFF\xFF\0\0\0\0\0\0\x19\x91\x90\x92\x16`\x01` \x1B\x02e\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x95\x16c\xFF\xFF\xFF\xFF\x90\x93\x16\x92\x90\x92\x17\x93\x90\x93\x17\x16\x91\x90\x91\x17\x90UQ\x7F>\xE6\xFE\x8DTa\x02D\xC3\xE9\xD3\xC0f\xAEJ\xEE\x99x\x84\xAA(\xF1\x06\x16\xAE\x82\x19%@\x13\x18\xAC\x90a\x1Ec\x90\x84\x90aTrV[`:T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x15/W`@Qcv\xD8\xAB\x17`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`5` R`@\x81 `2T\x90\x91\x90a/\x14\x90\x84\x90`\xFF\x16a,\xE2V[\x90P`\x01\x80\x83\x01T`\xFF\x16`\x02\x81\x11\x15a/0Wa/0aMtV[\x14\x80\x15a/EWP`\x01`\x01`\xC0\x1B\x03\x81\x16\x15\x15[\x15a\x0FHW`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x82\x01\x81\x806\x837\x01\x90PP\x90P_[\x84Q\x81\x10\x15a\x14\x03W\x84\x81\x81Q\x81\x10a/\x87Wa/\x87aT\xB3V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x82_\x81Q\x81\x10a/\xA4Wa/\xA4aT\xB3V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SPa/\xDC\x85\x82\x81Q\x81\x10a/\xCFWa/\xCFaT\xB3V[\x01` \x01Q`\xF8\x1Ca\x19\x19V[\x15a/\xF0Wa/\xEB\x86\x83a$dV[a/\xFAV[a/\xFA\x86\x83a;OV[`\x01\x01a/lV[_a\r\xE9a0\x0Ea9%V[\x83`@Qa\x19\x01`\xF0\x1B\x81R`\x02\x81\x01\x92\x90\x92R`\"\x82\x01R`B\x90 \x90V[```\xFC\x80Ta0=\x90a[:V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta0i\x90a[:V[\x80\x15a0\xB4W\x80`\x1F\x10a0\x8BWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a0\xB4V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a0\x97W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[```\xFD\x80Ta0=\x90a[:V[_a\x01\0\x82Q\x11\x15a0\xF2W`@Qc}\xA5NG`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x81Q_\x03a1\x01WP_\x91\x90PV[__\x83_\x81Q\x81\x10a1\x15Wa1\x15aT\xB3V[\x01` \x01Q`\x01`\xF8\x91\x90\x91\x1C\x81\x90\x1B\x92P[\x84Q\x81\x10\x15a1\x7FW\x84\x81\x81Q\x81\x10a1CWa1CaT\xB3V[\x01` \x01Q`\x01`\xF8\x91\x90\x91\x1C\x1B\x91P\x82\x82\x11a1sW`@Qc\x10\x19\x10i`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x91\x81\x17\x91`\x01\x01a1(V[P\x90\x93\x92PPPV[_\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\x03\xC5\xA6\xB6\x84\x84a1\xC3\x87a\x0F\x0EV[`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a1\xE1\x93\x92\x91\x90a[\x94V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a1\xFDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xD1\x91\x90a\\\rV[\x83Q\x82Q\x14a2CW`@Qc\xAA\xAD\x13\xF7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a2O\x86\x86\x84\x84a;\x84V[_a2]\x87\x87\x87\x87_a4\x16V[\x90P_[\x85Q\x81\x10\x15a,\xD8W_`3_\x88\x84\x81Q\x81\x10a2\x80Wa2\x80aT\xB3V[\x01` \x90\x81\x01Q`\xF8\x1C\x82R\x81\x81\x01\x92\x90\x92R`@\x90\x81\x01_ \x81Q``\x81\x01\x83R\x90Tc\xFF\xFF\xFF\xFF\x81\x16\x80\x83Ra\xFF\xFF`\x01` \x1B\x83\x04\x81\x16\x95\x84\x01\x95\x90\x95R`\x01`0\x1B\x90\x91\x04\x90\x93\x16\x91\x81\x01\x91\x90\x91R\x84Q\x80Q\x91\x93P\x90\x84\x90\x81\x10a2\xEBWa2\xEBaT\xB3V[` \x02` \x01\x01Qc\xFF\xFF\xFF\xFF\x16\x11\x15a4\rWa3\x7F\x87\x83\x81Q\x81\x10a3\x14Wa3\x14aT\xB3V[` \x01\x01Q`\xF8\x1C`\xF8\x1B`\xF8\x1C\x84`@\x01Q\x84\x81Q\x81\x10a38Wa38aT\xB3V[` \x02` \x01\x01Q\x8B\x86` \x01Q\x86\x81Q\x81\x10a3WWa3WaT\xB3V[` \x02` \x01\x01Q\x89\x87\x81Q\x81\x10a3qWa3qaT\xB3V[` \x02` \x01\x01Q\x86a</V[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x82\x01\x81\x806\x837\x01\x90PP\x90P\x87\x83\x81Q\x81\x10a3\xB1Wa3\xB1aT\xB3V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x81_\x81Q\x81\x10a3\xCEWa3\xCEaT\xB3V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SPa4\x0B\x86\x84\x81Q\x81\x10a3\xF9Wa3\xF9aT\xB3V[` \x02` \x01\x01Q` \x01Q\x82a.\xE9V[P[P`\x01\x01a2aV[a4:`@Q\x80``\x01`@R\x80``\x81R` \x01``\x81R` \x01``\x81RP\x90V[`2T_\x90a4M\x90\x86\x90`\xFF\x16a,\xE2V[\x90P_a4Y\x87a\x1EoV[\x90P`\x01`\x01`\xC0\x1B\x03\x82\x16a4\x82W`@Qc\x13\xCAFW`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80\x82\x16`\x01`\x01`\xC0\x1B\x03\x16\x15a4\xACW`@Qc\x0Ch\x16\xCD`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`<T`\x01`\x01`\xA0\x1B\x03\x89\x16_\x90\x81R`;` R`@\x90 T`\x01`\x01`\xC0\x1B\x03\x83\x81\x16\x90\x85\x16\x17\x91B\x91a4\xE3\x91\x90a\\$V[\x10a5\x01W`@Qc\x19hg}`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a5\x0B\x88\x82a9\xC2V[a5\x15\x88\x87a!_V[`\x01`\x01`\x01`\xA0\x1B\x03\x8A\x16_\x90\x81R`5` R`@\x90 `\x01\x01T`\xFF\x16`\x02\x81\x11\x15a5FWa5FaMtV[\x14a5\xDDW`@\x80Q\x80\x82\x01\x82R\x89\x81R`\x01` \x80\x83\x01\x82\x81R`\x01`\x01`\xA0\x1B\x03\x8E\x16_\x90\x81R`5\x90\x92R\x93\x90 \x82Q\x81U\x92Q\x83\x82\x01\x80T\x93\x94\x93\x91\x92\x90\x91`\xFF\x19\x16\x90\x83`\x02\x81\x11\x15a5\xA0Wa5\xA0aMtV[\x02\x17\x90UPP`@Q\x89\x91P`\x01`\x01`\xA0\x1B\x03\x8B\x16\x90\x7F\xE8\xE6\x8C\xEF\x1C:v\x1E\xD7\xBE~\x84c\xA3u\xF2\x7F{\xC35\xE5\x18$\"<\xAC\xCEcn\xC5\xC3\xFE\x90_\x90\xA3[`@Qc\x1F\xD9<\xA9`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c?\xB2yR\x90a6+\x90\x8C\x90\x8B\x90`\x04\x01aX\x88V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a6BW__\xFD[PZ\xF1\x15\x80\x15a6TW=__>=_\xFD[PP`@Qc%PGw`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x92Pc%PGw\x91Pa6\xA8\x90\x8C\x90\x8C\x90\x8C\x90`\x04\x01a\\7V[_`@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a6\xC3W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra6\xEA\x91\x90\x81\x01\x90a\\\xC1V[`@\x80\x87\x01\x91\x90\x91R` \x86\x01\x91\x90\x91RQb\xBF\xF0M`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90b\xBF\xF0M\x90a7E\x90\x8B\x90\x8B\x90`\x04\x01aXVV[_`@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a7`W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra7\x87\x91\x90\x81\x01\x90a]\x1AV[\x84R\x84\x15a8SW_[\x87Q\x81\x10\x15a8QW_`3_\x8A\x84\x81Q\x81\x10a7\xB0Wa7\xB0aT\xB3V[\x01` \x90\x81\x01Q`\xF8\x1C\x82R\x81\x81\x01\x92\x90\x92R`@\x90\x81\x01_ \x81Q``\x81\x01\x83R\x90Tc\xFF\xFF\xFF\xFF\x81\x16\x80\x83Ra\xFF\xFF`\x01` \x1B\x83\x04\x81\x16\x95\x84\x01\x95\x90\x95R`\x01`0\x1B\x90\x91\x04\x90\x93\x16\x91\x81\x01\x91\x90\x91R\x87Q\x80Q\x91\x93P\x90\x84\x90\x81\x10a8\x1BWa8\x1BaT\xB3V[` \x02` \x01\x01Qc\xFF\xFF\xFF\xFF\x16\x11\x15a8HW`@Qc\xC6\xB9\xE7g`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P`\x01\x01a7\x91V[P[PPP\x95\x94PPPPPV[``_\x82Q`\x01`\x01`@\x1B\x03\x81\x11\x15a8{Wa8{aFbV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a8\xA4W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x83Q\x81\x10\x15a9\x05Wa8\xD6\x86\x86\x86\x84\x81Q\x81\x10a8\xC9Wa8\xC9aT\xB3V[` \x02` \x01\x01Qa=\xA5V[\x82\x82\x81Q\x81\x10a8\xE8Wa8\xE8aT\xB3V[c\xFF\xFF\xFF\xFF\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`\x01\x01a8\xA9V[P\x94\x93PPPPV[`2T_\x90a\x1C\xD4\x90`\x01\x90`\xFF\x16\x81\x90\x1Ba]\xA9V[_a\x1C\xD4a>\xBDV[_\x81\x81R` \x83\x90R`@\x81 T\x80\x82\x03a9LW_\x91PPa\r\xE9V[_\x83\x81R` \x85\x90R`@\x90 a9d`\x01\x83a]\xA9V[\x81T\x81\x10a9tWa9taT\xB3V[_\x91\x82R` \x90\x91 \x01T`\x01`@\x1B\x90\x04`\x01`\x01`\xC0\x1B\x03\x16\x91Pa\r\xE9\x90PV[_\x80[\x82\x15a\r\xE9Wa9\xAC`\x01\x84a]\xA9V[\x90\x92\x16\x91\x80a9\xBA\x81a]\xBCV[\x91PPa9\x9BV[a\r]`4\x83\x83a?0V[_a9\xD7a9\x0EV[\x90P_a9\xEBa9\xE5a\x1C\xBAV[\x19\x83\x16\x90V[\x90P`\x01`\x01`\xC0\x1B\x03\x81\x19\x84\x16\x16\x80a'$W`@QcQ\xB2zm`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xA3d\xF4\xDA\x90a:K\x90\x8A\x90`\x04\x01aH'V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a:bW__\xFD[PZ\xF1\x15\x80\x15a\x1CIW=__>=_\xFD[_\x80\x80_Q` a_\xCE_9_Q\x90_R`\x03_Q` a_\xCE_9_Q\x90_R\x86_Q` a_\xCE_9_Q\x90_R\x88\x89\t\t\x08\x90P_a:\xE4\x82\x7F\x0C\x19\x13\x9C\xB8Lh\nn\x14\x11m\xA0`V\x17e\xE0Z\xA4Z\x1Cr\xA3O\x08#\x05\xB6\x1F?R_Q` a_\xCE_9_Q\x90_Ra@\xE9V[\x91\x95\x91\x94P\x90\x92PPPV[_T`\xFF\x16a\x0C7Wa\x0C7aAbV[`dTa\x01\0\x90\x04`\xFF\x16a;(W`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x13\x0E\x90aZ\xEFV[`\xFCa;4\x83\x82a^ V[P`\xFDa;A\x82\x82a^ V[PP_`\xFA\x81\x90U`\xFBUPV[_a;ja;[a\x1C\xBAV[a;d\x84a0\xCDV[\x90\x19\x16\x90V[\x90P\x80\x15a\x0B\xBBWa\x0B\xBB\x83a;\x7F\x83a\x1E{V[aA\xC7V[` \x80\x82\x01Q_\x90\x81R`6\x90\x91R`@\x90 T`\xFF\x16\x15a;\xB9W`@Qco\xBE\xFE\xC3`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[B\x81`@\x01Q\x10\x15a;\xDEW`@Qc\x08\x19\xBD\xCD`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[` \x80\x82\x01\x80Q_\x90\x81R`6\x90\x92R`@\x91\x82\x90 \x80T`\xFF\x19\x16`\x01\x17\x90U`9T\x90Q\x91\x83\x01Qa\x0FH\x92`\x01`\x01`\xA0\x1B\x03\x90\x92\x16\x91a<(\x91\x88\x91\x88\x91\x88\x91\x90a\x17\x03V[\x83QaBeV[` \x80\x83\x01Q`\x01`\x01`\xA0\x1B\x03\x80\x82\x16_\x81\x81R`5\x90\x94R`@\x90\x93 T\x91\x92\x90\x87\x16\x03a<rW`@QcV\x16\x8BA`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x87`\xFF\x16\x84_\x01Q`\xFF\x16\x14a<\x9BW`@Qc\x8EZ\xEE\xE7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@QcT\x01\xED'`\xE0\x1B\x81R`\x04\x81\x01\x82\x90R`\xFF\x89\x16`$\x82\x01R_\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x90cT\x01\xED'\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a=\tW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a=-\x91\x90a^\xDAV[\x90Pa=9\x81\x85aB\x8DV[`\x01`\x01``\x1B\x03\x16\x86`\x01`\x01``\x1B\x03\x16\x11a=jW`@QcLD\x99]`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a=t\x88\x85aB\xB0V[`\x01`\x01``\x1B\x03\x16\x81`\x01`\x01``\x1B\x03\x16\x10a\x19\x0EW`@Qc\xB1\x87\xE8i`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x81\x81R` \x84\x90R`@\x81 T\x81[\x81\x81\x10\x15a>(W`\x01a=\xC9\x82\x84a]\xA9V[a=\xD3\x91\x90a]\xA9V[\x92P\x84c\xFF\xFF\xFF\xFF\x16\x86_\x86\x81R` \x01\x90\x81R` \x01_ \x84c\xFF\xFF\xFF\xFF\x16\x81T\x81\x10a>\x03Wa>\x03aT\xB3V[_\x91\x82R` \x90\x91 \x01Tc\xFF\xFF\xFF\xFF\x16\x11a> WPPa\x0B\xD1V[`\x01\x01a=\xB5V[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\\`$\x82\x01R\x7FRegistryCoordinator.getQuorumBit`D\x82\x01R\x7FmapIndexAtBlockNumber: no bitmap`d\x82\x01R\x7F update found for operatorId\0\0\0\0`\x84\x82\x01R`\xA4\x01a\x13\x0EV[_\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0Fa>\xE7aB\xC9V[a>\xEFaC!V[`@\x80Q` \x81\x01\x94\x90\x94R\x83\x01\x91\x90\x91R``\x82\x01RF`\x80\x82\x01R0`\xA0\x82\x01R`\xC0\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x90V[_\x82\x81R` \x84\x90R`@\x81 T\x90\x81\x90\x03a?\xD4W_\x83\x81R` \x85\x81R`@\x80\x83 \x81Q``\x81\x01\x83Rc\xFF\xFF\xFF\xFFC\x81\x16\x82R\x81\x85\x01\x86\x81R`\x01`\x01`\xC0\x1B\x03\x80\x8A\x16\x95\x84\x01\x95\x86R\x84T`\x01\x81\x01\x86U\x94\x88R\x95\x90\x96 \x91Q\x91\x90\x92\x01\x80T\x95Q\x93Q\x90\x94\x16`\x01`@\x1B\x02`\x01`\x01`@\x1B\x03\x93\x83\x16`\x01` \x1B\x02g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x96\x16\x91\x90\x92\x16\x17\x93\x90\x93\x17\x16\x91\x90\x91\x17\x90Ua\x0FHV[_\x83\x81R` \x85\x90R`@\x81 a?\xEC`\x01\x84a]\xA9V[\x81T\x81\x10a?\xFCWa?\xFCaT\xB3V[_\x91\x82R` \x90\x91 \x01\x80T\x90\x91Pc\xFF\xFF\xFF\xFFC\x81\x16\x91\x16\x03a@=W\x80T`\x01`\x01`@\x1B\x03\x16`\x01`@\x1B`\x01`\x01`\xC0\x1B\x03\x85\x16\x02\x17\x81Ua\x0F\x07V[\x80Tc\xFF\xFF\xFF\xFFC\x81\x16`\x01` \x1B\x81\x81\x02g\xFF\xFF\xFF\xFF\0\0\0\0\x19\x90\x94\x16\x93\x90\x93\x17\x84U_\x87\x81R` \x89\x81R`@\x80\x83 \x81Q``\x81\x01\x83R\x94\x85R\x84\x83\x01\x84\x81R`\x01`\x01`\xC0\x1B\x03\x80\x8C\x16\x93\x87\x01\x93\x84R\x82T`\x01\x81\x01\x84U\x92\x86R\x93\x90\x94 \x94Q\x94\x01\x80T\x93Q\x91Q\x90\x92\x16`\x01`@\x1B\x02`\x01`\x01`@\x1B\x03\x91\x86\x16\x90\x96\x02g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x93\x16\x93\x90\x94\x16\x92\x90\x92\x17\x17\x91\x90\x91\x16\x91\x90\x91\x17\x90UPPPPPV[__a@\xF3aF&V[a@\xFBaFDV[` \x80\x82R\x81\x81\x01\x81\x90R`@\x82\x01\x81\x90R``\x82\x01\x88\x90R`\x80\x82\x01\x87\x90R`\xA0\x82\x01\x86\x90R\x82`\xC0\x83`\x05a\x07\xD0Z\x03\xFA\x92P\x82\x80aA8W\xFE[P\x82aAWW`@Qc\xD5\x1E\xDA\xE3`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PQ\x95\x94PPPPPV[_T`\xFF\x16\x15aA\x85W`@Qc\xB2\xE1\x8E\x05`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[aA\x8Da9\x0EV[`\x01\x90\x81U_\x80T`\xFF\x19\x16\x90\x91\x17\x81U`@Q\x7F\x0B\x880o\xF4bq!\xF5\xB3\xE5\xB1\xC5\xF8\x8Fk\x1EB\xFD,\x04x\xEF\x1C\x91f-I\xD1\xF0wU\x91\x90\xA1V[`@\x80Q``\x81\x01\x82R`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x82R`=T\x81\x16` \x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91cn4\x92\xB5\x91\x90\x81\x01aB\x1D\x85aCQV[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01aB<\x91\x90a^\xF5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15aBSW__\xFD[PZ\xF1\x15\x80\x15a\x14\x03W=__>=_\xFD[aBp\x83\x83\x83aC\xF6V[a\x0B\xBBW`@Qc\x8B\xAAW\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[` \x81\x01Q_\x90a'\x10\x90aB\xA6\x90a\xFF\xFF\x16\x85a_cV[a\x0B\xD1\x91\x90a_\x85V[`@\x81\x01Q_\x90a'\x10\x90aB\xA6\x90a\xFF\xFF\x16\x85a_cV[__aB\xD3a0.V[\x80Q\x90\x91P\x15aB\xEAW\x80Q` \x90\x91\x01 \x91\x90PV[`\xFAT\x80\x15aB\xF9W\x92\x91PPV[\x7F\xC5\xD2F\x01\x86\xF7#<\x92~}\xB2\xDC\xC7\x03\xC0\xE5\0\xB6S\xCA\x82';{\xFA\xD8\x04]\x85\xA4p\x92PPP\x90V[__aC+a0\xBEV[\x80Q\x90\x91P\x15aCBW\x80Q` \x90\x91\x01 \x91\x90PV[`\xFBT\x80\x15aB\xF9W\x92\x91PPV[``_\x82Q`\x01`\x01`@\x1B\x03\x81\x11\x15aCmWaCmaFbV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15aC\x96W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x83Q\x81\x10\x15a$]W\x83\x81\x81Q\x81\x10aC\xB6WaC\xB6aT\xB3V[` \x01\x01Q`\xF8\x1C`\xF8\x1B`\xF8\x1C`\xFF\x16\x82\x82\x81Q\x81\x10aC\xD9WaC\xD9aT\xB3V[c\xFF\xFF\xFF\xFF\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`\x01\x01aC\x9BV[___aD\x03\x85\x85aDJV[\x90\x92P\x90P_\x81`\x04\x81\x11\x15aD\x1BWaD\x1BaMtV[\x14\x80\x15aD9WP\x85`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14[\x80a\x17BWPa\x17B\x86\x86\x86aD\x8CV[__\x82Q`A\x03aD~W` \x83\x01Q`@\x84\x01Q``\x85\x01Q_\x1AaDr\x87\x82\x85\x85aEsV[\x94P\x94PPPPaD\x85V[P_\x90P`\x02[\x92P\x92\x90PV[___\x85`\x01`\x01`\xA0\x1B\x03\x16c\x16&\xBA~`\xE0\x1B\x86\x86`@Q`$\x01aD\xB4\x92\x91\x90aXVV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x81R` \x82\x01\x80Q`\x01`\x01`\xE0\x1B\x03\x16`\x01`\x01`\xE0\x1B\x03\x19\x90\x94\x16\x93\x90\x93\x17\x90\x92R\x90QaD\xF2\x91\x90a_\xB2V[_`@Q\x80\x83\x03\x81\x85Z\xFA\x91PP=\x80_\x81\x14aE*W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>aE/V[``\x91P[P\x91P\x91P\x81\x80\x15aECWP` \x81Q\x10\x15[\x80\x15a\x17BWP\x80Qc\x0B\x13]?`\xE1\x1B\x90aEh\x90\x83\x01` \x90\x81\x01\x90\x84\x01a\\\rV[\x14\x96\x95PPPPPPV[_\x80o\xA2\xA8\x91\x8C\xA8[\xAF\xE2 \x16\xD0\xB9\x97\xE4\xDF``\x01`\xFF\x1B\x03\x83\x11\x15aE\x9EWP_\x90P`\x03aF\x1DV[`@\x80Q_\x80\x82R` \x82\x01\x80\x84R\x89\x90R`\xFF\x88\x16\x92\x82\x01\x92\x90\x92R``\x81\x01\x86\x90R`\x80\x81\x01\x85\x90R`\x01\x90`\xA0\x01` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15aE\xEFW=__>=_\xFD[PP`@Q`\x1F\x19\x01Q\x91PP`\x01`\x01`\xA0\x1B\x03\x81\x16aF\x17W_`\x01\x92P\x92PPaF\x1DV[\x91P_\x90P[\x94P\x94\x92PPPV[`@Q\x80` \x01`@R\x80`\x01\x90` \x82\x02\x806\x837P\x91\x92\x91PPV[`@Q\x80`\xC0\x01`@R\x80`\x06\x90` \x82\x02\x806\x837P\x91\x92\x91PPV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@Q``\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15aF\x98WaF\x98aFbV[`@R\x90V[`@\x80Q\x90\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15aF\x98WaF\x98aFbV[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15aF\xE8WaF\xE8aFbV[`@R\x91\x90PV[_`\x01`\x01`@\x1B\x03\x82\x11\x15aG\x08WaG\x08aFbV[P`\x05\x1B` \x01\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0C7W__\xFD[_\x82`\x1F\x83\x01\x12aG5W__\xFD[\x815aGHaGC\x82aF\xF0V[aF\xC0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x86\x01\x01\x92P\x85\x83\x11\x15aGiW__\xFD[` \x85\x01[\x83\x81\x10\x15aG\x8FW\x805aG\x81\x81aG\x12V[\x83R` \x92\x83\x01\x92\x01aGnV[P\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15aG\xA9W__\xFD[\x815`\x01`\x01`@\x1B\x03\x81\x11\x15aG\xBEW__\xFD[a!W\x84\x82\x85\x01aG&V[_` \x82\x84\x03\x12\x15aG\xDAW__\xFD[P5\x91\x90PV[c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x0C7W__\xFD[___``\x84\x86\x03\x12\x15aH\x04W__\xFD[\x835\x92P` \x84\x015aH\x16\x81aG\xE1V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[_\x82`\x1F\x83\x01\x12aHJW__\xFD[\x815` \x83\x01__`\x01`\x01`@\x1B\x03\x84\x11\x15aHiWaHiaFbV[P`\x1F\x83\x01`\x1F\x19\x16` \x01aH~\x81aF\xC0V[\x91PP\x82\x81R\x85\x83\x83\x01\x11\x15aH\x92W__\xFD[\x82\x82` \x83\x017_\x92\x81\x01` \x01\x92\x90\x92RP\x93\x92PPPV[_` \x82\x84\x03\x12\x15aH\xBCW__\xFD[\x815`\x01`\x01`@\x1B\x03\x81\x11\x15aH\xD1W__\xFD[a!W\x84\x82\x85\x01aH;V[_` \x82\x84\x03\x12\x15aH\xEDW__\xFD[\x815a\x0B\xD1\x81aG\x12V[__`@\x83\x85\x03\x12\x15aI\tW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[\x805`\xFF\x81\x16\x81\x14aI(W__\xFD[\x91\x90PV[_` \x82\x84\x03\x12\x15aI=W__\xFD[a\x0B\xD1\x82aI\x18V[_\x82`\x1F\x83\x01\x12aIUW__\xFD[\x815aIcaGC\x82aF\xF0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x86\x01\x01\x92P\x85\x83\x11\x15aI\x84W__\xFD[` \x85\x01[\x83\x81\x10\x15aG\x8FW\x805aI\x9C\x81aG\xE1V[\x83R` \x92\x83\x01\x92\x01aI\x89V[___``\x84\x86\x03\x12\x15aI\xBCW__\xFD[\x835aI\xC7\x81aG\x12V[\x92P` \x84\x015aI\xD7\x81aG\x12V[\x91P`@\x84\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aI\xF1W__\xFD[aI\xFD\x86\x82\x87\x01aIFV[\x91PP\x92P\x92P\x92V[\x81Q\x81R` \x80\x83\x01Q\x90\x82\x01R`@\x81\x01a\r\xE9V[\x805a\xFF\xFF\x81\x16\x81\x14aI(W__\xFD[_``\x82\x84\x03\x12\x15aJ?W__\xFD[aJGaFvV[\x90P\x815aJT\x81aG\xE1V[\x81RaJb` \x83\x01aJ\x1EV[` \x82\x01RaJs`@\x83\x01aJ\x1EV[`@\x82\x01R\x92\x91PPV[`\x01`\x01``\x1B\x03\x81\x16\x81\x14a\x0C7W__\xFD[_\x82`\x1F\x83\x01\x12aJ\xA1W__\xFD[\x815aJ\xAFaGC\x82aF\xF0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x06\x1B\x86\x01\x01\x92P\x85\x83\x11\x15aJ\xD0W__\xFD[` \x85\x01[\x83\x81\x10\x15aG\x8FW`@\x81\x88\x03\x12\x15aJ\xECW__\xFD[aJ\xF4aF\x9EV[\x815aJ\xFF\x81aG\x12V[\x81R` \x82\x015aK\x0F\x81aJ~V[` \x82\x81\x01\x91\x90\x91R\x90\x84R\x92\x90\x92\x01\x91`@\x01aJ\xD5V[____`\xC0\x85\x87\x03\x12\x15aK;W__\xFD[aKE\x86\x86aJ/V[\x93P``\x85\x015aKU\x81aJ~V[\x92P`\x80\x85\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aKoW__\xFD[aK{\x87\x82\x88\x01aJ\x92V[\x92PP`\xA0\x85\x015aK\x8C\x81aG\xE1V[\x93\x96\x92\x95P\x90\x93PPV[__\x83`\x1F\x84\x01\x12aK\xA7W__\xFD[P\x815`\x01`\x01`@\x1B\x03\x81\x11\x15aK\xBDW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15aD\x85W__\xFD[___`@\x84\x86\x03\x12\x15aK\xE6W__\xFD[\x835`\x01`\x01`@\x1B\x03\x81\x11\x15aK\xFBW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13aL\x0BW__\xFD[\x805aL\x19aGC\x82aF\xF0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x85\x01\x01\x92P\x88\x83\x11\x15aL:W__\xFD[` \x84\x01[\x83\x81\x10\x15aLzW\x805`\x01`\x01`@\x1B\x03\x81\x11\x15aL\\W__\xFD[aLk\x8B` \x83\x89\x01\x01aG&V[\x84RP` \x92\x83\x01\x92\x01aL?V[P\x95PPPP` \x84\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aL\x98W__\xFD[aL\xA4\x86\x82\x87\x01aK\x97V[\x94\x97\x90\x96P\x93\x94PPPPV[_____`\xA0\x86\x88\x03\x12\x15aL\xC5W__\xFD[\x855aL\xD0\x81aG\x12V[\x94P` \x86\x015aL\xE0\x81aG\x12V[\x93P`@\x86\x015aL\xF0\x81aG\x12V[\x92P``\x86\x015\x91P`\x80\x86\x015aM\x07\x81aG\x12V[\x80\x91PP\x92\x95P\x92\x95\x90\x93PV[_[\x83\x81\x10\x15aM/W\x81\x81\x01Q\x83\x82\x01R` \x01aM\x17V[PP_\x91\x01RV[_\x81Q\x80\x84RaMN\x81` \x86\x01` \x86\x01aM\x15V[`\x1F\x01`\x1F\x19\x16\x92\x90\x92\x01` \x01\x92\x91PPV[` \x81R_a\x0B\xD1` \x83\x01\x84aM7V[cNH{q`\xE0\x1B_R`!`\x04R`$_\xFD[`\x03\x81\x10aM\x98WaM\x98aMtV[\x90RV[\x81Q\x81R` \x80\x83\x01Q`@\x83\x01\x91a$]\x90\x84\x01\x82aM\x88V[__`\x80\x83\x85\x03\x12\x15aM\xC8W__\xFD[aM\xD1\x83aI\x18V[\x91PaM\xE0\x84` \x85\x01aJ/V[\x90P\x92P\x92\x90PV[__`@\x83\x85\x03\x12\x15aM\xFAW__\xFD[\x825aN\x05\x81aG\x12V[\x91P` \x83\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aN\x1FW__\xFD[aN+\x85\x82\x86\x01aH;V[\x91PP\x92P\x92\x90PV[___`\xA0\x84\x86\x03\x12\x15aNGW__\xFD[aNQ\x85\x85aJ/V[\x92P``\x84\x015aNa\x81aJ~V[\x91P`\x80\x84\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aN{W__\xFD[aI\xFD\x86\x82\x87\x01aJ\x92V[`\xFF`\xF8\x1B\x88\x16\x81R`\xE0` \x82\x01R_aN\xA5`\xE0\x83\x01\x89aM7V[\x82\x81\x03`@\x84\x01RaN\xB7\x81\x89aM7V[``\x84\x01\x88\x90R`\x01`\x01`\xA0\x1B\x03\x87\x16`\x80\x85\x01R`\xA0\x84\x01\x86\x90R\x83\x81\x03`\xC0\x85\x01R\x84Q\x80\x82R` \x80\x87\x01\x93P\x90\x91\x01\x90_[\x81\x81\x10\x15aO\x0CW\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01aN\xEEV[P\x90\x9B\x9APPPPPPPPPPPV[_\x82`\x1F\x83\x01\x12aO,W__\xFD[\x815aO:aGC\x82aF\xF0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x06\x1B\x86\x01\x01\x92P\x85\x83\x11\x15aO[W__\xFD[` \x85\x01[\x83\x81\x10\x15aG\x8FW`@\x81\x88\x03\x12\x15aOwW__\xFD[aO\x7FaF\x9EV[aO\x88\x82aI\x18V[\x81R` \x82\x015aO\x98\x81aG\x12V[` \x82\x81\x01\x91\x90\x91R\x90\x84R\x92\x90\x92\x01\x91`@\x01aO`V[_____`\xA0\x86\x88\x03\x12\x15aO\xC5W__\xFD[\x855aO\xD0\x81aG\x12V[\x94P` \x86\x015\x93P`@\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aO\xF1W__\xFD[aO\xFD\x88\x82\x89\x01aO\x1DV[\x95\x98\x94\x97P\x94\x95``\x81\x015\x95P`\x80\x015\x93\x92PPPV[_`@\x82\x84\x03\x12\x15aP&W__\xFD[aP.aF\x9EV[\x825\x81R` \x92\x83\x015\x92\x81\x01\x92\x90\x92RP\x91\x90PV[_\x82`\x1F\x83\x01\x12aPTW__\xFD[aP\\aF\x9EV[\x80`@\x84\x01\x85\x81\x11\x15aPmW__\xFD[\x84[\x81\x81\x10\x15aP\x87W\x805\x84R` \x93\x84\x01\x93\x01aPoV[P\x90\x95\x94PPPPPV[_\x81\x83\x03a\x01\0\x81\x12\x15aP\xA4W__\xFD[aP\xACaFvV[\x91PaP\xB8\x84\x84aP\x16V[\x82RaP\xC7\x84`@\x85\x01aP\x16V[` \x83\x01R`\x80`\x7F\x19\x82\x01\x12\x15aP\xDDW__\xFD[PaP\xE6aF\x9EV[aP\xF3\x84`\x80\x85\x01aPEV[\x81RaQ\x02\x84`\xC0\x85\x01aPEV[` \x82\x01R`@\x82\x01R\x92\x91PPV[_``\x82\x84\x03\x12\x15aQ\"W__\xFD[aQ*aFvV[\x90P\x815`\x01`\x01`@\x1B\x03\x81\x11\x15aQAW__\xFD[aQM\x84\x82\x85\x01aH;V[\x82RP` \x82\x81\x015\x90\x82\x01R`@\x91\x82\x015\x91\x81\x01\x91\x90\x91R\x91\x90PV[_______a\x01\xA0\x88\x8A\x03\x12\x15aQ\x83W__\xFD[\x875`\x01`\x01`@\x1B\x03\x81\x11\x15aQ\x98W__\xFD[aQ\xA4\x8A\x82\x8B\x01aK\x97V[\x90\x98P\x96PP` \x88\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aQ\xC2W__\xFD[aQ\xCE\x8A\x82\x8B\x01aH;V[\x95PPaQ\xDE\x89`@\x8A\x01aP\x92V[\x93Pa\x01@\x88\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aQ\xF9W__\xFD[aR\x05\x8A\x82\x8B\x01aO\x1DV[\x93PPa\x01`\x88\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aR!W__\xFD[aR-\x8A\x82\x8B\x01aQ\x12V[\x92PPa\x01\x80\x88\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aRIW__\xFD[aRU\x8A\x82\x8B\x01aQ\x12V[\x91PP\x92\x95\x98\x91\x94\x97P\x92\x95PV[____a\x01`\x85\x87\x03\x12\x15aRxW__\xFD[\x845`\x01`\x01`@\x1B\x03\x81\x11\x15aR\x8DW__\xFD[aR\x99\x87\x82\x88\x01aH;V[\x94PP` \x85\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aR\xB4W__\xFD[aR\xC0\x87\x82\x88\x01aH;V[\x93PPaR\xD0\x86`@\x87\x01aP\x92V[\x91Pa\x01@\x85\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aR\xEBW__\xFD[aR\xF7\x87\x82\x88\x01aQ\x12V[\x91PP\x92\x95\x91\x94P\x92PV[__`@\x83\x85\x03\x12\x15aS\x14W__\xFD[\x825aS\x1F\x81aG\xE1V[\x91P` \x83\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aS9W__\xFD[\x83\x01`\x1F\x81\x01\x85\x13aSIW__\xFD[\x805aSWaGC\x82aF\xF0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x85\x01\x01\x92P\x87\x83\x11\x15aSxW__\xFD[` \x84\x01\x93P[\x82\x84\x10\x15aS\x9AW\x835\x82R` \x93\x84\x01\x93\x90\x91\x01\x90aS\x7FV[\x80\x94PPPPP\x92P\x92\x90PV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15aP\x87W\x83Qc\xFF\xFF\xFF\xFF\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01aS\xC1V[_____`\x80\x86\x88\x03\x12\x15aS\xF9W__\xFD[\x855aT\x04\x81aG\x12V[\x94P` \x86\x015aT\x14\x81aG\x12V[\x93P`@\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aT.W__\xFD[aT:\x88\x82\x89\x01aIFV[\x93PP``\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aTUW__\xFD[aTa\x88\x82\x89\x01aK\x97V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[``\x81\x01a\r\xE9\x82\x84c\xFF\xFF\xFF\xFF\x81Q\x16\x82Ra\xFF\xFF` \x82\x01Q\x16` \x83\x01Ra\xFF\xFF`@\x82\x01Q\x16`@\x83\x01RPPV[` \x81\x01a\r\xE9\x82\x84aM\x88V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[\x80Q\x80\x15\x15\x81\x14aI(W__\xFD[_` \x82\x84\x03\x12\x15aT\xE6W__\xFD[a\x0B\xD1\x82aT\xC7V[_` \x82\x84\x03\x12\x15aT\xFFW__\xFD[\x81Qa\x0B\xD1\x81aG\x12V[_` \x82\x84\x03\x12\x15aU\x1AW__\xFD[\x81Qa\x0B\xD1\x81aG\xE1V[_`\xC0\x82\x01\x88\x83R`\x01\x80`\xA0\x1B\x03\x88\x16` \x84\x01R\x86`@\x84\x01R`\xC0``\x84\x01R\x80\x86Q\x80\x83R`\xE0\x85\x01\x91P` \x88\x01\x92P_[\x81\x81\x10\x15aU\x92W\x83Q\x80Q`\xFF\x16\x84R` \x90\x81\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x81\x85\x01R\x90\x93\x01\x92`@\x90\x92\x01\x91`\x01\x01aU\\V[PP`\x80\x84\x01\x95\x90\x95RPP`\xA0\x01R\x94\x93PPPPV[`\x01\x80`\xA0\x1B\x03\x83\x16\x81R`@` \x82\x01R_\x82Q```@\x84\x01RaU\xD3`\xA0\x84\x01\x82aM7V[\x90P` \x84\x01Q``\x84\x01R`@\x84\x01Q`\x80\x84\x01R\x80\x91PP\x93\x92PPPV[\x805`\x02\x81\x10aI(W__\xFD[___a\x01@\x84\x86\x03\x12\x15aV\x15W__\xFD[aV\x1E\x84aU\xF4V[\x92P` \x84\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aV8W__\xFD[aVD\x86\x82\x87\x01aH;V[\x92PPaVT\x85`@\x86\x01aP\x92V[\x90P\x92P\x92P\x92V[_____a\x01\x80\x86\x88\x03\x12\x15aVrW__\xFD[aV{\x86aU\xF4V[\x94P` \x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aV\x95W__\xFD[aV\xA1\x88\x82\x89\x01aH;V[\x94PPaV\xB1\x87`@\x88\x01aP\x92V[\x92Pa\x01@\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aV\xCCW__\xFD[aV\xD8\x88\x82\x89\x01aO\x1DV[\x92PPa\x01`\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aV\xF4W__\xFD[aW\0\x88\x82\x89\x01aQ\x12V[\x91PP\x92\x95P\x92\x95\x90\x93PV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[_`\x01\x82\x01aW2WaW2aW\rV[P`\x01\x01\x90V[``\x80\x82R\x84Q\x90\x82\x01\x81\x90R_\x90` \x86\x01\x90`\x80\x84\x01\x90\x83[\x81\x81\x10\x15aW{W\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01aWTV[PP\x83\x81\x03` \x80\x86\x01\x91\x90\x91R\x86Q\x80\x83R\x91\x81\x01\x92P\x86\x01\x90_[\x81\x81\x10\x15aW\xB6W\x82Q\x84R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01aW\x98V[PPP`\xFF\x84\x16`@\x84\x01R\x90Pa!WV[_` \x82\x84\x03\x12\x15aW\xD9W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15aW\xEEW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13aW\xFEW__\xFD[\x80QaX\x0CaGC\x82aF\xF0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x85\x01\x01\x92P\x86\x83\x11\x15aX-W__\xFD[` \x84\x01\x93P[\x82\x84\x10\x15a\x17BWaXE\x84aT\xC7V[\x82R` \x93\x84\x01\x93\x90\x91\x01\x90aX4V[\x82\x81R`@` \x82\x01R_a\x0B\xCE`@\x83\x01\x84aM7V[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x83\x16\x81R`@` \x82\x01\x81\x90R_\x90a\x0B\xCE\x90\x83\x01\x84aM7V[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82aX\xCDWaX\xCDaX\xABV[P\x06\x90V[`\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\r\xE9Wa\r\xE9aW\rV[_`@\x82\x01`\x01\x80`\xA0\x1B\x03\x85\x16\x83R`@` \x84\x01R\x80\x84Q\x80\x83R``\x85\x01\x91P``\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15aY\xA0W\x86\x85\x03`_\x19\x01\x84R\x81Q\x80Qc\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90_\x90``\x88\x01\x90[\x80\x83\x10\x15aY\x88W\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x82R` \x93\x84\x01\x93`\x01\x93\x90\x93\x01\x92\x90\x91\x01\x90aY]V[P\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01aY\x1FV[P\x92\x97\x96PPPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15aY\xFBW\x81Q\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x87R` \x90\x81\x01Q`\x01`\x01``\x1B\x03\x16\x81\x88\x01R`@\x90\x96\x01\x95\x90\x91\x01\x90`\x01\x01aY\xBFV[P\x93\x94\x93PPPPV[`\xFF\x84\x16\x81R`\x01`\x01``\x1B\x03\x83\x16` \x82\x01R```@\x82\x01R_aZ/``\x83\x01\x84aY\xADV[\x95\x94PPPPPV[`\xFF\x85\x16\x81R`\x01`\x01``\x1B\x03\x84\x16` \x82\x01Rc\xFF\xFF\xFF\xFF\x83\x16`@\x82\x01R`\x80``\x82\x01R_a\x17B`\x80\x83\x01\x84aY\xADV[aZ\x9D\x81\x87c\xFF\xFF\xFF\xFF\x81Q\x16\x82Ra\xFF\xFF` \x82\x01Q\x16` \x83\x01Ra\xFF\xFF`@\x82\x01Q\x16`@\x83\x01RPPV[`\x01`\x01``\x1B\x03\x85\x16``\x82\x01R`\xE0`\x80\x82\x01R_aZ\xC1`\xE0\x83\x01\x86aY\xADV[\x90P`\x02\x84\x10aZ\xD3WaZ\xD3aMtV[\x83`\xA0\x83\x01Rc\xFF\xFF\xFF\xFF\x83\x16`\xC0\x83\x01R\x96\x95PPPPPPV[` \x80\x82R`+\x90\x82\x01R\x7FInitializable: contract is not i`@\x82\x01Rjnitializing`\xA8\x1B``\x82\x01R`\x80\x01\x90V[`\x01\x81\x81\x1C\x90\x82\x16\x80a[NW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a[lWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[\x80_[`\x02\x81\x10\x15a\x0FHW\x81Q\x84R` \x93\x84\x01\x93\x90\x91\x01\x90`\x01\x01a[uV[`\x01`\x01`\xA0\x1B\x03\x84\x16\x81R\x82Q\x80Q` \x80\x84\x01\x91\x90\x91R\x01Q`@\x82\x01Ra\x01`\x81\x01` \x84\x81\x01Q\x80Q``\x85\x01R\x90\x81\x01Q`\x80\x84\x01RP`@\x84\x01Qa[\xE3`\xA0\x84\x01\x82Qa[rV[` \x01Qa[\xF4`\xE0\x84\x01\x82a[rV[P\x82Qa\x01 \x83\x01R` \x83\x01Qa\x01@\x83\x01Ra!WV[_` \x82\x84\x03\x12\x15a\\\x1DW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r\xE9Wa\r\xE9aW\rV[`\x01\x80`\xA0\x1B\x03\x84\x16\x81R\x82` \x82\x01R```@\x82\x01R_aZ/``\x83\x01\x84aM7V[_\x82`\x1F\x83\x01\x12a\\lW__\xFD[\x81Qa\\zaGC\x82aF\xF0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x86\x01\x01\x92P\x85\x83\x11\x15a\\\x9BW__\xFD[` \x85\x01[\x83\x81\x10\x15aG\x8FW\x80Qa\\\xB3\x81aJ~V[\x83R` \x92\x83\x01\x92\x01a\\\xA0V[__`@\x83\x85\x03\x12\x15a\\\xD2W__\xFD[\x82Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\\\xE7W__\xFD[a\\\xF3\x85\x82\x86\x01a\\]V[\x92PP` \x83\x01Q`\x01`\x01`@\x1B\x03\x81\x11\x15a]\x0EW__\xFD[aN+\x85\x82\x86\x01a\\]V[_` \x82\x84\x03\x12\x15a]*W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a]?W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a]OW__\xFD[\x80Qa]]aGC\x82aF\xF0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x85\x01\x01\x92P\x86\x83\x11\x15a]~W__\xFD[` \x84\x01\x93P[\x82\x84\x10\x15a\x17BW\x83Qa]\x98\x81aG\xE1V[\x82R` \x93\x84\x01\x93\x90\x91\x01\x90a]\x85V[\x81\x81\x03\x81\x81\x11\x15a\r\xE9Wa\r\xE9aW\rV[_a\xFF\xFF\x82\x16a\xFF\xFF\x81\x03a]\xD3Wa]\xD3aW\rV[`\x01\x01\x92\x91PPV[`\x1F\x82\x11\x15a\x0B\xBBW\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a^\x01WP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x0F\x07W_\x81U`\x01\x01a^\rV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a^9Wa^9aFbV[a^M\x81a^G\x84Ta[:V[\x84a]\xDCV[` `\x1F\x82\x11`\x01\x81\x14a^\x7FW_\x83\x15a^hWP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x0F\x07V[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a^\xAEW\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a^\x8EV[P\x84\x82\x10\x15a^\xCBW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[_` \x82\x84\x03\x12\x15a^\xEAW__\xFD[\x81Qa\x0B\xD1\x81aJ~V[` \x80\x82R\x82Q`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x83\x83\x01R\x83\x82\x01Q\x16`@\x80\x84\x01\x91\x90\x91R\x83\x01Q``\x80\x84\x01R\x80Q`\x80\x84\x01\x81\x90R_\x92\x91\x90\x91\x01\x90\x82\x90`\xA0\x85\x01\x90[\x80\x83\x10\x15aG\x8FWc\xFF\xFF\xFF\xFF\x84Q\x16\x82R` \x82\x01\x91P` \x84\x01\x93P`\x01\x83\x01\x92Pa_:V[`\x01`\x01``\x1B\x03\x81\x81\x16\x83\x82\x16\x02\x90\x81\x16\x90\x81\x81\x14a$]Wa$]aW\rV[_`\x01`\x01``\x1B\x03\x83\x16\x80a_\x9DWa_\x9DaX\xABV[\x80`\x01`\x01``\x1B\x03\x84\x16\x04\x91PP\x92\x91PPV[_\x82Qa_\xC3\x81\x84` \x87\x01aM\x15V[\x91\x90\x91\x01\x92\x91PPV\xFE0dNr\xE11\xA0)\xB8PE\xB6\x81\x81X]\x97\x81j\x91hq\xCA\x8D< \x8C\x16\xD8|\xFDG\xA2dipfsX\"\x12 \xBB}I~Q\xC6\x0Fz\x89T\x91\xC0\xE5\xA7\x89v\x8C\x126\x16\xC6b\x84U\xDE;\xC9`\xACVa\x1FdsolcC\0\x08\x1B\x003",
6101    );
6102    /// The runtime bytecode of the contract, as deployed on the network.
6103    ///
6104    /// ```text
6105    ///0x608060405234801561000f575f5ffd5b5060043610610346575f3560e01c8063733b7507116101b9578063a96f783e116100f6578063e65797ad1161009a578063e65797ad146108fb578063e814ca9d14610976578063ea32afae14610987578063ec8c3a1e146109ae578063f2fde38b146109b6578063f698da25146109c9578063fabc1cbc146109d1578063fd39105a146109e4575f5ffd5b8063a96f783e14610838578063b526578714610841578063c391425e14610854578063c63fd50214610874578063ca0de88214610887578063ca4f2d97146108ae578063ca8aa7c7146108c1578063de1164bb146108e8575f5ffd5b80638da5cb5b1161015d5780638da5cb5b1461076e5780639aa1653d1461077f5780639b5d177b1461079e5780639e9923c2146107b15780639feab859146107d8578063a4d7871f146107ff578063a50857bf14610812578063a65497c614610825575f5ffd5b8063733b7507146106cc57806373447992146106d457806381f936d2146106e75780638281ab75146106f357806384b0196e1461070657806384ca521314610721578063871ef04914610734578063886f119514610747575f5ffd5b8063303ca95611610287578063595c6a671161022b578063595c6a671461061d5780635ac86ab7146106255780635b0b829f146106485780635c975abb1461065b5780635df4594614610663578063683048351461068a5780636e3b17db146106b1578063715018a6146106c4575f5ffd5b8063303ca956146105425780633998fdd3146105555780633c2a7f4c1461057c5780633eef3a511461059c5780635140a548146105af578063530b97a4146105c257806354fd4d50146105d55780635865c60c146105fd575f5ffd5b8063136439dd116102ee578063136439dd146104495780631478851f1461045c5780631eb812da1461048e578063249a0c42146104d757806328f61b31146104f6578063296bb0641461050957806329d1e0c31461051c5780632cdd1e861461052f575f5ffd5b8062cf2ab51461034a57806303fd34921461035f57806304ec635114610391578063054310e6146103bc5780630cf4b767146103dc5780630d3f2134146103ef578063125e05841461040257806313542a4e14610421575b5f5ffd5b61035d610358366004614799565b610a1f565b005b61037e61036d3660046147ca565b5f9081526034602052604090205490565b6040519081526020015b60405180910390f35b6103a461039f3660046147f2565b610bc0565b6040516001600160c01b039091168152602001610388565b6039546103cf906001600160a01b031681565b6040516103889190614827565b61035d6103ea3660046148ac565b610bd8565b61035d6103fd3660046147ca565b610c3a565b61037e6104103660046148dd565b603b6020525f908152604090205481565b61037e61042f3660046148dd565b6001600160a01b03165f9081526035602052604090205490565b61035d6104573660046147ca565b610c87565b61047e61046a3660046147ca565b60366020525f908152604090205460ff1681565b6040519015158152602001610388565b6104a161049c3660046148f8565b610d61565b60408051825163ffffffff908116825260208085015190911690820152918101516001600160c01b031690820152606001610388565b61037e6104e536600461492d565b60376020525f908152604090205481565b603a546103cf906001600160a01b031681565b6103cf6105173660046147ca565b610def565b61035d61052a3660046148dd565b610e78565b61035d61053d3660046148dd565b610e89565b61035d6105503660046149aa565b610e9a565b6103cf7f000000000000000000000000000000000000000000000000000000000000000081565b61058f61058a3660046148dd565b610f0e565b6040516103889190614a07565b61035d6105aa366004614b28565b610f32565b61035d6105bd366004614bd4565b610f4e565b61035d6105d0366004614cb1565b611275565b604080518082018252600681526576302e302e3160d01b602082015290516103889190614d62565b61061061060b3660046148dd565b61140b565b6040516103889190614d9c565b61035d61147d565b61047e61063336600461492d565b606554600160ff9092169190911b9081161490565b61035d610656366004614db7565b611531565b60655461037e565b6103cf7f000000000000000000000000000000000000000000000000000000000000000081565b6103cf7f000000000000000000000000000000000000000000000000000000000000000081565b61035d6106bf366004614de9565b61154d565b61035d611579565b61035d61158a565b61037e6106e23660046148dd565b6115f1565b5f5461047e9060ff1681565b61035d610701366004614e35565b611655565b61070e61166a565b6040516103889796959493929190614e87565b61037e61072f366004614fb1565b611703565b6103a46107423660046147ca565b61174c565b6103cf7f000000000000000000000000000000000000000000000000000000000000000081565b60c8546001600160a01b03166103cf565b60325461078c9060ff1681565b60405160ff9091168152602001610388565b61035d6107ac36600461516c565b611756565b6103cf7f000000000000000000000000000000000000000000000000000000000000000081565b61037e7f2bd82124057f0913bc3b772ce7b83e8057c1ad1f3510fc83778be20f10ec5de681565b61047e61080d36600461492d565b611919565b61035d610820366004615264565b611934565b61035d6108333660046148dd565b611a81565b61037e603c5481565b61047e61084f3660046148dd565b611a92565b610867610862366004615303565b611aa6565b60405161038891906153a8565b61035d6108823660046153e5565b611ab4565b61037e7f4d404e3276e7ac2163d8ee476afa6a41d1f68fb71f2d8b6546b24e55ce01b72a81565b61035d6108bc3660046148ac565b611c56565b6103cf7f000000000000000000000000000000000000000000000000000000000000000081565b603d546103cf906001600160a01b031681565b61096961090936600461492d565b60408051606080820183525f808352602080840182905292840181905260ff9490941684526033825292829020825193840183525463ffffffff8116845261ffff600160201b8204811692850192909252600160301b9004169082015290565b6040516103889190615472565b5f5461047e90610100900460ff1681565b6103cf7f000000000000000000000000000000000000000000000000000000000000000081565b61037e611cba565b61035d6109c43660046148dd565b611cd9565b61037e611d4f565b61035d6109df3660046147ca565b611d58565b610a126109f23660046148dd565b6001600160a01b03165f9081526035602052604090206001015460ff1690565b60405161038891906154a5565b606554600290600490811603610a485760405163840a48d560e01b815260040160405180910390fd5b5f5b8251811015610bbb576040805160018082528183019092525f9160208083019080368337019050509050838281518110610a8657610a866154b3565b6020026020010151815f81518110610aa057610aa06154b3565b6001600160a01b0392909216602092830291909101909101526040805160018082528183019092525f9181602001602082028036833701905050905060355f868581518110610af157610af16154b3565b60200260200101516001600160a01b03166001600160a01b031681526020019081526020015f205f0154815f81518110610b2d57610b2d6154b3565b6020026020010181815250505f610b5c825f81518110610b4f57610b4f6154b3565b6020026020010151611e6f565b90505f610b71826001600160c01b0316611e7b565b90505f5b8151811015610baa57610ba28585848481518110610b9557610b956154b3565b016020015160f81c611f44565b600101610b75565b505060019093019250610a4a915050565b505050565b5f610bce603485858561207b565b90505b9392505050565b6001335f9081526035602052604090206001015460ff166002811115610c0057610c00614d74565b14610c1e5760405163aba4733960e01b815260040160405180910390fd5b335f90815260356020526040902054610c37908261215f565b50565b610c4261220a565b603c80549082905560408051828152602081018490527fa77a91bea7b6d95a8eb5a54878a1d9e3c875e26c86a9b70e3420c5c5db193b62910160405180910390a15050565b60405163237dfb4760e11b81526001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016906346fbf68e90610cd3903390600401614827565b602060405180830381865afa158015610cee573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610d1291906154d6565b610d2f57604051631d77d47760e21b815260040160405180910390fd5b6065548181168114610d545760405163c61dca5d60e01b815260040160405180910390fd5b610d5d82612264565b5050565b604080516060810182525f80825260208201819052918101919091525f838152603460205260409020805483908110610d9c57610d9c6154b3565b5f91825260209182902060408051606081018252919092015463ffffffff8082168352600160201b820416938201939093526001600160c01b03600160401b909304929092169082015290505b92915050565b6040516308f6629d60e31b8152600481018290525f907f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906347b314e890602401602060405180830381865afa158015610e54573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610de991906154ef565b610e8061220a565b610c37816122a1565b610e9161220a565b610c378161230a565b610ea2612373565b606554600190600290811603610ecb5760405163840a48d560e01b815260040160405180910390fd5b610ed483611a92565b610ef1576040516366e565df60e01b815260040160405180910390fd5b5f610efb836123bc565b9050610f078582612464565b5050505050565b604080518082019091525f8082526020820152610de9610f2d836115f1565b61272d565b610f3a61220a565b610f488484846001856127b7565b50505050565b606554600290600490811603610f775760405163840a48d560e01b815260040160405180910390fd5b610fbc83838080601f0160208091040260200160405190810160405280939291908181526020018383808284375f920191909152505060325460ff169150612ce29050565b5083518214610fde5760405163aaad13f760e01b815260040160405180910390fd5b5f5b82811015610f07575f848483818110610ffb57610ffb6154b3565b885192013560f81c92505f918891508490811061101a5761101a6154b3565b60209081029190910101516040516379a0849160e11b815260ff841660048201529091506001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169063f341092290602401602060405180830381865afa15801561108d573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906110b1919061550a565b63ffffffff168151146110d757604051638e5aeee760e01b815260040160405180910390fd5b5f81516001600160401b038111156110f1576110f1614662565b60405190808252806020026020018201604052801561111a578160200160208202803683370190505b5090505f805b8351811015611210575f84828151811061113c5761113c6154b3565b6020026020010151905060355f826001600160a01b03166001600160a01b031681526020019081526020015f205f015484838151811061117e5761117e6154b3565b6020026020010181815250505f6111a0858481518110610b4f57610b4f6154b3565b905060016001600160c01b03821660ff89161c8116146111d35760405163d053aa2160e01b815260040160405180910390fd5b836001600160a01b0316826001600160a01b0316116112055760405163ba50f91160e01b815260040160405180910390fd5b509150600101611120565b5061121c838386611f44565b60ff84165f81815260376020908152604091829020439081905591519182527f46077d55330763f16269fd75e5761663f4192d2791747c0189b16ad31db07db4910160405180910390a250505050806001019050610fe0565b606454610100900460ff16158080156112955750606454600160ff909116105b806112af5750303b1580156112af575060645460ff166001145b6113175760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b60648201526084015b60405180910390fd5b6064805460ff19166001179055801561133a576064805461ff0019166101001790555b6113906040518060400160405280601681526020017520ab29a932b3b4b9ba393ca1b7b7b93234b730ba37b960511b8152506040518060400160405280600681526020016576302e302e3160d01b815250612d16565b61139986612d47565b6113a2856122a1565b6113ab83612264565b6113b48461230a565b6113bd82612d98565b8015611403576064805461ff0019169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b505050505050565b604080518082019091525f80825260208201526001600160a01b0382165f908152603560209081526040918290208251808401909352805483526001810154909183019060ff16600281111561146357611463614d74565b600281111561147457611474614d74565b90525092915050565b60405163237dfb4760e11b81526001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016906346fbf68e906114c9903390600401614827565b602060405180830381865afa1580156114e4573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061150891906154d6565b61152557604051631d77d47760e21b815260040160405180910390fd5b61152f5f19612264565b565b61153961220a565b8161154381612e04565b610bbb8383612e2d565b611555612ebe565b6001600160a01b0382165f908152603b60205260409020429055610d5d8282612ee9565b61158161220a565b61152f5f612d47565b61159261220a565b5f54610100900460ff16156115ba576040516321fa91f360e01b815260040160405180910390fd5b5f805461ff0019166101001781556040517f0fc3c0e6f8b4795f371e19de7f4c5733dd9e549fa8c39e5842eb66c31572d99e9190a1565b5f610de97f2bd82124057f0913bc3b772ce7b83e8057c1ad1f3510fc83778be20f10ec5de68360405160200161163a9291909182526001600160a01b0316602082015260400190565b60405160208183030381529060405280519060200120613002565b61165d61220a565b610bbb8383835f5f6127b7565b5f6060805f5f5f606060fa545f5f1b148015611686575060fb54155b6116ca5760405162461bcd60e51b81526020600482015260156024820152741152540dcc4c8e88155b9a5b9a5d1a585b1a5e9959605a1b604482015260640161130e565b6116d261302e565b6116da6130be565b604080515f80825260208201909252600f60f81b9b939a50919850469750309650945092509050565b5f6117427f4d404e3276e7ac2163d8ee476afa6a41d1f68fb71f2d8b6546b24e55ce01b72a878787878760405160200161163a96959493929190615525565b9695505050505050565b5f610de982611e6f565b6065545f9060019081160361177e5760405163840a48d560e01b815260040160405180910390fd5b5f54610100900460ff16156117a6576040516321fa91f360e01b815260040160405180910390fd5b6117f66117b1611cba565b6117ef8a8a8080601f0160208091040260200160405190810160405280939291908181526020018383808284375f920191909152506130cd92505050565b9081161490565b6118135760405163afaa70ef60e01b815260040160405180910390fd5b5f6001335f9081526035602052604090206001015460ff16600281111561183c5761183c614d74565b14905061188d3361184d3389613188565b8b8b8080601f0160208091040260200160405190810160405280939291908181526020018383808284375f920191909152508d92508b91508a9050613221565b8061190e57604051639926ee7d60e01b81526001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001690639926ee7d906118e090339087906004016155aa565b5f604051808303815f87803b1580156118f7575f5ffd5b505af1158015611909573d5f5f3e3d5ffd5b505050505b505050505050505050565b5f610de982611926611cba565b9060ff161c60019081161490565b6065545f9060019081160361195c5760405163840a48d560e01b815260040160405180910390fd5b5f54610100900460ff1615611984576040516321fa91f360e01b815260040160405180910390fd5b61199861198f611cba565b6117ef876130cd565b6119b55760405163afaa70ef60e01b815260040160405180910390fd5b5f6001335f9081526035602052604090206001015460ff1660028111156119de576119de614d74565b1490506119f8336119ef3387613188565b88886001613416565b508061140357604051639926ee7d60e01b81526001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001690639926ee7d90611a4c90339087906004016155aa565b5f604051808303815f87803b158015611a63575f5ffd5b505af1158015611a75573d5f5f3e3d5ffd5b50505050505050505050565b611a8961220a565b610c3781612d98565b603d546001600160a01b0391821691161490565b6060610bd16034848461385f565b611abc612373565b6065545f90600190811603611ae45760405163840a48d560e01b815260040160405180910390fd5b611aed85611a92565b611b0a576040516366e565df60e01b815260040160405180910390fd5b5f611b14856123bc565b90505f8080611b2586880188615602565b9250925092505f611b368b83613188565b90505f846001811115611b4b57611b4b614d74565b03611bf4575f611b5f8c8388876001613416565b5190505f5b8651811015611bed575f878281518110611b8057611b806154b3565b0160209081015160f81c5f8181526033909252604090912054845191925063ffffffff1690849084908110611bb757611bb76154b3565b602002602001015163ffffffff161115611be45760405163c6b9e76760e01b815260040160405180910390fd5b50600101611b64565b5050611c49565b6001846001811115611c0857611c08614d74565b03611c30575f80611c1b898b018b61565d565b94509450505050611bed8d8489888686613221565b60405163354bb8ab60e01b815260040160405180910390fd5b5050505050505050505050565b606554600190600290811603611c7f5760405163840a48d560e01b815260040160405180910390fd5b611c93611c8a611cba565b6117ef846130cd565b611cb05760405163afaa70ef60e01b815260040160405180910390fd5b610d5d3383612464565b5f805460ff1615611ccc575060015490565b611cd461390e565b905090565b611ce161220a565b6001600160a01b038116611d465760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b606482015260840161130e565b610c3781612d47565b5f611cd4613925565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663eab66d7a6040518163ffffffff1660e01b8152600401602060405180830381865afa158015611db4573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611dd891906154ef565b6001600160a01b0316336001600160a01b031614611e095760405163794821ff60e01b815260040160405180910390fd5b60655480198219811614611e305760405163c61dca5d60e01b815260040160405180910390fd5b606582905560405182815233907f3582d1828e26bf56bd801502bc021ac0bc8afb57c826e4986b45593c8fad389c906020015b60405180910390a25050565b5f610de960348361392e565b60605f5f611e8884613998565b61ffff166001600160401b03811115611ea357611ea3614662565b6040519080825280601f01601f191660200182016040528015611ecd576020820181803683370190505b5090505f805b825182108015611ee4575061010081105b15611f3a576001811b935085841615611f2a578060f81b838381518110611f0d57611f0d6154b3565b60200101906001600160f81b03191690815f1a9053508160010191505b611f3381615721565b9050611ed3565b5090949350505050565b6040805160018082528183019092525f916020820181803683370190505090508160f81b815f81518110611f7a57611f7a6154b3565b60200101906001600160f81b03191690815f1a905350604051636c3fb4bf60e01b81525f906001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001690636c3fb4bf90611fe290889088908890600401615739565b5f604051808303815f875af1158015611ffd573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f1916820160405261202491908101906157c9565b90505f5b855181101561140357818181518110612043576120436154b3565b60200260200101511561207357612073868281518110612065576120656154b3565b602002602001015184612ee9565b600101612028565b5f83815260208590526040812080548291908490811061209d5761209d6154b3565b5f91825260209182902060408051606081018252929091015463ffffffff808216808552600160201b8304821695850195909552600160401b9091046001600160c01b0316918301919091529092508516101561210d57604051636cb19aff60e01b815260040160405180910390fd5b602081015163ffffffff1615806121335750806020015163ffffffff168463ffffffff16105b6121505760405163bbba60cb60e01b815260040160405180910390fd5b6040015190505b949350505050565b6040516378219b3f60e11b81526001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169063f043367e906121ad9085908590600401615856565b5f604051808303815f87803b1580156121c4575f5ffd5b505af11580156121d6573d5f5f3e3d5ffd5b50505050817fec2963ab21c1e50e1e582aa542af2e4bf7bf38e6e1403c27b42e1c5d6e621eaa82604051611e639190614d62565b60c8546001600160a01b0316331461152f5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161130e565b606581905560405181815233907fab40a374bc51de372200a8bc981af8c9ecdc08dfdaef0bb6e09f88f3c616ef3d9060200160405180910390a250565b6039546040517f315457d8a8fe60f04af17c16e2f5a5e1db612b31648e58030360759ef8f3528c916122e0916001600160a01b0390911690849061586e565b60405180910390a1603980546001600160a01b0319166001600160a01b0392909216919091179055565b603a546040517f8f30ab09f43a6c157d7fce7e0a13c003042c1c95e8a72e7a146a21c0caa24dc991612349916001600160a01b0390911690849061586e565b60405180910390a1603a80546001600160a01b0319166001600160a01b0392909216919091179055565b336001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000161461152f576040516323d871a560e01b815260040160405180910390fd5b60605f82516001600160401b038111156123d8576123d8614662565b6040519080825280601f01601f191660200182016040528015612402576020820181803683370190505b5090505f5b835181101561245d57838181518110612422576124226154b3565b602002602001015160f81b82828151811061243f5761243f6154b3565b60200101906001600160f81b03191690815f1a905350600101612407565b5092915050565b6001600160a01b0382165f9081526035602052604081208054909161248882611e6f565b905060018084015460ff1660028111156124a4576124a4614d74565b146124c25760405163aba4733960e01b815260040160405180910390fd5b6032545f906124d590869060ff16612ce2565b90506001600160c01b0381166124fe576040516368b6a87560e11b815260040160405180910390fd5b6125156001600160c01b0382811690841681161490565b6125325760405163d053aa2160e01b815260040160405180910390fd5b6001600160c01b038181161983161661254b84826139c2565b6001600160c01b0381166125a7576001600160a01b0387165f81815260356020526040808220600101805460ff19166002179055518692917f396fdcb180cb0fea26928113fb0fd1c3549863f9cd563e6a184f1d578116c8e491a35b60405163f4e24fe560e01b81526001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169063f4e24fe5906125f5908a908a90600401615888565b5f604051808303815f87803b15801561260c575f5ffd5b505af115801561261e573d5f5f3e3d5ffd5b505060405163bd29b8cd60e01b81526001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016925063bd29b8cd91506126709087908a90600401615856565b5f604051808303815f87803b158015612687575f5ffd5b505af1158015612699573d5f5f3e3d5ffd5b505060405163bd29b8cd60e01b81526001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016925063bd29b8cd91506126eb9087908a90600401615856565b5f604051808303815f87803b158015612702575f5ffd5b505af1158015612714573d5f5f3e3d5ffd5b50505050612724878588846139ce565b50505050505050565b604080518082019091525f80825260208201525f808061275a5f516020615fce5f395f51905f52866158bf565b90505b61276681613a74565b90935091505f516020615fce5f395f51905f52828309830361279e576040805180820190915290815260208101919091529392505050565b5f516020615fce5f395f51905f5260018208905061275d565b60325460ff166127c681613af0565b60c060ff8216106127ea57604051633cb89c9760e01b815260040160405180910390fd5b60328054600191905f9061280290849060ff166158d2565b92506101000a81548160ff021916908360ff1602179055506128248187612e2d565b6040805160018082528183019092525f91816020015b604080518082019091525f81526060602082015281526020019060019003908161283a5790505090505f85516001600160401b0381111561287d5761287d614662565b6040519080825280602002602001820160405280156128a6578160200160208202803683370190505b5090505f5b8651811015612903578681815181106128c6576128c66154b3565b60200260200101515f01518282815181106128e3576128e36154b3565b6001600160a01b03909216602092830291909101909101526001016128ab565b5060405180604001604052808460ff1663ffffffff16815260200182815250825f81518110612934576129346154b3565b6020908102919091010152603d54604051630130fc2760e51b81526001600160a01b037f000000000000000000000000000000000000000000000000000000000000000081169263261f84e09261299492919091169086906004016158eb565b5f604051808303815f87803b1580156129ab575f5ffd5b505af11580156129bd573d5f5f3e3d5ffd5b505f92506129c9915050565b8560018111156129db576129db614d74565b03612a6257604051633aea0b9d60e11b81526001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016906375d4173a90612a309086908b908b90600401615a05565b5f604051808303815f87803b158015612a47575f5ffd5b505af1158015612a59573d5f5f3e3d5ffd5b50505050612ba6565b6001856001811115612a7657612a76614d74565b03612ba6578363ffffffff167f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316632981eb776040518163ffffffff1660e01b8152600401602060405180830381865afa158015612ade573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190612b02919061550a565b63ffffffff1611612b2657604051630bd441b960e21b815260040160405180910390fd5b604051630662d3e160e51b81526001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169063cc5a7c2090612b789086908b9089908c90600401615a38565b5f604051808303815f87803b158015612b8f575f5ffd5b505af1158015612ba1573d5f5f3e3d5ffd5b505050505b60405163136ca0f960e11b815260ff841660048201527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906326d941f2906024015f604051808303815f87803b158015612c07575f5ffd5b505af1158015612c19573d5f5f3e3d5ffd5b505060405163136ca0f960e11b815260ff861660048201527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031692506326d941f291506024015f604051808303815f87803b158015612c7e575f5ffd5b505af1158015612c90573d5f5f3e3d5ffd5b505050508260ff167fa34835bc2b673ec37fcf1591a91295b163fc2e181e4ea4e733beb27de1ceac4c8989898989604051612ccf959493929190615a6e565b60405180910390a25b5050505050505050565b5f5f612ced846130cd565b9050808360ff166001901b11610bd15760405163ca95733360e01b815260040160405180910390fd5b606454610100900460ff16612d3d5760405162461bcd60e51b815260040161130e90615aef565b610d5d8282613b01565b60c880546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0905f90a35050565b603d546040516001600160a01b03909116907f9770f3cadfdcbb6f93af935e86047111590c3768271d237e4a2bc0b874bed69390612dd9908390859061586e565b60405180910390a150603d80546001600160a01b0319166001600160a01b0392909216919091179055565b60325460ff90811690821610610c3757604051637310cff560e11b815260040160405180910390fd5b60ff82165f8181526033602090815260409182902084518154928601518487015161ffff908116600160301b0267ffff0000000000001991909216600160201b0265ffffffffffff1990951663ffffffff909316929092179390931716919091179055517f3ee6fe8d54610244c3e9d3c066ae4aee997884aa28f10616ae821925401318ac90611e63908490615472565b603a546001600160a01b0316331461152f576040516376d8ab1760e11b815260040160405180910390fd5b6001600160a01b0382165f908152603560205260408120603254909190612f1490849060ff16612ce2565b905060018083015460ff166002811115612f3057612f30614d74565b148015612f4557506001600160c01b03811615155b15610f48576040805160018082528183019092525f916020820181803683370190505090505f5b845181101561140357848181518110612f8757612f876154b3565b602001015160f81c60f81b825f81518110612fa457612fa46154b3565b60200101906001600160f81b03191690815f1a905350612fdc858281518110612fcf57612fcf6154b3565b016020015160f81c611919565b15612ff057612feb8683612464565b612ffa565b612ffa8683613b4f565b600101612f6c565b5f610de961300e613925565b8360405161190160f01b8152600281019290925260228201526042902090565b606060fc805461303d90615b3a565b80601f016020809104026020016040519081016040528092919081815260200182805461306990615b3a565b80156130b45780601f1061308b576101008083540402835291602001916130b4565b820191905f5260205f20905b81548152906001019060200180831161309757829003601f168201915b5050505050905090565b606060fd805461303d90615b3a565b5f610100825111156130f257604051637da54e4760e11b815260040160405180910390fd5b81515f0361310157505f919050565b5f5f835f81518110613115576131156154b3565b0160200151600160f89190911c81901b92505b845181101561317f57848181518110613143576131436154b3565b0160200151600160f89190911c1b915082821161317357604051631019106960e31b815260040160405180910390fd5b91811791600101613128565b50909392505050565b5f7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166303c5a6b684846131c387610f0e565b6040518463ffffffff1660e01b81526004016131e193929190615b94565b6020604051808303815f875af11580156131fd573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610bd19190615c0d565b83518251146132435760405163aaad13f760e01b815260040160405180910390fd5b61324f86868484613b84565b5f61325d878787875f613416565b90505f5b8551811015612cd8575f60335f888481518110613280576132806154b3565b0160209081015160f81c82528181019290925260409081015f208151606081018352905463ffffffff811680835261ffff600160201b8304811695840195909552600160301b909104909316918101919091528451805191935090849081106132eb576132eb6154b3565b602002602001015163ffffffff16111561340d5761337f878381518110613314576133146154b3565b602001015160f81c60f81b60f81c84604001518481518110613338576133386154b3565b60200260200101518b86602001518681518110613357576133576154b3565b6020026020010151898781518110613371576133716154b3565b602002602001015186613c2f565b6040805160018082528183019092525f916020820181803683370190505090508783815181106133b1576133b16154b3565b602001015160f81c60f81b815f815181106133ce576133ce6154b3565b60200101906001600160f81b03191690815f1a90535061340b8684815181106133f9576133f96154b3565b60200260200101516020015182612ee9565b505b50600101613261565b61343a60405180606001604052806060815260200160608152602001606081525090565b6032545f9061344d90869060ff16612ce2565b90505f61345987611e6f565b90506001600160c01b038216613482576040516313ca465760e01b815260040160405180910390fd5b8082166001600160c01b0316156134ac57604051630c6816cd60e01b815260040160405180910390fd5b603c546001600160a01b0389165f908152603b60205260409020546001600160c01b03838116908516179142916134e39190615c24565b1061350157604051631968677d60e11b815260040160405180910390fd5b61350b88826139c2565b613515888761215f565b60016001600160a01b038a165f9081526035602052604090206001015460ff16600281111561354657613546614d74565b146135dd57604080518082018252898152600160208083018281526001600160a01b038e165f908152603590925293902082518155925183820180549394939192909160ff1916908360028111156135a0576135a0614d74565b0217905550506040518991506001600160a01b038b16907fe8e68cef1c3a761ed7be7e8463a375f27f7bc335e51824223cacce636ec5c3fe905f90a35b604051631fd93ca960e11b81526001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001690633fb279529061362b908c908b90600401615888565b5f604051808303815f87803b158015613642575f5ffd5b505af1158015613654573d5f5f3e3d5ffd5b5050604051632550477760e01b81526001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169250632550477791506136a8908c908c908c90600401615c37565b5f604051808303815f875af11580156136c3573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f191682016040526136ea9190810190615cc1565b60408087019190915260208601919091525162bff04d60e01b81526001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169062bff04d90613745908b908b90600401615856565b5f604051808303815f875af1158015613760573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f191682016040526137879190810190615d1a565b84528415613853575f5b8751811015613851575f60335f8a84815181106137b0576137b06154b3565b0160209081015160f81c82528181019290925260409081015f208151606081018352905463ffffffff811680835261ffff600160201b8304811695840195909552600160301b9091049093169181019190915287518051919350908490811061381b5761381b6154b3565b602002602001015163ffffffff1611156138485760405163c6b9e76760e01b815260040160405180910390fd5b50600101613791565b505b50505095945050505050565b60605f82516001600160401b0381111561387b5761387b614662565b6040519080825280602002602001820160405280156138a4578160200160208202803683370190505b5090505f5b8351811015613905576138d686868684815181106138c9576138c96154b3565b6020026020010151613da5565b8282815181106138e8576138e86154b3565b63ffffffff909216602092830291909101909101526001016138a9565b50949350505050565b6032545f90611cd49060019060ff1681901b615da9565b5f611cd4613ebd565b5f8181526020839052604081205480820361394c575f915050610de9565b5f838152602085905260409020613964600183615da9565b81548110613974576139746154b3565b5f91825260209091200154600160401b90046001600160c01b03169150610de99050565b5f805b8215610de9576139ac600184615da9565b90921691806139ba81615dbc565b91505061399b565b610d5d60348383613f30565b5f6139d761390e565b90505f6139eb6139e5611cba565b19831690565b90506001600160c01b03811984161680612724576040516351b27a6d60e11b81526001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169063a364f4da90613a4b908a90600401614827565b5f604051808303815f87803b158015613a62575f5ffd5b505af1158015611c49573d5f5f3e3d5ffd5b5f80805f516020615fce5f395f51905f5260035f516020615fce5f395f51905f52865f516020615fce5f395f51905f52888909090890505f613ae4827f0c19139cb84c680a6e14116da060561765e05aa45a1c72a34f082305b61f3f525f516020615fce5f395f51905f526140e9565b91959194509092505050565b5f5460ff16610c3757610c37614162565b606454610100900460ff16613b285760405162461bcd60e51b815260040161130e90615aef565b60fc613b348382615e20565b5060fd613b418282615e20565b50505f60fa81905560fb5550565b5f613b6a613b5b611cba565b613b64846130cd565b90191690565b90508015610bbb57610bbb83613b7f83611e7b565b6141c7565b6020808201515f9081526036909152604090205460ff1615613bb957604051636fbefec360e11b815260040160405180910390fd5b4281604001511015613bde57604051630819bdcd60e01b815260040160405180910390fd5b602080820180515f9081526036909252604091829020805460ff19166001179055603954905191830151610f48926001600160a01b0390921691613c289188918891889190611703565b8351614265565b6020808301516001600160a01b038082165f8181526035909452604090932054919290871603613c72576040516356168b4160e11b815260040160405180910390fd5b8760ff16845f015160ff1614613c9b57604051638e5aeee760e01b815260040160405180910390fd5b604051635401ed2760e01b81526004810182905260ff891660248201525f907f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031690635401ed2790604401602060405180830381865afa158015613d09573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190613d2d9190615eda565b9050613d39818561428d565b6001600160601b0316866001600160601b031611613d6a57604051634c44995d60e01b815260040160405180910390fd5b613d7488856142b0565b6001600160601b0316816001600160601b03161061190e5760405163b187e86960e01b815260040160405180910390fd5b5f81815260208490526040812054815b81811015613e28576001613dc98284615da9565b613dd39190615da9565b92508463ffffffff16865f8681526020019081526020015f208463ffffffff1681548110613e0357613e036154b3565b5f9182526020909120015463ffffffff1611613e20575050610bd1565b600101613db5565b5060405162461bcd60e51b815260206004820152605c60248201527f5265676973747279436f6f7264696e61746f722e67657451756f72756d42697460448201527f6d6170496e6465784174426c6f636b4e756d6265723a206e6f206269746d617060648201527f2075706461746520666f756e6420666f72206f70657261746f72496400000000608482015260a40161130e565b5f7f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f613ee76142c9565b613eef614321565b60408051602081019490945283019190915260608201524660808201523060a082015260c00160405160208183030381529060405280519060200120905090565b5f8281526020849052604081205490819003613fd4575f83815260208581526040808320815160608101835263ffffffff43811682528185018681526001600160c01b03808a16958401958652845460018101865594885295909620915191909201805495519351909416600160401b026001600160401b03938316600160201b0267ffffffffffffffff1990961691909216179390931716919091179055610f48565b5f838152602085905260408120613fec600184615da9565b81548110613ffc57613ffc6154b3565b5f918252602090912001805490915063ffffffff43811691160361403d5780546001600160401b0316600160401b6001600160c01b03851602178155610f07565b805463ffffffff438116600160201b81810267ffffffff00000000199094169390931784555f8781526020898152604080832081516060810183529485528483018481526001600160c01b03808c1693870193845282546001810184559286529390942094519401805493519151909216600160401b026001600160401b0391861690960267ffffffffffffffff19909316939094169290921717919091169190911790555050505050565b5f5f6140f3614626565b6140fb614644565b602080825281810181905260408201819052606082018890526080820187905260a082018690528260c08360056107d05a03fa9250828061413857fe5b50826141575760405163d51edae360e01b815260040160405180910390fd5b505195945050505050565b5f5460ff16156141855760405163b2e18e0560e01b815260040160405180910390fd5b61418d61390e565b60019081555f805460ff191690911781556040517f0b88306ff4627121f5b3e5b1c5f88f6b1e42fd2c0478ef1c91662d49d1f077559190a1565b604080516060810182526001600160a01b038481168252603d54811660208301527f00000000000000000000000000000000000000000000000000000000000000001691636e3492b59190810161421d85614351565b8152506040518263ffffffff1660e01b815260040161423c9190615ef5565b5f604051808303815f87803b158015614253575f5ffd5b505af1158015611403573d5f5f3e3d5ffd5b6142708383836143f6565b610bbb57604051638baa579f60e01b815260040160405180910390fd5b60208101515f90612710906142a69061ffff1685615f63565b610bd19190615f85565b60408101515f90612710906142a69061ffff1685615f63565b5f5f6142d361302e565b8051909150156142ea578051602090910120919050565b60fa5480156142f95792915050565b7fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a4709250505090565b5f5f61432b6130be565b805190915015614342578051602090910120919050565b60fb5480156142f95792915050565b60605f82516001600160401b0381111561436d5761436d614662565b604051908082528060200260200182016040528015614396578160200160208202803683370190505b5090505f5b835181101561245d578381815181106143b6576143b66154b3565b602001015160f81c60f81b60f81c60ff168282815181106143d9576143d96154b3565b63ffffffff9092166020928302919091019091015260010161439b565b5f5f5f614403858561444a565b90925090505f81600481111561441b5761441b614d74565b1480156144395750856001600160a01b0316826001600160a01b0316145b80611742575061174286868661448c565b5f5f825160410361447e576020830151604084015160608501515f1a61447287828585614573565b94509450505050614485565b505f905060025b9250929050565b5f5f5f856001600160a01b0316631626ba7e60e01b86866040516024016144b4929190615856565b60408051601f198184030181529181526020820180516001600160e01b03166001600160e01b03199094169390931790925290516144f29190615fb2565b5f60405180830381855afa9150503d805f811461452a576040519150601f19603f3d011682016040523d82523d5f602084013e61452f565b606091505b509150915081801561454357506020815110155b801561174257508051630b135d3f60e11b906145689083016020908101908401615c0d565b149695505050505050565b5f806fa2a8918ca85bafe22016d0b997e4df60600160ff1b0383111561459e57505f9050600361461d565b604080515f8082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa1580156145ef573d5f5f3e3d5ffd5b5050604051601f1901519150506001600160a01b038116614617575f6001925092505061461d565b91505f90505b94509492505050565b60405180602001604052806001906020820280368337509192915050565b6040518060c001604052806006906020820280368337509192915050565b634e487b7160e01b5f52604160045260245ffd5b604051606081016001600160401b038111828210171561469857614698614662565b60405290565b604080519081016001600160401b038111828210171561469857614698614662565b604051601f8201601f191681016001600160401b03811182821017156146e8576146e8614662565b604052919050565b5f6001600160401b0382111561470857614708614662565b5060051b60200190565b6001600160a01b0381168114610c37575f5ffd5b5f82601f830112614735575f5ffd5b8135614748614743826146f0565b6146c0565b8082825260208201915060208360051b860101925085831115614769575f5ffd5b602085015b8381101561478f57803561478181614712565b83526020928301920161476e565b5095945050505050565b5f602082840312156147a9575f5ffd5b81356001600160401b038111156147be575f5ffd5b61215784828501614726565b5f602082840312156147da575f5ffd5b5035919050565b63ffffffff81168114610c37575f5ffd5b5f5f5f60608486031215614804575f5ffd5b833592506020840135614816816147e1565b929592945050506040919091013590565b6001600160a01b0391909116815260200190565b5f82601f83011261484a575f5ffd5b8135602083015f5f6001600160401b0384111561486957614869614662565b50601f8301601f191660200161487e816146c0565b915050828152858383011115614892575f5ffd5b828260208301375f92810160200192909252509392505050565b5f602082840312156148bc575f5ffd5b81356001600160401b038111156148d1575f5ffd5b6121578482850161483b565b5f602082840312156148ed575f5ffd5b8135610bd181614712565b5f5f60408385031215614909575f5ffd5b50508035926020909101359150565b803560ff81168114614928575f5ffd5b919050565b5f6020828403121561493d575f5ffd5b610bd182614918565b5f82601f830112614955575f5ffd5b8135614963614743826146f0565b8082825260208201915060208360051b860101925085831115614984575f5ffd5b602085015b8381101561478f57803561499c816147e1565b835260209283019201614989565b5f5f5f606084860312156149bc575f5ffd5b83356149c781614712565b925060208401356149d781614712565b915060408401356001600160401b038111156149f1575f5ffd5b6149fd86828701614946565b9150509250925092565b815181526020808301519082015260408101610de9565b803561ffff81168114614928575f5ffd5b5f60608284031215614a3f575f5ffd5b614a47614676565b90508135614a54816147e1565b8152614a6260208301614a1e565b6020820152614a7360408301614a1e565b604082015292915050565b6001600160601b0381168114610c37575f5ffd5b5f82601f830112614aa1575f5ffd5b8135614aaf614743826146f0565b8082825260208201915060208360061b860101925085831115614ad0575f5ffd5b602085015b8381101561478f5760408188031215614aec575f5ffd5b614af461469e565b8135614aff81614712565b81526020820135614b0f81614a7e565b6020828101919091529084529290920191604001614ad5565b5f5f5f5f60c08587031215614b3b575f5ffd5b614b458686614a2f565b93506060850135614b5581614a7e565b925060808501356001600160401b03811115614b6f575f5ffd5b614b7b87828801614a92565b92505060a0850135614b8c816147e1565b939692955090935050565b5f5f83601f840112614ba7575f5ffd5b5081356001600160401b03811115614bbd575f5ffd5b602083019150836020828501011115614485575f5ffd5b5f5f5f60408486031215614be6575f5ffd5b83356001600160401b03811115614bfb575f5ffd5b8401601f81018613614c0b575f5ffd5b8035614c19614743826146f0565b8082825260208201915060208360051b850101925088831115614c3a575f5ffd5b602084015b83811015614c7a5780356001600160401b03811115614c5c575f5ffd5b614c6b8b602083890101614726565b84525060209283019201614c3f565b50955050505060208401356001600160401b03811115614c98575f5ffd5b614ca486828701614b97565b9497909650939450505050565b5f5f5f5f5f60a08688031215614cc5575f5ffd5b8535614cd081614712565b94506020860135614ce081614712565b93506040860135614cf081614712565b9250606086013591506080860135614d0781614712565b809150509295509295909350565b5f5b83811015614d2f578181015183820152602001614d17565b50505f910152565b5f8151808452614d4e816020860160208601614d15565b601f01601f19169290920160200192915050565b602081525f610bd16020830184614d37565b634e487b7160e01b5f52602160045260245ffd5b60038110614d9857614d98614d74565b9052565b81518152602080830151604083019161245d90840182614d88565b5f5f60808385031215614dc8575f5ffd5b614dd183614918565b9150614de08460208501614a2f565b90509250929050565b5f5f60408385031215614dfa575f5ffd5b8235614e0581614712565b915060208301356001600160401b03811115614e1f575f5ffd5b614e2b8582860161483b565b9150509250929050565b5f5f5f60a08486031215614e47575f5ffd5b614e518585614a2f565b92506060840135614e6181614a7e565b915060808401356001600160401b03811115614e7b575f5ffd5b6149fd86828701614a92565b60ff60f81b8816815260e060208201525f614ea560e0830189614d37565b8281036040840152614eb78189614d37565b606084018890526001600160a01b038716608085015260a0840186905283810360c0850152845180825260208087019350909101905f5b81811015614f0c578351835260209384019390920191600101614eee565b50909b9a5050505050505050505050565b5f82601f830112614f2c575f5ffd5b8135614f3a614743826146f0565b8082825260208201915060208360061b860101925085831115614f5b575f5ffd5b602085015b8381101561478f5760408188031215614f77575f5ffd5b614f7f61469e565b614f8882614918565b81526020820135614f9881614712565b6020828101919091529084529290920191604001614f60565b5f5f5f5f5f60a08688031215614fc5575f5ffd5b8535614fd081614712565b94506020860135935060408601356001600160401b03811115614ff1575f5ffd5b614ffd88828901614f1d565b9598949750949560608101359550608001359392505050565b5f60408284031215615026575f5ffd5b61502e61469e565b823581526020928301359281019290925250919050565b5f82601f830112615054575f5ffd5b61505c61469e565b80604084018581111561506d575f5ffd5b845b8181101561508757803584526020938401930161506f565b509095945050505050565b5f8183036101008112156150a4575f5ffd5b6150ac614676565b91506150b88484615016565b82526150c78460408501615016565b60208301526080607f19820112156150dd575f5ffd5b506150e661469e565b6150f38460808501615045565b81526151028460c08501615045565b6020820152604082015292915050565b5f60608284031215615122575f5ffd5b61512a614676565b905081356001600160401b03811115615141575f5ffd5b61514d8482850161483b565b8252506020828101359082015260409182013591810191909152919050565b5f5f5f5f5f5f5f6101a0888a031215615183575f5ffd5b87356001600160401b03811115615198575f5ffd5b6151a48a828b01614b97565b90985096505060208801356001600160401b038111156151c2575f5ffd5b6151ce8a828b0161483b565b9550506151de8960408a01615092565b93506101408801356001600160401b038111156151f9575f5ffd5b6152058a828b01614f1d565b9350506101608801356001600160401b03811115615221575f5ffd5b61522d8a828b01615112565b9250506101808801356001600160401b03811115615249575f5ffd5b6152558a828b01615112565b91505092959891949750929550565b5f5f5f5f6101608587031215615278575f5ffd5b84356001600160401b0381111561528d575f5ffd5b6152998782880161483b565b94505060208501356001600160401b038111156152b4575f5ffd5b6152c08782880161483b565b9350506152d08660408701615092565b91506101408501356001600160401b038111156152eb575f5ffd5b6152f787828801615112565b91505092959194509250565b5f5f60408385031215615314575f5ffd5b823561531f816147e1565b915060208301356001600160401b03811115615339575f5ffd5b8301601f81018513615349575f5ffd5b8035615357614743826146f0565b8082825260208201915060208360051b850101925087831115615378575f5ffd5b6020840193505b8284101561539a57833582526020938401939091019061537f565b809450505050509250929050565b602080825282518282018190525f918401906040840190835b8181101561508757835163ffffffff168352602093840193909201916001016153c1565b5f5f5f5f5f608086880312156153f9575f5ffd5b853561540481614712565b9450602086013561541481614712565b935060408601356001600160401b0381111561542e575f5ffd5b61543a88828901614946565b93505060608601356001600160401b03811115615455575f5ffd5b61546188828901614b97565b969995985093965092949392505050565b60608101610de9828463ffffffff815116825261ffff602082015116602083015261ffff60408201511660408301525050565b60208101610de98284614d88565b634e487b7160e01b5f52603260045260245ffd5b80518015158114614928575f5ffd5b5f602082840312156154e6575f5ffd5b610bd1826154c7565b5f602082840312156154ff575f5ffd5b8151610bd181614712565b5f6020828403121561551a575f5ffd5b8151610bd1816147e1565b5f60c0820188835260018060a01b038816602084015286604084015260c0606084015280865180835260e0850191506020880192505f5b81811015615592578351805160ff1684526020908101516001600160a01b0316818501529093019260409092019160010161555c565b50506080840195909552505060a00152949350505050565b60018060a01b0383168152604060208201525f8251606060408401526155d360a0840182614d37565b90506020840151606084015260408401516080840152809150509392505050565b803560028110614928575f5ffd5b5f5f5f6101408486031215615615575f5ffd5b61561e846155f4565b925060208401356001600160401b03811115615638575f5ffd5b6156448682870161483b565b9250506156548560408601615092565b90509250925092565b5f5f5f5f5f6101808688031215615672575f5ffd5b61567b866155f4565b945060208601356001600160401b03811115615695575f5ffd5b6156a18882890161483b565b9450506156b18760408801615092565b92506101408601356001600160401b038111156156cc575f5ffd5b6156d888828901614f1d565b9250506101608601356001600160401b038111156156f4575f5ffd5b61570088828901615112565b9150509295509295909350565b634e487b7160e01b5f52601160045260245ffd5b5f600182016157325761573261570d565b5060010190565b606080825284519082018190525f9060208601906080840190835b8181101561577b5783516001600160a01b0316835260209384019390920191600101615754565b5050838103602080860191909152865180835291810192508601905f5b818110156157b6578251845260209384019390920191600101615798565b50505060ff841660408401529050612157565b5f602082840312156157d9575f5ffd5b81516001600160401b038111156157ee575f5ffd5b8201601f810184136157fe575f5ffd5b805161580c614743826146f0565b8082825260208201915060208360051b85010192508683111561582d575f5ffd5b6020840193505b8284101561174257615845846154c7565b825260209384019390910190615834565b828152604060208201525f610bce6040830184614d37565b6001600160a01b0392831681529116602082015260400190565b6001600160a01b03831681526040602082018190525f90610bce90830184614d37565b634e487b7160e01b5f52601260045260245ffd5b5f826158cd576158cd6158ab565b500690565b60ff8181168382160190811115610de957610de961570d565b5f6040820160018060a01b03851683526040602084015280845180835260608501915060608160051b8601019250602086015f5b828110156159a057868503605f190184528151805163ffffffff168652602090810151604082880181905281519088018190529101905f9060608801905b808310156159885783516001600160a01b03168252602093840193600193909301929091019061595d565b5096505050602093840193919091019060010161591f565b5092979650505050505050565b5f8151808452602084019350602083015f5b828110156159fb57815180516001600160a01b031687526020908101516001600160601b031681880152604090960195909101906001016159bf565b5093949350505050565b60ff841681526001600160601b0383166020820152606060408201525f615a2f60608301846159ad565b95945050505050565b60ff851681526001600160601b038416602082015263ffffffff83166040820152608060608201525f61174260808301846159ad565b615a9d818763ffffffff815116825261ffff602082015116602083015261ffff60408201511660408301525050565b6001600160601b038516606082015260e060808201525f615ac160e08301866159ad565b905060028410615ad357615ad3614d74565b8360a083015263ffffffff831660c08301529695505050505050565b6020808252602b908201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960408201526a6e697469616c697a696e6760a81b606082015260800190565b600181811c90821680615b4e57607f821691505b602082108103615b6c57634e487b7160e01b5f52602260045260245ffd5b50919050565b805f5b6002811015610f48578151845260209384019390910190600101615b75565b6001600160a01b03841681528251805160208084019190915201516040820152610160810160208481015180516060850152908101516080840152506040840151615be360a084018251615b72565b60200151615bf460e0840182615b72565b5082516101208301526020830151610140830152612157565b5f60208284031215615c1d575f5ffd5b5051919050565b80820180821115610de957610de961570d565b60018060a01b0384168152826020820152606060408201525f615a2f6060830184614d37565b5f82601f830112615c6c575f5ffd5b8151615c7a614743826146f0565b8082825260208201915060208360051b860101925085831115615c9b575f5ffd5b602085015b8381101561478f578051615cb381614a7e565b835260209283019201615ca0565b5f5f60408385031215615cd2575f5ffd5b82516001600160401b03811115615ce7575f5ffd5b615cf385828601615c5d565b92505060208301516001600160401b03811115615d0e575f5ffd5b614e2b85828601615c5d565b5f60208284031215615d2a575f5ffd5b81516001600160401b03811115615d3f575f5ffd5b8201601f81018413615d4f575f5ffd5b8051615d5d614743826146f0565b8082825260208201915060208360051b850101925086831115615d7e575f5ffd5b6020840193505b82841015611742578351615d98816147e1565b825260209384019390910190615d85565b81810381811115610de957610de961570d565b5f61ffff821661ffff8103615dd357615dd361570d565b60010192915050565b601f821115610bbb57805f5260205f20601f840160051c81016020851015615e015750805b601f840160051c820191505b81811015610f07575f8155600101615e0d565b81516001600160401b03811115615e3957615e39614662565b615e4d81615e478454615b3a565b84615ddc565b6020601f821160018114615e7f575f8315615e685750848201515b5f19600385901b1c1916600184901b178455610f07565b5f84815260208120601f198516915b82811015615eae5787850151825560209485019460019092019101615e8e565b5084821015615ecb57868401515f19600387901b60f8161c191681555b50505050600190811b01905550565b5f60208284031215615eea575f5ffd5b8151610bd181614a7e565b602080825282516001600160a01b039081168383015283820151166040808401919091528301516060808401528051608084018190525f929190910190829060a08501905b8083101561478f5763ffffffff8451168252602082019150602084019350600183019250615f3a565b6001600160601b03818116838216029081169081811461245d5761245d61570d565b5f6001600160601b03831680615f9d57615f9d6158ab565b806001600160601b0384160491505092915050565b5f8251615fc3818460208701614d15565b919091019291505056fe30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47a2646970667358221220bb7d497e51c60f7a895491c0e5a789768c123616c6628455de3bc960ac56611f64736f6c634300081b0033
6106    /// ```
6107    #[rustfmt::skip]
6108    #[allow(clippy::all)]
6109    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
6110        b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x03FW_5`\xE0\x1C\x80cs;u\x07\x11a\x01\xB9W\x80c\xA9ox>\x11a\0\xF6W\x80c\xE6W\x97\xAD\x11a\0\x9AW\x80c\xE6W\x97\xAD\x14a\x08\xFBW\x80c\xE8\x14\xCA\x9D\x14a\tvW\x80c\xEA2\xAF\xAE\x14a\t\x87W\x80c\xEC\x8C:\x1E\x14a\t\xAEW\x80c\xF2\xFD\xE3\x8B\x14a\t\xB6W\x80c\xF6\x98\xDA%\x14a\t\xC9W\x80c\xFA\xBC\x1C\xBC\x14a\t\xD1W\x80c\xFD9\x10Z\x14a\t\xE4W__\xFD[\x80c\xA9ox>\x14a\x088W\x80c\xB5&W\x87\x14a\x08AW\x80c\xC3\x91B^\x14a\x08TW\x80c\xC6?\xD5\x02\x14a\x08tW\x80c\xCA\r\xE8\x82\x14a\x08\x87W\x80c\xCAO-\x97\x14a\x08\xAEW\x80c\xCA\x8A\xA7\xC7\x14a\x08\xC1W\x80c\xDE\x11d\xBB\x14a\x08\xE8W__\xFD[\x80c\x8D\xA5\xCB[\x11a\x01]W\x80c\x8D\xA5\xCB[\x14a\x07nW\x80c\x9A\xA1e=\x14a\x07\x7FW\x80c\x9B]\x17{\x14a\x07\x9EW\x80c\x9E\x99#\xC2\x14a\x07\xB1W\x80c\x9F\xEA\xB8Y\x14a\x07\xD8W\x80c\xA4\xD7\x87\x1F\x14a\x07\xFFW\x80c\xA5\x08W\xBF\x14a\x08\x12W\x80c\xA6T\x97\xC6\x14a\x08%W__\xFD[\x80cs;u\x07\x14a\x06\xCCW\x80csDy\x92\x14a\x06\xD4W\x80c\x81\xF96\xD2\x14a\x06\xE7W\x80c\x82\x81\xABu\x14a\x06\xF3W\x80c\x84\xB0\x19n\x14a\x07\x06W\x80c\x84\xCAR\x13\x14a\x07!W\x80c\x87\x1E\xF0I\x14a\x074W\x80c\x88o\x11\x95\x14a\x07GW__\xFD[\x80c0<\xA9V\x11a\x02\x87W\x80cY\\jg\x11a\x02+W\x80cY\\jg\x14a\x06\x1DW\x80cZ\xC8j\xB7\x14a\x06%W\x80c[\x0B\x82\x9F\x14a\x06HW\x80c\\\x97Z\xBB\x14a\x06[W\x80c]\xF4YF\x14a\x06cW\x80ch0H5\x14a\x06\x8AW\x80cn;\x17\xDB\x14a\x06\xB1W\x80cqP\x18\xA6\x14a\x06\xC4W__\xFD[\x80c0<\xA9V\x14a\x05BW\x80c9\x98\xFD\xD3\x14a\x05UW\x80c<*\x7FL\x14a\x05|W\x80c>\xEF:Q\x14a\x05\x9CW\x80cQ@\xA5H\x14a\x05\xAFW\x80cS\x0B\x97\xA4\x14a\x05\xC2W\x80cT\xFDMP\x14a\x05\xD5W\x80cXe\xC6\x0C\x14a\x05\xFDW__\xFD[\x80c\x13d9\xDD\x11a\x02\xEEW\x80c\x13d9\xDD\x14a\x04IW\x80c\x14x\x85\x1F\x14a\x04\\W\x80c\x1E\xB8\x12\xDA\x14a\x04\x8EW\x80c$\x9A\x0CB\x14a\x04\xD7W\x80c(\xF6\x1B1\x14a\x04\xF6W\x80c)k\xB0d\x14a\x05\tW\x80c)\xD1\xE0\xC3\x14a\x05\x1CW\x80c,\xDD\x1E\x86\x14a\x05/W__\xFD[\x80b\xCF*\xB5\x14a\x03JW\x80c\x03\xFD4\x92\x14a\x03_W\x80c\x04\xECcQ\x14a\x03\x91W\x80c\x05C\x10\xE6\x14a\x03\xBCW\x80c\x0C\xF4\xB7g\x14a\x03\xDCW\x80c\r?!4\x14a\x03\xEFW\x80c\x12^\x05\x84\x14a\x04\x02W\x80c\x13T*N\x14a\x04!W[__\xFD[a\x03]a\x03X6`\x04aG\x99V[a\n\x1FV[\0[a\x03~a\x03m6`\x04aG\xCAV[_\x90\x81R`4` R`@\x90 T\x90V[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\x03\xA4a\x03\x9F6`\x04aG\xF2V[a\x0B\xC0V[`@Q`\x01`\x01`\xC0\x1B\x03\x90\x91\x16\x81R` \x01a\x03\x88V[`9Ta\x03\xCF\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Qa\x03\x88\x91\x90aH'V[a\x03]a\x03\xEA6`\x04aH\xACV[a\x0B\xD8V[a\x03]a\x03\xFD6`\x04aG\xCAV[a\x0C:V[a\x03~a\x04\x106`\x04aH\xDDV[`;` R_\x90\x81R`@\x90 T\x81V[a\x03~a\x04/6`\x04aH\xDDV[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R`5` R`@\x90 T\x90V[a\x03]a\x04W6`\x04aG\xCAV[a\x0C\x87V[a\x04~a\x04j6`\x04aG\xCAV[`6` R_\x90\x81R`@\x90 T`\xFF\x16\x81V[`@Q\x90\x15\x15\x81R` \x01a\x03\x88V[a\x04\xA1a\x04\x9C6`\x04aH\xF8V[a\raV[`@\x80Q\x82Qc\xFF\xFF\xFF\xFF\x90\x81\x16\x82R` \x80\x85\x01Q\x90\x91\x16\x90\x82\x01R\x91\x81\x01Q`\x01`\x01`\xC0\x1B\x03\x16\x90\x82\x01R``\x01a\x03\x88V[a\x03~a\x04\xE56`\x04aI-V[`7` R_\x90\x81R`@\x90 T\x81V[`:Ta\x03\xCF\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[a\x03\xCFa\x05\x176`\x04aG\xCAV[a\r\xEFV[a\x03]a\x05*6`\x04aH\xDDV[a\x0ExV[a\x03]a\x05=6`\x04aH\xDDV[a\x0E\x89V[a\x03]a\x05P6`\x04aI\xAAV[a\x0E\x9AV[a\x03\xCF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x05\x8Fa\x05\x8A6`\x04aH\xDDV[a\x0F\x0EV[`@Qa\x03\x88\x91\x90aJ\x07V[a\x03]a\x05\xAA6`\x04aK(V[a\x0F2V[a\x03]a\x05\xBD6`\x04aK\xD4V[a\x0FNV[a\x03]a\x05\xD06`\x04aL\xB1V[a\x12uV[`@\x80Q\x80\x82\x01\x82R`\x06\x81Rev0.0.1`\xD0\x1B` \x82\x01R\x90Qa\x03\x88\x91\x90aMbV[a\x06\x10a\x06\x0B6`\x04aH\xDDV[a\x14\x0BV[`@Qa\x03\x88\x91\x90aM\x9CV[a\x03]a\x14}V[a\x04~a\x0636`\x04aI-V[`eT`\x01`\xFF\x90\x92\x16\x91\x90\x91\x1B\x90\x81\x16\x14\x90V[a\x03]a\x06V6`\x04aM\xB7V[a\x151V[`eTa\x03~V[a\x03\xCF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x03\xCF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x03]a\x06\xBF6`\x04aM\xE9V[a\x15MV[a\x03]a\x15yV[a\x03]a\x15\x8AV[a\x03~a\x06\xE26`\x04aH\xDDV[a\x15\xF1V[_Ta\x04~\x90`\xFF\x16\x81V[a\x03]a\x07\x016`\x04aN5V[a\x16UV[a\x07\x0Ea\x16jV[`@Qa\x03\x88\x97\x96\x95\x94\x93\x92\x91\x90aN\x87V[a\x03~a\x07/6`\x04aO\xB1V[a\x17\x03V[a\x03\xA4a\x07B6`\x04aG\xCAV[a\x17LV[a\x03\xCF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`\xC8T`\x01`\x01`\xA0\x1B\x03\x16a\x03\xCFV[`2Ta\x07\x8C\x90`\xFF\x16\x81V[`@Q`\xFF\x90\x91\x16\x81R` \x01a\x03\x88V[a\x03]a\x07\xAC6`\x04aQlV[a\x17VV[a\x03\xCF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x03~\x7F+\xD8!$\x05\x7F\t\x13\xBC;w,\xE7\xB8>\x80W\xC1\xAD\x1F5\x10\xFC\x83w\x8B\xE2\x0F\x10\xEC]\xE6\x81V[a\x04~a\x08\r6`\x04aI-V[a\x19\x19V[a\x03]a\x08 6`\x04aRdV[a\x194V[a\x03]a\x0836`\x04aH\xDDV[a\x1A\x81V[a\x03~`<T\x81V[a\x04~a\x08O6`\x04aH\xDDV[a\x1A\x92V[a\x08ga\x08b6`\x04aS\x03V[a\x1A\xA6V[`@Qa\x03\x88\x91\x90aS\xA8V[a\x03]a\x08\x826`\x04aS\xE5V[a\x1A\xB4V[a\x03~\x7FM@N2v\xE7\xAC!c\xD8\xEEGj\xFAjA\xD1\xF6\x8F\xB7\x1F-\x8BeF\xB2NU\xCE\x01\xB7*\x81V[a\x03]a\x08\xBC6`\x04aH\xACV[a\x1CVV[a\x03\xCF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`=Ta\x03\xCF\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[a\tia\t\t6`\x04aI-V[`@\x80Q``\x80\x82\x01\x83R_\x80\x83R` \x80\x84\x01\x82\x90R\x92\x84\x01\x81\x90R`\xFF\x94\x90\x94\x16\x84R`3\x82R\x92\x82\x90 \x82Q\x93\x84\x01\x83RTc\xFF\xFF\xFF\xFF\x81\x16\x84Ra\xFF\xFF`\x01` \x1B\x82\x04\x81\x16\x92\x85\x01\x92\x90\x92R`\x01`0\x1B\x90\x04\x16\x90\x82\x01R\x90V[`@Qa\x03\x88\x91\x90aTrV[_Ta\x04~\x90a\x01\0\x90\x04`\xFF\x16\x81V[a\x03\xCF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x03~a\x1C\xBAV[a\x03]a\t\xC46`\x04aH\xDDV[a\x1C\xD9V[a\x03~a\x1DOV[a\x03]a\t\xDF6`\x04aG\xCAV[a\x1DXV[a\n\x12a\t\xF26`\x04aH\xDDV[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R`5` R`@\x90 `\x01\x01T`\xFF\x16\x90V[`@Qa\x03\x88\x91\x90aT\xA5V[`eT`\x02\x90`\x04\x90\x81\x16\x03a\nHW`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_[\x82Q\x81\x10\x15a\x0B\xBBW`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x80\x83\x01\x90\x806\x837\x01\x90PP\x90P\x83\x82\x81Q\x81\x10a\n\x86Wa\n\x86aT\xB3V[` \x02` \x01\x01Q\x81_\x81Q\x81\x10a\n\xA0Wa\n\xA0aT\xB3V[`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91\x81` \x01` \x82\x02\x806\x837\x01\x90PP\x90P`5_\x86\x85\x81Q\x81\x10a\n\xF1Wa\n\xF1aT\xB3V[` \x02` \x01\x01Q`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x90\x81R` \x01_ _\x01T\x81_\x81Q\x81\x10a\x0B-Wa\x0B-aT\xB3V[` \x02` \x01\x01\x81\x81RPP_a\x0B\\\x82_\x81Q\x81\x10a\x0BOWa\x0BOaT\xB3V[` \x02` \x01\x01Qa\x1EoV[\x90P_a\x0Bq\x82`\x01`\x01`\xC0\x1B\x03\x16a\x1E{V[\x90P_[\x81Q\x81\x10\x15a\x0B\xAAWa\x0B\xA2\x85\x85\x84\x84\x81Q\x81\x10a\x0B\x95Wa\x0B\x95aT\xB3V[\x01` \x01Q`\xF8\x1Ca\x1FDV[`\x01\x01a\x0BuV[PP`\x01\x90\x93\x01\x92Pa\nJ\x91PPV[PPPV[_a\x0B\xCE`4\x85\x85\x85a {V[\x90P[\x93\x92PPPV[`\x013_\x90\x81R`5` R`@\x90 `\x01\x01T`\xFF\x16`\x02\x81\x11\x15a\x0C\0Wa\x0C\0aMtV[\x14a\x0C\x1EW`@Qc\xAB\xA4s9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3_\x90\x81R`5` R`@\x90 Ta\x0C7\x90\x82a!_V[PV[a\x0CBa\"\nV[`<\x80T\x90\x82\x90U`@\x80Q\x82\x81R` \x81\x01\x84\x90R\x7F\xA7z\x91\xBE\xA7\xB6\xD9Z\x8E\xB5\xA5Hx\xA1\xD9\xE3\xC8u\xE2l\x86\xA9\xB7\x0E4 \xC5\xC5\xDB\x19;b\x91\x01`@Q\x80\x91\x03\x90\xA1PPV[`@Qc#}\xFBG`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90cF\xFB\xF6\x8E\x90a\x0C\xD3\x903\x90`\x04\x01aH'V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0C\xEEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\x12\x91\x90aT\xD6V[a\r/W`@Qc\x1Dw\xD4w`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`eT\x81\x81\x16\x81\x14a\rTW`@Qc\xC6\x1D\xCA]`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\r]\x82a\"dV[PPV[`@\x80Q``\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x91\x90\x91R_\x83\x81R`4` R`@\x90 \x80T\x83\x90\x81\x10a\r\x9CWa\r\x9CaT\xB3V[_\x91\x82R` \x91\x82\x90 `@\x80Q``\x81\x01\x82R\x91\x90\x92\x01Tc\xFF\xFF\xFF\xFF\x80\x82\x16\x83R`\x01` \x1B\x82\x04\x16\x93\x82\x01\x93\x90\x93R`\x01`\x01`\xC0\x1B\x03`\x01`@\x1B\x90\x93\x04\x92\x90\x92\x16\x90\x82\x01R\x90P[\x92\x91PPV[`@Qc\x08\xF6b\x9D`\xE3\x1B\x81R`\x04\x81\x01\x82\x90R_\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x90cG\xB3\x14\xE8\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0ETW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\xE9\x91\x90aT\xEFV[a\x0E\x80a\"\nV[a\x0C7\x81a\"\xA1V[a\x0E\x91a\"\nV[a\x0C7\x81a#\nV[a\x0E\xA2a#sV[`eT`\x01\x90`\x02\x90\x81\x16\x03a\x0E\xCBW`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x0E\xD4\x83a\x1A\x92V[a\x0E\xF1W`@Qcf\xE5e\xDF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x0E\xFB\x83a#\xBCV[\x90Pa\x0F\x07\x85\x82a$dV[PPPPPV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01Ra\r\xE9a\x0F-\x83a\x15\xF1V[a'-V[a\x0F:a\"\nV[a\x0FH\x84\x84\x84`\x01\x85a'\xB7V[PPPPV[`eT`\x02\x90`\x04\x90\x81\x16\x03a\x0FwW`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x0F\xBC\x83\x83\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPP`2T`\xFF\x16\x91Pa,\xE2\x90PV[P\x83Q\x82\x14a\x0F\xDEW`@Qc\xAA\xAD\x13\xF7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_[\x82\x81\x10\x15a\x0F\x07W_\x84\x84\x83\x81\x81\x10a\x0F\xFBWa\x0F\xFBaT\xB3V[\x88Q\x92\x015`\xF8\x1C\x92P_\x91\x88\x91P\x84\x90\x81\x10a\x10\x1AWa\x10\x1AaT\xB3V[` \x90\x81\x02\x91\x90\x91\x01\x01Q`@Qcy\xA0\x84\x91`\xE1\x1B\x81R`\xFF\x84\x16`\x04\x82\x01R\x90\x91P`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xF3A\t\"\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\x8DW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xB1\x91\x90aU\nV[c\xFF\xFF\xFF\xFF\x16\x81Q\x14a\x10\xD7W`@Qc\x8EZ\xEE\xE7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x10\xF1Wa\x10\xF1aFbV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x11\x1AW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[\x83Q\x81\x10\x15a\x12\x10W_\x84\x82\x81Q\x81\x10a\x11<Wa\x11<aT\xB3V[` \x02` \x01\x01Q\x90P`5_\x82`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x90\x81R` \x01_ _\x01T\x84\x83\x81Q\x81\x10a\x11~Wa\x11~aT\xB3V[` \x02` \x01\x01\x81\x81RPP_a\x11\xA0\x85\x84\x81Q\x81\x10a\x0BOWa\x0BOaT\xB3V[\x90P`\x01`\x01`\x01`\xC0\x1B\x03\x82\x16`\xFF\x89\x16\x1C\x81\x16\x14a\x11\xD3W`@Qc\xD0S\xAA!`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x83`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x11a\x12\x05W`@Qc\xBAP\xF9\x11`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P\x91P`\x01\x01a\x11 V[Pa\x12\x1C\x83\x83\x86a\x1FDV[`\xFF\x84\x16_\x81\x81R`7` \x90\x81R`@\x91\x82\x90 C\x90\x81\x90U\x91Q\x91\x82R\x7FF\x07}U3\x07c\xF1bi\xFDu\xE5v\x16c\xF4\x19-'\x91t|\x01\x89\xB1j\xD3\x1D\xB0}\xB4\x91\x01`@Q\x80\x91\x03\x90\xA2PPPP\x80`\x01\x01\x90Pa\x0F\xE0V[`dTa\x01\0\x90\x04`\xFF\x16\x15\x80\x80\x15a\x12\x95WP`dT`\x01`\xFF\x90\x91\x16\x10[\x80a\x12\xAFWP0;\x15\x80\x15a\x12\xAFWP`dT`\xFF\x16`\x01\x14[a\x13\x17W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`.`$\x82\x01R\x7FInitializable: contract is alrea`D\x82\x01Rm\x19\x1EH\x1A[\x9A]\x1AX[\x1A^\x99Y`\x92\x1B`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[`d\x80T`\xFF\x19\x16`\x01\x17\x90U\x80\x15a\x13:W`d\x80Ta\xFF\0\x19\x16a\x01\0\x17\x90U[a\x13\x90`@Q\x80`@\x01`@R\x80`\x16\x81R` \x01u \xAB)\xA92\xB3\xB4\xB9\xBA9<\xA1\xB7\xB7\xB924\xB70\xBA7\xB9`Q\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01ev0.0.1`\xD0\x1B\x81RPa-\x16V[a\x13\x99\x86a-GV[a\x13\xA2\x85a\"\xA1V[a\x13\xAB\x83a\"dV[a\x13\xB4\x84a#\nV[a\x13\xBD\x82a-\x98V[\x80\x15a\x14\x03W`d\x80Ta\xFF\0\x19\x16\x90U`@Q`\x01\x81R\x7F\x7F&\xB8?\xF9n\x1F+jh/\x138R\xF6y\x8A\t\xC4e\xDA\x95\x92\x14`\xCE\xFB8G@$\x98\x90` \x01`@Q\x80\x91\x03\x90\xA1[PPPPPPV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`5` \x90\x81R`@\x91\x82\x90 \x82Q\x80\x84\x01\x90\x93R\x80T\x83R`\x01\x81\x01T\x90\x91\x83\x01\x90`\xFF\x16`\x02\x81\x11\x15a\x14cWa\x14caMtV[`\x02\x81\x11\x15a\x14tWa\x14taMtV[\x90RP\x92\x91PPV[`@Qc#}\xFBG`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90cF\xFB\xF6\x8E\x90a\x14\xC9\x903\x90`\x04\x01aH'V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x14\xE4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15\x08\x91\x90aT\xD6V[a\x15%W`@Qc\x1Dw\xD4w`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x15/_\x19a\"dV[V[a\x159a\"\nV[\x81a\x15C\x81a.\x04V[a\x0B\xBB\x83\x83a.-V[a\x15Ua.\xBEV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`;` R`@\x90 B\x90Ua\r]\x82\x82a.\xE9V[a\x15\x81a\"\nV[a\x15/_a-GV[a\x15\x92a\"\nV[_Ta\x01\0\x90\x04`\xFF\x16\x15a\x15\xBAW`@Qc!\xFA\x91\xF3`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80Ta\xFF\0\x19\x16a\x01\0\x17\x81U`@Q\x7F\x0F\xC3\xC0\xE6\xF8\xB4y_7\x1E\x19\xDE\x7FLW3\xDD\x9ET\x9F\xA8\xC3\x9EXB\xEBf\xC3\x15r\xD9\x9E\x91\x90\xA1V[_a\r\xE9\x7F+\xD8!$\x05\x7F\t\x13\xBC;w,\xE7\xB8>\x80W\xC1\xAD\x1F5\x10\xFC\x83w\x8B\xE2\x0F\x10\xEC]\xE6\x83`@Q` \x01a\x16:\x92\x91\x90\x91\x82R`\x01`\x01`\xA0\x1B\x03\x16` \x82\x01R`@\x01\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 a0\x02V[a\x16]a\"\nV[a\x0B\xBB\x83\x83\x83__a'\xB7V[_``\x80___```\xFAT__\x1B\x14\x80\x15a\x16\x86WP`\xFBT\x15[a\x16\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x15`$\x82\x01Rt\x11RT\r\xCCL\x8E\x88\x15[\x9A[\x9A]\x1AX[\x1A^\x99Y`Z\x1B`D\x82\x01R`d\x01a\x13\x0EV[a\x16\xD2a0.V[a\x16\xDAa0\xBEV[`@\x80Q_\x80\x82R` \x82\x01\x90\x92R`\x0F`\xF8\x1B\x9B\x93\x9AP\x91\x98PF\x97P0\x96P\x94P\x92P\x90PV[_a\x17B\x7FM@N2v\xE7\xAC!c\xD8\xEEGj\xFAjA\xD1\xF6\x8F\xB7\x1F-\x8BeF\xB2NU\xCE\x01\xB7*\x87\x87\x87\x87\x87`@Q` \x01a\x16:\x96\x95\x94\x93\x92\x91\x90aU%V[\x96\x95PPPPPPV[_a\r\xE9\x82a\x1EoV[`eT_\x90`\x01\x90\x81\x16\x03a\x17~W`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_Ta\x01\0\x90\x04`\xFF\x16\x15a\x17\xA6W`@Qc!\xFA\x91\xF3`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x17\xF6a\x17\xB1a\x1C\xBAV[a\x17\xEF\x8A\x8A\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPa0\xCD\x92PPPV[\x90\x81\x16\x14\x90V[a\x18\x13W`@Qc\xAF\xAAp\xEF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_`\x013_\x90\x81R`5` R`@\x90 `\x01\x01T`\xFF\x16`\x02\x81\x11\x15a\x18<Wa\x18<aMtV[\x14\x90Pa\x18\x8D3a\x18M3\x89a1\x88V[\x8B\x8B\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RP\x8D\x92P\x8B\x91P\x8A\x90Pa2!V[\x80a\x19\x0EW`@Qc\x99&\xEE}`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\x99&\xEE}\x90a\x18\xE0\x903\x90\x87\x90`\x04\x01aU\xAAV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x18\xF7W__\xFD[PZ\xF1\x15\x80\x15a\x19\tW=__>=_\xFD[PPPP[PPPPPPPPPV[_a\r\xE9\x82a\x19&a\x1C\xBAV[\x90`\xFF\x16\x1C`\x01\x90\x81\x16\x14\x90V[`eT_\x90`\x01\x90\x81\x16\x03a\x19\\W`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_Ta\x01\0\x90\x04`\xFF\x16\x15a\x19\x84W`@Qc!\xFA\x91\xF3`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x19\x98a\x19\x8Fa\x1C\xBAV[a\x17\xEF\x87a0\xCDV[a\x19\xB5W`@Qc\xAF\xAAp\xEF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_`\x013_\x90\x81R`5` R`@\x90 `\x01\x01T`\xFF\x16`\x02\x81\x11\x15a\x19\xDEWa\x19\xDEaMtV[\x14\x90Pa\x19\xF83a\x19\xEF3\x87a1\x88V[\x88\x88`\x01a4\x16V[P\x80a\x14\x03W`@Qc\x99&\xEE}`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\x99&\xEE}\x90a\x1AL\x903\x90\x87\x90`\x04\x01aU\xAAV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1AcW__\xFD[PZ\xF1\x15\x80\x15a\x1AuW=__>=_\xFD[PPPPPPPPPPV[a\x1A\x89a\"\nV[a\x0C7\x81a-\x98V[`=T`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x91\x16\x14\x90V[``a\x0B\xD1`4\x84\x84a8_V[a\x1A\xBCa#sV[`eT_\x90`\x01\x90\x81\x16\x03a\x1A\xE4W`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1A\xED\x85a\x1A\x92V[a\x1B\nW`@Qcf\xE5e\xDF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x1B\x14\x85a#\xBCV[\x90P_\x80\x80a\x1B%\x86\x88\x01\x88aV\x02V[\x92P\x92P\x92P_a\x1B6\x8B\x83a1\x88V[\x90P_\x84`\x01\x81\x11\x15a\x1BKWa\x1BKaMtV[\x03a\x1B\xF4W_a\x1B_\x8C\x83\x88\x87`\x01a4\x16V[Q\x90P_[\x86Q\x81\x10\x15a\x1B\xEDW_\x87\x82\x81Q\x81\x10a\x1B\x80Wa\x1B\x80aT\xB3V[\x01` \x90\x81\x01Q`\xF8\x1C_\x81\x81R`3\x90\x92R`@\x90\x91 T\x84Q\x91\x92Pc\xFF\xFF\xFF\xFF\x16\x90\x84\x90\x84\x90\x81\x10a\x1B\xB7Wa\x1B\xB7aT\xB3V[` \x02` \x01\x01Qc\xFF\xFF\xFF\xFF\x16\x11\x15a\x1B\xE4W`@Qc\xC6\xB9\xE7g`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P`\x01\x01a\x1BdV[PPa\x1CIV[`\x01\x84`\x01\x81\x11\x15a\x1C\x08Wa\x1C\x08aMtV[\x03a\x1C0W_\x80a\x1C\x1B\x89\x8B\x01\x8BaV]V[\x94P\x94PPPPa\x1B\xED\x8D\x84\x89\x88\x86\x86a2!V[`@Qc5K\xB8\xAB`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPPPPPPPPPV[`eT`\x01\x90`\x02\x90\x81\x16\x03a\x1C\x7FW`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1C\x93a\x1C\x8Aa\x1C\xBAV[a\x17\xEF\x84a0\xCDV[a\x1C\xB0W`@Qc\xAF\xAAp\xEF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\r]3\x83a$dV[_\x80T`\xFF\x16\x15a\x1C\xCCWP`\x01T\x90V[a\x1C\xD4a9\x0EV[\x90P\x90V[a\x1C\xE1a\"\nV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x1DFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01Reddress`\xD0\x1B`d\x82\x01R`\x84\x01a\x13\x0EV[a\x0C7\x81a-GV[_a\x1C\xD4a9%V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xEA\xB6mz`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1D\xB4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1D\xD8\x91\x90aT\xEFV[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\x1E\tW`@QcyH!\xFF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`eT\x80\x19\x82\x19\x81\x16\x14a\x1E0W`@Qc\xC6\x1D\xCA]`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`e\x82\x90U`@Q\x82\x81R3\x90\x7F5\x82\xD1\x82\x8E&\xBFV\xBD\x80\x15\x02\xBC\x02\x1A\xC0\xBC\x8A\xFBW\xC8&\xE4\x98kEY<\x8F\xAD8\x9C\x90` \x01[`@Q\x80\x91\x03\x90\xA2PPV[_a\r\xE9`4\x83a9.V[``__a\x1E\x88\x84a9\x98V[a\xFF\xFF\x16`\x01`\x01`@\x1B\x03\x81\x11\x15a\x1E\xA3Wa\x1E\xA3aFbV[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x1E\xCDW` \x82\x01\x81\x806\x837\x01\x90P[P\x90P_\x80[\x82Q\x82\x10\x80\x15a\x1E\xE4WPa\x01\0\x81\x10[\x15a\x1F:W`\x01\x81\x1B\x93P\x85\x84\x16\x15a\x1F*W\x80`\xF8\x1B\x83\x83\x81Q\x81\x10a\x1F\rWa\x1F\raT\xB3V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SP\x81`\x01\x01\x91P[a\x1F3\x81aW!V[\x90Pa\x1E\xD3V[P\x90\x94\x93PPPPV[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x82\x01\x81\x806\x837\x01\x90PP\x90P\x81`\xF8\x1B\x81_\x81Q\x81\x10a\x1FzWa\x1FzaT\xB3V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SP`@Qcl?\xB4\xBF`\xE0\x1B\x81R_\x90`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90cl?\xB4\xBF\x90a\x1F\xE2\x90\x88\x90\x88\x90\x88\x90`\x04\x01aW9V[_`@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x1F\xFDW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra $\x91\x90\x81\x01\x90aW\xC9V[\x90P_[\x85Q\x81\x10\x15a\x14\x03W\x81\x81\x81Q\x81\x10a CWa CaT\xB3V[` \x02` \x01\x01Q\x15a sWa s\x86\x82\x81Q\x81\x10a eWa eaT\xB3V[` \x02` \x01\x01Q\x84a.\xE9V[`\x01\x01a (V[_\x83\x81R` \x85\x90R`@\x81 \x80T\x82\x91\x90\x84\x90\x81\x10a \x9DWa \x9DaT\xB3V[_\x91\x82R` \x91\x82\x90 `@\x80Q``\x81\x01\x82R\x92\x90\x91\x01Tc\xFF\xFF\xFF\xFF\x80\x82\x16\x80\x85R`\x01` \x1B\x83\x04\x82\x16\x95\x85\x01\x95\x90\x95R`\x01`@\x1B\x90\x91\x04`\x01`\x01`\xC0\x1B\x03\x16\x91\x83\x01\x91\x90\x91R\x90\x92P\x85\x16\x10\x15a!\rW`@Qcl\xB1\x9A\xFF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[` \x81\x01Qc\xFF\xFF\xFF\xFF\x16\x15\x80a!3WP\x80` \x01Qc\xFF\xFF\xFF\xFF\x16\x84c\xFF\xFF\xFF\xFF\x16\x10[a!PW`@Qc\xBB\xBA`\xCB`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x01Q\x90P[\x94\x93PPPPV[`@Qcx!\x9B?`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xF0C6~\x90a!\xAD\x90\x85\x90\x85\x90`\x04\x01aXVV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a!\xC4W__\xFD[PZ\xF1\x15\x80\x15a!\xD6W=__>=_\xFD[PPPP\x81\x7F\xEC)c\xAB!\xC1\xE5\x0E\x1EX*\xA5B\xAF.K\xF7\xBF8\xE6\xE1@<'\xB4.\x1C]nb\x1E\xAA\x82`@Qa\x1Ec\x91\x90aMbV[`\xC8T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x15/W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x13\x0EV[`e\x81\x90U`@Q\x81\x81R3\x90\x7F\xAB@\xA3t\xBCQ\xDE7\"\0\xA8\xBC\x98\x1A\xF8\xC9\xEC\xDC\x08\xDF\xDA\xEF\x0B\xB6\xE0\x9F\x88\xF3\xC6\x16\xEF=\x90` \x01`@Q\x80\x91\x03\x90\xA2PV[`9T`@Q\x7F1TW\xD8\xA8\xFE`\xF0J\xF1|\x16\xE2\xF5\xA5\xE1\xDBa+1d\x8EX\x03\x03`u\x9E\xF8\xF3R\x8C\x91a\"\xE0\x91`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90\x84\x90aXnV[`@Q\x80\x91\x03\x90\xA1`9\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[`:T`@Q\x7F\x8F0\xAB\t\xF4:l\x15}\x7F\xCE~\n\x13\xC0\x03\x04,\x1C\x95\xE8\xA7.z\x14j!\xC0\xCA\xA2M\xC9\x91a#I\x91`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90\x84\x90aXnV[`@Q\x80\x91\x03\x90\xA1`:\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[3`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x15/W`@Qc#\xD8q\xA5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[``_\x82Q`\x01`\x01`@\x1B\x03\x81\x11\x15a#\xD8Wa#\xD8aFbV[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a$\x02W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P_[\x83Q\x81\x10\x15a$]W\x83\x81\x81Q\x81\x10a$\"Wa$\"aT\xB3V[` \x02` \x01\x01Q`\xF8\x1B\x82\x82\x81Q\x81\x10a$?Wa$?aT\xB3V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SP`\x01\x01a$\x07V[P\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`5` R`@\x81 \x80T\x90\x91a$\x88\x82a\x1EoV[\x90P`\x01\x80\x84\x01T`\xFF\x16`\x02\x81\x11\x15a$\xA4Wa$\xA4aMtV[\x14a$\xC2W`@Qc\xAB\xA4s9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`2T_\x90a$\xD5\x90\x86\x90`\xFF\x16a,\xE2V[\x90P`\x01`\x01`\xC0\x1B\x03\x81\x16a$\xFEW`@Qch\xB6\xA8u`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a%\x15`\x01`\x01`\xC0\x1B\x03\x82\x81\x16\x90\x84\x16\x81\x16\x14\x90V[a%2W`@Qc\xD0S\xAA!`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xC0\x1B\x03\x81\x81\x16\x19\x83\x16\x16a%K\x84\x82a9\xC2V[`\x01`\x01`\xC0\x1B\x03\x81\x16a%\xA7W`\x01`\x01`\xA0\x1B\x03\x87\x16_\x81\x81R`5` R`@\x80\x82 `\x01\x01\x80T`\xFF\x19\x16`\x02\x17\x90UQ\x86\x92\x91\x7F9o\xDC\xB1\x80\xCB\x0F\xEA&\x92\x81\x13\xFB\x0F\xD1\xC3T\x98c\xF9\xCDV>j\x18O\x1DW\x81\x16\xC8\xE4\x91\xA3[`@Qc\xF4\xE2O\xE5`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xF4\xE2O\xE5\x90a%\xF5\x90\x8A\x90\x8A\x90`\x04\x01aX\x88V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a&\x0CW__\xFD[PZ\xF1\x15\x80\x15a&\x1EW=__>=_\xFD[PP`@Qc\xBD)\xB8\xCD`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x92Pc\xBD)\xB8\xCD\x91Pa&p\x90\x87\x90\x8A\x90`\x04\x01aXVV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a&\x87W__\xFD[PZ\xF1\x15\x80\x15a&\x99W=__>=_\xFD[PP`@Qc\xBD)\xB8\xCD`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x92Pc\xBD)\xB8\xCD\x91Pa&\xEB\x90\x87\x90\x8A\x90`\x04\x01aXVV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a'\x02W__\xFD[PZ\xF1\x15\x80\x15a'\x14W=__>=_\xFD[PPPPa'$\x87\x85\x88\x84a9\xCEV[PPPPPPPV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R_\x80\x80a'Z_Q` a_\xCE_9_Q\x90_R\x86aX\xBFV[\x90P[a'f\x81a:tV[\x90\x93P\x91P_Q` a_\xCE_9_Q\x90_R\x82\x83\t\x83\x03a'\x9EW`@\x80Q\x80\x82\x01\x90\x91R\x90\x81R` \x81\x01\x91\x90\x91R\x93\x92PPPV[_Q` a_\xCE_9_Q\x90_R`\x01\x82\x08\x90Pa']V[`2T`\xFF\x16a'\xC6\x81a:\xF0V[`\xC0`\xFF\x82\x16\x10a'\xEAW`@Qc<\xB8\x9C\x97`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`2\x80T`\x01\x91\x90_\x90a(\x02\x90\x84\x90`\xFF\x16aX\xD2V[\x92Pa\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\xFF\x16\x02\x17\x90UPa($\x81\x87a.-V[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91\x81` \x01[`@\x80Q\x80\x82\x01\x90\x91R_\x81R``` \x82\x01R\x81R` \x01\x90`\x01\x90\x03\x90\x81a(:W\x90PP\x90P_\x85Q`\x01`\x01`@\x1B\x03\x81\x11\x15a(}Wa(}aFbV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a(\xA6W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x86Q\x81\x10\x15a)\x03W\x86\x81\x81Q\x81\x10a(\xC6Wa(\xC6aT\xB3V[` \x02` \x01\x01Q_\x01Q\x82\x82\x81Q\x81\x10a(\xE3Wa(\xE3aT\xB3V[`\x01`\x01`\xA0\x1B\x03\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`\x01\x01a(\xABV[P`@Q\x80`@\x01`@R\x80\x84`\xFF\x16c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81RP\x82_\x81Q\x81\x10a)4Wa)4aT\xB3V[` \x90\x81\x02\x91\x90\x91\x01\x01R`=T`@Qc\x010\xFC'`\xE5\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16\x92c&\x1F\x84\xE0\x92a)\x94\x92\x91\x90\x91\x16\x90\x86\x90`\x04\x01aX\xEBV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a)\xABW__\xFD[PZ\xF1\x15\x80\x15a)\xBDW=__>=_\xFD[P_\x92Pa)\xC9\x91PPV[\x85`\x01\x81\x11\x15a)\xDBWa)\xDBaMtV[\x03a*bW`@Qc:\xEA\x0B\x9D`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90cu\xD4\x17:\x90a*0\x90\x86\x90\x8B\x90\x8B\x90`\x04\x01aZ\x05V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a*GW__\xFD[PZ\xF1\x15\x80\x15a*YW=__>=_\xFD[PPPPa+\xA6V[`\x01\x85`\x01\x81\x11\x15a*vWa*vaMtV[\x03a+\xA6W\x83c\xFF\xFF\xFF\xFF\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c)\x81\xEBw`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a*\xDEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a+\x02\x91\x90aU\nV[c\xFF\xFF\xFF\xFF\x16\x11a+&W`@Qc\x0B\xD4A\xB9`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Qc\x06b\xD3\xE1`\xE5\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xCCZ| \x90a+x\x90\x86\x90\x8B\x90\x89\x90\x8C\x90`\x04\x01aZ8V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a+\x8FW__\xFD[PZ\xF1\x15\x80\x15a+\xA1W=__>=_\xFD[PPPP[`@Qc\x13l\xA0\xF9`\xE1\x1B\x81R`\xFF\x84\x16`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x90c&\xD9A\xF2\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a,\x07W__\xFD[PZ\xF1\x15\x80\x15a,\x19W=__>=_\xFD[PP`@Qc\x13l\xA0\xF9`\xE1\x1B\x81R`\xFF\x86\x16`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x92Pc&\xD9A\xF2\x91P`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a,~W__\xFD[PZ\xF1\x15\x80\x15a,\x90W=__>=_\xFD[PPPP\x82`\xFF\x16\x7F\xA3H5\xBC+g>\xC3\x7F\xCF\x15\x91\xA9\x12\x95\xB1c\xFC.\x18\x1EN\xA4\xE73\xBE\xB2}\xE1\xCE\xACL\x89\x89\x89\x89\x89`@Qa,\xCF\x95\x94\x93\x92\x91\x90aZnV[`@Q\x80\x91\x03\x90\xA2[PPPPPPPPV[__a,\xED\x84a0\xCDV[\x90P\x80\x83`\xFF\x16`\x01\x90\x1B\x11a\x0B\xD1W`@Qc\xCA\x95s3`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`dTa\x01\0\x90\x04`\xFF\x16a-=W`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x13\x0E\x90aZ\xEFV[a\r]\x82\x82a;\x01V[`\xC8\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x01`\x01`\xA0\x1B\x03\x19\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[`=T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90\x7F\x97p\xF3\xCA\xDF\xDC\xBBo\x93\xAF\x93^\x86\x04q\x11Y\x0C7h'\x1D#~J+\xC0\xB8t\xBE\xD6\x93\x90a-\xD9\x90\x83\x90\x85\x90aXnV[`@Q\x80\x91\x03\x90\xA1P`=\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[`2T`\xFF\x90\x81\x16\x90\x82\x16\x10a\x0C7W`@Qcs\x10\xCF\xF5`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\xFF\x82\x16_\x81\x81R`3` \x90\x81R`@\x91\x82\x90 \x84Q\x81T\x92\x86\x01Q\x84\x87\x01Qa\xFF\xFF\x90\x81\x16`\x01`0\x1B\x02g\xFF\xFF\0\0\0\0\0\0\x19\x91\x90\x92\x16`\x01` \x1B\x02e\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x95\x16c\xFF\xFF\xFF\xFF\x90\x93\x16\x92\x90\x92\x17\x93\x90\x93\x17\x16\x91\x90\x91\x17\x90UQ\x7F>\xE6\xFE\x8DTa\x02D\xC3\xE9\xD3\xC0f\xAEJ\xEE\x99x\x84\xAA(\xF1\x06\x16\xAE\x82\x19%@\x13\x18\xAC\x90a\x1Ec\x90\x84\x90aTrV[`:T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x15/W`@Qcv\xD8\xAB\x17`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`5` R`@\x81 `2T\x90\x91\x90a/\x14\x90\x84\x90`\xFF\x16a,\xE2V[\x90P`\x01\x80\x83\x01T`\xFF\x16`\x02\x81\x11\x15a/0Wa/0aMtV[\x14\x80\x15a/EWP`\x01`\x01`\xC0\x1B\x03\x81\x16\x15\x15[\x15a\x0FHW`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x82\x01\x81\x806\x837\x01\x90PP\x90P_[\x84Q\x81\x10\x15a\x14\x03W\x84\x81\x81Q\x81\x10a/\x87Wa/\x87aT\xB3V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x82_\x81Q\x81\x10a/\xA4Wa/\xA4aT\xB3V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SPa/\xDC\x85\x82\x81Q\x81\x10a/\xCFWa/\xCFaT\xB3V[\x01` \x01Q`\xF8\x1Ca\x19\x19V[\x15a/\xF0Wa/\xEB\x86\x83a$dV[a/\xFAV[a/\xFA\x86\x83a;OV[`\x01\x01a/lV[_a\r\xE9a0\x0Ea9%V[\x83`@Qa\x19\x01`\xF0\x1B\x81R`\x02\x81\x01\x92\x90\x92R`\"\x82\x01R`B\x90 \x90V[```\xFC\x80Ta0=\x90a[:V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta0i\x90a[:V[\x80\x15a0\xB4W\x80`\x1F\x10a0\x8BWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a0\xB4V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a0\x97W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[```\xFD\x80Ta0=\x90a[:V[_a\x01\0\x82Q\x11\x15a0\xF2W`@Qc}\xA5NG`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x81Q_\x03a1\x01WP_\x91\x90PV[__\x83_\x81Q\x81\x10a1\x15Wa1\x15aT\xB3V[\x01` \x01Q`\x01`\xF8\x91\x90\x91\x1C\x81\x90\x1B\x92P[\x84Q\x81\x10\x15a1\x7FW\x84\x81\x81Q\x81\x10a1CWa1CaT\xB3V[\x01` \x01Q`\x01`\xF8\x91\x90\x91\x1C\x1B\x91P\x82\x82\x11a1sW`@Qc\x10\x19\x10i`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x91\x81\x17\x91`\x01\x01a1(V[P\x90\x93\x92PPPV[_\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\x03\xC5\xA6\xB6\x84\x84a1\xC3\x87a\x0F\x0EV[`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a1\xE1\x93\x92\x91\x90a[\x94V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a1\xFDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xD1\x91\x90a\\\rV[\x83Q\x82Q\x14a2CW`@Qc\xAA\xAD\x13\xF7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a2O\x86\x86\x84\x84a;\x84V[_a2]\x87\x87\x87\x87_a4\x16V[\x90P_[\x85Q\x81\x10\x15a,\xD8W_`3_\x88\x84\x81Q\x81\x10a2\x80Wa2\x80aT\xB3V[\x01` \x90\x81\x01Q`\xF8\x1C\x82R\x81\x81\x01\x92\x90\x92R`@\x90\x81\x01_ \x81Q``\x81\x01\x83R\x90Tc\xFF\xFF\xFF\xFF\x81\x16\x80\x83Ra\xFF\xFF`\x01` \x1B\x83\x04\x81\x16\x95\x84\x01\x95\x90\x95R`\x01`0\x1B\x90\x91\x04\x90\x93\x16\x91\x81\x01\x91\x90\x91R\x84Q\x80Q\x91\x93P\x90\x84\x90\x81\x10a2\xEBWa2\xEBaT\xB3V[` \x02` \x01\x01Qc\xFF\xFF\xFF\xFF\x16\x11\x15a4\rWa3\x7F\x87\x83\x81Q\x81\x10a3\x14Wa3\x14aT\xB3V[` \x01\x01Q`\xF8\x1C`\xF8\x1B`\xF8\x1C\x84`@\x01Q\x84\x81Q\x81\x10a38Wa38aT\xB3V[` \x02` \x01\x01Q\x8B\x86` \x01Q\x86\x81Q\x81\x10a3WWa3WaT\xB3V[` \x02` \x01\x01Q\x89\x87\x81Q\x81\x10a3qWa3qaT\xB3V[` \x02` \x01\x01Q\x86a</V[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x82\x01\x81\x806\x837\x01\x90PP\x90P\x87\x83\x81Q\x81\x10a3\xB1Wa3\xB1aT\xB3V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x81_\x81Q\x81\x10a3\xCEWa3\xCEaT\xB3V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SPa4\x0B\x86\x84\x81Q\x81\x10a3\xF9Wa3\xF9aT\xB3V[` \x02` \x01\x01Q` \x01Q\x82a.\xE9V[P[P`\x01\x01a2aV[a4:`@Q\x80``\x01`@R\x80``\x81R` \x01``\x81R` \x01``\x81RP\x90V[`2T_\x90a4M\x90\x86\x90`\xFF\x16a,\xE2V[\x90P_a4Y\x87a\x1EoV[\x90P`\x01`\x01`\xC0\x1B\x03\x82\x16a4\x82W`@Qc\x13\xCAFW`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80\x82\x16`\x01`\x01`\xC0\x1B\x03\x16\x15a4\xACW`@Qc\x0Ch\x16\xCD`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`<T`\x01`\x01`\xA0\x1B\x03\x89\x16_\x90\x81R`;` R`@\x90 T`\x01`\x01`\xC0\x1B\x03\x83\x81\x16\x90\x85\x16\x17\x91B\x91a4\xE3\x91\x90a\\$V[\x10a5\x01W`@Qc\x19hg}`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a5\x0B\x88\x82a9\xC2V[a5\x15\x88\x87a!_V[`\x01`\x01`\x01`\xA0\x1B\x03\x8A\x16_\x90\x81R`5` R`@\x90 `\x01\x01T`\xFF\x16`\x02\x81\x11\x15a5FWa5FaMtV[\x14a5\xDDW`@\x80Q\x80\x82\x01\x82R\x89\x81R`\x01` \x80\x83\x01\x82\x81R`\x01`\x01`\xA0\x1B\x03\x8E\x16_\x90\x81R`5\x90\x92R\x93\x90 \x82Q\x81U\x92Q\x83\x82\x01\x80T\x93\x94\x93\x91\x92\x90\x91`\xFF\x19\x16\x90\x83`\x02\x81\x11\x15a5\xA0Wa5\xA0aMtV[\x02\x17\x90UPP`@Q\x89\x91P`\x01`\x01`\xA0\x1B\x03\x8B\x16\x90\x7F\xE8\xE6\x8C\xEF\x1C:v\x1E\xD7\xBE~\x84c\xA3u\xF2\x7F{\xC35\xE5\x18$\"<\xAC\xCEcn\xC5\xC3\xFE\x90_\x90\xA3[`@Qc\x1F\xD9<\xA9`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c?\xB2yR\x90a6+\x90\x8C\x90\x8B\x90`\x04\x01aX\x88V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a6BW__\xFD[PZ\xF1\x15\x80\x15a6TW=__>=_\xFD[PP`@Qc%PGw`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x92Pc%PGw\x91Pa6\xA8\x90\x8C\x90\x8C\x90\x8C\x90`\x04\x01a\\7V[_`@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a6\xC3W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra6\xEA\x91\x90\x81\x01\x90a\\\xC1V[`@\x80\x87\x01\x91\x90\x91R` \x86\x01\x91\x90\x91RQb\xBF\xF0M`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90b\xBF\xF0M\x90a7E\x90\x8B\x90\x8B\x90`\x04\x01aXVV[_`@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a7`W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra7\x87\x91\x90\x81\x01\x90a]\x1AV[\x84R\x84\x15a8SW_[\x87Q\x81\x10\x15a8QW_`3_\x8A\x84\x81Q\x81\x10a7\xB0Wa7\xB0aT\xB3V[\x01` \x90\x81\x01Q`\xF8\x1C\x82R\x81\x81\x01\x92\x90\x92R`@\x90\x81\x01_ \x81Q``\x81\x01\x83R\x90Tc\xFF\xFF\xFF\xFF\x81\x16\x80\x83Ra\xFF\xFF`\x01` \x1B\x83\x04\x81\x16\x95\x84\x01\x95\x90\x95R`\x01`0\x1B\x90\x91\x04\x90\x93\x16\x91\x81\x01\x91\x90\x91R\x87Q\x80Q\x91\x93P\x90\x84\x90\x81\x10a8\x1BWa8\x1BaT\xB3V[` \x02` \x01\x01Qc\xFF\xFF\xFF\xFF\x16\x11\x15a8HW`@Qc\xC6\xB9\xE7g`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P`\x01\x01a7\x91V[P[PPP\x95\x94PPPPPV[``_\x82Q`\x01`\x01`@\x1B\x03\x81\x11\x15a8{Wa8{aFbV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a8\xA4W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x83Q\x81\x10\x15a9\x05Wa8\xD6\x86\x86\x86\x84\x81Q\x81\x10a8\xC9Wa8\xC9aT\xB3V[` \x02` \x01\x01Qa=\xA5V[\x82\x82\x81Q\x81\x10a8\xE8Wa8\xE8aT\xB3V[c\xFF\xFF\xFF\xFF\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`\x01\x01a8\xA9V[P\x94\x93PPPPV[`2T_\x90a\x1C\xD4\x90`\x01\x90`\xFF\x16\x81\x90\x1Ba]\xA9V[_a\x1C\xD4a>\xBDV[_\x81\x81R` \x83\x90R`@\x81 T\x80\x82\x03a9LW_\x91PPa\r\xE9V[_\x83\x81R` \x85\x90R`@\x90 a9d`\x01\x83a]\xA9V[\x81T\x81\x10a9tWa9taT\xB3V[_\x91\x82R` \x90\x91 \x01T`\x01`@\x1B\x90\x04`\x01`\x01`\xC0\x1B\x03\x16\x91Pa\r\xE9\x90PV[_\x80[\x82\x15a\r\xE9Wa9\xAC`\x01\x84a]\xA9V[\x90\x92\x16\x91\x80a9\xBA\x81a]\xBCV[\x91PPa9\x9BV[a\r]`4\x83\x83a?0V[_a9\xD7a9\x0EV[\x90P_a9\xEBa9\xE5a\x1C\xBAV[\x19\x83\x16\x90V[\x90P`\x01`\x01`\xC0\x1B\x03\x81\x19\x84\x16\x16\x80a'$W`@QcQ\xB2zm`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xA3d\xF4\xDA\x90a:K\x90\x8A\x90`\x04\x01aH'V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a:bW__\xFD[PZ\xF1\x15\x80\x15a\x1CIW=__>=_\xFD[_\x80\x80_Q` a_\xCE_9_Q\x90_R`\x03_Q` a_\xCE_9_Q\x90_R\x86_Q` a_\xCE_9_Q\x90_R\x88\x89\t\t\x08\x90P_a:\xE4\x82\x7F\x0C\x19\x13\x9C\xB8Lh\nn\x14\x11m\xA0`V\x17e\xE0Z\xA4Z\x1Cr\xA3O\x08#\x05\xB6\x1F?R_Q` a_\xCE_9_Q\x90_Ra@\xE9V[\x91\x95\x91\x94P\x90\x92PPPV[_T`\xFF\x16a\x0C7Wa\x0C7aAbV[`dTa\x01\0\x90\x04`\xFF\x16a;(W`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x13\x0E\x90aZ\xEFV[`\xFCa;4\x83\x82a^ V[P`\xFDa;A\x82\x82a^ V[PP_`\xFA\x81\x90U`\xFBUPV[_a;ja;[a\x1C\xBAV[a;d\x84a0\xCDV[\x90\x19\x16\x90V[\x90P\x80\x15a\x0B\xBBWa\x0B\xBB\x83a;\x7F\x83a\x1E{V[aA\xC7V[` \x80\x82\x01Q_\x90\x81R`6\x90\x91R`@\x90 T`\xFF\x16\x15a;\xB9W`@Qco\xBE\xFE\xC3`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[B\x81`@\x01Q\x10\x15a;\xDEW`@Qc\x08\x19\xBD\xCD`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[` \x80\x82\x01\x80Q_\x90\x81R`6\x90\x92R`@\x91\x82\x90 \x80T`\xFF\x19\x16`\x01\x17\x90U`9T\x90Q\x91\x83\x01Qa\x0FH\x92`\x01`\x01`\xA0\x1B\x03\x90\x92\x16\x91a<(\x91\x88\x91\x88\x91\x88\x91\x90a\x17\x03V[\x83QaBeV[` \x80\x83\x01Q`\x01`\x01`\xA0\x1B\x03\x80\x82\x16_\x81\x81R`5\x90\x94R`@\x90\x93 T\x91\x92\x90\x87\x16\x03a<rW`@QcV\x16\x8BA`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x87`\xFF\x16\x84_\x01Q`\xFF\x16\x14a<\x9BW`@Qc\x8EZ\xEE\xE7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@QcT\x01\xED'`\xE0\x1B\x81R`\x04\x81\x01\x82\x90R`\xFF\x89\x16`$\x82\x01R_\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x90cT\x01\xED'\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a=\tW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a=-\x91\x90a^\xDAV[\x90Pa=9\x81\x85aB\x8DV[`\x01`\x01``\x1B\x03\x16\x86`\x01`\x01``\x1B\x03\x16\x11a=jW`@QcLD\x99]`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a=t\x88\x85aB\xB0V[`\x01`\x01``\x1B\x03\x16\x81`\x01`\x01``\x1B\x03\x16\x10a\x19\x0EW`@Qc\xB1\x87\xE8i`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x81\x81R` \x84\x90R`@\x81 T\x81[\x81\x81\x10\x15a>(W`\x01a=\xC9\x82\x84a]\xA9V[a=\xD3\x91\x90a]\xA9V[\x92P\x84c\xFF\xFF\xFF\xFF\x16\x86_\x86\x81R` \x01\x90\x81R` \x01_ \x84c\xFF\xFF\xFF\xFF\x16\x81T\x81\x10a>\x03Wa>\x03aT\xB3V[_\x91\x82R` \x90\x91 \x01Tc\xFF\xFF\xFF\xFF\x16\x11a> WPPa\x0B\xD1V[`\x01\x01a=\xB5V[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\\`$\x82\x01R\x7FRegistryCoordinator.getQuorumBit`D\x82\x01R\x7FmapIndexAtBlockNumber: no bitmap`d\x82\x01R\x7F update found for operatorId\0\0\0\0`\x84\x82\x01R`\xA4\x01a\x13\x0EV[_\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0Fa>\xE7aB\xC9V[a>\xEFaC!V[`@\x80Q` \x81\x01\x94\x90\x94R\x83\x01\x91\x90\x91R``\x82\x01RF`\x80\x82\x01R0`\xA0\x82\x01R`\xC0\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x90V[_\x82\x81R` \x84\x90R`@\x81 T\x90\x81\x90\x03a?\xD4W_\x83\x81R` \x85\x81R`@\x80\x83 \x81Q``\x81\x01\x83Rc\xFF\xFF\xFF\xFFC\x81\x16\x82R\x81\x85\x01\x86\x81R`\x01`\x01`\xC0\x1B\x03\x80\x8A\x16\x95\x84\x01\x95\x86R\x84T`\x01\x81\x01\x86U\x94\x88R\x95\x90\x96 \x91Q\x91\x90\x92\x01\x80T\x95Q\x93Q\x90\x94\x16`\x01`@\x1B\x02`\x01`\x01`@\x1B\x03\x93\x83\x16`\x01` \x1B\x02g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x96\x16\x91\x90\x92\x16\x17\x93\x90\x93\x17\x16\x91\x90\x91\x17\x90Ua\x0FHV[_\x83\x81R` \x85\x90R`@\x81 a?\xEC`\x01\x84a]\xA9V[\x81T\x81\x10a?\xFCWa?\xFCaT\xB3V[_\x91\x82R` \x90\x91 \x01\x80T\x90\x91Pc\xFF\xFF\xFF\xFFC\x81\x16\x91\x16\x03a@=W\x80T`\x01`\x01`@\x1B\x03\x16`\x01`@\x1B`\x01`\x01`\xC0\x1B\x03\x85\x16\x02\x17\x81Ua\x0F\x07V[\x80Tc\xFF\xFF\xFF\xFFC\x81\x16`\x01` \x1B\x81\x81\x02g\xFF\xFF\xFF\xFF\0\0\0\0\x19\x90\x94\x16\x93\x90\x93\x17\x84U_\x87\x81R` \x89\x81R`@\x80\x83 \x81Q``\x81\x01\x83R\x94\x85R\x84\x83\x01\x84\x81R`\x01`\x01`\xC0\x1B\x03\x80\x8C\x16\x93\x87\x01\x93\x84R\x82T`\x01\x81\x01\x84U\x92\x86R\x93\x90\x94 \x94Q\x94\x01\x80T\x93Q\x91Q\x90\x92\x16`\x01`@\x1B\x02`\x01`\x01`@\x1B\x03\x91\x86\x16\x90\x96\x02g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x93\x16\x93\x90\x94\x16\x92\x90\x92\x17\x17\x91\x90\x91\x16\x91\x90\x91\x17\x90UPPPPPV[__a@\xF3aF&V[a@\xFBaFDV[` \x80\x82R\x81\x81\x01\x81\x90R`@\x82\x01\x81\x90R``\x82\x01\x88\x90R`\x80\x82\x01\x87\x90R`\xA0\x82\x01\x86\x90R\x82`\xC0\x83`\x05a\x07\xD0Z\x03\xFA\x92P\x82\x80aA8W\xFE[P\x82aAWW`@Qc\xD5\x1E\xDA\xE3`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PQ\x95\x94PPPPPV[_T`\xFF\x16\x15aA\x85W`@Qc\xB2\xE1\x8E\x05`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[aA\x8Da9\x0EV[`\x01\x90\x81U_\x80T`\xFF\x19\x16\x90\x91\x17\x81U`@Q\x7F\x0B\x880o\xF4bq!\xF5\xB3\xE5\xB1\xC5\xF8\x8Fk\x1EB\xFD,\x04x\xEF\x1C\x91f-I\xD1\xF0wU\x91\x90\xA1V[`@\x80Q``\x81\x01\x82R`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x82R`=T\x81\x16` \x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91cn4\x92\xB5\x91\x90\x81\x01aB\x1D\x85aCQV[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01aB<\x91\x90a^\xF5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15aBSW__\xFD[PZ\xF1\x15\x80\x15a\x14\x03W=__>=_\xFD[aBp\x83\x83\x83aC\xF6V[a\x0B\xBBW`@Qc\x8B\xAAW\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[` \x81\x01Q_\x90a'\x10\x90aB\xA6\x90a\xFF\xFF\x16\x85a_cV[a\x0B\xD1\x91\x90a_\x85V[`@\x81\x01Q_\x90a'\x10\x90aB\xA6\x90a\xFF\xFF\x16\x85a_cV[__aB\xD3a0.V[\x80Q\x90\x91P\x15aB\xEAW\x80Q` \x90\x91\x01 \x91\x90PV[`\xFAT\x80\x15aB\xF9W\x92\x91PPV[\x7F\xC5\xD2F\x01\x86\xF7#<\x92~}\xB2\xDC\xC7\x03\xC0\xE5\0\xB6S\xCA\x82';{\xFA\xD8\x04]\x85\xA4p\x92PPP\x90V[__aC+a0\xBEV[\x80Q\x90\x91P\x15aCBW\x80Q` \x90\x91\x01 \x91\x90PV[`\xFBT\x80\x15aB\xF9W\x92\x91PPV[``_\x82Q`\x01`\x01`@\x1B\x03\x81\x11\x15aCmWaCmaFbV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15aC\x96W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x83Q\x81\x10\x15a$]W\x83\x81\x81Q\x81\x10aC\xB6WaC\xB6aT\xB3V[` \x01\x01Q`\xF8\x1C`\xF8\x1B`\xF8\x1C`\xFF\x16\x82\x82\x81Q\x81\x10aC\xD9WaC\xD9aT\xB3V[c\xFF\xFF\xFF\xFF\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`\x01\x01aC\x9BV[___aD\x03\x85\x85aDJV[\x90\x92P\x90P_\x81`\x04\x81\x11\x15aD\x1BWaD\x1BaMtV[\x14\x80\x15aD9WP\x85`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14[\x80a\x17BWPa\x17B\x86\x86\x86aD\x8CV[__\x82Q`A\x03aD~W` \x83\x01Q`@\x84\x01Q``\x85\x01Q_\x1AaDr\x87\x82\x85\x85aEsV[\x94P\x94PPPPaD\x85V[P_\x90P`\x02[\x92P\x92\x90PV[___\x85`\x01`\x01`\xA0\x1B\x03\x16c\x16&\xBA~`\xE0\x1B\x86\x86`@Q`$\x01aD\xB4\x92\x91\x90aXVV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x81R` \x82\x01\x80Q`\x01`\x01`\xE0\x1B\x03\x16`\x01`\x01`\xE0\x1B\x03\x19\x90\x94\x16\x93\x90\x93\x17\x90\x92R\x90QaD\xF2\x91\x90a_\xB2V[_`@Q\x80\x83\x03\x81\x85Z\xFA\x91PP=\x80_\x81\x14aE*W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>aE/V[``\x91P[P\x91P\x91P\x81\x80\x15aECWP` \x81Q\x10\x15[\x80\x15a\x17BWP\x80Qc\x0B\x13]?`\xE1\x1B\x90aEh\x90\x83\x01` \x90\x81\x01\x90\x84\x01a\\\rV[\x14\x96\x95PPPPPPV[_\x80o\xA2\xA8\x91\x8C\xA8[\xAF\xE2 \x16\xD0\xB9\x97\xE4\xDF``\x01`\xFF\x1B\x03\x83\x11\x15aE\x9EWP_\x90P`\x03aF\x1DV[`@\x80Q_\x80\x82R` \x82\x01\x80\x84R\x89\x90R`\xFF\x88\x16\x92\x82\x01\x92\x90\x92R``\x81\x01\x86\x90R`\x80\x81\x01\x85\x90R`\x01\x90`\xA0\x01` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15aE\xEFW=__>=_\xFD[PP`@Q`\x1F\x19\x01Q\x91PP`\x01`\x01`\xA0\x1B\x03\x81\x16aF\x17W_`\x01\x92P\x92PPaF\x1DV[\x91P_\x90P[\x94P\x94\x92PPPV[`@Q\x80` \x01`@R\x80`\x01\x90` \x82\x02\x806\x837P\x91\x92\x91PPV[`@Q\x80`\xC0\x01`@R\x80`\x06\x90` \x82\x02\x806\x837P\x91\x92\x91PPV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@Q``\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15aF\x98WaF\x98aFbV[`@R\x90V[`@\x80Q\x90\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15aF\x98WaF\x98aFbV[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15aF\xE8WaF\xE8aFbV[`@R\x91\x90PV[_`\x01`\x01`@\x1B\x03\x82\x11\x15aG\x08WaG\x08aFbV[P`\x05\x1B` \x01\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0C7W__\xFD[_\x82`\x1F\x83\x01\x12aG5W__\xFD[\x815aGHaGC\x82aF\xF0V[aF\xC0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x86\x01\x01\x92P\x85\x83\x11\x15aGiW__\xFD[` \x85\x01[\x83\x81\x10\x15aG\x8FW\x805aG\x81\x81aG\x12V[\x83R` \x92\x83\x01\x92\x01aGnV[P\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15aG\xA9W__\xFD[\x815`\x01`\x01`@\x1B\x03\x81\x11\x15aG\xBEW__\xFD[a!W\x84\x82\x85\x01aG&V[_` \x82\x84\x03\x12\x15aG\xDAW__\xFD[P5\x91\x90PV[c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x0C7W__\xFD[___``\x84\x86\x03\x12\x15aH\x04W__\xFD[\x835\x92P` \x84\x015aH\x16\x81aG\xE1V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[_\x82`\x1F\x83\x01\x12aHJW__\xFD[\x815` \x83\x01__`\x01`\x01`@\x1B\x03\x84\x11\x15aHiWaHiaFbV[P`\x1F\x83\x01`\x1F\x19\x16` \x01aH~\x81aF\xC0V[\x91PP\x82\x81R\x85\x83\x83\x01\x11\x15aH\x92W__\xFD[\x82\x82` \x83\x017_\x92\x81\x01` \x01\x92\x90\x92RP\x93\x92PPPV[_` \x82\x84\x03\x12\x15aH\xBCW__\xFD[\x815`\x01`\x01`@\x1B\x03\x81\x11\x15aH\xD1W__\xFD[a!W\x84\x82\x85\x01aH;V[_` \x82\x84\x03\x12\x15aH\xEDW__\xFD[\x815a\x0B\xD1\x81aG\x12V[__`@\x83\x85\x03\x12\x15aI\tW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[\x805`\xFF\x81\x16\x81\x14aI(W__\xFD[\x91\x90PV[_` \x82\x84\x03\x12\x15aI=W__\xFD[a\x0B\xD1\x82aI\x18V[_\x82`\x1F\x83\x01\x12aIUW__\xFD[\x815aIcaGC\x82aF\xF0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x86\x01\x01\x92P\x85\x83\x11\x15aI\x84W__\xFD[` \x85\x01[\x83\x81\x10\x15aG\x8FW\x805aI\x9C\x81aG\xE1V[\x83R` \x92\x83\x01\x92\x01aI\x89V[___``\x84\x86\x03\x12\x15aI\xBCW__\xFD[\x835aI\xC7\x81aG\x12V[\x92P` \x84\x015aI\xD7\x81aG\x12V[\x91P`@\x84\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aI\xF1W__\xFD[aI\xFD\x86\x82\x87\x01aIFV[\x91PP\x92P\x92P\x92V[\x81Q\x81R` \x80\x83\x01Q\x90\x82\x01R`@\x81\x01a\r\xE9V[\x805a\xFF\xFF\x81\x16\x81\x14aI(W__\xFD[_``\x82\x84\x03\x12\x15aJ?W__\xFD[aJGaFvV[\x90P\x815aJT\x81aG\xE1V[\x81RaJb` \x83\x01aJ\x1EV[` \x82\x01RaJs`@\x83\x01aJ\x1EV[`@\x82\x01R\x92\x91PPV[`\x01`\x01``\x1B\x03\x81\x16\x81\x14a\x0C7W__\xFD[_\x82`\x1F\x83\x01\x12aJ\xA1W__\xFD[\x815aJ\xAFaGC\x82aF\xF0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x06\x1B\x86\x01\x01\x92P\x85\x83\x11\x15aJ\xD0W__\xFD[` \x85\x01[\x83\x81\x10\x15aG\x8FW`@\x81\x88\x03\x12\x15aJ\xECW__\xFD[aJ\xF4aF\x9EV[\x815aJ\xFF\x81aG\x12V[\x81R` \x82\x015aK\x0F\x81aJ~V[` \x82\x81\x01\x91\x90\x91R\x90\x84R\x92\x90\x92\x01\x91`@\x01aJ\xD5V[____`\xC0\x85\x87\x03\x12\x15aK;W__\xFD[aKE\x86\x86aJ/V[\x93P``\x85\x015aKU\x81aJ~V[\x92P`\x80\x85\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aKoW__\xFD[aK{\x87\x82\x88\x01aJ\x92V[\x92PP`\xA0\x85\x015aK\x8C\x81aG\xE1V[\x93\x96\x92\x95P\x90\x93PPV[__\x83`\x1F\x84\x01\x12aK\xA7W__\xFD[P\x815`\x01`\x01`@\x1B\x03\x81\x11\x15aK\xBDW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15aD\x85W__\xFD[___`@\x84\x86\x03\x12\x15aK\xE6W__\xFD[\x835`\x01`\x01`@\x1B\x03\x81\x11\x15aK\xFBW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13aL\x0BW__\xFD[\x805aL\x19aGC\x82aF\xF0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x85\x01\x01\x92P\x88\x83\x11\x15aL:W__\xFD[` \x84\x01[\x83\x81\x10\x15aLzW\x805`\x01`\x01`@\x1B\x03\x81\x11\x15aL\\W__\xFD[aLk\x8B` \x83\x89\x01\x01aG&V[\x84RP` \x92\x83\x01\x92\x01aL?V[P\x95PPPP` \x84\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aL\x98W__\xFD[aL\xA4\x86\x82\x87\x01aK\x97V[\x94\x97\x90\x96P\x93\x94PPPPV[_____`\xA0\x86\x88\x03\x12\x15aL\xC5W__\xFD[\x855aL\xD0\x81aG\x12V[\x94P` \x86\x015aL\xE0\x81aG\x12V[\x93P`@\x86\x015aL\xF0\x81aG\x12V[\x92P``\x86\x015\x91P`\x80\x86\x015aM\x07\x81aG\x12V[\x80\x91PP\x92\x95P\x92\x95\x90\x93PV[_[\x83\x81\x10\x15aM/W\x81\x81\x01Q\x83\x82\x01R` \x01aM\x17V[PP_\x91\x01RV[_\x81Q\x80\x84RaMN\x81` \x86\x01` \x86\x01aM\x15V[`\x1F\x01`\x1F\x19\x16\x92\x90\x92\x01` \x01\x92\x91PPV[` \x81R_a\x0B\xD1` \x83\x01\x84aM7V[cNH{q`\xE0\x1B_R`!`\x04R`$_\xFD[`\x03\x81\x10aM\x98WaM\x98aMtV[\x90RV[\x81Q\x81R` \x80\x83\x01Q`@\x83\x01\x91a$]\x90\x84\x01\x82aM\x88V[__`\x80\x83\x85\x03\x12\x15aM\xC8W__\xFD[aM\xD1\x83aI\x18V[\x91PaM\xE0\x84` \x85\x01aJ/V[\x90P\x92P\x92\x90PV[__`@\x83\x85\x03\x12\x15aM\xFAW__\xFD[\x825aN\x05\x81aG\x12V[\x91P` \x83\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aN\x1FW__\xFD[aN+\x85\x82\x86\x01aH;V[\x91PP\x92P\x92\x90PV[___`\xA0\x84\x86\x03\x12\x15aNGW__\xFD[aNQ\x85\x85aJ/V[\x92P``\x84\x015aNa\x81aJ~V[\x91P`\x80\x84\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aN{W__\xFD[aI\xFD\x86\x82\x87\x01aJ\x92V[`\xFF`\xF8\x1B\x88\x16\x81R`\xE0` \x82\x01R_aN\xA5`\xE0\x83\x01\x89aM7V[\x82\x81\x03`@\x84\x01RaN\xB7\x81\x89aM7V[``\x84\x01\x88\x90R`\x01`\x01`\xA0\x1B\x03\x87\x16`\x80\x85\x01R`\xA0\x84\x01\x86\x90R\x83\x81\x03`\xC0\x85\x01R\x84Q\x80\x82R` \x80\x87\x01\x93P\x90\x91\x01\x90_[\x81\x81\x10\x15aO\x0CW\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01aN\xEEV[P\x90\x9B\x9APPPPPPPPPPPV[_\x82`\x1F\x83\x01\x12aO,W__\xFD[\x815aO:aGC\x82aF\xF0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x06\x1B\x86\x01\x01\x92P\x85\x83\x11\x15aO[W__\xFD[` \x85\x01[\x83\x81\x10\x15aG\x8FW`@\x81\x88\x03\x12\x15aOwW__\xFD[aO\x7FaF\x9EV[aO\x88\x82aI\x18V[\x81R` \x82\x015aO\x98\x81aG\x12V[` \x82\x81\x01\x91\x90\x91R\x90\x84R\x92\x90\x92\x01\x91`@\x01aO`V[_____`\xA0\x86\x88\x03\x12\x15aO\xC5W__\xFD[\x855aO\xD0\x81aG\x12V[\x94P` \x86\x015\x93P`@\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aO\xF1W__\xFD[aO\xFD\x88\x82\x89\x01aO\x1DV[\x95\x98\x94\x97P\x94\x95``\x81\x015\x95P`\x80\x015\x93\x92PPPV[_`@\x82\x84\x03\x12\x15aP&W__\xFD[aP.aF\x9EV[\x825\x81R` \x92\x83\x015\x92\x81\x01\x92\x90\x92RP\x91\x90PV[_\x82`\x1F\x83\x01\x12aPTW__\xFD[aP\\aF\x9EV[\x80`@\x84\x01\x85\x81\x11\x15aPmW__\xFD[\x84[\x81\x81\x10\x15aP\x87W\x805\x84R` \x93\x84\x01\x93\x01aPoV[P\x90\x95\x94PPPPPV[_\x81\x83\x03a\x01\0\x81\x12\x15aP\xA4W__\xFD[aP\xACaFvV[\x91PaP\xB8\x84\x84aP\x16V[\x82RaP\xC7\x84`@\x85\x01aP\x16V[` \x83\x01R`\x80`\x7F\x19\x82\x01\x12\x15aP\xDDW__\xFD[PaP\xE6aF\x9EV[aP\xF3\x84`\x80\x85\x01aPEV[\x81RaQ\x02\x84`\xC0\x85\x01aPEV[` \x82\x01R`@\x82\x01R\x92\x91PPV[_``\x82\x84\x03\x12\x15aQ\"W__\xFD[aQ*aFvV[\x90P\x815`\x01`\x01`@\x1B\x03\x81\x11\x15aQAW__\xFD[aQM\x84\x82\x85\x01aH;V[\x82RP` \x82\x81\x015\x90\x82\x01R`@\x91\x82\x015\x91\x81\x01\x91\x90\x91R\x91\x90PV[_______a\x01\xA0\x88\x8A\x03\x12\x15aQ\x83W__\xFD[\x875`\x01`\x01`@\x1B\x03\x81\x11\x15aQ\x98W__\xFD[aQ\xA4\x8A\x82\x8B\x01aK\x97V[\x90\x98P\x96PP` \x88\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aQ\xC2W__\xFD[aQ\xCE\x8A\x82\x8B\x01aH;V[\x95PPaQ\xDE\x89`@\x8A\x01aP\x92V[\x93Pa\x01@\x88\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aQ\xF9W__\xFD[aR\x05\x8A\x82\x8B\x01aO\x1DV[\x93PPa\x01`\x88\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aR!W__\xFD[aR-\x8A\x82\x8B\x01aQ\x12V[\x92PPa\x01\x80\x88\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aRIW__\xFD[aRU\x8A\x82\x8B\x01aQ\x12V[\x91PP\x92\x95\x98\x91\x94\x97P\x92\x95PV[____a\x01`\x85\x87\x03\x12\x15aRxW__\xFD[\x845`\x01`\x01`@\x1B\x03\x81\x11\x15aR\x8DW__\xFD[aR\x99\x87\x82\x88\x01aH;V[\x94PP` \x85\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aR\xB4W__\xFD[aR\xC0\x87\x82\x88\x01aH;V[\x93PPaR\xD0\x86`@\x87\x01aP\x92V[\x91Pa\x01@\x85\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aR\xEBW__\xFD[aR\xF7\x87\x82\x88\x01aQ\x12V[\x91PP\x92\x95\x91\x94P\x92PV[__`@\x83\x85\x03\x12\x15aS\x14W__\xFD[\x825aS\x1F\x81aG\xE1V[\x91P` \x83\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aS9W__\xFD[\x83\x01`\x1F\x81\x01\x85\x13aSIW__\xFD[\x805aSWaGC\x82aF\xF0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x85\x01\x01\x92P\x87\x83\x11\x15aSxW__\xFD[` \x84\x01\x93P[\x82\x84\x10\x15aS\x9AW\x835\x82R` \x93\x84\x01\x93\x90\x91\x01\x90aS\x7FV[\x80\x94PPPPP\x92P\x92\x90PV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15aP\x87W\x83Qc\xFF\xFF\xFF\xFF\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01aS\xC1V[_____`\x80\x86\x88\x03\x12\x15aS\xF9W__\xFD[\x855aT\x04\x81aG\x12V[\x94P` \x86\x015aT\x14\x81aG\x12V[\x93P`@\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aT.W__\xFD[aT:\x88\x82\x89\x01aIFV[\x93PP``\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aTUW__\xFD[aTa\x88\x82\x89\x01aK\x97V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[``\x81\x01a\r\xE9\x82\x84c\xFF\xFF\xFF\xFF\x81Q\x16\x82Ra\xFF\xFF` \x82\x01Q\x16` \x83\x01Ra\xFF\xFF`@\x82\x01Q\x16`@\x83\x01RPPV[` \x81\x01a\r\xE9\x82\x84aM\x88V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[\x80Q\x80\x15\x15\x81\x14aI(W__\xFD[_` \x82\x84\x03\x12\x15aT\xE6W__\xFD[a\x0B\xD1\x82aT\xC7V[_` \x82\x84\x03\x12\x15aT\xFFW__\xFD[\x81Qa\x0B\xD1\x81aG\x12V[_` \x82\x84\x03\x12\x15aU\x1AW__\xFD[\x81Qa\x0B\xD1\x81aG\xE1V[_`\xC0\x82\x01\x88\x83R`\x01\x80`\xA0\x1B\x03\x88\x16` \x84\x01R\x86`@\x84\x01R`\xC0``\x84\x01R\x80\x86Q\x80\x83R`\xE0\x85\x01\x91P` \x88\x01\x92P_[\x81\x81\x10\x15aU\x92W\x83Q\x80Q`\xFF\x16\x84R` \x90\x81\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x81\x85\x01R\x90\x93\x01\x92`@\x90\x92\x01\x91`\x01\x01aU\\V[PP`\x80\x84\x01\x95\x90\x95RPP`\xA0\x01R\x94\x93PPPPV[`\x01\x80`\xA0\x1B\x03\x83\x16\x81R`@` \x82\x01R_\x82Q```@\x84\x01RaU\xD3`\xA0\x84\x01\x82aM7V[\x90P` \x84\x01Q``\x84\x01R`@\x84\x01Q`\x80\x84\x01R\x80\x91PP\x93\x92PPPV[\x805`\x02\x81\x10aI(W__\xFD[___a\x01@\x84\x86\x03\x12\x15aV\x15W__\xFD[aV\x1E\x84aU\xF4V[\x92P` \x84\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aV8W__\xFD[aVD\x86\x82\x87\x01aH;V[\x92PPaVT\x85`@\x86\x01aP\x92V[\x90P\x92P\x92P\x92V[_____a\x01\x80\x86\x88\x03\x12\x15aVrW__\xFD[aV{\x86aU\xF4V[\x94P` \x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aV\x95W__\xFD[aV\xA1\x88\x82\x89\x01aH;V[\x94PPaV\xB1\x87`@\x88\x01aP\x92V[\x92Pa\x01@\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aV\xCCW__\xFD[aV\xD8\x88\x82\x89\x01aO\x1DV[\x92PPa\x01`\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aV\xF4W__\xFD[aW\0\x88\x82\x89\x01aQ\x12V[\x91PP\x92\x95P\x92\x95\x90\x93PV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[_`\x01\x82\x01aW2WaW2aW\rV[P`\x01\x01\x90V[``\x80\x82R\x84Q\x90\x82\x01\x81\x90R_\x90` \x86\x01\x90`\x80\x84\x01\x90\x83[\x81\x81\x10\x15aW{W\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01aWTV[PP\x83\x81\x03` \x80\x86\x01\x91\x90\x91R\x86Q\x80\x83R\x91\x81\x01\x92P\x86\x01\x90_[\x81\x81\x10\x15aW\xB6W\x82Q\x84R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01aW\x98V[PPP`\xFF\x84\x16`@\x84\x01R\x90Pa!WV[_` \x82\x84\x03\x12\x15aW\xD9W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15aW\xEEW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13aW\xFEW__\xFD[\x80QaX\x0CaGC\x82aF\xF0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x85\x01\x01\x92P\x86\x83\x11\x15aX-W__\xFD[` \x84\x01\x93P[\x82\x84\x10\x15a\x17BWaXE\x84aT\xC7V[\x82R` \x93\x84\x01\x93\x90\x91\x01\x90aX4V[\x82\x81R`@` \x82\x01R_a\x0B\xCE`@\x83\x01\x84aM7V[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x83\x16\x81R`@` \x82\x01\x81\x90R_\x90a\x0B\xCE\x90\x83\x01\x84aM7V[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82aX\xCDWaX\xCDaX\xABV[P\x06\x90V[`\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\r\xE9Wa\r\xE9aW\rV[_`@\x82\x01`\x01\x80`\xA0\x1B\x03\x85\x16\x83R`@` \x84\x01R\x80\x84Q\x80\x83R``\x85\x01\x91P``\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15aY\xA0W\x86\x85\x03`_\x19\x01\x84R\x81Q\x80Qc\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90_\x90``\x88\x01\x90[\x80\x83\x10\x15aY\x88W\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x82R` \x93\x84\x01\x93`\x01\x93\x90\x93\x01\x92\x90\x91\x01\x90aY]V[P\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01aY\x1FV[P\x92\x97\x96PPPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15aY\xFBW\x81Q\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x87R` \x90\x81\x01Q`\x01`\x01``\x1B\x03\x16\x81\x88\x01R`@\x90\x96\x01\x95\x90\x91\x01\x90`\x01\x01aY\xBFV[P\x93\x94\x93PPPPV[`\xFF\x84\x16\x81R`\x01`\x01``\x1B\x03\x83\x16` \x82\x01R```@\x82\x01R_aZ/``\x83\x01\x84aY\xADV[\x95\x94PPPPPV[`\xFF\x85\x16\x81R`\x01`\x01``\x1B\x03\x84\x16` \x82\x01Rc\xFF\xFF\xFF\xFF\x83\x16`@\x82\x01R`\x80``\x82\x01R_a\x17B`\x80\x83\x01\x84aY\xADV[aZ\x9D\x81\x87c\xFF\xFF\xFF\xFF\x81Q\x16\x82Ra\xFF\xFF` \x82\x01Q\x16` \x83\x01Ra\xFF\xFF`@\x82\x01Q\x16`@\x83\x01RPPV[`\x01`\x01``\x1B\x03\x85\x16``\x82\x01R`\xE0`\x80\x82\x01R_aZ\xC1`\xE0\x83\x01\x86aY\xADV[\x90P`\x02\x84\x10aZ\xD3WaZ\xD3aMtV[\x83`\xA0\x83\x01Rc\xFF\xFF\xFF\xFF\x83\x16`\xC0\x83\x01R\x96\x95PPPPPPV[` \x80\x82R`+\x90\x82\x01R\x7FInitializable: contract is not i`@\x82\x01Rjnitializing`\xA8\x1B``\x82\x01R`\x80\x01\x90V[`\x01\x81\x81\x1C\x90\x82\x16\x80a[NW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a[lWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[\x80_[`\x02\x81\x10\x15a\x0FHW\x81Q\x84R` \x93\x84\x01\x93\x90\x91\x01\x90`\x01\x01a[uV[`\x01`\x01`\xA0\x1B\x03\x84\x16\x81R\x82Q\x80Q` \x80\x84\x01\x91\x90\x91R\x01Q`@\x82\x01Ra\x01`\x81\x01` \x84\x81\x01Q\x80Q``\x85\x01R\x90\x81\x01Q`\x80\x84\x01RP`@\x84\x01Qa[\xE3`\xA0\x84\x01\x82Qa[rV[` \x01Qa[\xF4`\xE0\x84\x01\x82a[rV[P\x82Qa\x01 \x83\x01R` \x83\x01Qa\x01@\x83\x01Ra!WV[_` \x82\x84\x03\x12\x15a\\\x1DW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r\xE9Wa\r\xE9aW\rV[`\x01\x80`\xA0\x1B\x03\x84\x16\x81R\x82` \x82\x01R```@\x82\x01R_aZ/``\x83\x01\x84aM7V[_\x82`\x1F\x83\x01\x12a\\lW__\xFD[\x81Qa\\zaGC\x82aF\xF0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x86\x01\x01\x92P\x85\x83\x11\x15a\\\x9BW__\xFD[` \x85\x01[\x83\x81\x10\x15aG\x8FW\x80Qa\\\xB3\x81aJ~V[\x83R` \x92\x83\x01\x92\x01a\\\xA0V[__`@\x83\x85\x03\x12\x15a\\\xD2W__\xFD[\x82Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\\\xE7W__\xFD[a\\\xF3\x85\x82\x86\x01a\\]V[\x92PP` \x83\x01Q`\x01`\x01`@\x1B\x03\x81\x11\x15a]\x0EW__\xFD[aN+\x85\x82\x86\x01a\\]V[_` \x82\x84\x03\x12\x15a]*W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a]?W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a]OW__\xFD[\x80Qa]]aGC\x82aF\xF0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x85\x01\x01\x92P\x86\x83\x11\x15a]~W__\xFD[` \x84\x01\x93P[\x82\x84\x10\x15a\x17BW\x83Qa]\x98\x81aG\xE1V[\x82R` \x93\x84\x01\x93\x90\x91\x01\x90a]\x85V[\x81\x81\x03\x81\x81\x11\x15a\r\xE9Wa\r\xE9aW\rV[_a\xFF\xFF\x82\x16a\xFF\xFF\x81\x03a]\xD3Wa]\xD3aW\rV[`\x01\x01\x92\x91PPV[`\x1F\x82\x11\x15a\x0B\xBBW\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a^\x01WP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x0F\x07W_\x81U`\x01\x01a^\rV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a^9Wa^9aFbV[a^M\x81a^G\x84Ta[:V[\x84a]\xDCV[` `\x1F\x82\x11`\x01\x81\x14a^\x7FW_\x83\x15a^hWP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x0F\x07V[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a^\xAEW\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a^\x8EV[P\x84\x82\x10\x15a^\xCBW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[_` \x82\x84\x03\x12\x15a^\xEAW__\xFD[\x81Qa\x0B\xD1\x81aJ~V[` \x80\x82R\x82Q`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x83\x83\x01R\x83\x82\x01Q\x16`@\x80\x84\x01\x91\x90\x91R\x83\x01Q``\x80\x84\x01R\x80Q`\x80\x84\x01\x81\x90R_\x92\x91\x90\x91\x01\x90\x82\x90`\xA0\x85\x01\x90[\x80\x83\x10\x15aG\x8FWc\xFF\xFF\xFF\xFF\x84Q\x16\x82R` \x82\x01\x91P` \x84\x01\x93P`\x01\x83\x01\x92Pa_:V[`\x01`\x01``\x1B\x03\x81\x81\x16\x83\x82\x16\x02\x90\x81\x16\x90\x81\x81\x14a$]Wa$]aW\rV[_`\x01`\x01``\x1B\x03\x83\x16\x80a_\x9DWa_\x9DaX\xABV[\x80`\x01`\x01``\x1B\x03\x84\x16\x04\x91PP\x92\x91PPV[_\x82Qa_\xC3\x81\x84` \x87\x01aM\x15V[\x91\x90\x91\x01\x92\x91PPV\xFE0dNr\xE11\xA0)\xB8PE\xB6\x81\x81X]\x97\x81j\x91hq\xCA\x8D< \x8C\x16\xD8|\xFDG\xA2dipfsX\"\x12 \xBB}I~Q\xC6\x0Fz\x89T\x91\xC0\xE5\xA7\x89v\x8C\x126\x16\xC6b\x84U\xDE;\xC9`\xACVa\x1FdsolcC\0\x08\x1B\x003",
6111    );
6112    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6113    /**Custom error with signature `AlreadyRegisteredForQuorums()` and selector `0x0c6816cd`.
6114```solidity
6115error AlreadyRegisteredForQuorums();
6116```*/
6117    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6118    #[derive(Clone)]
6119    pub struct AlreadyRegisteredForQuorums {}
6120    #[allow(
6121        non_camel_case_types,
6122        non_snake_case,
6123        clippy::pub_underscore_fields,
6124        clippy::style
6125    )]
6126    const _: () = {
6127        use alloy::sol_types as alloy_sol_types;
6128        #[doc(hidden)]
6129        type UnderlyingSolTuple<'a> = ();
6130        #[doc(hidden)]
6131        type UnderlyingRustTuple<'a> = ();
6132        #[cfg(test)]
6133        #[allow(dead_code, unreachable_patterns)]
6134        fn _type_assertion(
6135            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6136        ) {
6137            match _t {
6138                alloy_sol_types::private::AssertTypeEq::<
6139                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6140                >(_) => {}
6141            }
6142        }
6143        #[automatically_derived]
6144        #[doc(hidden)]
6145        impl ::core::convert::From<AlreadyRegisteredForQuorums>
6146        for UnderlyingRustTuple<'_> {
6147            fn from(value: AlreadyRegisteredForQuorums) -> Self {
6148                ()
6149            }
6150        }
6151        #[automatically_derived]
6152        #[doc(hidden)]
6153        impl ::core::convert::From<UnderlyingRustTuple<'_>>
6154        for AlreadyRegisteredForQuorums {
6155            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6156                Self {}
6157            }
6158        }
6159        #[automatically_derived]
6160        impl alloy_sol_types::SolError for AlreadyRegisteredForQuorums {
6161            type Parameters<'a> = UnderlyingSolTuple<'a>;
6162            type Token<'a> = <Self::Parameters<
6163                'a,
6164            > as alloy_sol_types::SolType>::Token<'a>;
6165            const SIGNATURE: &'static str = "AlreadyRegisteredForQuorums()";
6166            const SELECTOR: [u8; 4] = [12u8, 104u8, 22u8, 205u8];
6167            #[inline]
6168            fn new<'a>(
6169                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6170            ) -> Self {
6171                tuple.into()
6172            }
6173            #[inline]
6174            fn tokenize(&self) -> Self::Token<'_> {
6175                ()
6176            }
6177        }
6178    };
6179    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6180    /**Custom error with signature `BitmapCannotBeZero()` and selector `0xd16d50ea`.
6181```solidity
6182error BitmapCannotBeZero();
6183```*/
6184    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6185    #[derive(Clone)]
6186    pub struct BitmapCannotBeZero {}
6187    #[allow(
6188        non_camel_case_types,
6189        non_snake_case,
6190        clippy::pub_underscore_fields,
6191        clippy::style
6192    )]
6193    const _: () = {
6194        use alloy::sol_types as alloy_sol_types;
6195        #[doc(hidden)]
6196        type UnderlyingSolTuple<'a> = ();
6197        #[doc(hidden)]
6198        type UnderlyingRustTuple<'a> = ();
6199        #[cfg(test)]
6200        #[allow(dead_code, unreachable_patterns)]
6201        fn _type_assertion(
6202            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6203        ) {
6204            match _t {
6205                alloy_sol_types::private::AssertTypeEq::<
6206                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6207                >(_) => {}
6208            }
6209        }
6210        #[automatically_derived]
6211        #[doc(hidden)]
6212        impl ::core::convert::From<BitmapCannotBeZero> for UnderlyingRustTuple<'_> {
6213            fn from(value: BitmapCannotBeZero) -> Self {
6214                ()
6215            }
6216        }
6217        #[automatically_derived]
6218        #[doc(hidden)]
6219        impl ::core::convert::From<UnderlyingRustTuple<'_>> for BitmapCannotBeZero {
6220            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6221                Self {}
6222            }
6223        }
6224        #[automatically_derived]
6225        impl alloy_sol_types::SolError for BitmapCannotBeZero {
6226            type Parameters<'a> = UnderlyingSolTuple<'a>;
6227            type Token<'a> = <Self::Parameters<
6228                'a,
6229            > as alloy_sol_types::SolType>::Token<'a>;
6230            const SIGNATURE: &'static str = "BitmapCannotBeZero()";
6231            const SELECTOR: [u8; 4] = [209u8, 109u8, 80u8, 234u8];
6232            #[inline]
6233            fn new<'a>(
6234                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6235            ) -> Self {
6236                tuple.into()
6237            }
6238            #[inline]
6239            fn tokenize(&self) -> Self::Token<'_> {
6240                ()
6241            }
6242        }
6243    };
6244    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6245    /**Custom error with signature `BitmapEmpty()` and selector `0x13ca4657`.
6246```solidity
6247error BitmapEmpty();
6248```*/
6249    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6250    #[derive(Clone)]
6251    pub struct BitmapEmpty {}
6252    #[allow(
6253        non_camel_case_types,
6254        non_snake_case,
6255        clippy::pub_underscore_fields,
6256        clippy::style
6257    )]
6258    const _: () = {
6259        use alloy::sol_types as alloy_sol_types;
6260        #[doc(hidden)]
6261        type UnderlyingSolTuple<'a> = ();
6262        #[doc(hidden)]
6263        type UnderlyingRustTuple<'a> = ();
6264        #[cfg(test)]
6265        #[allow(dead_code, unreachable_patterns)]
6266        fn _type_assertion(
6267            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6268        ) {
6269            match _t {
6270                alloy_sol_types::private::AssertTypeEq::<
6271                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6272                >(_) => {}
6273            }
6274        }
6275        #[automatically_derived]
6276        #[doc(hidden)]
6277        impl ::core::convert::From<BitmapEmpty> for UnderlyingRustTuple<'_> {
6278            fn from(value: BitmapEmpty) -> Self {
6279                ()
6280            }
6281        }
6282        #[automatically_derived]
6283        #[doc(hidden)]
6284        impl ::core::convert::From<UnderlyingRustTuple<'_>> for BitmapEmpty {
6285            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6286                Self {}
6287            }
6288        }
6289        #[automatically_derived]
6290        impl alloy_sol_types::SolError for BitmapEmpty {
6291            type Parameters<'a> = UnderlyingSolTuple<'a>;
6292            type Token<'a> = <Self::Parameters<
6293                'a,
6294            > as alloy_sol_types::SolType>::Token<'a>;
6295            const SIGNATURE: &'static str = "BitmapEmpty()";
6296            const SELECTOR: [u8; 4] = [19u8, 202u8, 70u8, 87u8];
6297            #[inline]
6298            fn new<'a>(
6299                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6300            ) -> Self {
6301                tuple.into()
6302            }
6303            #[inline]
6304            fn tokenize(&self) -> Self::Token<'_> {
6305                ()
6306            }
6307        }
6308    };
6309    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6310    /**Custom error with signature `BitmapUpdateIsAfterBlockNumber()` and selector `0x6cb19aff`.
6311```solidity
6312error BitmapUpdateIsAfterBlockNumber();
6313```*/
6314    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6315    #[derive(Clone)]
6316    pub struct BitmapUpdateIsAfterBlockNumber {}
6317    #[allow(
6318        non_camel_case_types,
6319        non_snake_case,
6320        clippy::pub_underscore_fields,
6321        clippy::style
6322    )]
6323    const _: () = {
6324        use alloy::sol_types as alloy_sol_types;
6325        #[doc(hidden)]
6326        type UnderlyingSolTuple<'a> = ();
6327        #[doc(hidden)]
6328        type UnderlyingRustTuple<'a> = ();
6329        #[cfg(test)]
6330        #[allow(dead_code, unreachable_patterns)]
6331        fn _type_assertion(
6332            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6333        ) {
6334            match _t {
6335                alloy_sol_types::private::AssertTypeEq::<
6336                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6337                >(_) => {}
6338            }
6339        }
6340        #[automatically_derived]
6341        #[doc(hidden)]
6342        impl ::core::convert::From<BitmapUpdateIsAfterBlockNumber>
6343        for UnderlyingRustTuple<'_> {
6344            fn from(value: BitmapUpdateIsAfterBlockNumber) -> Self {
6345                ()
6346            }
6347        }
6348        #[automatically_derived]
6349        #[doc(hidden)]
6350        impl ::core::convert::From<UnderlyingRustTuple<'_>>
6351        for BitmapUpdateIsAfterBlockNumber {
6352            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6353                Self {}
6354            }
6355        }
6356        #[automatically_derived]
6357        impl alloy_sol_types::SolError for BitmapUpdateIsAfterBlockNumber {
6358            type Parameters<'a> = UnderlyingSolTuple<'a>;
6359            type Token<'a> = <Self::Parameters<
6360                'a,
6361            > as alloy_sol_types::SolType>::Token<'a>;
6362            const SIGNATURE: &'static str = "BitmapUpdateIsAfterBlockNumber()";
6363            const SELECTOR: [u8; 4] = [108u8, 177u8, 154u8, 255u8];
6364            #[inline]
6365            fn new<'a>(
6366                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6367            ) -> Self {
6368                tuple.into()
6369            }
6370            #[inline]
6371            fn tokenize(&self) -> Self::Token<'_> {
6372                ()
6373            }
6374        }
6375    };
6376    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6377    /**Custom error with signature `BitmapValueTooLarge()` and selector `0xca957333`.
6378```solidity
6379error BitmapValueTooLarge();
6380```*/
6381    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6382    #[derive(Clone)]
6383    pub struct BitmapValueTooLarge {}
6384    #[allow(
6385        non_camel_case_types,
6386        non_snake_case,
6387        clippy::pub_underscore_fields,
6388        clippy::style
6389    )]
6390    const _: () = {
6391        use alloy::sol_types as alloy_sol_types;
6392        #[doc(hidden)]
6393        type UnderlyingSolTuple<'a> = ();
6394        #[doc(hidden)]
6395        type UnderlyingRustTuple<'a> = ();
6396        #[cfg(test)]
6397        #[allow(dead_code, unreachable_patterns)]
6398        fn _type_assertion(
6399            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6400        ) {
6401            match _t {
6402                alloy_sol_types::private::AssertTypeEq::<
6403                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6404                >(_) => {}
6405            }
6406        }
6407        #[automatically_derived]
6408        #[doc(hidden)]
6409        impl ::core::convert::From<BitmapValueTooLarge> for UnderlyingRustTuple<'_> {
6410            fn from(value: BitmapValueTooLarge) -> Self {
6411                ()
6412            }
6413        }
6414        #[automatically_derived]
6415        #[doc(hidden)]
6416        impl ::core::convert::From<UnderlyingRustTuple<'_>> for BitmapValueTooLarge {
6417            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6418                Self {}
6419            }
6420        }
6421        #[automatically_derived]
6422        impl alloy_sol_types::SolError for BitmapValueTooLarge {
6423            type Parameters<'a> = UnderlyingSolTuple<'a>;
6424            type Token<'a> = <Self::Parameters<
6425                'a,
6426            > as alloy_sol_types::SolType>::Token<'a>;
6427            const SIGNATURE: &'static str = "BitmapValueTooLarge()";
6428            const SELECTOR: [u8; 4] = [202u8, 149u8, 115u8, 51u8];
6429            #[inline]
6430            fn new<'a>(
6431                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6432            ) -> Self {
6433                tuple.into()
6434            }
6435            #[inline]
6436            fn tokenize(&self) -> Self::Token<'_> {
6437                ()
6438            }
6439        }
6440    };
6441    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6442    /**Custom error with signature `BytesArrayLengthTooLong()` and selector `0xfb4a9c8e`.
6443```solidity
6444error BytesArrayLengthTooLong();
6445```*/
6446    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6447    #[derive(Clone)]
6448    pub struct BytesArrayLengthTooLong {}
6449    #[allow(
6450        non_camel_case_types,
6451        non_snake_case,
6452        clippy::pub_underscore_fields,
6453        clippy::style
6454    )]
6455    const _: () = {
6456        use alloy::sol_types as alloy_sol_types;
6457        #[doc(hidden)]
6458        type UnderlyingSolTuple<'a> = ();
6459        #[doc(hidden)]
6460        type UnderlyingRustTuple<'a> = ();
6461        #[cfg(test)]
6462        #[allow(dead_code, unreachable_patterns)]
6463        fn _type_assertion(
6464            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6465        ) {
6466            match _t {
6467                alloy_sol_types::private::AssertTypeEq::<
6468                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6469                >(_) => {}
6470            }
6471        }
6472        #[automatically_derived]
6473        #[doc(hidden)]
6474        impl ::core::convert::From<BytesArrayLengthTooLong> for UnderlyingRustTuple<'_> {
6475            fn from(value: BytesArrayLengthTooLong) -> Self {
6476                ()
6477            }
6478        }
6479        #[automatically_derived]
6480        #[doc(hidden)]
6481        impl ::core::convert::From<UnderlyingRustTuple<'_>> for BytesArrayLengthTooLong {
6482            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6483                Self {}
6484            }
6485        }
6486        #[automatically_derived]
6487        impl alloy_sol_types::SolError for BytesArrayLengthTooLong {
6488            type Parameters<'a> = UnderlyingSolTuple<'a>;
6489            type Token<'a> = <Self::Parameters<
6490                'a,
6491            > as alloy_sol_types::SolType>::Token<'a>;
6492            const SIGNATURE: &'static str = "BytesArrayLengthTooLong()";
6493            const SELECTOR: [u8; 4] = [251u8, 74u8, 156u8, 142u8];
6494            #[inline]
6495            fn new<'a>(
6496                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6497            ) -> Self {
6498                tuple.into()
6499            }
6500            #[inline]
6501            fn tokenize(&self) -> Self::Token<'_> {
6502                ()
6503            }
6504        }
6505    };
6506    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6507    /**Custom error with signature `BytesArrayNotOrdered()` and selector `0x80c88348`.
6508```solidity
6509error BytesArrayNotOrdered();
6510```*/
6511    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6512    #[derive(Clone)]
6513    pub struct BytesArrayNotOrdered {}
6514    #[allow(
6515        non_camel_case_types,
6516        non_snake_case,
6517        clippy::pub_underscore_fields,
6518        clippy::style
6519    )]
6520    const _: () = {
6521        use alloy::sol_types as alloy_sol_types;
6522        #[doc(hidden)]
6523        type UnderlyingSolTuple<'a> = ();
6524        #[doc(hidden)]
6525        type UnderlyingRustTuple<'a> = ();
6526        #[cfg(test)]
6527        #[allow(dead_code, unreachable_patterns)]
6528        fn _type_assertion(
6529            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6530        ) {
6531            match _t {
6532                alloy_sol_types::private::AssertTypeEq::<
6533                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6534                >(_) => {}
6535            }
6536        }
6537        #[automatically_derived]
6538        #[doc(hidden)]
6539        impl ::core::convert::From<BytesArrayNotOrdered> for UnderlyingRustTuple<'_> {
6540            fn from(value: BytesArrayNotOrdered) -> Self {
6541                ()
6542            }
6543        }
6544        #[automatically_derived]
6545        #[doc(hidden)]
6546        impl ::core::convert::From<UnderlyingRustTuple<'_>> for BytesArrayNotOrdered {
6547            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6548                Self {}
6549            }
6550        }
6551        #[automatically_derived]
6552        impl alloy_sol_types::SolError for BytesArrayNotOrdered {
6553            type Parameters<'a> = UnderlyingSolTuple<'a>;
6554            type Token<'a> = <Self::Parameters<
6555                'a,
6556            > as alloy_sol_types::SolType>::Token<'a>;
6557            const SIGNATURE: &'static str = "BytesArrayNotOrdered()";
6558            const SELECTOR: [u8; 4] = [128u8, 200u8, 131u8, 72u8];
6559            #[inline]
6560            fn new<'a>(
6561                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6562            ) -> Self {
6563                tuple.into()
6564            }
6565            #[inline]
6566            fn tokenize(&self) -> Self::Token<'_> {
6567                ()
6568            }
6569        }
6570    };
6571    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6572    /**Custom error with signature `CannotChurnSelf()` and selector `0xac2d1682`.
6573```solidity
6574error CannotChurnSelf();
6575```*/
6576    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6577    #[derive(Clone)]
6578    pub struct CannotChurnSelf {}
6579    #[allow(
6580        non_camel_case_types,
6581        non_snake_case,
6582        clippy::pub_underscore_fields,
6583        clippy::style
6584    )]
6585    const _: () = {
6586        use alloy::sol_types as alloy_sol_types;
6587        #[doc(hidden)]
6588        type UnderlyingSolTuple<'a> = ();
6589        #[doc(hidden)]
6590        type UnderlyingRustTuple<'a> = ();
6591        #[cfg(test)]
6592        #[allow(dead_code, unreachable_patterns)]
6593        fn _type_assertion(
6594            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6595        ) {
6596            match _t {
6597                alloy_sol_types::private::AssertTypeEq::<
6598                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6599                >(_) => {}
6600            }
6601        }
6602        #[automatically_derived]
6603        #[doc(hidden)]
6604        impl ::core::convert::From<CannotChurnSelf> for UnderlyingRustTuple<'_> {
6605            fn from(value: CannotChurnSelf) -> Self {
6606                ()
6607            }
6608        }
6609        #[automatically_derived]
6610        #[doc(hidden)]
6611        impl ::core::convert::From<UnderlyingRustTuple<'_>> for CannotChurnSelf {
6612            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6613                Self {}
6614            }
6615        }
6616        #[automatically_derived]
6617        impl alloy_sol_types::SolError for CannotChurnSelf {
6618            type Parameters<'a> = UnderlyingSolTuple<'a>;
6619            type Token<'a> = <Self::Parameters<
6620                'a,
6621            > as alloy_sol_types::SolType>::Token<'a>;
6622            const SIGNATURE: &'static str = "CannotChurnSelf()";
6623            const SELECTOR: [u8; 4] = [172u8, 45u8, 22u8, 130u8];
6624            #[inline]
6625            fn new<'a>(
6626                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6627            ) -> Self {
6628                tuple.into()
6629            }
6630            #[inline]
6631            fn tokenize(&self) -> Self::Token<'_> {
6632                ()
6633            }
6634        }
6635    };
6636    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6637    /**Custom error with signature `CannotKickOperatorAboveThreshold()` and selector `0xb187e869`.
6638```solidity
6639error CannotKickOperatorAboveThreshold();
6640```*/
6641    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6642    #[derive(Clone)]
6643    pub struct CannotKickOperatorAboveThreshold {}
6644    #[allow(
6645        non_camel_case_types,
6646        non_snake_case,
6647        clippy::pub_underscore_fields,
6648        clippy::style
6649    )]
6650    const _: () = {
6651        use alloy::sol_types as alloy_sol_types;
6652        #[doc(hidden)]
6653        type UnderlyingSolTuple<'a> = ();
6654        #[doc(hidden)]
6655        type UnderlyingRustTuple<'a> = ();
6656        #[cfg(test)]
6657        #[allow(dead_code, unreachable_patterns)]
6658        fn _type_assertion(
6659            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6660        ) {
6661            match _t {
6662                alloy_sol_types::private::AssertTypeEq::<
6663                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6664                >(_) => {}
6665            }
6666        }
6667        #[automatically_derived]
6668        #[doc(hidden)]
6669        impl ::core::convert::From<CannotKickOperatorAboveThreshold>
6670        for UnderlyingRustTuple<'_> {
6671            fn from(value: CannotKickOperatorAboveThreshold) -> Self {
6672                ()
6673            }
6674        }
6675        #[automatically_derived]
6676        #[doc(hidden)]
6677        impl ::core::convert::From<UnderlyingRustTuple<'_>>
6678        for CannotKickOperatorAboveThreshold {
6679            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6680                Self {}
6681            }
6682        }
6683        #[automatically_derived]
6684        impl alloy_sol_types::SolError for CannotKickOperatorAboveThreshold {
6685            type Parameters<'a> = UnderlyingSolTuple<'a>;
6686            type Token<'a> = <Self::Parameters<
6687                'a,
6688            > as alloy_sol_types::SolType>::Token<'a>;
6689            const SIGNATURE: &'static str = "CannotKickOperatorAboveThreshold()";
6690            const SELECTOR: [u8; 4] = [177u8, 135u8, 232u8, 105u8];
6691            #[inline]
6692            fn new<'a>(
6693                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6694            ) -> Self {
6695                tuple.into()
6696            }
6697            #[inline]
6698            fn tokenize(&self) -> Self::Token<'_> {
6699                ()
6700            }
6701        }
6702    };
6703    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6704    /**Custom error with signature `CannotReregisterYet()` and selector `0x32d0cefa`.
6705```solidity
6706error CannotReregisterYet();
6707```*/
6708    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6709    #[derive(Clone)]
6710    pub struct CannotReregisterYet {}
6711    #[allow(
6712        non_camel_case_types,
6713        non_snake_case,
6714        clippy::pub_underscore_fields,
6715        clippy::style
6716    )]
6717    const _: () = {
6718        use alloy::sol_types as alloy_sol_types;
6719        #[doc(hidden)]
6720        type UnderlyingSolTuple<'a> = ();
6721        #[doc(hidden)]
6722        type UnderlyingRustTuple<'a> = ();
6723        #[cfg(test)]
6724        #[allow(dead_code, unreachable_patterns)]
6725        fn _type_assertion(
6726            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6727        ) {
6728            match _t {
6729                alloy_sol_types::private::AssertTypeEq::<
6730                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6731                >(_) => {}
6732            }
6733        }
6734        #[automatically_derived]
6735        #[doc(hidden)]
6736        impl ::core::convert::From<CannotReregisterYet> for UnderlyingRustTuple<'_> {
6737            fn from(value: CannotReregisterYet) -> Self {
6738                ()
6739            }
6740        }
6741        #[automatically_derived]
6742        #[doc(hidden)]
6743        impl ::core::convert::From<UnderlyingRustTuple<'_>> for CannotReregisterYet {
6744            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6745                Self {}
6746            }
6747        }
6748        #[automatically_derived]
6749        impl alloy_sol_types::SolError for CannotReregisterYet {
6750            type Parameters<'a> = UnderlyingSolTuple<'a>;
6751            type Token<'a> = <Self::Parameters<
6752                'a,
6753            > as alloy_sol_types::SolType>::Token<'a>;
6754            const SIGNATURE: &'static str = "CannotReregisterYet()";
6755            const SELECTOR: [u8; 4] = [50u8, 208u8, 206u8, 250u8];
6756            #[inline]
6757            fn new<'a>(
6758                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6759            ) -> Self {
6760                tuple.into()
6761            }
6762            #[inline]
6763            fn tokenize(&self) -> Self::Token<'_> {
6764                ()
6765            }
6766        }
6767    };
6768    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6769    /**Custom error with signature `ChurnApproverSaltUsed()` and selector `0xdf7dfd86`.
6770```solidity
6771error ChurnApproverSaltUsed();
6772```*/
6773    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6774    #[derive(Clone)]
6775    pub struct ChurnApproverSaltUsed {}
6776    #[allow(
6777        non_camel_case_types,
6778        non_snake_case,
6779        clippy::pub_underscore_fields,
6780        clippy::style
6781    )]
6782    const _: () = {
6783        use alloy::sol_types as alloy_sol_types;
6784        #[doc(hidden)]
6785        type UnderlyingSolTuple<'a> = ();
6786        #[doc(hidden)]
6787        type UnderlyingRustTuple<'a> = ();
6788        #[cfg(test)]
6789        #[allow(dead_code, unreachable_patterns)]
6790        fn _type_assertion(
6791            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6792        ) {
6793            match _t {
6794                alloy_sol_types::private::AssertTypeEq::<
6795                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6796                >(_) => {}
6797            }
6798        }
6799        #[automatically_derived]
6800        #[doc(hidden)]
6801        impl ::core::convert::From<ChurnApproverSaltUsed> for UnderlyingRustTuple<'_> {
6802            fn from(value: ChurnApproverSaltUsed) -> Self {
6803                ()
6804            }
6805        }
6806        #[automatically_derived]
6807        #[doc(hidden)]
6808        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ChurnApproverSaltUsed {
6809            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6810                Self {}
6811            }
6812        }
6813        #[automatically_derived]
6814        impl alloy_sol_types::SolError for ChurnApproverSaltUsed {
6815            type Parameters<'a> = UnderlyingSolTuple<'a>;
6816            type Token<'a> = <Self::Parameters<
6817                'a,
6818            > as alloy_sol_types::SolType>::Token<'a>;
6819            const SIGNATURE: &'static str = "ChurnApproverSaltUsed()";
6820            const SELECTOR: [u8; 4] = [223u8, 125u8, 253u8, 134u8];
6821            #[inline]
6822            fn new<'a>(
6823                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6824            ) -> Self {
6825                tuple.into()
6826            }
6827            #[inline]
6828            fn tokenize(&self) -> Self::Token<'_> {
6829                ()
6830            }
6831        }
6832    };
6833    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6834    /**Custom error with signature `CurrentlyPaused()` and selector `0x840a48d5`.
6835```solidity
6836error CurrentlyPaused();
6837```*/
6838    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6839    #[derive(Clone)]
6840    pub struct CurrentlyPaused {}
6841    #[allow(
6842        non_camel_case_types,
6843        non_snake_case,
6844        clippy::pub_underscore_fields,
6845        clippy::style
6846    )]
6847    const _: () = {
6848        use alloy::sol_types as alloy_sol_types;
6849        #[doc(hidden)]
6850        type UnderlyingSolTuple<'a> = ();
6851        #[doc(hidden)]
6852        type UnderlyingRustTuple<'a> = ();
6853        #[cfg(test)]
6854        #[allow(dead_code, unreachable_patterns)]
6855        fn _type_assertion(
6856            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6857        ) {
6858            match _t {
6859                alloy_sol_types::private::AssertTypeEq::<
6860                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6861                >(_) => {}
6862            }
6863        }
6864        #[automatically_derived]
6865        #[doc(hidden)]
6866        impl ::core::convert::From<CurrentlyPaused> for UnderlyingRustTuple<'_> {
6867            fn from(value: CurrentlyPaused) -> Self {
6868                ()
6869            }
6870        }
6871        #[automatically_derived]
6872        #[doc(hidden)]
6873        impl ::core::convert::From<UnderlyingRustTuple<'_>> for CurrentlyPaused {
6874            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6875                Self {}
6876            }
6877        }
6878        #[automatically_derived]
6879        impl alloy_sol_types::SolError for CurrentlyPaused {
6880            type Parameters<'a> = UnderlyingSolTuple<'a>;
6881            type Token<'a> = <Self::Parameters<
6882                'a,
6883            > as alloy_sol_types::SolType>::Token<'a>;
6884            const SIGNATURE: &'static str = "CurrentlyPaused()";
6885            const SELECTOR: [u8; 4] = [132u8, 10u8, 72u8, 213u8];
6886            #[inline]
6887            fn new<'a>(
6888                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6889            ) -> Self {
6890                tuple.into()
6891            }
6892            #[inline]
6893            fn tokenize(&self) -> Self::Token<'_> {
6894                ()
6895            }
6896        }
6897    };
6898    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6899    /**Custom error with signature `ExpModFailed()` and selector `0xd51edae3`.
6900```solidity
6901error ExpModFailed();
6902```*/
6903    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6904    #[derive(Clone)]
6905    pub struct ExpModFailed {}
6906    #[allow(
6907        non_camel_case_types,
6908        non_snake_case,
6909        clippy::pub_underscore_fields,
6910        clippy::style
6911    )]
6912    const _: () = {
6913        use alloy::sol_types as alloy_sol_types;
6914        #[doc(hidden)]
6915        type UnderlyingSolTuple<'a> = ();
6916        #[doc(hidden)]
6917        type UnderlyingRustTuple<'a> = ();
6918        #[cfg(test)]
6919        #[allow(dead_code, unreachable_patterns)]
6920        fn _type_assertion(
6921            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6922        ) {
6923            match _t {
6924                alloy_sol_types::private::AssertTypeEq::<
6925                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6926                >(_) => {}
6927            }
6928        }
6929        #[automatically_derived]
6930        #[doc(hidden)]
6931        impl ::core::convert::From<ExpModFailed> for UnderlyingRustTuple<'_> {
6932            fn from(value: ExpModFailed) -> Self {
6933                ()
6934            }
6935        }
6936        #[automatically_derived]
6937        #[doc(hidden)]
6938        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ExpModFailed {
6939            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6940                Self {}
6941            }
6942        }
6943        #[automatically_derived]
6944        impl alloy_sol_types::SolError for ExpModFailed {
6945            type Parameters<'a> = UnderlyingSolTuple<'a>;
6946            type Token<'a> = <Self::Parameters<
6947                'a,
6948            > as alloy_sol_types::SolType>::Token<'a>;
6949            const SIGNATURE: &'static str = "ExpModFailed()";
6950            const SELECTOR: [u8; 4] = [213u8, 30u8, 218u8, 227u8];
6951            #[inline]
6952            fn new<'a>(
6953                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6954            ) -> Self {
6955                tuple.into()
6956            }
6957            #[inline]
6958            fn tokenize(&self) -> Self::Token<'_> {
6959                ()
6960            }
6961        }
6962    };
6963    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6964    /**Custom error with signature `InputAddressZero()` and selector `0x73632176`.
6965```solidity
6966error InputAddressZero();
6967```*/
6968    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6969    #[derive(Clone)]
6970    pub struct InputAddressZero {}
6971    #[allow(
6972        non_camel_case_types,
6973        non_snake_case,
6974        clippy::pub_underscore_fields,
6975        clippy::style
6976    )]
6977    const _: () = {
6978        use alloy::sol_types as alloy_sol_types;
6979        #[doc(hidden)]
6980        type UnderlyingSolTuple<'a> = ();
6981        #[doc(hidden)]
6982        type UnderlyingRustTuple<'a> = ();
6983        #[cfg(test)]
6984        #[allow(dead_code, unreachable_patterns)]
6985        fn _type_assertion(
6986            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6987        ) {
6988            match _t {
6989                alloy_sol_types::private::AssertTypeEq::<
6990                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6991                >(_) => {}
6992            }
6993        }
6994        #[automatically_derived]
6995        #[doc(hidden)]
6996        impl ::core::convert::From<InputAddressZero> for UnderlyingRustTuple<'_> {
6997            fn from(value: InputAddressZero) -> Self {
6998                ()
6999            }
7000        }
7001        #[automatically_derived]
7002        #[doc(hidden)]
7003        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InputAddressZero {
7004            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7005                Self {}
7006            }
7007        }
7008        #[automatically_derived]
7009        impl alloy_sol_types::SolError for InputAddressZero {
7010            type Parameters<'a> = UnderlyingSolTuple<'a>;
7011            type Token<'a> = <Self::Parameters<
7012                'a,
7013            > as alloy_sol_types::SolType>::Token<'a>;
7014            const SIGNATURE: &'static str = "InputAddressZero()";
7015            const SELECTOR: [u8; 4] = [115u8, 99u8, 33u8, 118u8];
7016            #[inline]
7017            fn new<'a>(
7018                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7019            ) -> Self {
7020                tuple.into()
7021            }
7022            #[inline]
7023            fn tokenize(&self) -> Self::Token<'_> {
7024                ()
7025            }
7026        }
7027    };
7028    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7029    /**Custom error with signature `InputLengthMismatch()` and selector `0xaaad13f7`.
7030```solidity
7031error InputLengthMismatch();
7032```*/
7033    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7034    #[derive(Clone)]
7035    pub struct InputLengthMismatch {}
7036    #[allow(
7037        non_camel_case_types,
7038        non_snake_case,
7039        clippy::pub_underscore_fields,
7040        clippy::style
7041    )]
7042    const _: () = {
7043        use alloy::sol_types as alloy_sol_types;
7044        #[doc(hidden)]
7045        type UnderlyingSolTuple<'a> = ();
7046        #[doc(hidden)]
7047        type UnderlyingRustTuple<'a> = ();
7048        #[cfg(test)]
7049        #[allow(dead_code, unreachable_patterns)]
7050        fn _type_assertion(
7051            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7052        ) {
7053            match _t {
7054                alloy_sol_types::private::AssertTypeEq::<
7055                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7056                >(_) => {}
7057            }
7058        }
7059        #[automatically_derived]
7060        #[doc(hidden)]
7061        impl ::core::convert::From<InputLengthMismatch> for UnderlyingRustTuple<'_> {
7062            fn from(value: InputLengthMismatch) -> Self {
7063                ()
7064            }
7065        }
7066        #[automatically_derived]
7067        #[doc(hidden)]
7068        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InputLengthMismatch {
7069            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7070                Self {}
7071            }
7072        }
7073        #[automatically_derived]
7074        impl alloy_sol_types::SolError for InputLengthMismatch {
7075            type Parameters<'a> = UnderlyingSolTuple<'a>;
7076            type Token<'a> = <Self::Parameters<
7077                'a,
7078            > as alloy_sol_types::SolType>::Token<'a>;
7079            const SIGNATURE: &'static str = "InputLengthMismatch()";
7080            const SELECTOR: [u8; 4] = [170u8, 173u8, 19u8, 247u8];
7081            #[inline]
7082            fn new<'a>(
7083                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7084            ) -> Self {
7085                tuple.into()
7086            }
7087            #[inline]
7088            fn tokenize(&self) -> Self::Token<'_> {
7089                ()
7090            }
7091        }
7092    };
7093    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7094    /**Custom error with signature `InsufficientStakeForChurn()` and selector `0x4c44995d`.
7095```solidity
7096error InsufficientStakeForChurn();
7097```*/
7098    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7099    #[derive(Clone)]
7100    pub struct InsufficientStakeForChurn {}
7101    #[allow(
7102        non_camel_case_types,
7103        non_snake_case,
7104        clippy::pub_underscore_fields,
7105        clippy::style
7106    )]
7107    const _: () = {
7108        use alloy::sol_types as alloy_sol_types;
7109        #[doc(hidden)]
7110        type UnderlyingSolTuple<'a> = ();
7111        #[doc(hidden)]
7112        type UnderlyingRustTuple<'a> = ();
7113        #[cfg(test)]
7114        #[allow(dead_code, unreachable_patterns)]
7115        fn _type_assertion(
7116            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7117        ) {
7118            match _t {
7119                alloy_sol_types::private::AssertTypeEq::<
7120                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7121                >(_) => {}
7122            }
7123        }
7124        #[automatically_derived]
7125        #[doc(hidden)]
7126        impl ::core::convert::From<InsufficientStakeForChurn>
7127        for UnderlyingRustTuple<'_> {
7128            fn from(value: InsufficientStakeForChurn) -> Self {
7129                ()
7130            }
7131        }
7132        #[automatically_derived]
7133        #[doc(hidden)]
7134        impl ::core::convert::From<UnderlyingRustTuple<'_>>
7135        for InsufficientStakeForChurn {
7136            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7137                Self {}
7138            }
7139        }
7140        #[automatically_derived]
7141        impl alloy_sol_types::SolError for InsufficientStakeForChurn {
7142            type Parameters<'a> = UnderlyingSolTuple<'a>;
7143            type Token<'a> = <Self::Parameters<
7144                'a,
7145            > as alloy_sol_types::SolType>::Token<'a>;
7146            const SIGNATURE: &'static str = "InsufficientStakeForChurn()";
7147            const SELECTOR: [u8; 4] = [76u8, 68u8, 153u8, 93u8];
7148            #[inline]
7149            fn new<'a>(
7150                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7151            ) -> Self {
7152                tuple.into()
7153            }
7154            #[inline]
7155            fn tokenize(&self) -> Self::Token<'_> {
7156                ()
7157            }
7158        }
7159    };
7160    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7161    /**Custom error with signature `InvalidAVS()` and selector `0x66e565df`.
7162```solidity
7163error InvalidAVS();
7164```*/
7165    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7166    #[derive(Clone)]
7167    pub struct InvalidAVS {}
7168    #[allow(
7169        non_camel_case_types,
7170        non_snake_case,
7171        clippy::pub_underscore_fields,
7172        clippy::style
7173    )]
7174    const _: () = {
7175        use alloy::sol_types as alloy_sol_types;
7176        #[doc(hidden)]
7177        type UnderlyingSolTuple<'a> = ();
7178        #[doc(hidden)]
7179        type UnderlyingRustTuple<'a> = ();
7180        #[cfg(test)]
7181        #[allow(dead_code, unreachable_patterns)]
7182        fn _type_assertion(
7183            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7184        ) {
7185            match _t {
7186                alloy_sol_types::private::AssertTypeEq::<
7187                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7188                >(_) => {}
7189            }
7190        }
7191        #[automatically_derived]
7192        #[doc(hidden)]
7193        impl ::core::convert::From<InvalidAVS> for UnderlyingRustTuple<'_> {
7194            fn from(value: InvalidAVS) -> Self {
7195                ()
7196            }
7197        }
7198        #[automatically_derived]
7199        #[doc(hidden)]
7200        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidAVS {
7201            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7202                Self {}
7203            }
7204        }
7205        #[automatically_derived]
7206        impl alloy_sol_types::SolError for InvalidAVS {
7207            type Parameters<'a> = UnderlyingSolTuple<'a>;
7208            type Token<'a> = <Self::Parameters<
7209                'a,
7210            > as alloy_sol_types::SolType>::Token<'a>;
7211            const SIGNATURE: &'static str = "InvalidAVS()";
7212            const SELECTOR: [u8; 4] = [102u8, 229u8, 101u8, 223u8];
7213            #[inline]
7214            fn new<'a>(
7215                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7216            ) -> Self {
7217                tuple.into()
7218            }
7219            #[inline]
7220            fn tokenize(&self) -> Self::Token<'_> {
7221                ()
7222            }
7223        }
7224    };
7225    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7226    /**Custom error with signature `InvalidNewPausedStatus()` and selector `0xc61dca5d`.
7227```solidity
7228error InvalidNewPausedStatus();
7229```*/
7230    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7231    #[derive(Clone)]
7232    pub struct InvalidNewPausedStatus {}
7233    #[allow(
7234        non_camel_case_types,
7235        non_snake_case,
7236        clippy::pub_underscore_fields,
7237        clippy::style
7238    )]
7239    const _: () = {
7240        use alloy::sol_types as alloy_sol_types;
7241        #[doc(hidden)]
7242        type UnderlyingSolTuple<'a> = ();
7243        #[doc(hidden)]
7244        type UnderlyingRustTuple<'a> = ();
7245        #[cfg(test)]
7246        #[allow(dead_code, unreachable_patterns)]
7247        fn _type_assertion(
7248            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7249        ) {
7250            match _t {
7251                alloy_sol_types::private::AssertTypeEq::<
7252                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7253                >(_) => {}
7254            }
7255        }
7256        #[automatically_derived]
7257        #[doc(hidden)]
7258        impl ::core::convert::From<InvalidNewPausedStatus> for UnderlyingRustTuple<'_> {
7259            fn from(value: InvalidNewPausedStatus) -> Self {
7260                ()
7261            }
7262        }
7263        #[automatically_derived]
7264        #[doc(hidden)]
7265        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidNewPausedStatus {
7266            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7267                Self {}
7268            }
7269        }
7270        #[automatically_derived]
7271        impl alloy_sol_types::SolError for InvalidNewPausedStatus {
7272            type Parameters<'a> = UnderlyingSolTuple<'a>;
7273            type Token<'a> = <Self::Parameters<
7274                'a,
7275            > as alloy_sol_types::SolType>::Token<'a>;
7276            const SIGNATURE: &'static str = "InvalidNewPausedStatus()";
7277            const SELECTOR: [u8; 4] = [198u8, 29u8, 202u8, 93u8];
7278            #[inline]
7279            fn new<'a>(
7280                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7281            ) -> Self {
7282                tuple.into()
7283            }
7284            #[inline]
7285            fn tokenize(&self) -> Self::Token<'_> {
7286                ()
7287            }
7288        }
7289    };
7290    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7291    /**Custom error with signature `InvalidRegistrationType()` and selector `0x354bb8ab`.
7292```solidity
7293error InvalidRegistrationType();
7294```*/
7295    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7296    #[derive(Clone)]
7297    pub struct InvalidRegistrationType {}
7298    #[allow(
7299        non_camel_case_types,
7300        non_snake_case,
7301        clippy::pub_underscore_fields,
7302        clippy::style
7303    )]
7304    const _: () = {
7305        use alloy::sol_types as alloy_sol_types;
7306        #[doc(hidden)]
7307        type UnderlyingSolTuple<'a> = ();
7308        #[doc(hidden)]
7309        type UnderlyingRustTuple<'a> = ();
7310        #[cfg(test)]
7311        #[allow(dead_code, unreachable_patterns)]
7312        fn _type_assertion(
7313            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7314        ) {
7315            match _t {
7316                alloy_sol_types::private::AssertTypeEq::<
7317                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7318                >(_) => {}
7319            }
7320        }
7321        #[automatically_derived]
7322        #[doc(hidden)]
7323        impl ::core::convert::From<InvalidRegistrationType> for UnderlyingRustTuple<'_> {
7324            fn from(value: InvalidRegistrationType) -> Self {
7325                ()
7326            }
7327        }
7328        #[automatically_derived]
7329        #[doc(hidden)]
7330        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidRegistrationType {
7331            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7332                Self {}
7333            }
7334        }
7335        #[automatically_derived]
7336        impl alloy_sol_types::SolError for InvalidRegistrationType {
7337            type Parameters<'a> = UnderlyingSolTuple<'a>;
7338            type Token<'a> = <Self::Parameters<
7339                'a,
7340            > as alloy_sol_types::SolType>::Token<'a>;
7341            const SIGNATURE: &'static str = "InvalidRegistrationType()";
7342            const SELECTOR: [u8; 4] = [53u8, 75u8, 184u8, 171u8];
7343            #[inline]
7344            fn new<'a>(
7345                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7346            ) -> Self {
7347                tuple.into()
7348            }
7349            #[inline]
7350            fn tokenize(&self) -> Self::Token<'_> {
7351                ()
7352            }
7353        }
7354    };
7355    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7356    /**Custom error with signature `InvalidSignature()` and selector `0x8baa579f`.
7357```solidity
7358error InvalidSignature();
7359```*/
7360    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7361    #[derive(Clone)]
7362    pub struct InvalidSignature {}
7363    #[allow(
7364        non_camel_case_types,
7365        non_snake_case,
7366        clippy::pub_underscore_fields,
7367        clippy::style
7368    )]
7369    const _: () = {
7370        use alloy::sol_types as alloy_sol_types;
7371        #[doc(hidden)]
7372        type UnderlyingSolTuple<'a> = ();
7373        #[doc(hidden)]
7374        type UnderlyingRustTuple<'a> = ();
7375        #[cfg(test)]
7376        #[allow(dead_code, unreachable_patterns)]
7377        fn _type_assertion(
7378            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7379        ) {
7380            match _t {
7381                alloy_sol_types::private::AssertTypeEq::<
7382                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7383                >(_) => {}
7384            }
7385        }
7386        #[automatically_derived]
7387        #[doc(hidden)]
7388        impl ::core::convert::From<InvalidSignature> for UnderlyingRustTuple<'_> {
7389            fn from(value: InvalidSignature) -> Self {
7390                ()
7391            }
7392        }
7393        #[automatically_derived]
7394        #[doc(hidden)]
7395        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSignature {
7396            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7397                Self {}
7398            }
7399        }
7400        #[automatically_derived]
7401        impl alloy_sol_types::SolError for InvalidSignature {
7402            type Parameters<'a> = UnderlyingSolTuple<'a>;
7403            type Token<'a> = <Self::Parameters<
7404                'a,
7405            > as alloy_sol_types::SolType>::Token<'a>;
7406            const SIGNATURE: &'static str = "InvalidSignature()";
7407            const SELECTOR: [u8; 4] = [139u8, 170u8, 87u8, 159u8];
7408            #[inline]
7409            fn new<'a>(
7410                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7411            ) -> Self {
7412                tuple.into()
7413            }
7414            #[inline]
7415            fn tokenize(&self) -> Self::Token<'_> {
7416                ()
7417            }
7418        }
7419    };
7420    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7421    /**Custom error with signature `LookAheadPeriodTooLong()` and selector `0x2f5106e4`.
7422```solidity
7423error LookAheadPeriodTooLong();
7424```*/
7425    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7426    #[derive(Clone)]
7427    pub struct LookAheadPeriodTooLong {}
7428    #[allow(
7429        non_camel_case_types,
7430        non_snake_case,
7431        clippy::pub_underscore_fields,
7432        clippy::style
7433    )]
7434    const _: () = {
7435        use alloy::sol_types as alloy_sol_types;
7436        #[doc(hidden)]
7437        type UnderlyingSolTuple<'a> = ();
7438        #[doc(hidden)]
7439        type UnderlyingRustTuple<'a> = ();
7440        #[cfg(test)]
7441        #[allow(dead_code, unreachable_patterns)]
7442        fn _type_assertion(
7443            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7444        ) {
7445            match _t {
7446                alloy_sol_types::private::AssertTypeEq::<
7447                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7448                >(_) => {}
7449            }
7450        }
7451        #[automatically_derived]
7452        #[doc(hidden)]
7453        impl ::core::convert::From<LookAheadPeriodTooLong> for UnderlyingRustTuple<'_> {
7454            fn from(value: LookAheadPeriodTooLong) -> Self {
7455                ()
7456            }
7457        }
7458        #[automatically_derived]
7459        #[doc(hidden)]
7460        impl ::core::convert::From<UnderlyingRustTuple<'_>> for LookAheadPeriodTooLong {
7461            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7462                Self {}
7463            }
7464        }
7465        #[automatically_derived]
7466        impl alloy_sol_types::SolError for LookAheadPeriodTooLong {
7467            type Parameters<'a> = UnderlyingSolTuple<'a>;
7468            type Token<'a> = <Self::Parameters<
7469                'a,
7470            > as alloy_sol_types::SolType>::Token<'a>;
7471            const SIGNATURE: &'static str = "LookAheadPeriodTooLong()";
7472            const SELECTOR: [u8; 4] = [47u8, 81u8, 6u8, 228u8];
7473            #[inline]
7474            fn new<'a>(
7475                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7476            ) -> Self {
7477                tuple.into()
7478            }
7479            #[inline]
7480            fn tokenize(&self) -> Self::Token<'_> {
7481                ()
7482            }
7483        }
7484    };
7485    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7486    /**Custom error with signature `M2QuorumRegistrationIsDisabled()` and selector `0x21fa91f3`.
7487```solidity
7488error M2QuorumRegistrationIsDisabled();
7489```*/
7490    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7491    #[derive(Clone)]
7492    pub struct M2QuorumRegistrationIsDisabled {}
7493    #[allow(
7494        non_camel_case_types,
7495        non_snake_case,
7496        clippy::pub_underscore_fields,
7497        clippy::style
7498    )]
7499    const _: () = {
7500        use alloy::sol_types as alloy_sol_types;
7501        #[doc(hidden)]
7502        type UnderlyingSolTuple<'a> = ();
7503        #[doc(hidden)]
7504        type UnderlyingRustTuple<'a> = ();
7505        #[cfg(test)]
7506        #[allow(dead_code, unreachable_patterns)]
7507        fn _type_assertion(
7508            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7509        ) {
7510            match _t {
7511                alloy_sol_types::private::AssertTypeEq::<
7512                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7513                >(_) => {}
7514            }
7515        }
7516        #[automatically_derived]
7517        #[doc(hidden)]
7518        impl ::core::convert::From<M2QuorumRegistrationIsDisabled>
7519        for UnderlyingRustTuple<'_> {
7520            fn from(value: M2QuorumRegistrationIsDisabled) -> Self {
7521                ()
7522            }
7523        }
7524        #[automatically_derived]
7525        #[doc(hidden)]
7526        impl ::core::convert::From<UnderlyingRustTuple<'_>>
7527        for M2QuorumRegistrationIsDisabled {
7528            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7529                Self {}
7530            }
7531        }
7532        #[automatically_derived]
7533        impl alloy_sol_types::SolError for M2QuorumRegistrationIsDisabled {
7534            type Parameters<'a> = UnderlyingSolTuple<'a>;
7535            type Token<'a> = <Self::Parameters<
7536                'a,
7537            > as alloy_sol_types::SolType>::Token<'a>;
7538            const SIGNATURE: &'static str = "M2QuorumRegistrationIsDisabled()";
7539            const SELECTOR: [u8; 4] = [33u8, 250u8, 145u8, 243u8];
7540            #[inline]
7541            fn new<'a>(
7542                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7543            ) -> Self {
7544                tuple.into()
7545            }
7546            #[inline]
7547            fn tokenize(&self) -> Self::Token<'_> {
7548                ()
7549            }
7550        }
7551    };
7552    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7553    /**Custom error with signature `MaxOperatorCountReached()` and selector `0xc6b9e767`.
7554```solidity
7555error MaxOperatorCountReached();
7556```*/
7557    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7558    #[derive(Clone)]
7559    pub struct MaxOperatorCountReached {}
7560    #[allow(
7561        non_camel_case_types,
7562        non_snake_case,
7563        clippy::pub_underscore_fields,
7564        clippy::style
7565    )]
7566    const _: () = {
7567        use alloy::sol_types as alloy_sol_types;
7568        #[doc(hidden)]
7569        type UnderlyingSolTuple<'a> = ();
7570        #[doc(hidden)]
7571        type UnderlyingRustTuple<'a> = ();
7572        #[cfg(test)]
7573        #[allow(dead_code, unreachable_patterns)]
7574        fn _type_assertion(
7575            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7576        ) {
7577            match _t {
7578                alloy_sol_types::private::AssertTypeEq::<
7579                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7580                >(_) => {}
7581            }
7582        }
7583        #[automatically_derived]
7584        #[doc(hidden)]
7585        impl ::core::convert::From<MaxOperatorCountReached> for UnderlyingRustTuple<'_> {
7586            fn from(value: MaxOperatorCountReached) -> Self {
7587                ()
7588            }
7589        }
7590        #[automatically_derived]
7591        #[doc(hidden)]
7592        impl ::core::convert::From<UnderlyingRustTuple<'_>> for MaxOperatorCountReached {
7593            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7594                Self {}
7595            }
7596        }
7597        #[automatically_derived]
7598        impl alloy_sol_types::SolError for MaxOperatorCountReached {
7599            type Parameters<'a> = UnderlyingSolTuple<'a>;
7600            type Token<'a> = <Self::Parameters<
7601                'a,
7602            > as alloy_sol_types::SolType>::Token<'a>;
7603            const SIGNATURE: &'static str = "MaxOperatorCountReached()";
7604            const SELECTOR: [u8; 4] = [198u8, 185u8, 231u8, 103u8];
7605            #[inline]
7606            fn new<'a>(
7607                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7608            ) -> Self {
7609                tuple.into()
7610            }
7611            #[inline]
7612            fn tokenize(&self) -> Self::Token<'_> {
7613                ()
7614            }
7615        }
7616    };
7617    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7618    /**Custom error with signature `MaxQuorumsReached()` and selector `0x3cb89c97`.
7619```solidity
7620error MaxQuorumsReached();
7621```*/
7622    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7623    #[derive(Clone)]
7624    pub struct MaxQuorumsReached {}
7625    #[allow(
7626        non_camel_case_types,
7627        non_snake_case,
7628        clippy::pub_underscore_fields,
7629        clippy::style
7630    )]
7631    const _: () = {
7632        use alloy::sol_types as alloy_sol_types;
7633        #[doc(hidden)]
7634        type UnderlyingSolTuple<'a> = ();
7635        #[doc(hidden)]
7636        type UnderlyingRustTuple<'a> = ();
7637        #[cfg(test)]
7638        #[allow(dead_code, unreachable_patterns)]
7639        fn _type_assertion(
7640            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7641        ) {
7642            match _t {
7643                alloy_sol_types::private::AssertTypeEq::<
7644                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7645                >(_) => {}
7646            }
7647        }
7648        #[automatically_derived]
7649        #[doc(hidden)]
7650        impl ::core::convert::From<MaxQuorumsReached> for UnderlyingRustTuple<'_> {
7651            fn from(value: MaxQuorumsReached) -> Self {
7652                ()
7653            }
7654        }
7655        #[automatically_derived]
7656        #[doc(hidden)]
7657        impl ::core::convert::From<UnderlyingRustTuple<'_>> for MaxQuorumsReached {
7658            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7659                Self {}
7660            }
7661        }
7662        #[automatically_derived]
7663        impl alloy_sol_types::SolError for MaxQuorumsReached {
7664            type Parameters<'a> = UnderlyingSolTuple<'a>;
7665            type Token<'a> = <Self::Parameters<
7666                'a,
7667            > as alloy_sol_types::SolType>::Token<'a>;
7668            const SIGNATURE: &'static str = "MaxQuorumsReached()";
7669            const SELECTOR: [u8; 4] = [60u8, 184u8, 156u8, 151u8];
7670            #[inline]
7671            fn new<'a>(
7672                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7673            ) -> Self {
7674                tuple.into()
7675            }
7676            #[inline]
7677            fn tokenize(&self) -> Self::Token<'_> {
7678                ()
7679            }
7680        }
7681    };
7682    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7683    /**Custom error with signature `NextBitmapUpdateIsBeforeBlockNumber()` and selector `0xbbba60cb`.
7684```solidity
7685error NextBitmapUpdateIsBeforeBlockNumber();
7686```*/
7687    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7688    #[derive(Clone)]
7689    pub struct NextBitmapUpdateIsBeforeBlockNumber {}
7690    #[allow(
7691        non_camel_case_types,
7692        non_snake_case,
7693        clippy::pub_underscore_fields,
7694        clippy::style
7695    )]
7696    const _: () = {
7697        use alloy::sol_types as alloy_sol_types;
7698        #[doc(hidden)]
7699        type UnderlyingSolTuple<'a> = ();
7700        #[doc(hidden)]
7701        type UnderlyingRustTuple<'a> = ();
7702        #[cfg(test)]
7703        #[allow(dead_code, unreachable_patterns)]
7704        fn _type_assertion(
7705            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7706        ) {
7707            match _t {
7708                alloy_sol_types::private::AssertTypeEq::<
7709                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7710                >(_) => {}
7711            }
7712        }
7713        #[automatically_derived]
7714        #[doc(hidden)]
7715        impl ::core::convert::From<NextBitmapUpdateIsBeforeBlockNumber>
7716        for UnderlyingRustTuple<'_> {
7717            fn from(value: NextBitmapUpdateIsBeforeBlockNumber) -> Self {
7718                ()
7719            }
7720        }
7721        #[automatically_derived]
7722        #[doc(hidden)]
7723        impl ::core::convert::From<UnderlyingRustTuple<'_>>
7724        for NextBitmapUpdateIsBeforeBlockNumber {
7725            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7726                Self {}
7727            }
7728        }
7729        #[automatically_derived]
7730        impl alloy_sol_types::SolError for NextBitmapUpdateIsBeforeBlockNumber {
7731            type Parameters<'a> = UnderlyingSolTuple<'a>;
7732            type Token<'a> = <Self::Parameters<
7733                'a,
7734            > as alloy_sol_types::SolType>::Token<'a>;
7735            const SIGNATURE: &'static str = "NextBitmapUpdateIsBeforeBlockNumber()";
7736            const SELECTOR: [u8; 4] = [187u8, 186u8, 96u8, 203u8];
7737            #[inline]
7738            fn new<'a>(
7739                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7740            ) -> Self {
7741                tuple.into()
7742            }
7743            #[inline]
7744            fn tokenize(&self) -> Self::Token<'_> {
7745                ()
7746            }
7747        }
7748    };
7749    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7750    /**Custom error with signature `NotRegistered()` and selector `0xaba47339`.
7751```solidity
7752error NotRegistered();
7753```*/
7754    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7755    #[derive(Clone)]
7756    pub struct NotRegistered {}
7757    #[allow(
7758        non_camel_case_types,
7759        non_snake_case,
7760        clippy::pub_underscore_fields,
7761        clippy::style
7762    )]
7763    const _: () = {
7764        use alloy::sol_types as alloy_sol_types;
7765        #[doc(hidden)]
7766        type UnderlyingSolTuple<'a> = ();
7767        #[doc(hidden)]
7768        type UnderlyingRustTuple<'a> = ();
7769        #[cfg(test)]
7770        #[allow(dead_code, unreachable_patterns)]
7771        fn _type_assertion(
7772            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7773        ) {
7774            match _t {
7775                alloy_sol_types::private::AssertTypeEq::<
7776                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7777                >(_) => {}
7778            }
7779        }
7780        #[automatically_derived]
7781        #[doc(hidden)]
7782        impl ::core::convert::From<NotRegistered> for UnderlyingRustTuple<'_> {
7783            fn from(value: NotRegistered) -> Self {
7784                ()
7785            }
7786        }
7787        #[automatically_derived]
7788        #[doc(hidden)]
7789        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotRegistered {
7790            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7791                Self {}
7792            }
7793        }
7794        #[automatically_derived]
7795        impl alloy_sol_types::SolError for NotRegistered {
7796            type Parameters<'a> = UnderlyingSolTuple<'a>;
7797            type Token<'a> = <Self::Parameters<
7798                'a,
7799            > as alloy_sol_types::SolType>::Token<'a>;
7800            const SIGNATURE: &'static str = "NotRegistered()";
7801            const SELECTOR: [u8; 4] = [171u8, 164u8, 115u8, 57u8];
7802            #[inline]
7803            fn new<'a>(
7804                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7805            ) -> Self {
7806                tuple.into()
7807            }
7808            #[inline]
7809            fn tokenize(&self) -> Self::Token<'_> {
7810                ()
7811            }
7812        }
7813    };
7814    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7815    /**Custom error with signature `NotRegisteredForQuorum()` and selector `0xd053aa21`.
7816```solidity
7817error NotRegisteredForQuorum();
7818```*/
7819    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7820    #[derive(Clone)]
7821    pub struct NotRegisteredForQuorum {}
7822    #[allow(
7823        non_camel_case_types,
7824        non_snake_case,
7825        clippy::pub_underscore_fields,
7826        clippy::style
7827    )]
7828    const _: () = {
7829        use alloy::sol_types as alloy_sol_types;
7830        #[doc(hidden)]
7831        type UnderlyingSolTuple<'a> = ();
7832        #[doc(hidden)]
7833        type UnderlyingRustTuple<'a> = ();
7834        #[cfg(test)]
7835        #[allow(dead_code, unreachable_patterns)]
7836        fn _type_assertion(
7837            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7838        ) {
7839            match _t {
7840                alloy_sol_types::private::AssertTypeEq::<
7841                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7842                >(_) => {}
7843            }
7844        }
7845        #[automatically_derived]
7846        #[doc(hidden)]
7847        impl ::core::convert::From<NotRegisteredForQuorum> for UnderlyingRustTuple<'_> {
7848            fn from(value: NotRegisteredForQuorum) -> Self {
7849                ()
7850            }
7851        }
7852        #[automatically_derived]
7853        #[doc(hidden)]
7854        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotRegisteredForQuorum {
7855            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7856                Self {}
7857            }
7858        }
7859        #[automatically_derived]
7860        impl alloy_sol_types::SolError for NotRegisteredForQuorum {
7861            type Parameters<'a> = UnderlyingSolTuple<'a>;
7862            type Token<'a> = <Self::Parameters<
7863                'a,
7864            > as alloy_sol_types::SolType>::Token<'a>;
7865            const SIGNATURE: &'static str = "NotRegisteredForQuorum()";
7866            const SELECTOR: [u8; 4] = [208u8, 83u8, 170u8, 33u8];
7867            #[inline]
7868            fn new<'a>(
7869                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7870            ) -> Self {
7871                tuple.into()
7872            }
7873            #[inline]
7874            fn tokenize(&self) -> Self::Token<'_> {
7875                ()
7876            }
7877        }
7878    };
7879    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7880    /**Custom error with signature `NotSorted()` and selector `0xba50f911`.
7881```solidity
7882error NotSorted();
7883```*/
7884    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7885    #[derive(Clone)]
7886    pub struct NotSorted {}
7887    #[allow(
7888        non_camel_case_types,
7889        non_snake_case,
7890        clippy::pub_underscore_fields,
7891        clippy::style
7892    )]
7893    const _: () = {
7894        use alloy::sol_types as alloy_sol_types;
7895        #[doc(hidden)]
7896        type UnderlyingSolTuple<'a> = ();
7897        #[doc(hidden)]
7898        type UnderlyingRustTuple<'a> = ();
7899        #[cfg(test)]
7900        #[allow(dead_code, unreachable_patterns)]
7901        fn _type_assertion(
7902            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7903        ) {
7904            match _t {
7905                alloy_sol_types::private::AssertTypeEq::<
7906                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7907                >(_) => {}
7908            }
7909        }
7910        #[automatically_derived]
7911        #[doc(hidden)]
7912        impl ::core::convert::From<NotSorted> for UnderlyingRustTuple<'_> {
7913            fn from(value: NotSorted) -> Self {
7914                ()
7915            }
7916        }
7917        #[automatically_derived]
7918        #[doc(hidden)]
7919        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotSorted {
7920            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7921                Self {}
7922            }
7923        }
7924        #[automatically_derived]
7925        impl alloy_sol_types::SolError for NotSorted {
7926            type Parameters<'a> = UnderlyingSolTuple<'a>;
7927            type Token<'a> = <Self::Parameters<
7928                'a,
7929            > as alloy_sol_types::SolType>::Token<'a>;
7930            const SIGNATURE: &'static str = "NotSorted()";
7931            const SELECTOR: [u8; 4] = [186u8, 80u8, 249u8, 17u8];
7932            #[inline]
7933            fn new<'a>(
7934                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7935            ) -> Self {
7936                tuple.into()
7937            }
7938            #[inline]
7939            fn tokenize(&self) -> Self::Token<'_> {
7940                ()
7941            }
7942        }
7943    };
7944    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7945    /**Custom error with signature `OnlyAllocationManager()` and selector `0x23d871a5`.
7946```solidity
7947error OnlyAllocationManager();
7948```*/
7949    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7950    #[derive(Clone)]
7951    pub struct OnlyAllocationManager {}
7952    #[allow(
7953        non_camel_case_types,
7954        non_snake_case,
7955        clippy::pub_underscore_fields,
7956        clippy::style
7957    )]
7958    const _: () = {
7959        use alloy::sol_types as alloy_sol_types;
7960        #[doc(hidden)]
7961        type UnderlyingSolTuple<'a> = ();
7962        #[doc(hidden)]
7963        type UnderlyingRustTuple<'a> = ();
7964        #[cfg(test)]
7965        #[allow(dead_code, unreachable_patterns)]
7966        fn _type_assertion(
7967            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7968        ) {
7969            match _t {
7970                alloy_sol_types::private::AssertTypeEq::<
7971                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7972                >(_) => {}
7973            }
7974        }
7975        #[automatically_derived]
7976        #[doc(hidden)]
7977        impl ::core::convert::From<OnlyAllocationManager> for UnderlyingRustTuple<'_> {
7978            fn from(value: OnlyAllocationManager) -> Self {
7979                ()
7980            }
7981        }
7982        #[automatically_derived]
7983        #[doc(hidden)]
7984        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyAllocationManager {
7985            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7986                Self {}
7987            }
7988        }
7989        #[automatically_derived]
7990        impl alloy_sol_types::SolError for OnlyAllocationManager {
7991            type Parameters<'a> = UnderlyingSolTuple<'a>;
7992            type Token<'a> = <Self::Parameters<
7993                'a,
7994            > as alloy_sol_types::SolType>::Token<'a>;
7995            const SIGNATURE: &'static str = "OnlyAllocationManager()";
7996            const SELECTOR: [u8; 4] = [35u8, 216u8, 113u8, 165u8];
7997            #[inline]
7998            fn new<'a>(
7999                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8000            ) -> Self {
8001                tuple.into()
8002            }
8003            #[inline]
8004            fn tokenize(&self) -> Self::Token<'_> {
8005                ()
8006            }
8007        }
8008    };
8009    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8010    /**Custom error with signature `OnlyEjector()` and selector `0xedb1562e`.
8011```solidity
8012error OnlyEjector();
8013```*/
8014    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8015    #[derive(Clone)]
8016    pub struct OnlyEjector {}
8017    #[allow(
8018        non_camel_case_types,
8019        non_snake_case,
8020        clippy::pub_underscore_fields,
8021        clippy::style
8022    )]
8023    const _: () = {
8024        use alloy::sol_types as alloy_sol_types;
8025        #[doc(hidden)]
8026        type UnderlyingSolTuple<'a> = ();
8027        #[doc(hidden)]
8028        type UnderlyingRustTuple<'a> = ();
8029        #[cfg(test)]
8030        #[allow(dead_code, unreachable_patterns)]
8031        fn _type_assertion(
8032            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8033        ) {
8034            match _t {
8035                alloy_sol_types::private::AssertTypeEq::<
8036                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8037                >(_) => {}
8038            }
8039        }
8040        #[automatically_derived]
8041        #[doc(hidden)]
8042        impl ::core::convert::From<OnlyEjector> for UnderlyingRustTuple<'_> {
8043            fn from(value: OnlyEjector) -> Self {
8044                ()
8045            }
8046        }
8047        #[automatically_derived]
8048        #[doc(hidden)]
8049        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyEjector {
8050            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8051                Self {}
8052            }
8053        }
8054        #[automatically_derived]
8055        impl alloy_sol_types::SolError for OnlyEjector {
8056            type Parameters<'a> = UnderlyingSolTuple<'a>;
8057            type Token<'a> = <Self::Parameters<
8058                'a,
8059            > as alloy_sol_types::SolType>::Token<'a>;
8060            const SIGNATURE: &'static str = "OnlyEjector()";
8061            const SELECTOR: [u8; 4] = [237u8, 177u8, 86u8, 46u8];
8062            #[inline]
8063            fn new<'a>(
8064                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8065            ) -> Self {
8066                tuple.into()
8067            }
8068            #[inline]
8069            fn tokenize(&self) -> Self::Token<'_> {
8070                ()
8071            }
8072        }
8073    };
8074    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8075    /**Custom error with signature `OnlyM2QuorumsAllowed()` and selector `0xafaa70ef`.
8076```solidity
8077error OnlyM2QuorumsAllowed();
8078```*/
8079    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8080    #[derive(Clone)]
8081    pub struct OnlyM2QuorumsAllowed {}
8082    #[allow(
8083        non_camel_case_types,
8084        non_snake_case,
8085        clippy::pub_underscore_fields,
8086        clippy::style
8087    )]
8088    const _: () = {
8089        use alloy::sol_types as alloy_sol_types;
8090        #[doc(hidden)]
8091        type UnderlyingSolTuple<'a> = ();
8092        #[doc(hidden)]
8093        type UnderlyingRustTuple<'a> = ();
8094        #[cfg(test)]
8095        #[allow(dead_code, unreachable_patterns)]
8096        fn _type_assertion(
8097            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8098        ) {
8099            match _t {
8100                alloy_sol_types::private::AssertTypeEq::<
8101                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8102                >(_) => {}
8103            }
8104        }
8105        #[automatically_derived]
8106        #[doc(hidden)]
8107        impl ::core::convert::From<OnlyM2QuorumsAllowed> for UnderlyingRustTuple<'_> {
8108            fn from(value: OnlyM2QuorumsAllowed) -> Self {
8109                ()
8110            }
8111        }
8112        #[automatically_derived]
8113        #[doc(hidden)]
8114        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyM2QuorumsAllowed {
8115            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8116                Self {}
8117            }
8118        }
8119        #[automatically_derived]
8120        impl alloy_sol_types::SolError for OnlyM2QuorumsAllowed {
8121            type Parameters<'a> = UnderlyingSolTuple<'a>;
8122            type Token<'a> = <Self::Parameters<
8123                'a,
8124            > as alloy_sol_types::SolType>::Token<'a>;
8125            const SIGNATURE: &'static str = "OnlyM2QuorumsAllowed()";
8126            const SELECTOR: [u8; 4] = [175u8, 170u8, 112u8, 239u8];
8127            #[inline]
8128            fn new<'a>(
8129                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8130            ) -> Self {
8131                tuple.into()
8132            }
8133            #[inline]
8134            fn tokenize(&self) -> Self::Token<'_> {
8135                ()
8136            }
8137        }
8138    };
8139    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8140    /**Custom error with signature `OnlyPauser()` and selector `0x75df51dc`.
8141```solidity
8142error OnlyPauser();
8143```*/
8144    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8145    #[derive(Clone)]
8146    pub struct OnlyPauser {}
8147    #[allow(
8148        non_camel_case_types,
8149        non_snake_case,
8150        clippy::pub_underscore_fields,
8151        clippy::style
8152    )]
8153    const _: () = {
8154        use alloy::sol_types as alloy_sol_types;
8155        #[doc(hidden)]
8156        type UnderlyingSolTuple<'a> = ();
8157        #[doc(hidden)]
8158        type UnderlyingRustTuple<'a> = ();
8159        #[cfg(test)]
8160        #[allow(dead_code, unreachable_patterns)]
8161        fn _type_assertion(
8162            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8163        ) {
8164            match _t {
8165                alloy_sol_types::private::AssertTypeEq::<
8166                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8167                >(_) => {}
8168            }
8169        }
8170        #[automatically_derived]
8171        #[doc(hidden)]
8172        impl ::core::convert::From<OnlyPauser> for UnderlyingRustTuple<'_> {
8173            fn from(value: OnlyPauser) -> Self {
8174                ()
8175            }
8176        }
8177        #[automatically_derived]
8178        #[doc(hidden)]
8179        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyPauser {
8180            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8181                Self {}
8182            }
8183        }
8184        #[automatically_derived]
8185        impl alloy_sol_types::SolError for OnlyPauser {
8186            type Parameters<'a> = UnderlyingSolTuple<'a>;
8187            type Token<'a> = <Self::Parameters<
8188                'a,
8189            > as alloy_sol_types::SolType>::Token<'a>;
8190            const SIGNATURE: &'static str = "OnlyPauser()";
8191            const SELECTOR: [u8; 4] = [117u8, 223u8, 81u8, 220u8];
8192            #[inline]
8193            fn new<'a>(
8194                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8195            ) -> Self {
8196                tuple.into()
8197            }
8198            #[inline]
8199            fn tokenize(&self) -> Self::Token<'_> {
8200                ()
8201            }
8202        }
8203    };
8204    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8205    /**Custom error with signature `OnlyUnpauser()` and selector `0x794821ff`.
8206```solidity
8207error OnlyUnpauser();
8208```*/
8209    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8210    #[derive(Clone)]
8211    pub struct OnlyUnpauser {}
8212    #[allow(
8213        non_camel_case_types,
8214        non_snake_case,
8215        clippy::pub_underscore_fields,
8216        clippy::style
8217    )]
8218    const _: () = {
8219        use alloy::sol_types as alloy_sol_types;
8220        #[doc(hidden)]
8221        type UnderlyingSolTuple<'a> = ();
8222        #[doc(hidden)]
8223        type UnderlyingRustTuple<'a> = ();
8224        #[cfg(test)]
8225        #[allow(dead_code, unreachable_patterns)]
8226        fn _type_assertion(
8227            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8228        ) {
8229            match _t {
8230                alloy_sol_types::private::AssertTypeEq::<
8231                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8232                >(_) => {}
8233            }
8234        }
8235        #[automatically_derived]
8236        #[doc(hidden)]
8237        impl ::core::convert::From<OnlyUnpauser> for UnderlyingRustTuple<'_> {
8238            fn from(value: OnlyUnpauser) -> Self {
8239                ()
8240            }
8241        }
8242        #[automatically_derived]
8243        #[doc(hidden)]
8244        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyUnpauser {
8245            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8246                Self {}
8247            }
8248        }
8249        #[automatically_derived]
8250        impl alloy_sol_types::SolError for OnlyUnpauser {
8251            type Parameters<'a> = UnderlyingSolTuple<'a>;
8252            type Token<'a> = <Self::Parameters<
8253                'a,
8254            > as alloy_sol_types::SolType>::Token<'a>;
8255            const SIGNATURE: &'static str = "OnlyUnpauser()";
8256            const SELECTOR: [u8; 4] = [121u8, 72u8, 33u8, 255u8];
8257            #[inline]
8258            fn new<'a>(
8259                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8260            ) -> Self {
8261                tuple.into()
8262            }
8263            #[inline]
8264            fn tokenize(&self) -> Self::Token<'_> {
8265                ()
8266            }
8267        }
8268    };
8269    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8270    /**Custom error with signature `OperatorNotRegistered()` and selector `0x25ec6c1f`.
8271```solidity
8272error OperatorNotRegistered();
8273```*/
8274    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8275    #[derive(Clone)]
8276    pub struct OperatorNotRegistered {}
8277    #[allow(
8278        non_camel_case_types,
8279        non_snake_case,
8280        clippy::pub_underscore_fields,
8281        clippy::style
8282    )]
8283    const _: () = {
8284        use alloy::sol_types as alloy_sol_types;
8285        #[doc(hidden)]
8286        type UnderlyingSolTuple<'a> = ();
8287        #[doc(hidden)]
8288        type UnderlyingRustTuple<'a> = ();
8289        #[cfg(test)]
8290        #[allow(dead_code, unreachable_patterns)]
8291        fn _type_assertion(
8292            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8293        ) {
8294            match _t {
8295                alloy_sol_types::private::AssertTypeEq::<
8296                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8297                >(_) => {}
8298            }
8299        }
8300        #[automatically_derived]
8301        #[doc(hidden)]
8302        impl ::core::convert::From<OperatorNotRegistered> for UnderlyingRustTuple<'_> {
8303            fn from(value: OperatorNotRegistered) -> Self {
8304                ()
8305            }
8306        }
8307        #[automatically_derived]
8308        #[doc(hidden)]
8309        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorNotRegistered {
8310            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8311                Self {}
8312            }
8313        }
8314        #[automatically_derived]
8315        impl alloy_sol_types::SolError for OperatorNotRegistered {
8316            type Parameters<'a> = UnderlyingSolTuple<'a>;
8317            type Token<'a> = <Self::Parameters<
8318                'a,
8319            > as alloy_sol_types::SolType>::Token<'a>;
8320            const SIGNATURE: &'static str = "OperatorNotRegistered()";
8321            const SELECTOR: [u8; 4] = [37u8, 236u8, 108u8, 31u8];
8322            #[inline]
8323            fn new<'a>(
8324                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8325            ) -> Self {
8326                tuple.into()
8327            }
8328            #[inline]
8329            fn tokenize(&self) -> Self::Token<'_> {
8330                ()
8331            }
8332        }
8333    };
8334    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8335    /**Custom error with signature `OperatorSetQuorum()` and selector `0x92013813`.
8336```solidity
8337error OperatorSetQuorum();
8338```*/
8339    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8340    #[derive(Clone)]
8341    pub struct OperatorSetQuorum {}
8342    #[allow(
8343        non_camel_case_types,
8344        non_snake_case,
8345        clippy::pub_underscore_fields,
8346        clippy::style
8347    )]
8348    const _: () = {
8349        use alloy::sol_types as alloy_sol_types;
8350        #[doc(hidden)]
8351        type UnderlyingSolTuple<'a> = ();
8352        #[doc(hidden)]
8353        type UnderlyingRustTuple<'a> = ();
8354        #[cfg(test)]
8355        #[allow(dead_code, unreachable_patterns)]
8356        fn _type_assertion(
8357            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8358        ) {
8359            match _t {
8360                alloy_sol_types::private::AssertTypeEq::<
8361                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8362                >(_) => {}
8363            }
8364        }
8365        #[automatically_derived]
8366        #[doc(hidden)]
8367        impl ::core::convert::From<OperatorSetQuorum> for UnderlyingRustTuple<'_> {
8368            fn from(value: OperatorSetQuorum) -> Self {
8369                ()
8370            }
8371        }
8372        #[automatically_derived]
8373        #[doc(hidden)]
8374        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorSetQuorum {
8375            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8376                Self {}
8377            }
8378        }
8379        #[automatically_derived]
8380        impl alloy_sol_types::SolError for OperatorSetQuorum {
8381            type Parameters<'a> = UnderlyingSolTuple<'a>;
8382            type Token<'a> = <Self::Parameters<
8383                'a,
8384            > as alloy_sol_types::SolType>::Token<'a>;
8385            const SIGNATURE: &'static str = "OperatorSetQuorum()";
8386            const SELECTOR: [u8; 4] = [146u8, 1u8, 56u8, 19u8];
8387            #[inline]
8388            fn new<'a>(
8389                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8390            ) -> Self {
8391                tuple.into()
8392            }
8393            #[inline]
8394            fn tokenize(&self) -> Self::Token<'_> {
8395                ()
8396            }
8397        }
8398    };
8399    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8400    /**Custom error with signature `OperatorSetsAlreadyEnabled()` and selector `0xb2e18e05`.
8401```solidity
8402error OperatorSetsAlreadyEnabled();
8403```*/
8404    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8405    #[derive(Clone)]
8406    pub struct OperatorSetsAlreadyEnabled {}
8407    #[allow(
8408        non_camel_case_types,
8409        non_snake_case,
8410        clippy::pub_underscore_fields,
8411        clippy::style
8412    )]
8413    const _: () = {
8414        use alloy::sol_types as alloy_sol_types;
8415        #[doc(hidden)]
8416        type UnderlyingSolTuple<'a> = ();
8417        #[doc(hidden)]
8418        type UnderlyingRustTuple<'a> = ();
8419        #[cfg(test)]
8420        #[allow(dead_code, unreachable_patterns)]
8421        fn _type_assertion(
8422            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8423        ) {
8424            match _t {
8425                alloy_sol_types::private::AssertTypeEq::<
8426                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8427                >(_) => {}
8428            }
8429        }
8430        #[automatically_derived]
8431        #[doc(hidden)]
8432        impl ::core::convert::From<OperatorSetsAlreadyEnabled>
8433        for UnderlyingRustTuple<'_> {
8434            fn from(value: OperatorSetsAlreadyEnabled) -> Self {
8435                ()
8436            }
8437        }
8438        #[automatically_derived]
8439        #[doc(hidden)]
8440        impl ::core::convert::From<UnderlyingRustTuple<'_>>
8441        for OperatorSetsAlreadyEnabled {
8442            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8443                Self {}
8444            }
8445        }
8446        #[automatically_derived]
8447        impl alloy_sol_types::SolError for OperatorSetsAlreadyEnabled {
8448            type Parameters<'a> = UnderlyingSolTuple<'a>;
8449            type Token<'a> = <Self::Parameters<
8450                'a,
8451            > as alloy_sol_types::SolType>::Token<'a>;
8452            const SIGNATURE: &'static str = "OperatorSetsAlreadyEnabled()";
8453            const SELECTOR: [u8; 4] = [178u8, 225u8, 142u8, 5u8];
8454            #[inline]
8455            fn new<'a>(
8456                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8457            ) -> Self {
8458                tuple.into()
8459            }
8460            #[inline]
8461            fn tokenize(&self) -> Self::Token<'_> {
8462                ()
8463            }
8464        }
8465    };
8466    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8467    /**Custom error with signature `OperatorSetsNotEnabled()` and selector `0x5b779019`.
8468```solidity
8469error OperatorSetsNotEnabled();
8470```*/
8471    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8472    #[derive(Clone)]
8473    pub struct OperatorSetsNotEnabled {}
8474    #[allow(
8475        non_camel_case_types,
8476        non_snake_case,
8477        clippy::pub_underscore_fields,
8478        clippy::style
8479    )]
8480    const _: () = {
8481        use alloy::sol_types as alloy_sol_types;
8482        #[doc(hidden)]
8483        type UnderlyingSolTuple<'a> = ();
8484        #[doc(hidden)]
8485        type UnderlyingRustTuple<'a> = ();
8486        #[cfg(test)]
8487        #[allow(dead_code, unreachable_patterns)]
8488        fn _type_assertion(
8489            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8490        ) {
8491            match _t {
8492                alloy_sol_types::private::AssertTypeEq::<
8493                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8494                >(_) => {}
8495            }
8496        }
8497        #[automatically_derived]
8498        #[doc(hidden)]
8499        impl ::core::convert::From<OperatorSetsNotEnabled> for UnderlyingRustTuple<'_> {
8500            fn from(value: OperatorSetsNotEnabled) -> Self {
8501                ()
8502            }
8503        }
8504        #[automatically_derived]
8505        #[doc(hidden)]
8506        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorSetsNotEnabled {
8507            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8508                Self {}
8509            }
8510        }
8511        #[automatically_derived]
8512        impl alloy_sol_types::SolError for OperatorSetsNotEnabled {
8513            type Parameters<'a> = UnderlyingSolTuple<'a>;
8514            type Token<'a> = <Self::Parameters<
8515                'a,
8516            > as alloy_sol_types::SolType>::Token<'a>;
8517            const SIGNATURE: &'static str = "OperatorSetsNotEnabled()";
8518            const SELECTOR: [u8; 4] = [91u8, 119u8, 144u8, 25u8];
8519            #[inline]
8520            fn new<'a>(
8521                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8522            ) -> Self {
8523                tuple.into()
8524            }
8525            #[inline]
8526            fn tokenize(&self) -> Self::Token<'_> {
8527                ()
8528            }
8529        }
8530    };
8531    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8532    /**Custom error with signature `QuorumDoesNotExist()` and selector `0xe6219fea`.
8533```solidity
8534error QuorumDoesNotExist();
8535```*/
8536    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8537    #[derive(Clone)]
8538    pub struct QuorumDoesNotExist {}
8539    #[allow(
8540        non_camel_case_types,
8541        non_snake_case,
8542        clippy::pub_underscore_fields,
8543        clippy::style
8544    )]
8545    const _: () = {
8546        use alloy::sol_types as alloy_sol_types;
8547        #[doc(hidden)]
8548        type UnderlyingSolTuple<'a> = ();
8549        #[doc(hidden)]
8550        type UnderlyingRustTuple<'a> = ();
8551        #[cfg(test)]
8552        #[allow(dead_code, unreachable_patterns)]
8553        fn _type_assertion(
8554            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8555        ) {
8556            match _t {
8557                alloy_sol_types::private::AssertTypeEq::<
8558                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8559                >(_) => {}
8560            }
8561        }
8562        #[automatically_derived]
8563        #[doc(hidden)]
8564        impl ::core::convert::From<QuorumDoesNotExist> for UnderlyingRustTuple<'_> {
8565            fn from(value: QuorumDoesNotExist) -> Self {
8566                ()
8567            }
8568        }
8569        #[automatically_derived]
8570        #[doc(hidden)]
8571        impl ::core::convert::From<UnderlyingRustTuple<'_>> for QuorumDoesNotExist {
8572            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8573                Self {}
8574            }
8575        }
8576        #[automatically_derived]
8577        impl alloy_sol_types::SolError for QuorumDoesNotExist {
8578            type Parameters<'a> = UnderlyingSolTuple<'a>;
8579            type Token<'a> = <Self::Parameters<
8580                'a,
8581            > as alloy_sol_types::SolType>::Token<'a>;
8582            const SIGNATURE: &'static str = "QuorumDoesNotExist()";
8583            const SELECTOR: [u8; 4] = [230u8, 33u8, 159u8, 234u8];
8584            #[inline]
8585            fn new<'a>(
8586                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8587            ) -> Self {
8588                tuple.into()
8589            }
8590            #[inline]
8591            fn tokenize(&self) -> Self::Token<'_> {
8592                ()
8593            }
8594        }
8595    };
8596    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8597    /**Custom error with signature `QuorumOperatorCountMismatch()` and selector `0x8e5aeee7`.
8598```solidity
8599error QuorumOperatorCountMismatch();
8600```*/
8601    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8602    #[derive(Clone)]
8603    pub struct QuorumOperatorCountMismatch {}
8604    #[allow(
8605        non_camel_case_types,
8606        non_snake_case,
8607        clippy::pub_underscore_fields,
8608        clippy::style
8609    )]
8610    const _: () = {
8611        use alloy::sol_types as alloy_sol_types;
8612        #[doc(hidden)]
8613        type UnderlyingSolTuple<'a> = ();
8614        #[doc(hidden)]
8615        type UnderlyingRustTuple<'a> = ();
8616        #[cfg(test)]
8617        #[allow(dead_code, unreachable_patterns)]
8618        fn _type_assertion(
8619            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8620        ) {
8621            match _t {
8622                alloy_sol_types::private::AssertTypeEq::<
8623                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8624                >(_) => {}
8625            }
8626        }
8627        #[automatically_derived]
8628        #[doc(hidden)]
8629        impl ::core::convert::From<QuorumOperatorCountMismatch>
8630        for UnderlyingRustTuple<'_> {
8631            fn from(value: QuorumOperatorCountMismatch) -> Self {
8632                ()
8633            }
8634        }
8635        #[automatically_derived]
8636        #[doc(hidden)]
8637        impl ::core::convert::From<UnderlyingRustTuple<'_>>
8638        for QuorumOperatorCountMismatch {
8639            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8640                Self {}
8641            }
8642        }
8643        #[automatically_derived]
8644        impl alloy_sol_types::SolError for QuorumOperatorCountMismatch {
8645            type Parameters<'a> = UnderlyingSolTuple<'a>;
8646            type Token<'a> = <Self::Parameters<
8647                'a,
8648            > as alloy_sol_types::SolType>::Token<'a>;
8649            const SIGNATURE: &'static str = "QuorumOperatorCountMismatch()";
8650            const SELECTOR: [u8; 4] = [142u8, 90u8, 238u8, 231u8];
8651            #[inline]
8652            fn new<'a>(
8653                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8654            ) -> Self {
8655                tuple.into()
8656            }
8657            #[inline]
8658            fn tokenize(&self) -> Self::Token<'_> {
8659                ()
8660            }
8661        }
8662    };
8663    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8664    /**Custom error with signature `SignatureExpired()` and selector `0x0819bdcd`.
8665```solidity
8666error SignatureExpired();
8667```*/
8668    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8669    #[derive(Clone)]
8670    pub struct SignatureExpired {}
8671    #[allow(
8672        non_camel_case_types,
8673        non_snake_case,
8674        clippy::pub_underscore_fields,
8675        clippy::style
8676    )]
8677    const _: () = {
8678        use alloy::sol_types as alloy_sol_types;
8679        #[doc(hidden)]
8680        type UnderlyingSolTuple<'a> = ();
8681        #[doc(hidden)]
8682        type UnderlyingRustTuple<'a> = ();
8683        #[cfg(test)]
8684        #[allow(dead_code, unreachable_patterns)]
8685        fn _type_assertion(
8686            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8687        ) {
8688            match _t {
8689                alloy_sol_types::private::AssertTypeEq::<
8690                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8691                >(_) => {}
8692            }
8693        }
8694        #[automatically_derived]
8695        #[doc(hidden)]
8696        impl ::core::convert::From<SignatureExpired> for UnderlyingRustTuple<'_> {
8697            fn from(value: SignatureExpired) -> Self {
8698                ()
8699            }
8700        }
8701        #[automatically_derived]
8702        #[doc(hidden)]
8703        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SignatureExpired {
8704            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8705                Self {}
8706            }
8707        }
8708        #[automatically_derived]
8709        impl alloy_sol_types::SolError for SignatureExpired {
8710            type Parameters<'a> = UnderlyingSolTuple<'a>;
8711            type Token<'a> = <Self::Parameters<
8712                'a,
8713            > as alloy_sol_types::SolType>::Token<'a>;
8714            const SIGNATURE: &'static str = "SignatureExpired()";
8715            const SELECTOR: [u8; 4] = [8u8, 25u8, 189u8, 205u8];
8716            #[inline]
8717            fn new<'a>(
8718                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8719            ) -> Self {
8720                tuple.into()
8721            }
8722            #[inline]
8723            fn tokenize(&self) -> Self::Token<'_> {
8724                ()
8725            }
8726        }
8727    };
8728    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8729    /**Custom error with signature `StringTooLong(string)` and selector `0x305a27a9`.
8730```solidity
8731error StringTooLong(string str);
8732```*/
8733    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8734    #[derive(Clone)]
8735    pub struct StringTooLong {
8736        #[allow(missing_docs)]
8737        pub str: alloy::sol_types::private::String,
8738    }
8739    #[allow(
8740        non_camel_case_types,
8741        non_snake_case,
8742        clippy::pub_underscore_fields,
8743        clippy::style
8744    )]
8745    const _: () = {
8746        use alloy::sol_types as alloy_sol_types;
8747        #[doc(hidden)]
8748        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
8749        #[doc(hidden)]
8750        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
8751        #[cfg(test)]
8752        #[allow(dead_code, unreachable_patterns)]
8753        fn _type_assertion(
8754            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8755        ) {
8756            match _t {
8757                alloy_sol_types::private::AssertTypeEq::<
8758                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8759                >(_) => {}
8760            }
8761        }
8762        #[automatically_derived]
8763        #[doc(hidden)]
8764        impl ::core::convert::From<StringTooLong> for UnderlyingRustTuple<'_> {
8765            fn from(value: StringTooLong) -> Self {
8766                (value.str,)
8767            }
8768        }
8769        #[automatically_derived]
8770        #[doc(hidden)]
8771        impl ::core::convert::From<UnderlyingRustTuple<'_>> for StringTooLong {
8772            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8773                Self { str: tuple.0 }
8774            }
8775        }
8776        #[automatically_derived]
8777        impl alloy_sol_types::SolError for StringTooLong {
8778            type Parameters<'a> = UnderlyingSolTuple<'a>;
8779            type Token<'a> = <Self::Parameters<
8780                'a,
8781            > as alloy_sol_types::SolType>::Token<'a>;
8782            const SIGNATURE: &'static str = "StringTooLong(string)";
8783            const SELECTOR: [u8; 4] = [48u8, 90u8, 39u8, 169u8];
8784            #[inline]
8785            fn new<'a>(
8786                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8787            ) -> Self {
8788                tuple.into()
8789            }
8790            #[inline]
8791            fn tokenize(&self) -> Self::Token<'_> {
8792                (
8793                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
8794                        &self.str,
8795                    ),
8796                )
8797            }
8798        }
8799    };
8800    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8801    /**Event with signature `AVSUpdated(address,address)` and selector `0x9770f3cadfdcbb6f93af935e86047111590c3768271d237e4a2bc0b874bed693`.
8802```solidity
8803event AVSUpdated(address prevAVS, address newAVS);
8804```*/
8805    #[allow(
8806        non_camel_case_types,
8807        non_snake_case,
8808        clippy::pub_underscore_fields,
8809        clippy::style
8810    )]
8811    #[derive(Clone)]
8812    pub struct AVSUpdated {
8813        #[allow(missing_docs)]
8814        pub prevAVS: alloy::sol_types::private::Address,
8815        #[allow(missing_docs)]
8816        pub newAVS: alloy::sol_types::private::Address,
8817    }
8818    #[allow(
8819        non_camel_case_types,
8820        non_snake_case,
8821        clippy::pub_underscore_fields,
8822        clippy::style
8823    )]
8824    const _: () = {
8825        use alloy::sol_types as alloy_sol_types;
8826        #[automatically_derived]
8827        impl alloy_sol_types::SolEvent for AVSUpdated {
8828            type DataTuple<'a> = (
8829                alloy::sol_types::sol_data::Address,
8830                alloy::sol_types::sol_data::Address,
8831            );
8832            type DataToken<'a> = <Self::DataTuple<
8833                'a,
8834            > as alloy_sol_types::SolType>::Token<'a>;
8835            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
8836            const SIGNATURE: &'static str = "AVSUpdated(address,address)";
8837            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
8838                151u8, 112u8, 243u8, 202u8, 223u8, 220u8, 187u8, 111u8, 147u8, 175u8,
8839                147u8, 94u8, 134u8, 4u8, 113u8, 17u8, 89u8, 12u8, 55u8, 104u8, 39u8,
8840                29u8, 35u8, 126u8, 74u8, 43u8, 192u8, 184u8, 116u8, 190u8, 214u8, 147u8,
8841            ]);
8842            const ANONYMOUS: bool = false;
8843            #[allow(unused_variables)]
8844            #[inline]
8845            fn new(
8846                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
8847                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
8848            ) -> Self {
8849                Self {
8850                    prevAVS: data.0,
8851                    newAVS: data.1,
8852                }
8853            }
8854            #[inline]
8855            fn check_signature(
8856                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
8857            ) -> alloy_sol_types::Result<()> {
8858                if topics.0 != Self::SIGNATURE_HASH {
8859                    return Err(
8860                        alloy_sol_types::Error::invalid_event_signature_hash(
8861                            Self::SIGNATURE,
8862                            topics.0,
8863                            Self::SIGNATURE_HASH,
8864                        ),
8865                    );
8866                }
8867                Ok(())
8868            }
8869            #[inline]
8870            fn tokenize_body(&self) -> Self::DataToken<'_> {
8871                (
8872                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8873                        &self.prevAVS,
8874                    ),
8875                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8876                        &self.newAVS,
8877                    ),
8878                )
8879            }
8880            #[inline]
8881            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
8882                (Self::SIGNATURE_HASH.into(),)
8883            }
8884            #[inline]
8885            fn encode_topics_raw(
8886                &self,
8887                out: &mut [alloy_sol_types::abi::token::WordToken],
8888            ) -> alloy_sol_types::Result<()> {
8889                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
8890                    return Err(alloy_sol_types::Error::Overrun);
8891                }
8892                out[0usize] = alloy_sol_types::abi::token::WordToken(
8893                    Self::SIGNATURE_HASH,
8894                );
8895                Ok(())
8896            }
8897        }
8898        #[automatically_derived]
8899        impl alloy_sol_types::private::IntoLogData for AVSUpdated {
8900            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
8901                From::from(self)
8902            }
8903            fn into_log_data(self) -> alloy_sol_types::private::LogData {
8904                From::from(&self)
8905            }
8906        }
8907        #[automatically_derived]
8908        impl From<&AVSUpdated> for alloy_sol_types::private::LogData {
8909            #[inline]
8910            fn from(this: &AVSUpdated) -> alloy_sol_types::private::LogData {
8911                alloy_sol_types::SolEvent::encode_log_data(this)
8912            }
8913        }
8914    };
8915    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8916    /**Event with signature `ChurnApproverUpdated(address,address)` and selector `0x315457d8a8fe60f04af17c16e2f5a5e1db612b31648e58030360759ef8f3528c`.
8917```solidity
8918event ChurnApproverUpdated(address prevChurnApprover, address newChurnApprover);
8919```*/
8920    #[allow(
8921        non_camel_case_types,
8922        non_snake_case,
8923        clippy::pub_underscore_fields,
8924        clippy::style
8925    )]
8926    #[derive(Clone)]
8927    pub struct ChurnApproverUpdated {
8928        #[allow(missing_docs)]
8929        pub prevChurnApprover: alloy::sol_types::private::Address,
8930        #[allow(missing_docs)]
8931        pub newChurnApprover: alloy::sol_types::private::Address,
8932    }
8933    #[allow(
8934        non_camel_case_types,
8935        non_snake_case,
8936        clippy::pub_underscore_fields,
8937        clippy::style
8938    )]
8939    const _: () = {
8940        use alloy::sol_types as alloy_sol_types;
8941        #[automatically_derived]
8942        impl alloy_sol_types::SolEvent for ChurnApproverUpdated {
8943            type DataTuple<'a> = (
8944                alloy::sol_types::sol_data::Address,
8945                alloy::sol_types::sol_data::Address,
8946            );
8947            type DataToken<'a> = <Self::DataTuple<
8948                'a,
8949            > as alloy_sol_types::SolType>::Token<'a>;
8950            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
8951            const SIGNATURE: &'static str = "ChurnApproverUpdated(address,address)";
8952            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
8953                49u8, 84u8, 87u8, 216u8, 168u8, 254u8, 96u8, 240u8, 74u8, 241u8, 124u8,
8954                22u8, 226u8, 245u8, 165u8, 225u8, 219u8, 97u8, 43u8, 49u8, 100u8, 142u8,
8955                88u8, 3u8, 3u8, 96u8, 117u8, 158u8, 248u8, 243u8, 82u8, 140u8,
8956            ]);
8957            const ANONYMOUS: bool = false;
8958            #[allow(unused_variables)]
8959            #[inline]
8960            fn new(
8961                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
8962                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
8963            ) -> Self {
8964                Self {
8965                    prevChurnApprover: data.0,
8966                    newChurnApprover: data.1,
8967                }
8968            }
8969            #[inline]
8970            fn check_signature(
8971                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
8972            ) -> alloy_sol_types::Result<()> {
8973                if topics.0 != Self::SIGNATURE_HASH {
8974                    return Err(
8975                        alloy_sol_types::Error::invalid_event_signature_hash(
8976                            Self::SIGNATURE,
8977                            topics.0,
8978                            Self::SIGNATURE_HASH,
8979                        ),
8980                    );
8981                }
8982                Ok(())
8983            }
8984            #[inline]
8985            fn tokenize_body(&self) -> Self::DataToken<'_> {
8986                (
8987                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8988                        &self.prevChurnApprover,
8989                    ),
8990                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8991                        &self.newChurnApprover,
8992                    ),
8993                )
8994            }
8995            #[inline]
8996            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
8997                (Self::SIGNATURE_HASH.into(),)
8998            }
8999            #[inline]
9000            fn encode_topics_raw(
9001                &self,
9002                out: &mut [alloy_sol_types::abi::token::WordToken],
9003            ) -> alloy_sol_types::Result<()> {
9004                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
9005                    return Err(alloy_sol_types::Error::Overrun);
9006                }
9007                out[0usize] = alloy_sol_types::abi::token::WordToken(
9008                    Self::SIGNATURE_HASH,
9009                );
9010                Ok(())
9011            }
9012        }
9013        #[automatically_derived]
9014        impl alloy_sol_types::private::IntoLogData for ChurnApproverUpdated {
9015            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
9016                From::from(self)
9017            }
9018            fn into_log_data(self) -> alloy_sol_types::private::LogData {
9019                From::from(&self)
9020            }
9021        }
9022        #[automatically_derived]
9023        impl From<&ChurnApproverUpdated> for alloy_sol_types::private::LogData {
9024            #[inline]
9025            fn from(this: &ChurnApproverUpdated) -> alloy_sol_types::private::LogData {
9026                alloy_sol_types::SolEvent::encode_log_data(this)
9027            }
9028        }
9029    };
9030    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9031    /**Event with signature `EIP712DomainChanged()` and selector `0x0a6387c9ea3628b88a633bb4f3b151770f70085117a15f9bf3787cda53f13d31`.
9032```solidity
9033event EIP712DomainChanged();
9034```*/
9035    #[allow(
9036        non_camel_case_types,
9037        non_snake_case,
9038        clippy::pub_underscore_fields,
9039        clippy::style
9040    )]
9041    #[derive(Clone)]
9042    pub struct EIP712DomainChanged {}
9043    #[allow(
9044        non_camel_case_types,
9045        non_snake_case,
9046        clippy::pub_underscore_fields,
9047        clippy::style
9048    )]
9049    const _: () = {
9050        use alloy::sol_types as alloy_sol_types;
9051        #[automatically_derived]
9052        impl alloy_sol_types::SolEvent for EIP712DomainChanged {
9053            type DataTuple<'a> = ();
9054            type DataToken<'a> = <Self::DataTuple<
9055                'a,
9056            > as alloy_sol_types::SolType>::Token<'a>;
9057            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
9058            const SIGNATURE: &'static str = "EIP712DomainChanged()";
9059            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
9060                10u8, 99u8, 135u8, 201u8, 234u8, 54u8, 40u8, 184u8, 138u8, 99u8, 59u8,
9061                180u8, 243u8, 177u8, 81u8, 119u8, 15u8, 112u8, 8u8, 81u8, 23u8, 161u8,
9062                95u8, 155u8, 243u8, 120u8, 124u8, 218u8, 83u8, 241u8, 61u8, 49u8,
9063            ]);
9064            const ANONYMOUS: bool = false;
9065            #[allow(unused_variables)]
9066            #[inline]
9067            fn new(
9068                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
9069                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
9070            ) -> Self {
9071                Self {}
9072            }
9073            #[inline]
9074            fn check_signature(
9075                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
9076            ) -> alloy_sol_types::Result<()> {
9077                if topics.0 != Self::SIGNATURE_HASH {
9078                    return Err(
9079                        alloy_sol_types::Error::invalid_event_signature_hash(
9080                            Self::SIGNATURE,
9081                            topics.0,
9082                            Self::SIGNATURE_HASH,
9083                        ),
9084                    );
9085                }
9086                Ok(())
9087            }
9088            #[inline]
9089            fn tokenize_body(&self) -> Self::DataToken<'_> {
9090                ()
9091            }
9092            #[inline]
9093            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
9094                (Self::SIGNATURE_HASH.into(),)
9095            }
9096            #[inline]
9097            fn encode_topics_raw(
9098                &self,
9099                out: &mut [alloy_sol_types::abi::token::WordToken],
9100            ) -> alloy_sol_types::Result<()> {
9101                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
9102                    return Err(alloy_sol_types::Error::Overrun);
9103                }
9104                out[0usize] = alloy_sol_types::abi::token::WordToken(
9105                    Self::SIGNATURE_HASH,
9106                );
9107                Ok(())
9108            }
9109        }
9110        #[automatically_derived]
9111        impl alloy_sol_types::private::IntoLogData for EIP712DomainChanged {
9112            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
9113                From::from(self)
9114            }
9115            fn into_log_data(self) -> alloy_sol_types::private::LogData {
9116                From::from(&self)
9117            }
9118        }
9119        #[automatically_derived]
9120        impl From<&EIP712DomainChanged> for alloy_sol_types::private::LogData {
9121            #[inline]
9122            fn from(this: &EIP712DomainChanged) -> alloy_sol_types::private::LogData {
9123                alloy_sol_types::SolEvent::encode_log_data(this)
9124            }
9125        }
9126    };
9127    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9128    /**Event with signature `EjectionCooldownUpdated(uint256,uint256)` and selector `0xa77a91bea7b6d95a8eb5a54878a1d9e3c875e26c86a9b70e3420c5c5db193b62`.
9129```solidity
9130event EjectionCooldownUpdated(uint256 prevEjectionCooldown, uint256 newEjectionCooldown);
9131```*/
9132    #[allow(
9133        non_camel_case_types,
9134        non_snake_case,
9135        clippy::pub_underscore_fields,
9136        clippy::style
9137    )]
9138    #[derive(Clone)]
9139    pub struct EjectionCooldownUpdated {
9140        #[allow(missing_docs)]
9141        pub prevEjectionCooldown: alloy::sol_types::private::primitives::aliases::U256,
9142        #[allow(missing_docs)]
9143        pub newEjectionCooldown: alloy::sol_types::private::primitives::aliases::U256,
9144    }
9145    #[allow(
9146        non_camel_case_types,
9147        non_snake_case,
9148        clippy::pub_underscore_fields,
9149        clippy::style
9150    )]
9151    const _: () = {
9152        use alloy::sol_types as alloy_sol_types;
9153        #[automatically_derived]
9154        impl alloy_sol_types::SolEvent for EjectionCooldownUpdated {
9155            type DataTuple<'a> = (
9156                alloy::sol_types::sol_data::Uint<256>,
9157                alloy::sol_types::sol_data::Uint<256>,
9158            );
9159            type DataToken<'a> = <Self::DataTuple<
9160                'a,
9161            > as alloy_sol_types::SolType>::Token<'a>;
9162            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
9163            const SIGNATURE: &'static str = "EjectionCooldownUpdated(uint256,uint256)";
9164            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
9165                167u8, 122u8, 145u8, 190u8, 167u8, 182u8, 217u8, 90u8, 142u8, 181u8,
9166                165u8, 72u8, 120u8, 161u8, 217u8, 227u8, 200u8, 117u8, 226u8, 108u8,
9167                134u8, 169u8, 183u8, 14u8, 52u8, 32u8, 197u8, 197u8, 219u8, 25u8, 59u8,
9168                98u8,
9169            ]);
9170            const ANONYMOUS: bool = false;
9171            #[allow(unused_variables)]
9172            #[inline]
9173            fn new(
9174                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
9175                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
9176            ) -> Self {
9177                Self {
9178                    prevEjectionCooldown: data.0,
9179                    newEjectionCooldown: data.1,
9180                }
9181            }
9182            #[inline]
9183            fn check_signature(
9184                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
9185            ) -> alloy_sol_types::Result<()> {
9186                if topics.0 != Self::SIGNATURE_HASH {
9187                    return Err(
9188                        alloy_sol_types::Error::invalid_event_signature_hash(
9189                            Self::SIGNATURE,
9190                            topics.0,
9191                            Self::SIGNATURE_HASH,
9192                        ),
9193                    );
9194                }
9195                Ok(())
9196            }
9197            #[inline]
9198            fn tokenize_body(&self) -> Self::DataToken<'_> {
9199                (
9200                    <alloy::sol_types::sol_data::Uint<
9201                        256,
9202                    > as alloy_sol_types::SolType>::tokenize(&self.prevEjectionCooldown),
9203                    <alloy::sol_types::sol_data::Uint<
9204                        256,
9205                    > as alloy_sol_types::SolType>::tokenize(&self.newEjectionCooldown),
9206                )
9207            }
9208            #[inline]
9209            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
9210                (Self::SIGNATURE_HASH.into(),)
9211            }
9212            #[inline]
9213            fn encode_topics_raw(
9214                &self,
9215                out: &mut [alloy_sol_types::abi::token::WordToken],
9216            ) -> alloy_sol_types::Result<()> {
9217                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
9218                    return Err(alloy_sol_types::Error::Overrun);
9219                }
9220                out[0usize] = alloy_sol_types::abi::token::WordToken(
9221                    Self::SIGNATURE_HASH,
9222                );
9223                Ok(())
9224            }
9225        }
9226        #[automatically_derived]
9227        impl alloy_sol_types::private::IntoLogData for EjectionCooldownUpdated {
9228            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
9229                From::from(self)
9230            }
9231            fn into_log_data(self) -> alloy_sol_types::private::LogData {
9232                From::from(&self)
9233            }
9234        }
9235        #[automatically_derived]
9236        impl From<&EjectionCooldownUpdated> for alloy_sol_types::private::LogData {
9237            #[inline]
9238            fn from(
9239                this: &EjectionCooldownUpdated,
9240            ) -> alloy_sol_types::private::LogData {
9241                alloy_sol_types::SolEvent::encode_log_data(this)
9242            }
9243        }
9244    };
9245    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9246    /**Event with signature `EjectorUpdated(address,address)` and selector `0x8f30ab09f43a6c157d7fce7e0a13c003042c1c95e8a72e7a146a21c0caa24dc9`.
9247```solidity
9248event EjectorUpdated(address prevEjector, address newEjector);
9249```*/
9250    #[allow(
9251        non_camel_case_types,
9252        non_snake_case,
9253        clippy::pub_underscore_fields,
9254        clippy::style
9255    )]
9256    #[derive(Clone)]
9257    pub struct EjectorUpdated {
9258        #[allow(missing_docs)]
9259        pub prevEjector: alloy::sol_types::private::Address,
9260        #[allow(missing_docs)]
9261        pub newEjector: alloy::sol_types::private::Address,
9262    }
9263    #[allow(
9264        non_camel_case_types,
9265        non_snake_case,
9266        clippy::pub_underscore_fields,
9267        clippy::style
9268    )]
9269    const _: () = {
9270        use alloy::sol_types as alloy_sol_types;
9271        #[automatically_derived]
9272        impl alloy_sol_types::SolEvent for EjectorUpdated {
9273            type DataTuple<'a> = (
9274                alloy::sol_types::sol_data::Address,
9275                alloy::sol_types::sol_data::Address,
9276            );
9277            type DataToken<'a> = <Self::DataTuple<
9278                'a,
9279            > as alloy_sol_types::SolType>::Token<'a>;
9280            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
9281            const SIGNATURE: &'static str = "EjectorUpdated(address,address)";
9282            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
9283                143u8, 48u8, 171u8, 9u8, 244u8, 58u8, 108u8, 21u8, 125u8, 127u8, 206u8,
9284                126u8, 10u8, 19u8, 192u8, 3u8, 4u8, 44u8, 28u8, 149u8, 232u8, 167u8,
9285                46u8, 122u8, 20u8, 106u8, 33u8, 192u8, 202u8, 162u8, 77u8, 201u8,
9286            ]);
9287            const ANONYMOUS: bool = false;
9288            #[allow(unused_variables)]
9289            #[inline]
9290            fn new(
9291                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
9292                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
9293            ) -> Self {
9294                Self {
9295                    prevEjector: data.0,
9296                    newEjector: data.1,
9297                }
9298            }
9299            #[inline]
9300            fn check_signature(
9301                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
9302            ) -> alloy_sol_types::Result<()> {
9303                if topics.0 != Self::SIGNATURE_HASH {
9304                    return Err(
9305                        alloy_sol_types::Error::invalid_event_signature_hash(
9306                            Self::SIGNATURE,
9307                            topics.0,
9308                            Self::SIGNATURE_HASH,
9309                        ),
9310                    );
9311                }
9312                Ok(())
9313            }
9314            #[inline]
9315            fn tokenize_body(&self) -> Self::DataToken<'_> {
9316                (
9317                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
9318                        &self.prevEjector,
9319                    ),
9320                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
9321                        &self.newEjector,
9322                    ),
9323                )
9324            }
9325            #[inline]
9326            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
9327                (Self::SIGNATURE_HASH.into(),)
9328            }
9329            #[inline]
9330            fn encode_topics_raw(
9331                &self,
9332                out: &mut [alloy_sol_types::abi::token::WordToken],
9333            ) -> alloy_sol_types::Result<()> {
9334                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
9335                    return Err(alloy_sol_types::Error::Overrun);
9336                }
9337                out[0usize] = alloy_sol_types::abi::token::WordToken(
9338                    Self::SIGNATURE_HASH,
9339                );
9340                Ok(())
9341            }
9342        }
9343        #[automatically_derived]
9344        impl alloy_sol_types::private::IntoLogData for EjectorUpdated {
9345            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
9346                From::from(self)
9347            }
9348            fn into_log_data(self) -> alloy_sol_types::private::LogData {
9349                From::from(&self)
9350            }
9351        }
9352        #[automatically_derived]
9353        impl From<&EjectorUpdated> for alloy_sol_types::private::LogData {
9354            #[inline]
9355            fn from(this: &EjectorUpdated) -> alloy_sol_types::private::LogData {
9356                alloy_sol_types::SolEvent::encode_log_data(this)
9357            }
9358        }
9359    };
9360    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9361    /**Event with signature `Initialized(uint8)` and selector `0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498`.
9362```solidity
9363event Initialized(uint8 version);
9364```*/
9365    #[allow(
9366        non_camel_case_types,
9367        non_snake_case,
9368        clippy::pub_underscore_fields,
9369        clippy::style
9370    )]
9371    #[derive(Clone)]
9372    pub struct Initialized {
9373        #[allow(missing_docs)]
9374        pub version: u8,
9375    }
9376    #[allow(
9377        non_camel_case_types,
9378        non_snake_case,
9379        clippy::pub_underscore_fields,
9380        clippy::style
9381    )]
9382    const _: () = {
9383        use alloy::sol_types as alloy_sol_types;
9384        #[automatically_derived]
9385        impl alloy_sol_types::SolEvent for Initialized {
9386            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
9387            type DataToken<'a> = <Self::DataTuple<
9388                'a,
9389            > as alloy_sol_types::SolType>::Token<'a>;
9390            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
9391            const SIGNATURE: &'static str = "Initialized(uint8)";
9392            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
9393                127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8,
9394                19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8,
9395                146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8,
9396            ]);
9397            const ANONYMOUS: bool = false;
9398            #[allow(unused_variables)]
9399            #[inline]
9400            fn new(
9401                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
9402                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
9403            ) -> Self {
9404                Self { version: data.0 }
9405            }
9406            #[inline]
9407            fn check_signature(
9408                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
9409            ) -> alloy_sol_types::Result<()> {
9410                if topics.0 != Self::SIGNATURE_HASH {
9411                    return Err(
9412                        alloy_sol_types::Error::invalid_event_signature_hash(
9413                            Self::SIGNATURE,
9414                            topics.0,
9415                            Self::SIGNATURE_HASH,
9416                        ),
9417                    );
9418                }
9419                Ok(())
9420            }
9421            #[inline]
9422            fn tokenize_body(&self) -> Self::DataToken<'_> {
9423                (
9424                    <alloy::sol_types::sol_data::Uint<
9425                        8,
9426                    > as alloy_sol_types::SolType>::tokenize(&self.version),
9427                )
9428            }
9429            #[inline]
9430            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
9431                (Self::SIGNATURE_HASH.into(),)
9432            }
9433            #[inline]
9434            fn encode_topics_raw(
9435                &self,
9436                out: &mut [alloy_sol_types::abi::token::WordToken],
9437            ) -> alloy_sol_types::Result<()> {
9438                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
9439                    return Err(alloy_sol_types::Error::Overrun);
9440                }
9441                out[0usize] = alloy_sol_types::abi::token::WordToken(
9442                    Self::SIGNATURE_HASH,
9443                );
9444                Ok(())
9445            }
9446        }
9447        #[automatically_derived]
9448        impl alloy_sol_types::private::IntoLogData for Initialized {
9449            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
9450                From::from(self)
9451            }
9452            fn into_log_data(self) -> alloy_sol_types::private::LogData {
9453                From::from(&self)
9454            }
9455        }
9456        #[automatically_derived]
9457        impl From<&Initialized> for alloy_sol_types::private::LogData {
9458            #[inline]
9459            fn from(this: &Initialized) -> alloy_sol_types::private::LogData {
9460                alloy_sol_types::SolEvent::encode_log_data(this)
9461            }
9462        }
9463    };
9464    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9465    /**Event with signature `M2QuorumRegistrationDisabled()` and selector `0x0fc3c0e6f8b4795f371e19de7f4c5733dd9e549fa8c39e5842eb66c31572d99e`.
9466```solidity
9467event M2QuorumRegistrationDisabled();
9468```*/
9469    #[allow(
9470        non_camel_case_types,
9471        non_snake_case,
9472        clippy::pub_underscore_fields,
9473        clippy::style
9474    )]
9475    #[derive(Clone)]
9476    pub struct M2QuorumRegistrationDisabled {}
9477    #[allow(
9478        non_camel_case_types,
9479        non_snake_case,
9480        clippy::pub_underscore_fields,
9481        clippy::style
9482    )]
9483    const _: () = {
9484        use alloy::sol_types as alloy_sol_types;
9485        #[automatically_derived]
9486        impl alloy_sol_types::SolEvent for M2QuorumRegistrationDisabled {
9487            type DataTuple<'a> = ();
9488            type DataToken<'a> = <Self::DataTuple<
9489                'a,
9490            > as alloy_sol_types::SolType>::Token<'a>;
9491            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
9492            const SIGNATURE: &'static str = "M2QuorumRegistrationDisabled()";
9493            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
9494                15u8, 195u8, 192u8, 230u8, 248u8, 180u8, 121u8, 95u8, 55u8, 30u8, 25u8,
9495                222u8, 127u8, 76u8, 87u8, 51u8, 221u8, 158u8, 84u8, 159u8, 168u8, 195u8,
9496                158u8, 88u8, 66u8, 235u8, 102u8, 195u8, 21u8, 114u8, 217u8, 158u8,
9497            ]);
9498            const ANONYMOUS: bool = false;
9499            #[allow(unused_variables)]
9500            #[inline]
9501            fn new(
9502                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
9503                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
9504            ) -> Self {
9505                Self {}
9506            }
9507            #[inline]
9508            fn check_signature(
9509                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
9510            ) -> alloy_sol_types::Result<()> {
9511                if topics.0 != Self::SIGNATURE_HASH {
9512                    return Err(
9513                        alloy_sol_types::Error::invalid_event_signature_hash(
9514                            Self::SIGNATURE,
9515                            topics.0,
9516                            Self::SIGNATURE_HASH,
9517                        ),
9518                    );
9519                }
9520                Ok(())
9521            }
9522            #[inline]
9523            fn tokenize_body(&self) -> Self::DataToken<'_> {
9524                ()
9525            }
9526            #[inline]
9527            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
9528                (Self::SIGNATURE_HASH.into(),)
9529            }
9530            #[inline]
9531            fn encode_topics_raw(
9532                &self,
9533                out: &mut [alloy_sol_types::abi::token::WordToken],
9534            ) -> alloy_sol_types::Result<()> {
9535                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
9536                    return Err(alloy_sol_types::Error::Overrun);
9537                }
9538                out[0usize] = alloy_sol_types::abi::token::WordToken(
9539                    Self::SIGNATURE_HASH,
9540                );
9541                Ok(())
9542            }
9543        }
9544        #[automatically_derived]
9545        impl alloy_sol_types::private::IntoLogData for M2QuorumRegistrationDisabled {
9546            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
9547                From::from(self)
9548            }
9549            fn into_log_data(self) -> alloy_sol_types::private::LogData {
9550                From::from(&self)
9551            }
9552        }
9553        #[automatically_derived]
9554        impl From<&M2QuorumRegistrationDisabled> for alloy_sol_types::private::LogData {
9555            #[inline]
9556            fn from(
9557                this: &M2QuorumRegistrationDisabled,
9558            ) -> alloy_sol_types::private::LogData {
9559                alloy_sol_types::SolEvent::encode_log_data(this)
9560            }
9561        }
9562    };
9563    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9564    /**Event with signature `OperatorDeregistered(address,bytes32)` and selector `0x396fdcb180cb0fea26928113fb0fd1c3549863f9cd563e6a184f1d578116c8e4`.
9565```solidity
9566event OperatorDeregistered(address indexed operator, bytes32 indexed operatorId);
9567```*/
9568    #[allow(
9569        non_camel_case_types,
9570        non_snake_case,
9571        clippy::pub_underscore_fields,
9572        clippy::style
9573    )]
9574    #[derive(Clone)]
9575    pub struct OperatorDeregistered {
9576        #[allow(missing_docs)]
9577        pub operator: alloy::sol_types::private::Address,
9578        #[allow(missing_docs)]
9579        pub operatorId: alloy::sol_types::private::FixedBytes<32>,
9580    }
9581    #[allow(
9582        non_camel_case_types,
9583        non_snake_case,
9584        clippy::pub_underscore_fields,
9585        clippy::style
9586    )]
9587    const _: () = {
9588        use alloy::sol_types as alloy_sol_types;
9589        #[automatically_derived]
9590        impl alloy_sol_types::SolEvent for OperatorDeregistered {
9591            type DataTuple<'a> = ();
9592            type DataToken<'a> = <Self::DataTuple<
9593                'a,
9594            > as alloy_sol_types::SolType>::Token<'a>;
9595            type TopicList = (
9596                alloy_sol_types::sol_data::FixedBytes<32>,
9597                alloy::sol_types::sol_data::Address,
9598                alloy::sol_types::sol_data::FixedBytes<32>,
9599            );
9600            const SIGNATURE: &'static str = "OperatorDeregistered(address,bytes32)";
9601            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
9602                57u8, 111u8, 220u8, 177u8, 128u8, 203u8, 15u8, 234u8, 38u8, 146u8, 129u8,
9603                19u8, 251u8, 15u8, 209u8, 195u8, 84u8, 152u8, 99u8, 249u8, 205u8, 86u8,
9604                62u8, 106u8, 24u8, 79u8, 29u8, 87u8, 129u8, 22u8, 200u8, 228u8,
9605            ]);
9606            const ANONYMOUS: bool = false;
9607            #[allow(unused_variables)]
9608            #[inline]
9609            fn new(
9610                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
9611                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
9612            ) -> Self {
9613                Self {
9614                    operator: topics.1,
9615                    operatorId: topics.2,
9616                }
9617            }
9618            #[inline]
9619            fn check_signature(
9620                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
9621            ) -> alloy_sol_types::Result<()> {
9622                if topics.0 != Self::SIGNATURE_HASH {
9623                    return Err(
9624                        alloy_sol_types::Error::invalid_event_signature_hash(
9625                            Self::SIGNATURE,
9626                            topics.0,
9627                            Self::SIGNATURE_HASH,
9628                        ),
9629                    );
9630                }
9631                Ok(())
9632            }
9633            #[inline]
9634            fn tokenize_body(&self) -> Self::DataToken<'_> {
9635                ()
9636            }
9637            #[inline]
9638            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
9639                (
9640                    Self::SIGNATURE_HASH.into(),
9641                    self.operator.clone(),
9642                    self.operatorId.clone(),
9643                )
9644            }
9645            #[inline]
9646            fn encode_topics_raw(
9647                &self,
9648                out: &mut [alloy_sol_types::abi::token::WordToken],
9649            ) -> alloy_sol_types::Result<()> {
9650                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
9651                    return Err(alloy_sol_types::Error::Overrun);
9652                }
9653                out[0usize] = alloy_sol_types::abi::token::WordToken(
9654                    Self::SIGNATURE_HASH,
9655                );
9656                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
9657                    &self.operator,
9658                );
9659                out[2usize] = <alloy::sol_types::sol_data::FixedBytes<
9660                    32,
9661                > as alloy_sol_types::EventTopic>::encode_topic(&self.operatorId);
9662                Ok(())
9663            }
9664        }
9665        #[automatically_derived]
9666        impl alloy_sol_types::private::IntoLogData for OperatorDeregistered {
9667            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
9668                From::from(self)
9669            }
9670            fn into_log_data(self) -> alloy_sol_types::private::LogData {
9671                From::from(&self)
9672            }
9673        }
9674        #[automatically_derived]
9675        impl From<&OperatorDeregistered> for alloy_sol_types::private::LogData {
9676            #[inline]
9677            fn from(this: &OperatorDeregistered) -> alloy_sol_types::private::LogData {
9678                alloy_sol_types::SolEvent::encode_log_data(this)
9679            }
9680        }
9681    };
9682    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9683    /**Event with signature `OperatorRegistered(address,bytes32)` and selector `0xe8e68cef1c3a761ed7be7e8463a375f27f7bc335e51824223cacce636ec5c3fe`.
9684```solidity
9685event OperatorRegistered(address indexed operator, bytes32 indexed operatorId);
9686```*/
9687    #[allow(
9688        non_camel_case_types,
9689        non_snake_case,
9690        clippy::pub_underscore_fields,
9691        clippy::style
9692    )]
9693    #[derive(Clone)]
9694    pub struct OperatorRegistered {
9695        #[allow(missing_docs)]
9696        pub operator: alloy::sol_types::private::Address,
9697        #[allow(missing_docs)]
9698        pub operatorId: alloy::sol_types::private::FixedBytes<32>,
9699    }
9700    #[allow(
9701        non_camel_case_types,
9702        non_snake_case,
9703        clippy::pub_underscore_fields,
9704        clippy::style
9705    )]
9706    const _: () = {
9707        use alloy::sol_types as alloy_sol_types;
9708        #[automatically_derived]
9709        impl alloy_sol_types::SolEvent for OperatorRegistered {
9710            type DataTuple<'a> = ();
9711            type DataToken<'a> = <Self::DataTuple<
9712                'a,
9713            > as alloy_sol_types::SolType>::Token<'a>;
9714            type TopicList = (
9715                alloy_sol_types::sol_data::FixedBytes<32>,
9716                alloy::sol_types::sol_data::Address,
9717                alloy::sol_types::sol_data::FixedBytes<32>,
9718            );
9719            const SIGNATURE: &'static str = "OperatorRegistered(address,bytes32)";
9720            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
9721                232u8, 230u8, 140u8, 239u8, 28u8, 58u8, 118u8, 30u8, 215u8, 190u8, 126u8,
9722                132u8, 99u8, 163u8, 117u8, 242u8, 127u8, 123u8, 195u8, 53u8, 229u8, 24u8,
9723                36u8, 34u8, 60u8, 172u8, 206u8, 99u8, 110u8, 197u8, 195u8, 254u8,
9724            ]);
9725            const ANONYMOUS: bool = false;
9726            #[allow(unused_variables)]
9727            #[inline]
9728            fn new(
9729                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
9730                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
9731            ) -> Self {
9732                Self {
9733                    operator: topics.1,
9734                    operatorId: topics.2,
9735                }
9736            }
9737            #[inline]
9738            fn check_signature(
9739                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
9740            ) -> alloy_sol_types::Result<()> {
9741                if topics.0 != Self::SIGNATURE_HASH {
9742                    return Err(
9743                        alloy_sol_types::Error::invalid_event_signature_hash(
9744                            Self::SIGNATURE,
9745                            topics.0,
9746                            Self::SIGNATURE_HASH,
9747                        ),
9748                    );
9749                }
9750                Ok(())
9751            }
9752            #[inline]
9753            fn tokenize_body(&self) -> Self::DataToken<'_> {
9754                ()
9755            }
9756            #[inline]
9757            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
9758                (
9759                    Self::SIGNATURE_HASH.into(),
9760                    self.operator.clone(),
9761                    self.operatorId.clone(),
9762                )
9763            }
9764            #[inline]
9765            fn encode_topics_raw(
9766                &self,
9767                out: &mut [alloy_sol_types::abi::token::WordToken],
9768            ) -> alloy_sol_types::Result<()> {
9769                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
9770                    return Err(alloy_sol_types::Error::Overrun);
9771                }
9772                out[0usize] = alloy_sol_types::abi::token::WordToken(
9773                    Self::SIGNATURE_HASH,
9774                );
9775                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
9776                    &self.operator,
9777                );
9778                out[2usize] = <alloy::sol_types::sol_data::FixedBytes<
9779                    32,
9780                > as alloy_sol_types::EventTopic>::encode_topic(&self.operatorId);
9781                Ok(())
9782            }
9783        }
9784        #[automatically_derived]
9785        impl alloy_sol_types::private::IntoLogData for OperatorRegistered {
9786            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
9787                From::from(self)
9788            }
9789            fn into_log_data(self) -> alloy_sol_types::private::LogData {
9790                From::from(&self)
9791            }
9792        }
9793        #[automatically_derived]
9794        impl From<&OperatorRegistered> for alloy_sol_types::private::LogData {
9795            #[inline]
9796            fn from(this: &OperatorRegistered) -> alloy_sol_types::private::LogData {
9797                alloy_sol_types::SolEvent::encode_log_data(this)
9798            }
9799        }
9800    };
9801    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9802    /**Event with signature `OperatorSetParamsUpdated(uint8,(uint32,uint16,uint16))` and selector `0x3ee6fe8d54610244c3e9d3c066ae4aee997884aa28f10616ae821925401318ac`.
9803```solidity
9804event OperatorSetParamsUpdated(uint8 indexed quorumNumber, ISlashingRegistryCoordinatorTypes.OperatorSetParam operatorSetParams);
9805```*/
9806    #[allow(
9807        non_camel_case_types,
9808        non_snake_case,
9809        clippy::pub_underscore_fields,
9810        clippy::style
9811    )]
9812    #[derive(Clone)]
9813    pub struct OperatorSetParamsUpdated {
9814        #[allow(missing_docs)]
9815        pub quorumNumber: u8,
9816        #[allow(missing_docs)]
9817        pub operatorSetParams: <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
9818    }
9819    #[allow(
9820        non_camel_case_types,
9821        non_snake_case,
9822        clippy::pub_underscore_fields,
9823        clippy::style
9824    )]
9825    const _: () = {
9826        use alloy::sol_types as alloy_sol_types;
9827        #[automatically_derived]
9828        impl alloy_sol_types::SolEvent for OperatorSetParamsUpdated {
9829            type DataTuple<'a> = (ISlashingRegistryCoordinatorTypes::OperatorSetParam,);
9830            type DataToken<'a> = <Self::DataTuple<
9831                'a,
9832            > as alloy_sol_types::SolType>::Token<'a>;
9833            type TopicList = (
9834                alloy_sol_types::sol_data::FixedBytes<32>,
9835                alloy::sol_types::sol_data::Uint<8>,
9836            );
9837            const SIGNATURE: &'static str = "OperatorSetParamsUpdated(uint8,(uint32,uint16,uint16))";
9838            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
9839                62u8, 230u8, 254u8, 141u8, 84u8, 97u8, 2u8, 68u8, 195u8, 233u8, 211u8,
9840                192u8, 102u8, 174u8, 74u8, 238u8, 153u8, 120u8, 132u8, 170u8, 40u8,
9841                241u8, 6u8, 22u8, 174u8, 130u8, 25u8, 37u8, 64u8, 19u8, 24u8, 172u8,
9842            ]);
9843            const ANONYMOUS: bool = false;
9844            #[allow(unused_variables)]
9845            #[inline]
9846            fn new(
9847                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
9848                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
9849            ) -> Self {
9850                Self {
9851                    quorumNumber: topics.1,
9852                    operatorSetParams: data.0,
9853                }
9854            }
9855            #[inline]
9856            fn check_signature(
9857                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
9858            ) -> alloy_sol_types::Result<()> {
9859                if topics.0 != Self::SIGNATURE_HASH {
9860                    return Err(
9861                        alloy_sol_types::Error::invalid_event_signature_hash(
9862                            Self::SIGNATURE,
9863                            topics.0,
9864                            Self::SIGNATURE_HASH,
9865                        ),
9866                    );
9867                }
9868                Ok(())
9869            }
9870            #[inline]
9871            fn tokenize_body(&self) -> Self::DataToken<'_> {
9872                (
9873                    <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy_sol_types::SolType>::tokenize(
9874                        &self.operatorSetParams,
9875                    ),
9876                )
9877            }
9878            #[inline]
9879            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
9880                (Self::SIGNATURE_HASH.into(), self.quorumNumber.clone())
9881            }
9882            #[inline]
9883            fn encode_topics_raw(
9884                &self,
9885                out: &mut [alloy_sol_types::abi::token::WordToken],
9886            ) -> alloy_sol_types::Result<()> {
9887                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
9888                    return Err(alloy_sol_types::Error::Overrun);
9889                }
9890                out[0usize] = alloy_sol_types::abi::token::WordToken(
9891                    Self::SIGNATURE_HASH,
9892                );
9893                out[1usize] = <alloy::sol_types::sol_data::Uint<
9894                    8,
9895                > as alloy_sol_types::EventTopic>::encode_topic(&self.quorumNumber);
9896                Ok(())
9897            }
9898        }
9899        #[automatically_derived]
9900        impl alloy_sol_types::private::IntoLogData for OperatorSetParamsUpdated {
9901            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
9902                From::from(self)
9903            }
9904            fn into_log_data(self) -> alloy_sol_types::private::LogData {
9905                From::from(&self)
9906            }
9907        }
9908        #[automatically_derived]
9909        impl From<&OperatorSetParamsUpdated> for alloy_sol_types::private::LogData {
9910            #[inline]
9911            fn from(
9912                this: &OperatorSetParamsUpdated,
9913            ) -> alloy_sol_types::private::LogData {
9914                alloy_sol_types::SolEvent::encode_log_data(this)
9915            }
9916        }
9917    };
9918    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9919    /**Event with signature `OperatorSetsEnabled()` and selector `0x0b88306ff4627121f5b3e5b1c5f88f6b1e42fd2c0478ef1c91662d49d1f07755`.
9920```solidity
9921event OperatorSetsEnabled();
9922```*/
9923    #[allow(
9924        non_camel_case_types,
9925        non_snake_case,
9926        clippy::pub_underscore_fields,
9927        clippy::style
9928    )]
9929    #[derive(Clone)]
9930    pub struct OperatorSetsEnabled {}
9931    #[allow(
9932        non_camel_case_types,
9933        non_snake_case,
9934        clippy::pub_underscore_fields,
9935        clippy::style
9936    )]
9937    const _: () = {
9938        use alloy::sol_types as alloy_sol_types;
9939        #[automatically_derived]
9940        impl alloy_sol_types::SolEvent for OperatorSetsEnabled {
9941            type DataTuple<'a> = ();
9942            type DataToken<'a> = <Self::DataTuple<
9943                'a,
9944            > as alloy_sol_types::SolType>::Token<'a>;
9945            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
9946            const SIGNATURE: &'static str = "OperatorSetsEnabled()";
9947            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
9948                11u8, 136u8, 48u8, 111u8, 244u8, 98u8, 113u8, 33u8, 245u8, 179u8, 229u8,
9949                177u8, 197u8, 248u8, 143u8, 107u8, 30u8, 66u8, 253u8, 44u8, 4u8, 120u8,
9950                239u8, 28u8, 145u8, 102u8, 45u8, 73u8, 209u8, 240u8, 119u8, 85u8,
9951            ]);
9952            const ANONYMOUS: bool = false;
9953            #[allow(unused_variables)]
9954            #[inline]
9955            fn new(
9956                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
9957                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
9958            ) -> Self {
9959                Self {}
9960            }
9961            #[inline]
9962            fn check_signature(
9963                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
9964            ) -> alloy_sol_types::Result<()> {
9965                if topics.0 != Self::SIGNATURE_HASH {
9966                    return Err(
9967                        alloy_sol_types::Error::invalid_event_signature_hash(
9968                            Self::SIGNATURE,
9969                            topics.0,
9970                            Self::SIGNATURE_HASH,
9971                        ),
9972                    );
9973                }
9974                Ok(())
9975            }
9976            #[inline]
9977            fn tokenize_body(&self) -> Self::DataToken<'_> {
9978                ()
9979            }
9980            #[inline]
9981            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
9982                (Self::SIGNATURE_HASH.into(),)
9983            }
9984            #[inline]
9985            fn encode_topics_raw(
9986                &self,
9987                out: &mut [alloy_sol_types::abi::token::WordToken],
9988            ) -> alloy_sol_types::Result<()> {
9989                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
9990                    return Err(alloy_sol_types::Error::Overrun);
9991                }
9992                out[0usize] = alloy_sol_types::abi::token::WordToken(
9993                    Self::SIGNATURE_HASH,
9994                );
9995                Ok(())
9996            }
9997        }
9998        #[automatically_derived]
9999        impl alloy_sol_types::private::IntoLogData for OperatorSetsEnabled {
10000            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
10001                From::from(self)
10002            }
10003            fn into_log_data(self) -> alloy_sol_types::private::LogData {
10004                From::from(&self)
10005            }
10006        }
10007        #[automatically_derived]
10008        impl From<&OperatorSetsEnabled> for alloy_sol_types::private::LogData {
10009            #[inline]
10010            fn from(this: &OperatorSetsEnabled) -> alloy_sol_types::private::LogData {
10011                alloy_sol_types::SolEvent::encode_log_data(this)
10012            }
10013        }
10014    };
10015    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10016    /**Event with signature `OperatorSocketUpdate(bytes32,string)` and selector `0xec2963ab21c1e50e1e582aa542af2e4bf7bf38e6e1403c27b42e1c5d6e621eaa`.
10017```solidity
10018event OperatorSocketUpdate(bytes32 indexed operatorId, string socket);
10019```*/
10020    #[allow(
10021        non_camel_case_types,
10022        non_snake_case,
10023        clippy::pub_underscore_fields,
10024        clippy::style
10025    )]
10026    #[derive(Clone)]
10027    pub struct OperatorSocketUpdate {
10028        #[allow(missing_docs)]
10029        pub operatorId: alloy::sol_types::private::FixedBytes<32>,
10030        #[allow(missing_docs)]
10031        pub socket: alloy::sol_types::private::String,
10032    }
10033    #[allow(
10034        non_camel_case_types,
10035        non_snake_case,
10036        clippy::pub_underscore_fields,
10037        clippy::style
10038    )]
10039    const _: () = {
10040        use alloy::sol_types as alloy_sol_types;
10041        #[automatically_derived]
10042        impl alloy_sol_types::SolEvent for OperatorSocketUpdate {
10043            type DataTuple<'a> = (alloy::sol_types::sol_data::String,);
10044            type DataToken<'a> = <Self::DataTuple<
10045                'a,
10046            > as alloy_sol_types::SolType>::Token<'a>;
10047            type TopicList = (
10048                alloy_sol_types::sol_data::FixedBytes<32>,
10049                alloy::sol_types::sol_data::FixedBytes<32>,
10050            );
10051            const SIGNATURE: &'static str = "OperatorSocketUpdate(bytes32,string)";
10052            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
10053                236u8, 41u8, 99u8, 171u8, 33u8, 193u8, 229u8, 14u8, 30u8, 88u8, 42u8,
10054                165u8, 66u8, 175u8, 46u8, 75u8, 247u8, 191u8, 56u8, 230u8, 225u8, 64u8,
10055                60u8, 39u8, 180u8, 46u8, 28u8, 93u8, 110u8, 98u8, 30u8, 170u8,
10056            ]);
10057            const ANONYMOUS: bool = false;
10058            #[allow(unused_variables)]
10059            #[inline]
10060            fn new(
10061                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
10062                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
10063            ) -> Self {
10064                Self {
10065                    operatorId: topics.1,
10066                    socket: data.0,
10067                }
10068            }
10069            #[inline]
10070            fn check_signature(
10071                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
10072            ) -> alloy_sol_types::Result<()> {
10073                if topics.0 != Self::SIGNATURE_HASH {
10074                    return Err(
10075                        alloy_sol_types::Error::invalid_event_signature_hash(
10076                            Self::SIGNATURE,
10077                            topics.0,
10078                            Self::SIGNATURE_HASH,
10079                        ),
10080                    );
10081                }
10082                Ok(())
10083            }
10084            #[inline]
10085            fn tokenize_body(&self) -> Self::DataToken<'_> {
10086                (
10087                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
10088                        &self.socket,
10089                    ),
10090                )
10091            }
10092            #[inline]
10093            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
10094                (Self::SIGNATURE_HASH.into(), self.operatorId.clone())
10095            }
10096            #[inline]
10097            fn encode_topics_raw(
10098                &self,
10099                out: &mut [alloy_sol_types::abi::token::WordToken],
10100            ) -> alloy_sol_types::Result<()> {
10101                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
10102                    return Err(alloy_sol_types::Error::Overrun);
10103                }
10104                out[0usize] = alloy_sol_types::abi::token::WordToken(
10105                    Self::SIGNATURE_HASH,
10106                );
10107                out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
10108                    32,
10109                > as alloy_sol_types::EventTopic>::encode_topic(&self.operatorId);
10110                Ok(())
10111            }
10112        }
10113        #[automatically_derived]
10114        impl alloy_sol_types::private::IntoLogData for OperatorSocketUpdate {
10115            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
10116                From::from(self)
10117            }
10118            fn into_log_data(self) -> alloy_sol_types::private::LogData {
10119                From::from(&self)
10120            }
10121        }
10122        #[automatically_derived]
10123        impl From<&OperatorSocketUpdate> for alloy_sol_types::private::LogData {
10124            #[inline]
10125            fn from(this: &OperatorSocketUpdate) -> alloy_sol_types::private::LogData {
10126                alloy_sol_types::SolEvent::encode_log_data(this)
10127            }
10128        }
10129    };
10130    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10131    /**Event with signature `OwnershipTransferred(address,address)` and selector `0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0`.
10132```solidity
10133event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
10134```*/
10135    #[allow(
10136        non_camel_case_types,
10137        non_snake_case,
10138        clippy::pub_underscore_fields,
10139        clippy::style
10140    )]
10141    #[derive(Clone)]
10142    pub struct OwnershipTransferred {
10143        #[allow(missing_docs)]
10144        pub previousOwner: alloy::sol_types::private::Address,
10145        #[allow(missing_docs)]
10146        pub newOwner: alloy::sol_types::private::Address,
10147    }
10148    #[allow(
10149        non_camel_case_types,
10150        non_snake_case,
10151        clippy::pub_underscore_fields,
10152        clippy::style
10153    )]
10154    const _: () = {
10155        use alloy::sol_types as alloy_sol_types;
10156        #[automatically_derived]
10157        impl alloy_sol_types::SolEvent for OwnershipTransferred {
10158            type DataTuple<'a> = ();
10159            type DataToken<'a> = <Self::DataTuple<
10160                'a,
10161            > as alloy_sol_types::SolType>::Token<'a>;
10162            type TopicList = (
10163                alloy_sol_types::sol_data::FixedBytes<32>,
10164                alloy::sol_types::sol_data::Address,
10165                alloy::sol_types::sol_data::Address,
10166            );
10167            const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
10168            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
10169                139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
10170                31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
10171                218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
10172            ]);
10173            const ANONYMOUS: bool = false;
10174            #[allow(unused_variables)]
10175            #[inline]
10176            fn new(
10177                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
10178                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
10179            ) -> Self {
10180                Self {
10181                    previousOwner: topics.1,
10182                    newOwner: topics.2,
10183                }
10184            }
10185            #[inline]
10186            fn check_signature(
10187                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
10188            ) -> alloy_sol_types::Result<()> {
10189                if topics.0 != Self::SIGNATURE_HASH {
10190                    return Err(
10191                        alloy_sol_types::Error::invalid_event_signature_hash(
10192                            Self::SIGNATURE,
10193                            topics.0,
10194                            Self::SIGNATURE_HASH,
10195                        ),
10196                    );
10197                }
10198                Ok(())
10199            }
10200            #[inline]
10201            fn tokenize_body(&self) -> Self::DataToken<'_> {
10202                ()
10203            }
10204            #[inline]
10205            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
10206                (
10207                    Self::SIGNATURE_HASH.into(),
10208                    self.previousOwner.clone(),
10209                    self.newOwner.clone(),
10210                )
10211            }
10212            #[inline]
10213            fn encode_topics_raw(
10214                &self,
10215                out: &mut [alloy_sol_types::abi::token::WordToken],
10216            ) -> alloy_sol_types::Result<()> {
10217                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
10218                    return Err(alloy_sol_types::Error::Overrun);
10219                }
10220                out[0usize] = alloy_sol_types::abi::token::WordToken(
10221                    Self::SIGNATURE_HASH,
10222                );
10223                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
10224                    &self.previousOwner,
10225                );
10226                out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
10227                    &self.newOwner,
10228                );
10229                Ok(())
10230            }
10231        }
10232        #[automatically_derived]
10233        impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
10234            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
10235                From::from(self)
10236            }
10237            fn into_log_data(self) -> alloy_sol_types::private::LogData {
10238                From::from(&self)
10239            }
10240        }
10241        #[automatically_derived]
10242        impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
10243            #[inline]
10244            fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
10245                alloy_sol_types::SolEvent::encode_log_data(this)
10246            }
10247        }
10248    };
10249    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10250    /**Event with signature `Paused(address,uint256)` and selector `0xab40a374bc51de372200a8bc981af8c9ecdc08dfdaef0bb6e09f88f3c616ef3d`.
10251```solidity
10252event Paused(address indexed account, uint256 newPausedStatus);
10253```*/
10254    #[allow(
10255        non_camel_case_types,
10256        non_snake_case,
10257        clippy::pub_underscore_fields,
10258        clippy::style
10259    )]
10260    #[derive(Clone)]
10261    pub struct Paused {
10262        #[allow(missing_docs)]
10263        pub account: alloy::sol_types::private::Address,
10264        #[allow(missing_docs)]
10265        pub newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
10266    }
10267    #[allow(
10268        non_camel_case_types,
10269        non_snake_case,
10270        clippy::pub_underscore_fields,
10271        clippy::style
10272    )]
10273    const _: () = {
10274        use alloy::sol_types as alloy_sol_types;
10275        #[automatically_derived]
10276        impl alloy_sol_types::SolEvent for Paused {
10277            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
10278            type DataToken<'a> = <Self::DataTuple<
10279                'a,
10280            > as alloy_sol_types::SolType>::Token<'a>;
10281            type TopicList = (
10282                alloy_sol_types::sol_data::FixedBytes<32>,
10283                alloy::sol_types::sol_data::Address,
10284            );
10285            const SIGNATURE: &'static str = "Paused(address,uint256)";
10286            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
10287                171u8, 64u8, 163u8, 116u8, 188u8, 81u8, 222u8, 55u8, 34u8, 0u8, 168u8,
10288                188u8, 152u8, 26u8, 248u8, 201u8, 236u8, 220u8, 8u8, 223u8, 218u8, 239u8,
10289                11u8, 182u8, 224u8, 159u8, 136u8, 243u8, 198u8, 22u8, 239u8, 61u8,
10290            ]);
10291            const ANONYMOUS: bool = false;
10292            #[allow(unused_variables)]
10293            #[inline]
10294            fn new(
10295                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
10296                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
10297            ) -> Self {
10298                Self {
10299                    account: topics.1,
10300                    newPausedStatus: data.0,
10301                }
10302            }
10303            #[inline]
10304            fn check_signature(
10305                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
10306            ) -> alloy_sol_types::Result<()> {
10307                if topics.0 != Self::SIGNATURE_HASH {
10308                    return Err(
10309                        alloy_sol_types::Error::invalid_event_signature_hash(
10310                            Self::SIGNATURE,
10311                            topics.0,
10312                            Self::SIGNATURE_HASH,
10313                        ),
10314                    );
10315                }
10316                Ok(())
10317            }
10318            #[inline]
10319            fn tokenize_body(&self) -> Self::DataToken<'_> {
10320                (
10321                    <alloy::sol_types::sol_data::Uint<
10322                        256,
10323                    > as alloy_sol_types::SolType>::tokenize(&self.newPausedStatus),
10324                )
10325            }
10326            #[inline]
10327            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
10328                (Self::SIGNATURE_HASH.into(), self.account.clone())
10329            }
10330            #[inline]
10331            fn encode_topics_raw(
10332                &self,
10333                out: &mut [alloy_sol_types::abi::token::WordToken],
10334            ) -> alloy_sol_types::Result<()> {
10335                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
10336                    return Err(alloy_sol_types::Error::Overrun);
10337                }
10338                out[0usize] = alloy_sol_types::abi::token::WordToken(
10339                    Self::SIGNATURE_HASH,
10340                );
10341                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
10342                    &self.account,
10343                );
10344                Ok(())
10345            }
10346        }
10347        #[automatically_derived]
10348        impl alloy_sol_types::private::IntoLogData for Paused {
10349            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
10350                From::from(self)
10351            }
10352            fn into_log_data(self) -> alloy_sol_types::private::LogData {
10353                From::from(&self)
10354            }
10355        }
10356        #[automatically_derived]
10357        impl From<&Paused> for alloy_sol_types::private::LogData {
10358            #[inline]
10359            fn from(this: &Paused) -> alloy_sol_types::private::LogData {
10360                alloy_sol_types::SolEvent::encode_log_data(this)
10361            }
10362        }
10363    };
10364    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10365    /**Event with signature `QuorumBlockNumberUpdated(uint8,uint256)` and selector `0x46077d55330763f16269fd75e5761663f4192d2791747c0189b16ad31db07db4`.
10366```solidity
10367event QuorumBlockNumberUpdated(uint8 indexed quorumNumber, uint256 blocknumber);
10368```*/
10369    #[allow(
10370        non_camel_case_types,
10371        non_snake_case,
10372        clippy::pub_underscore_fields,
10373        clippy::style
10374    )]
10375    #[derive(Clone)]
10376    pub struct QuorumBlockNumberUpdated {
10377        #[allow(missing_docs)]
10378        pub quorumNumber: u8,
10379        #[allow(missing_docs)]
10380        pub blocknumber: alloy::sol_types::private::primitives::aliases::U256,
10381    }
10382    #[allow(
10383        non_camel_case_types,
10384        non_snake_case,
10385        clippy::pub_underscore_fields,
10386        clippy::style
10387    )]
10388    const _: () = {
10389        use alloy::sol_types as alloy_sol_types;
10390        #[automatically_derived]
10391        impl alloy_sol_types::SolEvent for QuorumBlockNumberUpdated {
10392            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
10393            type DataToken<'a> = <Self::DataTuple<
10394                'a,
10395            > as alloy_sol_types::SolType>::Token<'a>;
10396            type TopicList = (
10397                alloy_sol_types::sol_data::FixedBytes<32>,
10398                alloy::sol_types::sol_data::Uint<8>,
10399            );
10400            const SIGNATURE: &'static str = "QuorumBlockNumberUpdated(uint8,uint256)";
10401            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
10402                70u8, 7u8, 125u8, 85u8, 51u8, 7u8, 99u8, 241u8, 98u8, 105u8, 253u8,
10403                117u8, 229u8, 118u8, 22u8, 99u8, 244u8, 25u8, 45u8, 39u8, 145u8, 116u8,
10404                124u8, 1u8, 137u8, 177u8, 106u8, 211u8, 29u8, 176u8, 125u8, 180u8,
10405            ]);
10406            const ANONYMOUS: bool = false;
10407            #[allow(unused_variables)]
10408            #[inline]
10409            fn new(
10410                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
10411                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
10412            ) -> Self {
10413                Self {
10414                    quorumNumber: topics.1,
10415                    blocknumber: data.0,
10416                }
10417            }
10418            #[inline]
10419            fn check_signature(
10420                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
10421            ) -> alloy_sol_types::Result<()> {
10422                if topics.0 != Self::SIGNATURE_HASH {
10423                    return Err(
10424                        alloy_sol_types::Error::invalid_event_signature_hash(
10425                            Self::SIGNATURE,
10426                            topics.0,
10427                            Self::SIGNATURE_HASH,
10428                        ),
10429                    );
10430                }
10431                Ok(())
10432            }
10433            #[inline]
10434            fn tokenize_body(&self) -> Self::DataToken<'_> {
10435                (
10436                    <alloy::sol_types::sol_data::Uint<
10437                        256,
10438                    > as alloy_sol_types::SolType>::tokenize(&self.blocknumber),
10439                )
10440            }
10441            #[inline]
10442            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
10443                (Self::SIGNATURE_HASH.into(), self.quorumNumber.clone())
10444            }
10445            #[inline]
10446            fn encode_topics_raw(
10447                &self,
10448                out: &mut [alloy_sol_types::abi::token::WordToken],
10449            ) -> alloy_sol_types::Result<()> {
10450                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
10451                    return Err(alloy_sol_types::Error::Overrun);
10452                }
10453                out[0usize] = alloy_sol_types::abi::token::WordToken(
10454                    Self::SIGNATURE_HASH,
10455                );
10456                out[1usize] = <alloy::sol_types::sol_data::Uint<
10457                    8,
10458                > as alloy_sol_types::EventTopic>::encode_topic(&self.quorumNumber);
10459                Ok(())
10460            }
10461        }
10462        #[automatically_derived]
10463        impl alloy_sol_types::private::IntoLogData for QuorumBlockNumberUpdated {
10464            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
10465                From::from(self)
10466            }
10467            fn into_log_data(self) -> alloy_sol_types::private::LogData {
10468                From::from(&self)
10469            }
10470        }
10471        #[automatically_derived]
10472        impl From<&QuorumBlockNumberUpdated> for alloy_sol_types::private::LogData {
10473            #[inline]
10474            fn from(
10475                this: &QuorumBlockNumberUpdated,
10476            ) -> alloy_sol_types::private::LogData {
10477                alloy_sol_types::SolEvent::encode_log_data(this)
10478            }
10479        }
10480    };
10481    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10482    /**Event with signature `QuorumCreated(uint8,(uint32,uint16,uint16),uint96,(address,uint96)[],uint8,uint32)` and selector `0xa34835bc2b673ec37fcf1591a91295b163fc2e181e4ea4e733beb27de1ceac4c`.
10483```solidity
10484event QuorumCreated(uint8 indexed quorumNumber, ISlashingRegistryCoordinatorTypes.OperatorSetParam operatorSetParams, uint96 minimumStake, IStakeRegistryTypes.StrategyParams[] strategyParams, IStakeRegistryTypes.StakeType stakeType, uint32 lookAheadPeriod);
10485```*/
10486    #[allow(
10487        non_camel_case_types,
10488        non_snake_case,
10489        clippy::pub_underscore_fields,
10490        clippy::style
10491    )]
10492    #[derive(Clone)]
10493    pub struct QuorumCreated {
10494        #[allow(missing_docs)]
10495        pub quorumNumber: u8,
10496        #[allow(missing_docs)]
10497        pub operatorSetParams: <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
10498        #[allow(missing_docs)]
10499        pub minimumStake: alloy::sol_types::private::primitives::aliases::U96,
10500        #[allow(missing_docs)]
10501        pub strategyParams: alloy::sol_types::private::Vec<
10502            <IStakeRegistryTypes::StrategyParams as alloy::sol_types::SolType>::RustType,
10503        >,
10504        #[allow(missing_docs)]
10505        pub stakeType: <IStakeRegistryTypes::StakeType as alloy::sol_types::SolType>::RustType,
10506        #[allow(missing_docs)]
10507        pub lookAheadPeriod: u32,
10508    }
10509    #[allow(
10510        non_camel_case_types,
10511        non_snake_case,
10512        clippy::pub_underscore_fields,
10513        clippy::style
10514    )]
10515    const _: () = {
10516        use alloy::sol_types as alloy_sol_types;
10517        #[automatically_derived]
10518        impl alloy_sol_types::SolEvent for QuorumCreated {
10519            type DataTuple<'a> = (
10520                ISlashingRegistryCoordinatorTypes::OperatorSetParam,
10521                alloy::sol_types::sol_data::Uint<96>,
10522                alloy::sol_types::sol_data::Array<IStakeRegistryTypes::StrategyParams>,
10523                IStakeRegistryTypes::StakeType,
10524                alloy::sol_types::sol_data::Uint<32>,
10525            );
10526            type DataToken<'a> = <Self::DataTuple<
10527                'a,
10528            > as alloy_sol_types::SolType>::Token<'a>;
10529            type TopicList = (
10530                alloy_sol_types::sol_data::FixedBytes<32>,
10531                alloy::sol_types::sol_data::Uint<8>,
10532            );
10533            const SIGNATURE: &'static str = "QuorumCreated(uint8,(uint32,uint16,uint16),uint96,(address,uint96)[],uint8,uint32)";
10534            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
10535                163u8, 72u8, 53u8, 188u8, 43u8, 103u8, 62u8, 195u8, 127u8, 207u8, 21u8,
10536                145u8, 169u8, 18u8, 149u8, 177u8, 99u8, 252u8, 46u8, 24u8, 30u8, 78u8,
10537                164u8, 231u8, 51u8, 190u8, 178u8, 125u8, 225u8, 206u8, 172u8, 76u8,
10538            ]);
10539            const ANONYMOUS: bool = false;
10540            #[allow(unused_variables)]
10541            #[inline]
10542            fn new(
10543                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
10544                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
10545            ) -> Self {
10546                Self {
10547                    quorumNumber: topics.1,
10548                    operatorSetParams: data.0,
10549                    minimumStake: data.1,
10550                    strategyParams: data.2,
10551                    stakeType: data.3,
10552                    lookAheadPeriod: data.4,
10553                }
10554            }
10555            #[inline]
10556            fn check_signature(
10557                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
10558            ) -> alloy_sol_types::Result<()> {
10559                if topics.0 != Self::SIGNATURE_HASH {
10560                    return Err(
10561                        alloy_sol_types::Error::invalid_event_signature_hash(
10562                            Self::SIGNATURE,
10563                            topics.0,
10564                            Self::SIGNATURE_HASH,
10565                        ),
10566                    );
10567                }
10568                Ok(())
10569            }
10570            #[inline]
10571            fn tokenize_body(&self) -> Self::DataToken<'_> {
10572                (
10573                    <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy_sol_types::SolType>::tokenize(
10574                        &self.operatorSetParams,
10575                    ),
10576                    <alloy::sol_types::sol_data::Uint<
10577                        96,
10578                    > as alloy_sol_types::SolType>::tokenize(&self.minimumStake),
10579                    <alloy::sol_types::sol_data::Array<
10580                        IStakeRegistryTypes::StrategyParams,
10581                    > as alloy_sol_types::SolType>::tokenize(&self.strategyParams),
10582                    <IStakeRegistryTypes::StakeType as alloy_sol_types::SolType>::tokenize(
10583                        &self.stakeType,
10584                    ),
10585                    <alloy::sol_types::sol_data::Uint<
10586                        32,
10587                    > as alloy_sol_types::SolType>::tokenize(&self.lookAheadPeriod),
10588                )
10589            }
10590            #[inline]
10591            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
10592                (Self::SIGNATURE_HASH.into(), self.quorumNumber.clone())
10593            }
10594            #[inline]
10595            fn encode_topics_raw(
10596                &self,
10597                out: &mut [alloy_sol_types::abi::token::WordToken],
10598            ) -> alloy_sol_types::Result<()> {
10599                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
10600                    return Err(alloy_sol_types::Error::Overrun);
10601                }
10602                out[0usize] = alloy_sol_types::abi::token::WordToken(
10603                    Self::SIGNATURE_HASH,
10604                );
10605                out[1usize] = <alloy::sol_types::sol_data::Uint<
10606                    8,
10607                > as alloy_sol_types::EventTopic>::encode_topic(&self.quorumNumber);
10608                Ok(())
10609            }
10610        }
10611        #[automatically_derived]
10612        impl alloy_sol_types::private::IntoLogData for QuorumCreated {
10613            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
10614                From::from(self)
10615            }
10616            fn into_log_data(self) -> alloy_sol_types::private::LogData {
10617                From::from(&self)
10618            }
10619        }
10620        #[automatically_derived]
10621        impl From<&QuorumCreated> for alloy_sol_types::private::LogData {
10622            #[inline]
10623            fn from(this: &QuorumCreated) -> alloy_sol_types::private::LogData {
10624                alloy_sol_types::SolEvent::encode_log_data(this)
10625            }
10626        }
10627    };
10628    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10629    /**Event with signature `Unpaused(address,uint256)` and selector `0x3582d1828e26bf56bd801502bc021ac0bc8afb57c826e4986b45593c8fad389c`.
10630```solidity
10631event Unpaused(address indexed account, uint256 newPausedStatus);
10632```*/
10633    #[allow(
10634        non_camel_case_types,
10635        non_snake_case,
10636        clippy::pub_underscore_fields,
10637        clippy::style
10638    )]
10639    #[derive(Clone)]
10640    pub struct Unpaused {
10641        #[allow(missing_docs)]
10642        pub account: alloy::sol_types::private::Address,
10643        #[allow(missing_docs)]
10644        pub newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
10645    }
10646    #[allow(
10647        non_camel_case_types,
10648        non_snake_case,
10649        clippy::pub_underscore_fields,
10650        clippy::style
10651    )]
10652    const _: () = {
10653        use alloy::sol_types as alloy_sol_types;
10654        #[automatically_derived]
10655        impl alloy_sol_types::SolEvent for Unpaused {
10656            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
10657            type DataToken<'a> = <Self::DataTuple<
10658                'a,
10659            > as alloy_sol_types::SolType>::Token<'a>;
10660            type TopicList = (
10661                alloy_sol_types::sol_data::FixedBytes<32>,
10662                alloy::sol_types::sol_data::Address,
10663            );
10664            const SIGNATURE: &'static str = "Unpaused(address,uint256)";
10665            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
10666                53u8, 130u8, 209u8, 130u8, 142u8, 38u8, 191u8, 86u8, 189u8, 128u8, 21u8,
10667                2u8, 188u8, 2u8, 26u8, 192u8, 188u8, 138u8, 251u8, 87u8, 200u8, 38u8,
10668                228u8, 152u8, 107u8, 69u8, 89u8, 60u8, 143u8, 173u8, 56u8, 156u8,
10669            ]);
10670            const ANONYMOUS: bool = false;
10671            #[allow(unused_variables)]
10672            #[inline]
10673            fn new(
10674                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
10675                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
10676            ) -> Self {
10677                Self {
10678                    account: topics.1,
10679                    newPausedStatus: data.0,
10680                }
10681            }
10682            #[inline]
10683            fn check_signature(
10684                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
10685            ) -> alloy_sol_types::Result<()> {
10686                if topics.0 != Self::SIGNATURE_HASH {
10687                    return Err(
10688                        alloy_sol_types::Error::invalid_event_signature_hash(
10689                            Self::SIGNATURE,
10690                            topics.0,
10691                            Self::SIGNATURE_HASH,
10692                        ),
10693                    );
10694                }
10695                Ok(())
10696            }
10697            #[inline]
10698            fn tokenize_body(&self) -> Self::DataToken<'_> {
10699                (
10700                    <alloy::sol_types::sol_data::Uint<
10701                        256,
10702                    > as alloy_sol_types::SolType>::tokenize(&self.newPausedStatus),
10703                )
10704            }
10705            #[inline]
10706            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
10707                (Self::SIGNATURE_HASH.into(), self.account.clone())
10708            }
10709            #[inline]
10710            fn encode_topics_raw(
10711                &self,
10712                out: &mut [alloy_sol_types::abi::token::WordToken],
10713            ) -> alloy_sol_types::Result<()> {
10714                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
10715                    return Err(alloy_sol_types::Error::Overrun);
10716                }
10717                out[0usize] = alloy_sol_types::abi::token::WordToken(
10718                    Self::SIGNATURE_HASH,
10719                );
10720                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
10721                    &self.account,
10722                );
10723                Ok(())
10724            }
10725        }
10726        #[automatically_derived]
10727        impl alloy_sol_types::private::IntoLogData for Unpaused {
10728            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
10729                From::from(self)
10730            }
10731            fn into_log_data(self) -> alloy_sol_types::private::LogData {
10732                From::from(&self)
10733            }
10734        }
10735        #[automatically_derived]
10736        impl From<&Unpaused> for alloy_sol_types::private::LogData {
10737            #[inline]
10738            fn from(this: &Unpaused) -> alloy_sol_types::private::LogData {
10739                alloy_sol_types::SolEvent::encode_log_data(this)
10740            }
10741        }
10742    };
10743    /**Constructor`.
10744```solidity
10745constructor(IRegistryCoordinatorTypes.RegistryCoordinatorParams params);
10746```*/
10747    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10748    #[derive(Clone)]
10749    pub struct constructorCall {
10750        #[allow(missing_docs)]
10751        pub params: <IRegistryCoordinatorTypes::RegistryCoordinatorParams as alloy::sol_types::SolType>::RustType,
10752    }
10753    const _: () = {
10754        use alloy::sol_types as alloy_sol_types;
10755        {
10756            #[doc(hidden)]
10757            type UnderlyingSolTuple<'a> = (
10758                IRegistryCoordinatorTypes::RegistryCoordinatorParams,
10759            );
10760            #[doc(hidden)]
10761            type UnderlyingRustTuple<'a> = (
10762                <IRegistryCoordinatorTypes::RegistryCoordinatorParams as alloy::sol_types::SolType>::RustType,
10763            );
10764            #[cfg(test)]
10765            #[allow(dead_code, unreachable_patterns)]
10766            fn _type_assertion(
10767                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10768            ) {
10769                match _t {
10770                    alloy_sol_types::private::AssertTypeEq::<
10771                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10772                    >(_) => {}
10773                }
10774            }
10775            #[automatically_derived]
10776            #[doc(hidden)]
10777            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
10778                fn from(value: constructorCall) -> Self {
10779                    (value.params,)
10780                }
10781            }
10782            #[automatically_derived]
10783            #[doc(hidden)]
10784            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
10785                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10786                    Self { params: tuple.0 }
10787                }
10788            }
10789        }
10790        #[automatically_derived]
10791        impl alloy_sol_types::SolConstructor for constructorCall {
10792            type Parameters<'a> = (
10793                IRegistryCoordinatorTypes::RegistryCoordinatorParams,
10794            );
10795            type Token<'a> = <Self::Parameters<
10796                'a,
10797            > as alloy_sol_types::SolType>::Token<'a>;
10798            #[inline]
10799            fn new<'a>(
10800                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10801            ) -> Self {
10802                tuple.into()
10803            }
10804            #[inline]
10805            fn tokenize(&self) -> Self::Token<'_> {
10806                (
10807                    <IRegistryCoordinatorTypes::RegistryCoordinatorParams as alloy_sol_types::SolType>::tokenize(
10808                        &self.params,
10809                    ),
10810                )
10811            }
10812        }
10813    };
10814    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10815    /**Function with signature `OPERATOR_CHURN_APPROVAL_TYPEHASH()` and selector `0xca0de882`.
10816```solidity
10817function OPERATOR_CHURN_APPROVAL_TYPEHASH() external view returns (bytes32);
10818```*/
10819    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10820    #[derive(Clone)]
10821    pub struct OPERATOR_CHURN_APPROVAL_TYPEHASHCall {}
10822    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10823    ///Container type for the return parameters of the [`OPERATOR_CHURN_APPROVAL_TYPEHASH()`](OPERATOR_CHURN_APPROVAL_TYPEHASHCall) function.
10824    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10825    #[derive(Clone)]
10826    pub struct OPERATOR_CHURN_APPROVAL_TYPEHASHReturn {
10827        #[allow(missing_docs)]
10828        pub _0: alloy::sol_types::private::FixedBytes<32>,
10829    }
10830    #[allow(
10831        non_camel_case_types,
10832        non_snake_case,
10833        clippy::pub_underscore_fields,
10834        clippy::style
10835    )]
10836    const _: () = {
10837        use alloy::sol_types as alloy_sol_types;
10838        {
10839            #[doc(hidden)]
10840            type UnderlyingSolTuple<'a> = ();
10841            #[doc(hidden)]
10842            type UnderlyingRustTuple<'a> = ();
10843            #[cfg(test)]
10844            #[allow(dead_code, unreachable_patterns)]
10845            fn _type_assertion(
10846                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10847            ) {
10848                match _t {
10849                    alloy_sol_types::private::AssertTypeEq::<
10850                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10851                    >(_) => {}
10852                }
10853            }
10854            #[automatically_derived]
10855            #[doc(hidden)]
10856            impl ::core::convert::From<OPERATOR_CHURN_APPROVAL_TYPEHASHCall>
10857            for UnderlyingRustTuple<'_> {
10858                fn from(value: OPERATOR_CHURN_APPROVAL_TYPEHASHCall) -> Self {
10859                    ()
10860                }
10861            }
10862            #[automatically_derived]
10863            #[doc(hidden)]
10864            impl ::core::convert::From<UnderlyingRustTuple<'_>>
10865            for OPERATOR_CHURN_APPROVAL_TYPEHASHCall {
10866                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10867                    Self {}
10868                }
10869            }
10870        }
10871        {
10872            #[doc(hidden)]
10873            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
10874            #[doc(hidden)]
10875            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
10876            #[cfg(test)]
10877            #[allow(dead_code, unreachable_patterns)]
10878            fn _type_assertion(
10879                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10880            ) {
10881                match _t {
10882                    alloy_sol_types::private::AssertTypeEq::<
10883                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10884                    >(_) => {}
10885                }
10886            }
10887            #[automatically_derived]
10888            #[doc(hidden)]
10889            impl ::core::convert::From<OPERATOR_CHURN_APPROVAL_TYPEHASHReturn>
10890            for UnderlyingRustTuple<'_> {
10891                fn from(value: OPERATOR_CHURN_APPROVAL_TYPEHASHReturn) -> Self {
10892                    (value._0,)
10893                }
10894            }
10895            #[automatically_derived]
10896            #[doc(hidden)]
10897            impl ::core::convert::From<UnderlyingRustTuple<'_>>
10898            for OPERATOR_CHURN_APPROVAL_TYPEHASHReturn {
10899                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10900                    Self { _0: tuple.0 }
10901                }
10902            }
10903        }
10904        #[automatically_derived]
10905        impl alloy_sol_types::SolCall for OPERATOR_CHURN_APPROVAL_TYPEHASHCall {
10906            type Parameters<'a> = ();
10907            type Token<'a> = <Self::Parameters<
10908                'a,
10909            > as alloy_sol_types::SolType>::Token<'a>;
10910            type Return = OPERATOR_CHURN_APPROVAL_TYPEHASHReturn;
10911            type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
10912            type ReturnToken<'a> = <Self::ReturnTuple<
10913                'a,
10914            > as alloy_sol_types::SolType>::Token<'a>;
10915            const SIGNATURE: &'static str = "OPERATOR_CHURN_APPROVAL_TYPEHASH()";
10916            const SELECTOR: [u8; 4] = [202u8, 13u8, 232u8, 130u8];
10917            #[inline]
10918            fn new<'a>(
10919                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10920            ) -> Self {
10921                tuple.into()
10922            }
10923            #[inline]
10924            fn tokenize(&self) -> Self::Token<'_> {
10925                ()
10926            }
10927            #[inline]
10928            fn abi_decode_returns(
10929                data: &[u8],
10930                validate: bool,
10931            ) -> alloy_sol_types::Result<Self::Return> {
10932                <Self::ReturnTuple<
10933                    '_,
10934                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
10935                    .map(Into::into)
10936            }
10937        }
10938    };
10939    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10940    /**Function with signature `PUBKEY_REGISTRATION_TYPEHASH()` and selector `0x9feab859`.
10941```solidity
10942function PUBKEY_REGISTRATION_TYPEHASH() external view returns (bytes32);
10943```*/
10944    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10945    #[derive(Clone)]
10946    pub struct PUBKEY_REGISTRATION_TYPEHASHCall {}
10947    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10948    ///Container type for the return parameters of the [`PUBKEY_REGISTRATION_TYPEHASH()`](PUBKEY_REGISTRATION_TYPEHASHCall) function.
10949    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10950    #[derive(Clone)]
10951    pub struct PUBKEY_REGISTRATION_TYPEHASHReturn {
10952        #[allow(missing_docs)]
10953        pub _0: alloy::sol_types::private::FixedBytes<32>,
10954    }
10955    #[allow(
10956        non_camel_case_types,
10957        non_snake_case,
10958        clippy::pub_underscore_fields,
10959        clippy::style
10960    )]
10961    const _: () = {
10962        use alloy::sol_types as alloy_sol_types;
10963        {
10964            #[doc(hidden)]
10965            type UnderlyingSolTuple<'a> = ();
10966            #[doc(hidden)]
10967            type UnderlyingRustTuple<'a> = ();
10968            #[cfg(test)]
10969            #[allow(dead_code, unreachable_patterns)]
10970            fn _type_assertion(
10971                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10972            ) {
10973                match _t {
10974                    alloy_sol_types::private::AssertTypeEq::<
10975                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10976                    >(_) => {}
10977                }
10978            }
10979            #[automatically_derived]
10980            #[doc(hidden)]
10981            impl ::core::convert::From<PUBKEY_REGISTRATION_TYPEHASHCall>
10982            for UnderlyingRustTuple<'_> {
10983                fn from(value: PUBKEY_REGISTRATION_TYPEHASHCall) -> Self {
10984                    ()
10985                }
10986            }
10987            #[automatically_derived]
10988            #[doc(hidden)]
10989            impl ::core::convert::From<UnderlyingRustTuple<'_>>
10990            for PUBKEY_REGISTRATION_TYPEHASHCall {
10991                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10992                    Self {}
10993                }
10994            }
10995        }
10996        {
10997            #[doc(hidden)]
10998            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
10999            #[doc(hidden)]
11000            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
11001            #[cfg(test)]
11002            #[allow(dead_code, unreachable_patterns)]
11003            fn _type_assertion(
11004                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11005            ) {
11006                match _t {
11007                    alloy_sol_types::private::AssertTypeEq::<
11008                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11009                    >(_) => {}
11010                }
11011            }
11012            #[automatically_derived]
11013            #[doc(hidden)]
11014            impl ::core::convert::From<PUBKEY_REGISTRATION_TYPEHASHReturn>
11015            for UnderlyingRustTuple<'_> {
11016                fn from(value: PUBKEY_REGISTRATION_TYPEHASHReturn) -> Self {
11017                    (value._0,)
11018                }
11019            }
11020            #[automatically_derived]
11021            #[doc(hidden)]
11022            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11023            for PUBKEY_REGISTRATION_TYPEHASHReturn {
11024                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11025                    Self { _0: tuple.0 }
11026                }
11027            }
11028        }
11029        #[automatically_derived]
11030        impl alloy_sol_types::SolCall for PUBKEY_REGISTRATION_TYPEHASHCall {
11031            type Parameters<'a> = ();
11032            type Token<'a> = <Self::Parameters<
11033                'a,
11034            > as alloy_sol_types::SolType>::Token<'a>;
11035            type Return = PUBKEY_REGISTRATION_TYPEHASHReturn;
11036            type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
11037            type ReturnToken<'a> = <Self::ReturnTuple<
11038                'a,
11039            > as alloy_sol_types::SolType>::Token<'a>;
11040            const SIGNATURE: &'static str = "PUBKEY_REGISTRATION_TYPEHASH()";
11041            const SELECTOR: [u8; 4] = [159u8, 234u8, 184u8, 89u8];
11042            #[inline]
11043            fn new<'a>(
11044                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11045            ) -> Self {
11046                tuple.into()
11047            }
11048            #[inline]
11049            fn tokenize(&self) -> Self::Token<'_> {
11050                ()
11051            }
11052            #[inline]
11053            fn abi_decode_returns(
11054                data: &[u8],
11055                validate: bool,
11056            ) -> alloy_sol_types::Result<Self::Return> {
11057                <Self::ReturnTuple<
11058                    '_,
11059                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
11060                    .map(Into::into)
11061            }
11062        }
11063    };
11064    #[derive(Default, Debug, PartialEq, Eq, Hash)]
11065    /**Function with signature `allocationManager()` and selector `0xca8aa7c7`.
11066```solidity
11067function allocationManager() external view returns (address);
11068```*/
11069    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11070    #[derive(Clone)]
11071    pub struct allocationManagerCall {}
11072    #[derive(Default, Debug, PartialEq, Eq, Hash)]
11073    ///Container type for the return parameters of the [`allocationManager()`](allocationManagerCall) function.
11074    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11075    #[derive(Clone)]
11076    pub struct allocationManagerReturn {
11077        #[allow(missing_docs)]
11078        pub _0: alloy::sol_types::private::Address,
11079    }
11080    #[allow(
11081        non_camel_case_types,
11082        non_snake_case,
11083        clippy::pub_underscore_fields,
11084        clippy::style
11085    )]
11086    const _: () = {
11087        use alloy::sol_types as alloy_sol_types;
11088        {
11089            #[doc(hidden)]
11090            type UnderlyingSolTuple<'a> = ();
11091            #[doc(hidden)]
11092            type UnderlyingRustTuple<'a> = ();
11093            #[cfg(test)]
11094            #[allow(dead_code, unreachable_patterns)]
11095            fn _type_assertion(
11096                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11097            ) {
11098                match _t {
11099                    alloy_sol_types::private::AssertTypeEq::<
11100                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11101                    >(_) => {}
11102                }
11103            }
11104            #[automatically_derived]
11105            #[doc(hidden)]
11106            impl ::core::convert::From<allocationManagerCall>
11107            for UnderlyingRustTuple<'_> {
11108                fn from(value: allocationManagerCall) -> Self {
11109                    ()
11110                }
11111            }
11112            #[automatically_derived]
11113            #[doc(hidden)]
11114            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11115            for allocationManagerCall {
11116                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11117                    Self {}
11118                }
11119            }
11120        }
11121        {
11122            #[doc(hidden)]
11123            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
11124            #[doc(hidden)]
11125            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
11126            #[cfg(test)]
11127            #[allow(dead_code, unreachable_patterns)]
11128            fn _type_assertion(
11129                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11130            ) {
11131                match _t {
11132                    alloy_sol_types::private::AssertTypeEq::<
11133                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11134                    >(_) => {}
11135                }
11136            }
11137            #[automatically_derived]
11138            #[doc(hidden)]
11139            impl ::core::convert::From<allocationManagerReturn>
11140            for UnderlyingRustTuple<'_> {
11141                fn from(value: allocationManagerReturn) -> Self {
11142                    (value._0,)
11143                }
11144            }
11145            #[automatically_derived]
11146            #[doc(hidden)]
11147            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11148            for allocationManagerReturn {
11149                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11150                    Self { _0: tuple.0 }
11151                }
11152            }
11153        }
11154        #[automatically_derived]
11155        impl alloy_sol_types::SolCall for allocationManagerCall {
11156            type Parameters<'a> = ();
11157            type Token<'a> = <Self::Parameters<
11158                'a,
11159            > as alloy_sol_types::SolType>::Token<'a>;
11160            type Return = allocationManagerReturn;
11161            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
11162            type ReturnToken<'a> = <Self::ReturnTuple<
11163                'a,
11164            > as alloy_sol_types::SolType>::Token<'a>;
11165            const SIGNATURE: &'static str = "allocationManager()";
11166            const SELECTOR: [u8; 4] = [202u8, 138u8, 167u8, 199u8];
11167            #[inline]
11168            fn new<'a>(
11169                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11170            ) -> Self {
11171                tuple.into()
11172            }
11173            #[inline]
11174            fn tokenize(&self) -> Self::Token<'_> {
11175                ()
11176            }
11177            #[inline]
11178            fn abi_decode_returns(
11179                data: &[u8],
11180                validate: bool,
11181            ) -> alloy_sol_types::Result<Self::Return> {
11182                <Self::ReturnTuple<
11183                    '_,
11184                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
11185                    .map(Into::into)
11186            }
11187        }
11188    };
11189    #[derive(Default, Debug, PartialEq, Eq, Hash)]
11190    /**Function with signature `avs()` and selector `0xde1164bb`.
11191```solidity
11192function avs() external view returns (address);
11193```*/
11194    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11195    #[derive(Clone)]
11196    pub struct avsCall {}
11197    #[derive(Default, Debug, PartialEq, Eq, Hash)]
11198    ///Container type for the return parameters of the [`avs()`](avsCall) function.
11199    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11200    #[derive(Clone)]
11201    pub struct avsReturn {
11202        #[allow(missing_docs)]
11203        pub _0: alloy::sol_types::private::Address,
11204    }
11205    #[allow(
11206        non_camel_case_types,
11207        non_snake_case,
11208        clippy::pub_underscore_fields,
11209        clippy::style
11210    )]
11211    const _: () = {
11212        use alloy::sol_types as alloy_sol_types;
11213        {
11214            #[doc(hidden)]
11215            type UnderlyingSolTuple<'a> = ();
11216            #[doc(hidden)]
11217            type UnderlyingRustTuple<'a> = ();
11218            #[cfg(test)]
11219            #[allow(dead_code, unreachable_patterns)]
11220            fn _type_assertion(
11221                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11222            ) {
11223                match _t {
11224                    alloy_sol_types::private::AssertTypeEq::<
11225                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11226                    >(_) => {}
11227                }
11228            }
11229            #[automatically_derived]
11230            #[doc(hidden)]
11231            impl ::core::convert::From<avsCall> for UnderlyingRustTuple<'_> {
11232                fn from(value: avsCall) -> Self {
11233                    ()
11234                }
11235            }
11236            #[automatically_derived]
11237            #[doc(hidden)]
11238            impl ::core::convert::From<UnderlyingRustTuple<'_>> for avsCall {
11239                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11240                    Self {}
11241                }
11242            }
11243        }
11244        {
11245            #[doc(hidden)]
11246            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
11247            #[doc(hidden)]
11248            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
11249            #[cfg(test)]
11250            #[allow(dead_code, unreachable_patterns)]
11251            fn _type_assertion(
11252                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11253            ) {
11254                match _t {
11255                    alloy_sol_types::private::AssertTypeEq::<
11256                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11257                    >(_) => {}
11258                }
11259            }
11260            #[automatically_derived]
11261            #[doc(hidden)]
11262            impl ::core::convert::From<avsReturn> for UnderlyingRustTuple<'_> {
11263                fn from(value: avsReturn) -> Self {
11264                    (value._0,)
11265                }
11266            }
11267            #[automatically_derived]
11268            #[doc(hidden)]
11269            impl ::core::convert::From<UnderlyingRustTuple<'_>> for avsReturn {
11270                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11271                    Self { _0: tuple.0 }
11272                }
11273            }
11274        }
11275        #[automatically_derived]
11276        impl alloy_sol_types::SolCall for avsCall {
11277            type Parameters<'a> = ();
11278            type Token<'a> = <Self::Parameters<
11279                'a,
11280            > as alloy_sol_types::SolType>::Token<'a>;
11281            type Return = avsReturn;
11282            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
11283            type ReturnToken<'a> = <Self::ReturnTuple<
11284                'a,
11285            > as alloy_sol_types::SolType>::Token<'a>;
11286            const SIGNATURE: &'static str = "avs()";
11287            const SELECTOR: [u8; 4] = [222u8, 17u8, 100u8, 187u8];
11288            #[inline]
11289            fn new<'a>(
11290                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11291            ) -> Self {
11292                tuple.into()
11293            }
11294            #[inline]
11295            fn tokenize(&self) -> Self::Token<'_> {
11296                ()
11297            }
11298            #[inline]
11299            fn abi_decode_returns(
11300                data: &[u8],
11301                validate: bool,
11302            ) -> alloy_sol_types::Result<Self::Return> {
11303                <Self::ReturnTuple<
11304                    '_,
11305                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
11306                    .map(Into::into)
11307            }
11308        }
11309    };
11310    #[derive(Default, Debug, PartialEq, Eq, Hash)]
11311    /**Function with signature `blsApkRegistry()` and selector `0x5df45946`.
11312```solidity
11313function blsApkRegistry() external view returns (address);
11314```*/
11315    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11316    #[derive(Clone)]
11317    pub struct blsApkRegistryCall {}
11318    #[derive(Default, Debug, PartialEq, Eq, Hash)]
11319    ///Container type for the return parameters of the [`blsApkRegistry()`](blsApkRegistryCall) function.
11320    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11321    #[derive(Clone)]
11322    pub struct blsApkRegistryReturn {
11323        #[allow(missing_docs)]
11324        pub _0: alloy::sol_types::private::Address,
11325    }
11326    #[allow(
11327        non_camel_case_types,
11328        non_snake_case,
11329        clippy::pub_underscore_fields,
11330        clippy::style
11331    )]
11332    const _: () = {
11333        use alloy::sol_types as alloy_sol_types;
11334        {
11335            #[doc(hidden)]
11336            type UnderlyingSolTuple<'a> = ();
11337            #[doc(hidden)]
11338            type UnderlyingRustTuple<'a> = ();
11339            #[cfg(test)]
11340            #[allow(dead_code, unreachable_patterns)]
11341            fn _type_assertion(
11342                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11343            ) {
11344                match _t {
11345                    alloy_sol_types::private::AssertTypeEq::<
11346                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11347                    >(_) => {}
11348                }
11349            }
11350            #[automatically_derived]
11351            #[doc(hidden)]
11352            impl ::core::convert::From<blsApkRegistryCall> for UnderlyingRustTuple<'_> {
11353                fn from(value: blsApkRegistryCall) -> Self {
11354                    ()
11355                }
11356            }
11357            #[automatically_derived]
11358            #[doc(hidden)]
11359            impl ::core::convert::From<UnderlyingRustTuple<'_>> for blsApkRegistryCall {
11360                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11361                    Self {}
11362                }
11363            }
11364        }
11365        {
11366            #[doc(hidden)]
11367            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
11368            #[doc(hidden)]
11369            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
11370            #[cfg(test)]
11371            #[allow(dead_code, unreachable_patterns)]
11372            fn _type_assertion(
11373                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11374            ) {
11375                match _t {
11376                    alloy_sol_types::private::AssertTypeEq::<
11377                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11378                    >(_) => {}
11379                }
11380            }
11381            #[automatically_derived]
11382            #[doc(hidden)]
11383            impl ::core::convert::From<blsApkRegistryReturn>
11384            for UnderlyingRustTuple<'_> {
11385                fn from(value: blsApkRegistryReturn) -> Self {
11386                    (value._0,)
11387                }
11388            }
11389            #[automatically_derived]
11390            #[doc(hidden)]
11391            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11392            for blsApkRegistryReturn {
11393                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11394                    Self { _0: tuple.0 }
11395                }
11396            }
11397        }
11398        #[automatically_derived]
11399        impl alloy_sol_types::SolCall for blsApkRegistryCall {
11400            type Parameters<'a> = ();
11401            type Token<'a> = <Self::Parameters<
11402                'a,
11403            > as alloy_sol_types::SolType>::Token<'a>;
11404            type Return = blsApkRegistryReturn;
11405            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
11406            type ReturnToken<'a> = <Self::ReturnTuple<
11407                'a,
11408            > as alloy_sol_types::SolType>::Token<'a>;
11409            const SIGNATURE: &'static str = "blsApkRegistry()";
11410            const SELECTOR: [u8; 4] = [93u8, 244u8, 89u8, 70u8];
11411            #[inline]
11412            fn new<'a>(
11413                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11414            ) -> Self {
11415                tuple.into()
11416            }
11417            #[inline]
11418            fn tokenize(&self) -> Self::Token<'_> {
11419                ()
11420            }
11421            #[inline]
11422            fn abi_decode_returns(
11423                data: &[u8],
11424                validate: bool,
11425            ) -> alloy_sol_types::Result<Self::Return> {
11426                <Self::ReturnTuple<
11427                    '_,
11428                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
11429                    .map(Into::into)
11430            }
11431        }
11432    };
11433    #[derive(Default, Debug, PartialEq, Eq, Hash)]
11434    /**Function with signature `calculateOperatorChurnApprovalDigestHash(address,bytes32,(uint8,address)[],bytes32,uint256)` and selector `0x84ca5213`.
11435```solidity
11436function calculateOperatorChurnApprovalDigestHash(address registeringOperator, bytes32 registeringOperatorId, ISlashingRegistryCoordinatorTypes.OperatorKickParam[] memory operatorKickParams, bytes32 salt, uint256 expiry) external view returns (bytes32);
11437```*/
11438    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11439    #[derive(Clone)]
11440    pub struct calculateOperatorChurnApprovalDigestHashCall {
11441        #[allow(missing_docs)]
11442        pub registeringOperator: alloy::sol_types::private::Address,
11443        #[allow(missing_docs)]
11444        pub registeringOperatorId: alloy::sol_types::private::FixedBytes<32>,
11445        #[allow(missing_docs)]
11446        pub operatorKickParams: alloy::sol_types::private::Vec<
11447            <ISlashingRegistryCoordinatorTypes::OperatorKickParam as alloy::sol_types::SolType>::RustType,
11448        >,
11449        #[allow(missing_docs)]
11450        pub salt: alloy::sol_types::private::FixedBytes<32>,
11451        #[allow(missing_docs)]
11452        pub expiry: alloy::sol_types::private::primitives::aliases::U256,
11453    }
11454    #[derive(Default, Debug, PartialEq, Eq, Hash)]
11455    ///Container type for the return parameters of the [`calculateOperatorChurnApprovalDigestHash(address,bytes32,(uint8,address)[],bytes32,uint256)`](calculateOperatorChurnApprovalDigestHashCall) function.
11456    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11457    #[derive(Clone)]
11458    pub struct calculateOperatorChurnApprovalDigestHashReturn {
11459        #[allow(missing_docs)]
11460        pub _0: alloy::sol_types::private::FixedBytes<32>,
11461    }
11462    #[allow(
11463        non_camel_case_types,
11464        non_snake_case,
11465        clippy::pub_underscore_fields,
11466        clippy::style
11467    )]
11468    const _: () = {
11469        use alloy::sol_types as alloy_sol_types;
11470        {
11471            #[doc(hidden)]
11472            type UnderlyingSolTuple<'a> = (
11473                alloy::sol_types::sol_data::Address,
11474                alloy::sol_types::sol_data::FixedBytes<32>,
11475                alloy::sol_types::sol_data::Array<
11476                    ISlashingRegistryCoordinatorTypes::OperatorKickParam,
11477                >,
11478                alloy::sol_types::sol_data::FixedBytes<32>,
11479                alloy::sol_types::sol_data::Uint<256>,
11480            );
11481            #[doc(hidden)]
11482            type UnderlyingRustTuple<'a> = (
11483                alloy::sol_types::private::Address,
11484                alloy::sol_types::private::FixedBytes<32>,
11485                alloy::sol_types::private::Vec<
11486                    <ISlashingRegistryCoordinatorTypes::OperatorKickParam as alloy::sol_types::SolType>::RustType,
11487                >,
11488                alloy::sol_types::private::FixedBytes<32>,
11489                alloy::sol_types::private::primitives::aliases::U256,
11490            );
11491            #[cfg(test)]
11492            #[allow(dead_code, unreachable_patterns)]
11493            fn _type_assertion(
11494                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11495            ) {
11496                match _t {
11497                    alloy_sol_types::private::AssertTypeEq::<
11498                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11499                    >(_) => {}
11500                }
11501            }
11502            #[automatically_derived]
11503            #[doc(hidden)]
11504            impl ::core::convert::From<calculateOperatorChurnApprovalDigestHashCall>
11505            for UnderlyingRustTuple<'_> {
11506                fn from(value: calculateOperatorChurnApprovalDigestHashCall) -> Self {
11507                    (
11508                        value.registeringOperator,
11509                        value.registeringOperatorId,
11510                        value.operatorKickParams,
11511                        value.salt,
11512                        value.expiry,
11513                    )
11514                }
11515            }
11516            #[automatically_derived]
11517            #[doc(hidden)]
11518            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11519            for calculateOperatorChurnApprovalDigestHashCall {
11520                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11521                    Self {
11522                        registeringOperator: tuple.0,
11523                        registeringOperatorId: tuple.1,
11524                        operatorKickParams: tuple.2,
11525                        salt: tuple.3,
11526                        expiry: tuple.4,
11527                    }
11528                }
11529            }
11530        }
11531        {
11532            #[doc(hidden)]
11533            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
11534            #[doc(hidden)]
11535            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
11536            #[cfg(test)]
11537            #[allow(dead_code, unreachable_patterns)]
11538            fn _type_assertion(
11539                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11540            ) {
11541                match _t {
11542                    alloy_sol_types::private::AssertTypeEq::<
11543                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11544                    >(_) => {}
11545                }
11546            }
11547            #[automatically_derived]
11548            #[doc(hidden)]
11549            impl ::core::convert::From<calculateOperatorChurnApprovalDigestHashReturn>
11550            for UnderlyingRustTuple<'_> {
11551                fn from(value: calculateOperatorChurnApprovalDigestHashReturn) -> Self {
11552                    (value._0,)
11553                }
11554            }
11555            #[automatically_derived]
11556            #[doc(hidden)]
11557            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11558            for calculateOperatorChurnApprovalDigestHashReturn {
11559                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11560                    Self { _0: tuple.0 }
11561                }
11562            }
11563        }
11564        #[automatically_derived]
11565        impl alloy_sol_types::SolCall for calculateOperatorChurnApprovalDigestHashCall {
11566            type Parameters<'a> = (
11567                alloy::sol_types::sol_data::Address,
11568                alloy::sol_types::sol_data::FixedBytes<32>,
11569                alloy::sol_types::sol_data::Array<
11570                    ISlashingRegistryCoordinatorTypes::OperatorKickParam,
11571                >,
11572                alloy::sol_types::sol_data::FixedBytes<32>,
11573                alloy::sol_types::sol_data::Uint<256>,
11574            );
11575            type Token<'a> = <Self::Parameters<
11576                'a,
11577            > as alloy_sol_types::SolType>::Token<'a>;
11578            type Return = calculateOperatorChurnApprovalDigestHashReturn;
11579            type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
11580            type ReturnToken<'a> = <Self::ReturnTuple<
11581                'a,
11582            > as alloy_sol_types::SolType>::Token<'a>;
11583            const SIGNATURE: &'static str = "calculateOperatorChurnApprovalDigestHash(address,bytes32,(uint8,address)[],bytes32,uint256)";
11584            const SELECTOR: [u8; 4] = [132u8, 202u8, 82u8, 19u8];
11585            #[inline]
11586            fn new<'a>(
11587                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11588            ) -> Self {
11589                tuple.into()
11590            }
11591            #[inline]
11592            fn tokenize(&self) -> Self::Token<'_> {
11593                (
11594                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
11595                        &self.registeringOperator,
11596                    ),
11597                    <alloy::sol_types::sol_data::FixedBytes<
11598                        32,
11599                    > as alloy_sol_types::SolType>::tokenize(
11600                        &self.registeringOperatorId,
11601                    ),
11602                    <alloy::sol_types::sol_data::Array<
11603                        ISlashingRegistryCoordinatorTypes::OperatorKickParam,
11604                    > as alloy_sol_types::SolType>::tokenize(&self.operatorKickParams),
11605                    <alloy::sol_types::sol_data::FixedBytes<
11606                        32,
11607                    > as alloy_sol_types::SolType>::tokenize(&self.salt),
11608                    <alloy::sol_types::sol_data::Uint<
11609                        256,
11610                    > as alloy_sol_types::SolType>::tokenize(&self.expiry),
11611                )
11612            }
11613            #[inline]
11614            fn abi_decode_returns(
11615                data: &[u8],
11616                validate: bool,
11617            ) -> alloy_sol_types::Result<Self::Return> {
11618                <Self::ReturnTuple<
11619                    '_,
11620                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
11621                    .map(Into::into)
11622            }
11623        }
11624    };
11625    #[derive(Default, Debug, PartialEq, Eq, Hash)]
11626    /**Function with signature `calculatePubkeyRegistrationMessageHash(address)` and selector `0x73447992`.
11627```solidity
11628function calculatePubkeyRegistrationMessageHash(address operator) external view returns (bytes32);
11629```*/
11630    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11631    #[derive(Clone)]
11632    pub struct calculatePubkeyRegistrationMessageHashCall {
11633        #[allow(missing_docs)]
11634        pub operator: alloy::sol_types::private::Address,
11635    }
11636    #[derive(Default, Debug, PartialEq, Eq, Hash)]
11637    ///Container type for the return parameters of the [`calculatePubkeyRegistrationMessageHash(address)`](calculatePubkeyRegistrationMessageHashCall) function.
11638    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11639    #[derive(Clone)]
11640    pub struct calculatePubkeyRegistrationMessageHashReturn {
11641        #[allow(missing_docs)]
11642        pub _0: alloy::sol_types::private::FixedBytes<32>,
11643    }
11644    #[allow(
11645        non_camel_case_types,
11646        non_snake_case,
11647        clippy::pub_underscore_fields,
11648        clippy::style
11649    )]
11650    const _: () = {
11651        use alloy::sol_types as alloy_sol_types;
11652        {
11653            #[doc(hidden)]
11654            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
11655            #[doc(hidden)]
11656            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
11657            #[cfg(test)]
11658            #[allow(dead_code, unreachable_patterns)]
11659            fn _type_assertion(
11660                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11661            ) {
11662                match _t {
11663                    alloy_sol_types::private::AssertTypeEq::<
11664                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11665                    >(_) => {}
11666                }
11667            }
11668            #[automatically_derived]
11669            #[doc(hidden)]
11670            impl ::core::convert::From<calculatePubkeyRegistrationMessageHashCall>
11671            for UnderlyingRustTuple<'_> {
11672                fn from(value: calculatePubkeyRegistrationMessageHashCall) -> Self {
11673                    (value.operator,)
11674                }
11675            }
11676            #[automatically_derived]
11677            #[doc(hidden)]
11678            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11679            for calculatePubkeyRegistrationMessageHashCall {
11680                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11681                    Self { operator: tuple.0 }
11682                }
11683            }
11684        }
11685        {
11686            #[doc(hidden)]
11687            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
11688            #[doc(hidden)]
11689            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
11690            #[cfg(test)]
11691            #[allow(dead_code, unreachable_patterns)]
11692            fn _type_assertion(
11693                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11694            ) {
11695                match _t {
11696                    alloy_sol_types::private::AssertTypeEq::<
11697                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11698                    >(_) => {}
11699                }
11700            }
11701            #[automatically_derived]
11702            #[doc(hidden)]
11703            impl ::core::convert::From<calculatePubkeyRegistrationMessageHashReturn>
11704            for UnderlyingRustTuple<'_> {
11705                fn from(value: calculatePubkeyRegistrationMessageHashReturn) -> Self {
11706                    (value._0,)
11707                }
11708            }
11709            #[automatically_derived]
11710            #[doc(hidden)]
11711            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11712            for calculatePubkeyRegistrationMessageHashReturn {
11713                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11714                    Self { _0: tuple.0 }
11715                }
11716            }
11717        }
11718        #[automatically_derived]
11719        impl alloy_sol_types::SolCall for calculatePubkeyRegistrationMessageHashCall {
11720            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
11721            type Token<'a> = <Self::Parameters<
11722                'a,
11723            > as alloy_sol_types::SolType>::Token<'a>;
11724            type Return = calculatePubkeyRegistrationMessageHashReturn;
11725            type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
11726            type ReturnToken<'a> = <Self::ReturnTuple<
11727                'a,
11728            > as alloy_sol_types::SolType>::Token<'a>;
11729            const SIGNATURE: &'static str = "calculatePubkeyRegistrationMessageHash(address)";
11730            const SELECTOR: [u8; 4] = [115u8, 68u8, 121u8, 146u8];
11731            #[inline]
11732            fn new<'a>(
11733                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11734            ) -> Self {
11735                tuple.into()
11736            }
11737            #[inline]
11738            fn tokenize(&self) -> Self::Token<'_> {
11739                (
11740                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
11741                        &self.operator,
11742                    ),
11743                )
11744            }
11745            #[inline]
11746            fn abi_decode_returns(
11747                data: &[u8],
11748                validate: bool,
11749            ) -> alloy_sol_types::Result<Self::Return> {
11750                <Self::ReturnTuple<
11751                    '_,
11752                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
11753                    .map(Into::into)
11754            }
11755        }
11756    };
11757    #[derive(Default, Debug, PartialEq, Eq, Hash)]
11758    /**Function with signature `churnApprover()` and selector `0x054310e6`.
11759```solidity
11760function churnApprover() external view returns (address);
11761```*/
11762    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11763    #[derive(Clone)]
11764    pub struct churnApproverCall {}
11765    #[derive(Default, Debug, PartialEq, Eq, Hash)]
11766    ///Container type for the return parameters of the [`churnApprover()`](churnApproverCall) function.
11767    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11768    #[derive(Clone)]
11769    pub struct churnApproverReturn {
11770        #[allow(missing_docs)]
11771        pub _0: alloy::sol_types::private::Address,
11772    }
11773    #[allow(
11774        non_camel_case_types,
11775        non_snake_case,
11776        clippy::pub_underscore_fields,
11777        clippy::style
11778    )]
11779    const _: () = {
11780        use alloy::sol_types as alloy_sol_types;
11781        {
11782            #[doc(hidden)]
11783            type UnderlyingSolTuple<'a> = ();
11784            #[doc(hidden)]
11785            type UnderlyingRustTuple<'a> = ();
11786            #[cfg(test)]
11787            #[allow(dead_code, unreachable_patterns)]
11788            fn _type_assertion(
11789                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11790            ) {
11791                match _t {
11792                    alloy_sol_types::private::AssertTypeEq::<
11793                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11794                    >(_) => {}
11795                }
11796            }
11797            #[automatically_derived]
11798            #[doc(hidden)]
11799            impl ::core::convert::From<churnApproverCall> for UnderlyingRustTuple<'_> {
11800                fn from(value: churnApproverCall) -> Self {
11801                    ()
11802                }
11803            }
11804            #[automatically_derived]
11805            #[doc(hidden)]
11806            impl ::core::convert::From<UnderlyingRustTuple<'_>> for churnApproverCall {
11807                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11808                    Self {}
11809                }
11810            }
11811        }
11812        {
11813            #[doc(hidden)]
11814            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
11815            #[doc(hidden)]
11816            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
11817            #[cfg(test)]
11818            #[allow(dead_code, unreachable_patterns)]
11819            fn _type_assertion(
11820                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11821            ) {
11822                match _t {
11823                    alloy_sol_types::private::AssertTypeEq::<
11824                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11825                    >(_) => {}
11826                }
11827            }
11828            #[automatically_derived]
11829            #[doc(hidden)]
11830            impl ::core::convert::From<churnApproverReturn> for UnderlyingRustTuple<'_> {
11831                fn from(value: churnApproverReturn) -> Self {
11832                    (value._0,)
11833                }
11834            }
11835            #[automatically_derived]
11836            #[doc(hidden)]
11837            impl ::core::convert::From<UnderlyingRustTuple<'_>> for churnApproverReturn {
11838                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11839                    Self { _0: tuple.0 }
11840                }
11841            }
11842        }
11843        #[automatically_derived]
11844        impl alloy_sol_types::SolCall for churnApproverCall {
11845            type Parameters<'a> = ();
11846            type Token<'a> = <Self::Parameters<
11847                'a,
11848            > as alloy_sol_types::SolType>::Token<'a>;
11849            type Return = churnApproverReturn;
11850            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
11851            type ReturnToken<'a> = <Self::ReturnTuple<
11852                'a,
11853            > as alloy_sol_types::SolType>::Token<'a>;
11854            const SIGNATURE: &'static str = "churnApprover()";
11855            const SELECTOR: [u8; 4] = [5u8, 67u8, 16u8, 230u8];
11856            #[inline]
11857            fn new<'a>(
11858                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11859            ) -> Self {
11860                tuple.into()
11861            }
11862            #[inline]
11863            fn tokenize(&self) -> Self::Token<'_> {
11864                ()
11865            }
11866            #[inline]
11867            fn abi_decode_returns(
11868                data: &[u8],
11869                validate: bool,
11870            ) -> alloy_sol_types::Result<Self::Return> {
11871                <Self::ReturnTuple<
11872                    '_,
11873                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
11874                    .map(Into::into)
11875            }
11876        }
11877    };
11878    #[derive(Default, Debug, PartialEq, Eq, Hash)]
11879    /**Function with signature `createSlashableStakeQuorum((uint32,uint16,uint16),uint96,(address,uint96)[],uint32)` and selector `0x3eef3a51`.
11880```solidity
11881function createSlashableStakeQuorum(ISlashingRegistryCoordinatorTypes.OperatorSetParam memory operatorSetParams, uint96 minimumStake, IStakeRegistryTypes.StrategyParams[] memory strategyParams, uint32 lookAheadPeriod) external;
11882```*/
11883    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11884    #[derive(Clone)]
11885    pub struct createSlashableStakeQuorumCall {
11886        #[allow(missing_docs)]
11887        pub operatorSetParams: <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
11888        #[allow(missing_docs)]
11889        pub minimumStake: alloy::sol_types::private::primitives::aliases::U96,
11890        #[allow(missing_docs)]
11891        pub strategyParams: alloy::sol_types::private::Vec<
11892            <IStakeRegistryTypes::StrategyParams as alloy::sol_types::SolType>::RustType,
11893        >,
11894        #[allow(missing_docs)]
11895        pub lookAheadPeriod: u32,
11896    }
11897    ///Container type for the return parameters of the [`createSlashableStakeQuorum((uint32,uint16,uint16),uint96,(address,uint96)[],uint32)`](createSlashableStakeQuorumCall) function.
11898    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11899    #[derive(Clone)]
11900    pub struct createSlashableStakeQuorumReturn {}
11901    #[allow(
11902        non_camel_case_types,
11903        non_snake_case,
11904        clippy::pub_underscore_fields,
11905        clippy::style
11906    )]
11907    const _: () = {
11908        use alloy::sol_types as alloy_sol_types;
11909        {
11910            #[doc(hidden)]
11911            type UnderlyingSolTuple<'a> = (
11912                ISlashingRegistryCoordinatorTypes::OperatorSetParam,
11913                alloy::sol_types::sol_data::Uint<96>,
11914                alloy::sol_types::sol_data::Array<IStakeRegistryTypes::StrategyParams>,
11915                alloy::sol_types::sol_data::Uint<32>,
11916            );
11917            #[doc(hidden)]
11918            type UnderlyingRustTuple<'a> = (
11919                <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
11920                alloy::sol_types::private::primitives::aliases::U96,
11921                alloy::sol_types::private::Vec<
11922                    <IStakeRegistryTypes::StrategyParams as alloy::sol_types::SolType>::RustType,
11923                >,
11924                u32,
11925            );
11926            #[cfg(test)]
11927            #[allow(dead_code, unreachable_patterns)]
11928            fn _type_assertion(
11929                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11930            ) {
11931                match _t {
11932                    alloy_sol_types::private::AssertTypeEq::<
11933                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11934                    >(_) => {}
11935                }
11936            }
11937            #[automatically_derived]
11938            #[doc(hidden)]
11939            impl ::core::convert::From<createSlashableStakeQuorumCall>
11940            for UnderlyingRustTuple<'_> {
11941                fn from(value: createSlashableStakeQuorumCall) -> Self {
11942                    (
11943                        value.operatorSetParams,
11944                        value.minimumStake,
11945                        value.strategyParams,
11946                        value.lookAheadPeriod,
11947                    )
11948                }
11949            }
11950            #[automatically_derived]
11951            #[doc(hidden)]
11952            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11953            for createSlashableStakeQuorumCall {
11954                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11955                    Self {
11956                        operatorSetParams: tuple.0,
11957                        minimumStake: tuple.1,
11958                        strategyParams: tuple.2,
11959                        lookAheadPeriod: tuple.3,
11960                    }
11961                }
11962            }
11963        }
11964        {
11965            #[doc(hidden)]
11966            type UnderlyingSolTuple<'a> = ();
11967            #[doc(hidden)]
11968            type UnderlyingRustTuple<'a> = ();
11969            #[cfg(test)]
11970            #[allow(dead_code, unreachable_patterns)]
11971            fn _type_assertion(
11972                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11973            ) {
11974                match _t {
11975                    alloy_sol_types::private::AssertTypeEq::<
11976                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11977                    >(_) => {}
11978                }
11979            }
11980            #[automatically_derived]
11981            #[doc(hidden)]
11982            impl ::core::convert::From<createSlashableStakeQuorumReturn>
11983            for UnderlyingRustTuple<'_> {
11984                fn from(value: createSlashableStakeQuorumReturn) -> Self {
11985                    ()
11986                }
11987            }
11988            #[automatically_derived]
11989            #[doc(hidden)]
11990            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11991            for createSlashableStakeQuorumReturn {
11992                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11993                    Self {}
11994                }
11995            }
11996        }
11997        #[automatically_derived]
11998        impl alloy_sol_types::SolCall for createSlashableStakeQuorumCall {
11999            type Parameters<'a> = (
12000                ISlashingRegistryCoordinatorTypes::OperatorSetParam,
12001                alloy::sol_types::sol_data::Uint<96>,
12002                alloy::sol_types::sol_data::Array<IStakeRegistryTypes::StrategyParams>,
12003                alloy::sol_types::sol_data::Uint<32>,
12004            );
12005            type Token<'a> = <Self::Parameters<
12006                'a,
12007            > as alloy_sol_types::SolType>::Token<'a>;
12008            type Return = createSlashableStakeQuorumReturn;
12009            type ReturnTuple<'a> = ();
12010            type ReturnToken<'a> = <Self::ReturnTuple<
12011                'a,
12012            > as alloy_sol_types::SolType>::Token<'a>;
12013            const SIGNATURE: &'static str = "createSlashableStakeQuorum((uint32,uint16,uint16),uint96,(address,uint96)[],uint32)";
12014            const SELECTOR: [u8; 4] = [62u8, 239u8, 58u8, 81u8];
12015            #[inline]
12016            fn new<'a>(
12017                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
12018            ) -> Self {
12019                tuple.into()
12020            }
12021            #[inline]
12022            fn tokenize(&self) -> Self::Token<'_> {
12023                (
12024                    <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy_sol_types::SolType>::tokenize(
12025                        &self.operatorSetParams,
12026                    ),
12027                    <alloy::sol_types::sol_data::Uint<
12028                        96,
12029                    > as alloy_sol_types::SolType>::tokenize(&self.minimumStake),
12030                    <alloy::sol_types::sol_data::Array<
12031                        IStakeRegistryTypes::StrategyParams,
12032                    > as alloy_sol_types::SolType>::tokenize(&self.strategyParams),
12033                    <alloy::sol_types::sol_data::Uint<
12034                        32,
12035                    > as alloy_sol_types::SolType>::tokenize(&self.lookAheadPeriod),
12036                )
12037            }
12038            #[inline]
12039            fn abi_decode_returns(
12040                data: &[u8],
12041                validate: bool,
12042            ) -> alloy_sol_types::Result<Self::Return> {
12043                <Self::ReturnTuple<
12044                    '_,
12045                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
12046                    .map(Into::into)
12047            }
12048        }
12049    };
12050    #[derive(Default, Debug, PartialEq, Eq, Hash)]
12051    /**Function with signature `createTotalDelegatedStakeQuorum((uint32,uint16,uint16),uint96,(address,uint96)[])` and selector `0x8281ab75`.
12052```solidity
12053function createTotalDelegatedStakeQuorum(ISlashingRegistryCoordinatorTypes.OperatorSetParam memory operatorSetParams, uint96 minimumStake, IStakeRegistryTypes.StrategyParams[] memory strategyParams) external;
12054```*/
12055    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12056    #[derive(Clone)]
12057    pub struct createTotalDelegatedStakeQuorumCall {
12058        #[allow(missing_docs)]
12059        pub operatorSetParams: <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
12060        #[allow(missing_docs)]
12061        pub minimumStake: alloy::sol_types::private::primitives::aliases::U96,
12062        #[allow(missing_docs)]
12063        pub strategyParams: alloy::sol_types::private::Vec<
12064            <IStakeRegistryTypes::StrategyParams as alloy::sol_types::SolType>::RustType,
12065        >,
12066    }
12067    ///Container type for the return parameters of the [`createTotalDelegatedStakeQuorum((uint32,uint16,uint16),uint96,(address,uint96)[])`](createTotalDelegatedStakeQuorumCall) function.
12068    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12069    #[derive(Clone)]
12070    pub struct createTotalDelegatedStakeQuorumReturn {}
12071    #[allow(
12072        non_camel_case_types,
12073        non_snake_case,
12074        clippy::pub_underscore_fields,
12075        clippy::style
12076    )]
12077    const _: () = {
12078        use alloy::sol_types as alloy_sol_types;
12079        {
12080            #[doc(hidden)]
12081            type UnderlyingSolTuple<'a> = (
12082                ISlashingRegistryCoordinatorTypes::OperatorSetParam,
12083                alloy::sol_types::sol_data::Uint<96>,
12084                alloy::sol_types::sol_data::Array<IStakeRegistryTypes::StrategyParams>,
12085            );
12086            #[doc(hidden)]
12087            type UnderlyingRustTuple<'a> = (
12088                <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
12089                alloy::sol_types::private::primitives::aliases::U96,
12090                alloy::sol_types::private::Vec<
12091                    <IStakeRegistryTypes::StrategyParams as alloy::sol_types::SolType>::RustType,
12092                >,
12093            );
12094            #[cfg(test)]
12095            #[allow(dead_code, unreachable_patterns)]
12096            fn _type_assertion(
12097                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
12098            ) {
12099                match _t {
12100                    alloy_sol_types::private::AssertTypeEq::<
12101                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12102                    >(_) => {}
12103                }
12104            }
12105            #[automatically_derived]
12106            #[doc(hidden)]
12107            impl ::core::convert::From<createTotalDelegatedStakeQuorumCall>
12108            for UnderlyingRustTuple<'_> {
12109                fn from(value: createTotalDelegatedStakeQuorumCall) -> Self {
12110                    (value.operatorSetParams, value.minimumStake, value.strategyParams)
12111                }
12112            }
12113            #[automatically_derived]
12114            #[doc(hidden)]
12115            impl ::core::convert::From<UnderlyingRustTuple<'_>>
12116            for createTotalDelegatedStakeQuorumCall {
12117                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12118                    Self {
12119                        operatorSetParams: tuple.0,
12120                        minimumStake: tuple.1,
12121                        strategyParams: tuple.2,
12122                    }
12123                }
12124            }
12125        }
12126        {
12127            #[doc(hidden)]
12128            type UnderlyingSolTuple<'a> = ();
12129            #[doc(hidden)]
12130            type UnderlyingRustTuple<'a> = ();
12131            #[cfg(test)]
12132            #[allow(dead_code, unreachable_patterns)]
12133            fn _type_assertion(
12134                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
12135            ) {
12136                match _t {
12137                    alloy_sol_types::private::AssertTypeEq::<
12138                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12139                    >(_) => {}
12140                }
12141            }
12142            #[automatically_derived]
12143            #[doc(hidden)]
12144            impl ::core::convert::From<createTotalDelegatedStakeQuorumReturn>
12145            for UnderlyingRustTuple<'_> {
12146                fn from(value: createTotalDelegatedStakeQuorumReturn) -> Self {
12147                    ()
12148                }
12149            }
12150            #[automatically_derived]
12151            #[doc(hidden)]
12152            impl ::core::convert::From<UnderlyingRustTuple<'_>>
12153            for createTotalDelegatedStakeQuorumReturn {
12154                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12155                    Self {}
12156                }
12157            }
12158        }
12159        #[automatically_derived]
12160        impl alloy_sol_types::SolCall for createTotalDelegatedStakeQuorumCall {
12161            type Parameters<'a> = (
12162                ISlashingRegistryCoordinatorTypes::OperatorSetParam,
12163                alloy::sol_types::sol_data::Uint<96>,
12164                alloy::sol_types::sol_data::Array<IStakeRegistryTypes::StrategyParams>,
12165            );
12166            type Token<'a> = <Self::Parameters<
12167                'a,
12168            > as alloy_sol_types::SolType>::Token<'a>;
12169            type Return = createTotalDelegatedStakeQuorumReturn;
12170            type ReturnTuple<'a> = ();
12171            type ReturnToken<'a> = <Self::ReturnTuple<
12172                'a,
12173            > as alloy_sol_types::SolType>::Token<'a>;
12174            const SIGNATURE: &'static str = "createTotalDelegatedStakeQuorum((uint32,uint16,uint16),uint96,(address,uint96)[])";
12175            const SELECTOR: [u8; 4] = [130u8, 129u8, 171u8, 117u8];
12176            #[inline]
12177            fn new<'a>(
12178                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
12179            ) -> Self {
12180                tuple.into()
12181            }
12182            #[inline]
12183            fn tokenize(&self) -> Self::Token<'_> {
12184                (
12185                    <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy_sol_types::SolType>::tokenize(
12186                        &self.operatorSetParams,
12187                    ),
12188                    <alloy::sol_types::sol_data::Uint<
12189                        96,
12190                    > as alloy_sol_types::SolType>::tokenize(&self.minimumStake),
12191                    <alloy::sol_types::sol_data::Array<
12192                        IStakeRegistryTypes::StrategyParams,
12193                    > as alloy_sol_types::SolType>::tokenize(&self.strategyParams),
12194                )
12195            }
12196            #[inline]
12197            fn abi_decode_returns(
12198                data: &[u8],
12199                validate: bool,
12200            ) -> alloy_sol_types::Result<Self::Return> {
12201                <Self::ReturnTuple<
12202                    '_,
12203                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
12204                    .map(Into::into)
12205            }
12206        }
12207    };
12208    #[derive(Default, Debug, PartialEq, Eq, Hash)]
12209    /**Function with signature `deregisterOperator(address,address,uint32[])` and selector `0x303ca956`.
12210```solidity
12211function deregisterOperator(address operator, address avs, uint32[] memory operatorSetIds) external;
12212```*/
12213    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12214    #[derive(Clone)]
12215    pub struct deregisterOperator_0Call {
12216        #[allow(missing_docs)]
12217        pub operator: alloy::sol_types::private::Address,
12218        #[allow(missing_docs)]
12219        pub avs: alloy::sol_types::private::Address,
12220        #[allow(missing_docs)]
12221        pub operatorSetIds: alloy::sol_types::private::Vec<u32>,
12222    }
12223    ///Container type for the return parameters of the [`deregisterOperator(address,address,uint32[])`](deregisterOperator_0Call) function.
12224    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12225    #[derive(Clone)]
12226    pub struct deregisterOperator_0Return {}
12227    #[allow(
12228        non_camel_case_types,
12229        non_snake_case,
12230        clippy::pub_underscore_fields,
12231        clippy::style
12232    )]
12233    const _: () = {
12234        use alloy::sol_types as alloy_sol_types;
12235        {
12236            #[doc(hidden)]
12237            type UnderlyingSolTuple<'a> = (
12238                alloy::sol_types::sol_data::Address,
12239                alloy::sol_types::sol_data::Address,
12240                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
12241            );
12242            #[doc(hidden)]
12243            type UnderlyingRustTuple<'a> = (
12244                alloy::sol_types::private::Address,
12245                alloy::sol_types::private::Address,
12246                alloy::sol_types::private::Vec<u32>,
12247            );
12248            #[cfg(test)]
12249            #[allow(dead_code, unreachable_patterns)]
12250            fn _type_assertion(
12251                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
12252            ) {
12253                match _t {
12254                    alloy_sol_types::private::AssertTypeEq::<
12255                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12256                    >(_) => {}
12257                }
12258            }
12259            #[automatically_derived]
12260            #[doc(hidden)]
12261            impl ::core::convert::From<deregisterOperator_0Call>
12262            for UnderlyingRustTuple<'_> {
12263                fn from(value: deregisterOperator_0Call) -> Self {
12264                    (value.operator, value.avs, value.operatorSetIds)
12265                }
12266            }
12267            #[automatically_derived]
12268            #[doc(hidden)]
12269            impl ::core::convert::From<UnderlyingRustTuple<'_>>
12270            for deregisterOperator_0Call {
12271                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12272                    Self {
12273                        operator: tuple.0,
12274                        avs: tuple.1,
12275                        operatorSetIds: tuple.2,
12276                    }
12277                }
12278            }
12279        }
12280        {
12281            #[doc(hidden)]
12282            type UnderlyingSolTuple<'a> = ();
12283            #[doc(hidden)]
12284            type UnderlyingRustTuple<'a> = ();
12285            #[cfg(test)]
12286            #[allow(dead_code, unreachable_patterns)]
12287            fn _type_assertion(
12288                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
12289            ) {
12290                match _t {
12291                    alloy_sol_types::private::AssertTypeEq::<
12292                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12293                    >(_) => {}
12294                }
12295            }
12296            #[automatically_derived]
12297            #[doc(hidden)]
12298            impl ::core::convert::From<deregisterOperator_0Return>
12299            for UnderlyingRustTuple<'_> {
12300                fn from(value: deregisterOperator_0Return) -> Self {
12301                    ()
12302                }
12303            }
12304            #[automatically_derived]
12305            #[doc(hidden)]
12306            impl ::core::convert::From<UnderlyingRustTuple<'_>>
12307            for deregisterOperator_0Return {
12308                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12309                    Self {}
12310                }
12311            }
12312        }
12313        #[automatically_derived]
12314        impl alloy_sol_types::SolCall for deregisterOperator_0Call {
12315            type Parameters<'a> = (
12316                alloy::sol_types::sol_data::Address,
12317                alloy::sol_types::sol_data::Address,
12318                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
12319            );
12320            type Token<'a> = <Self::Parameters<
12321                'a,
12322            > as alloy_sol_types::SolType>::Token<'a>;
12323            type Return = deregisterOperator_0Return;
12324            type ReturnTuple<'a> = ();
12325            type ReturnToken<'a> = <Self::ReturnTuple<
12326                'a,
12327            > as alloy_sol_types::SolType>::Token<'a>;
12328            const SIGNATURE: &'static str = "deregisterOperator(address,address,uint32[])";
12329            const SELECTOR: [u8; 4] = [48u8, 60u8, 169u8, 86u8];
12330            #[inline]
12331            fn new<'a>(
12332                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
12333            ) -> Self {
12334                tuple.into()
12335            }
12336            #[inline]
12337            fn tokenize(&self) -> Self::Token<'_> {
12338                (
12339                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
12340                        &self.operator,
12341                    ),
12342                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
12343                        &self.avs,
12344                    ),
12345                    <alloy::sol_types::sol_data::Array<
12346                        alloy::sol_types::sol_data::Uint<32>,
12347                    > as alloy_sol_types::SolType>::tokenize(&self.operatorSetIds),
12348                )
12349            }
12350            #[inline]
12351            fn abi_decode_returns(
12352                data: &[u8],
12353                validate: bool,
12354            ) -> alloy_sol_types::Result<Self::Return> {
12355                <Self::ReturnTuple<
12356                    '_,
12357                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
12358                    .map(Into::into)
12359            }
12360        }
12361    };
12362    #[derive(Default, Debug, PartialEq, Eq, Hash)]
12363    /**Function with signature `deregisterOperator(bytes)` and selector `0xca4f2d97`.
12364```solidity
12365function deregisterOperator(bytes memory quorumNumbers) external;
12366```*/
12367    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12368    #[derive(Clone)]
12369    pub struct deregisterOperator_1Call {
12370        #[allow(missing_docs)]
12371        pub quorumNumbers: alloy::sol_types::private::Bytes,
12372    }
12373    ///Container type for the return parameters of the [`deregisterOperator(bytes)`](deregisterOperator_1Call) function.
12374    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12375    #[derive(Clone)]
12376    pub struct deregisterOperator_1Return {}
12377    #[allow(
12378        non_camel_case_types,
12379        non_snake_case,
12380        clippy::pub_underscore_fields,
12381        clippy::style
12382    )]
12383    const _: () = {
12384        use alloy::sol_types as alloy_sol_types;
12385        {
12386            #[doc(hidden)]
12387            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bytes,);
12388            #[doc(hidden)]
12389            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Bytes,);
12390            #[cfg(test)]
12391            #[allow(dead_code, unreachable_patterns)]
12392            fn _type_assertion(
12393                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
12394            ) {
12395                match _t {
12396                    alloy_sol_types::private::AssertTypeEq::<
12397                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12398                    >(_) => {}
12399                }
12400            }
12401            #[automatically_derived]
12402            #[doc(hidden)]
12403            impl ::core::convert::From<deregisterOperator_1Call>
12404            for UnderlyingRustTuple<'_> {
12405                fn from(value: deregisterOperator_1Call) -> Self {
12406                    (value.quorumNumbers,)
12407                }
12408            }
12409            #[automatically_derived]
12410            #[doc(hidden)]
12411            impl ::core::convert::From<UnderlyingRustTuple<'_>>
12412            for deregisterOperator_1Call {
12413                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12414                    Self { quorumNumbers: tuple.0 }
12415                }
12416            }
12417        }
12418        {
12419            #[doc(hidden)]
12420            type UnderlyingSolTuple<'a> = ();
12421            #[doc(hidden)]
12422            type UnderlyingRustTuple<'a> = ();
12423            #[cfg(test)]
12424            #[allow(dead_code, unreachable_patterns)]
12425            fn _type_assertion(
12426                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
12427            ) {
12428                match _t {
12429                    alloy_sol_types::private::AssertTypeEq::<
12430                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12431                    >(_) => {}
12432                }
12433            }
12434            #[automatically_derived]
12435            #[doc(hidden)]
12436            impl ::core::convert::From<deregisterOperator_1Return>
12437            for UnderlyingRustTuple<'_> {
12438                fn from(value: deregisterOperator_1Return) -> Self {
12439                    ()
12440                }
12441            }
12442            #[automatically_derived]
12443            #[doc(hidden)]
12444            impl ::core::convert::From<UnderlyingRustTuple<'_>>
12445            for deregisterOperator_1Return {
12446                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12447                    Self {}
12448                }
12449            }
12450        }
12451        #[automatically_derived]
12452        impl alloy_sol_types::SolCall for deregisterOperator_1Call {
12453            type Parameters<'a> = (alloy::sol_types::sol_data::Bytes,);
12454            type Token<'a> = <Self::Parameters<
12455                'a,
12456            > as alloy_sol_types::SolType>::Token<'a>;
12457            type Return = deregisterOperator_1Return;
12458            type ReturnTuple<'a> = ();
12459            type ReturnToken<'a> = <Self::ReturnTuple<
12460                'a,
12461            > as alloy_sol_types::SolType>::Token<'a>;
12462            const SIGNATURE: &'static str = "deregisterOperator(bytes)";
12463            const SELECTOR: [u8; 4] = [202u8, 79u8, 45u8, 151u8];
12464            #[inline]
12465            fn new<'a>(
12466                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
12467            ) -> Self {
12468                tuple.into()
12469            }
12470            #[inline]
12471            fn tokenize(&self) -> Self::Token<'_> {
12472                (
12473                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
12474                        &self.quorumNumbers,
12475                    ),
12476                )
12477            }
12478            #[inline]
12479            fn abi_decode_returns(
12480                data: &[u8],
12481                validate: bool,
12482            ) -> alloy_sol_types::Result<Self::Return> {
12483                <Self::ReturnTuple<
12484                    '_,
12485                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
12486                    .map(Into::into)
12487            }
12488        }
12489    };
12490    #[derive(Default, Debug, PartialEq, Eq, Hash)]
12491    /**Function with signature `disableM2QuorumRegistration()` and selector `0x733b7507`.
12492```solidity
12493function disableM2QuorumRegistration() external;
12494```*/
12495    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12496    #[derive(Clone)]
12497    pub struct disableM2QuorumRegistrationCall {}
12498    ///Container type for the return parameters of the [`disableM2QuorumRegistration()`](disableM2QuorumRegistrationCall) function.
12499    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12500    #[derive(Clone)]
12501    pub struct disableM2QuorumRegistrationReturn {}
12502    #[allow(
12503        non_camel_case_types,
12504        non_snake_case,
12505        clippy::pub_underscore_fields,
12506        clippy::style
12507    )]
12508    const _: () = {
12509        use alloy::sol_types as alloy_sol_types;
12510        {
12511            #[doc(hidden)]
12512            type UnderlyingSolTuple<'a> = ();
12513            #[doc(hidden)]
12514            type UnderlyingRustTuple<'a> = ();
12515            #[cfg(test)]
12516            #[allow(dead_code, unreachable_patterns)]
12517            fn _type_assertion(
12518                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
12519            ) {
12520                match _t {
12521                    alloy_sol_types::private::AssertTypeEq::<
12522                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12523                    >(_) => {}
12524                }
12525            }
12526            #[automatically_derived]
12527            #[doc(hidden)]
12528            impl ::core::convert::From<disableM2QuorumRegistrationCall>
12529            for UnderlyingRustTuple<'_> {
12530                fn from(value: disableM2QuorumRegistrationCall) -> Self {
12531                    ()
12532                }
12533            }
12534            #[automatically_derived]
12535            #[doc(hidden)]
12536            impl ::core::convert::From<UnderlyingRustTuple<'_>>
12537            for disableM2QuorumRegistrationCall {
12538                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12539                    Self {}
12540                }
12541            }
12542        }
12543        {
12544            #[doc(hidden)]
12545            type UnderlyingSolTuple<'a> = ();
12546            #[doc(hidden)]
12547            type UnderlyingRustTuple<'a> = ();
12548            #[cfg(test)]
12549            #[allow(dead_code, unreachable_patterns)]
12550            fn _type_assertion(
12551                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
12552            ) {
12553                match _t {
12554                    alloy_sol_types::private::AssertTypeEq::<
12555                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12556                    >(_) => {}
12557                }
12558            }
12559            #[automatically_derived]
12560            #[doc(hidden)]
12561            impl ::core::convert::From<disableM2QuorumRegistrationReturn>
12562            for UnderlyingRustTuple<'_> {
12563                fn from(value: disableM2QuorumRegistrationReturn) -> Self {
12564                    ()
12565                }
12566            }
12567            #[automatically_derived]
12568            #[doc(hidden)]
12569            impl ::core::convert::From<UnderlyingRustTuple<'_>>
12570            for disableM2QuorumRegistrationReturn {
12571                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12572                    Self {}
12573                }
12574            }
12575        }
12576        #[automatically_derived]
12577        impl alloy_sol_types::SolCall for disableM2QuorumRegistrationCall {
12578            type Parameters<'a> = ();
12579            type Token<'a> = <Self::Parameters<
12580                'a,
12581            > as alloy_sol_types::SolType>::Token<'a>;
12582            type Return = disableM2QuorumRegistrationReturn;
12583            type ReturnTuple<'a> = ();
12584            type ReturnToken<'a> = <Self::ReturnTuple<
12585                'a,
12586            > as alloy_sol_types::SolType>::Token<'a>;
12587            const SIGNATURE: &'static str = "disableM2QuorumRegistration()";
12588            const SELECTOR: [u8; 4] = [115u8, 59u8, 117u8, 7u8];
12589            #[inline]
12590            fn new<'a>(
12591                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
12592            ) -> Self {
12593                tuple.into()
12594            }
12595            #[inline]
12596            fn tokenize(&self) -> Self::Token<'_> {
12597                ()
12598            }
12599            #[inline]
12600            fn abi_decode_returns(
12601                data: &[u8],
12602                validate: bool,
12603            ) -> alloy_sol_types::Result<Self::Return> {
12604                <Self::ReturnTuple<
12605                    '_,
12606                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
12607                    .map(Into::into)
12608            }
12609        }
12610    };
12611    #[derive(Default, Debug, PartialEq, Eq, Hash)]
12612    /**Function with signature `domainSeparator()` and selector `0xf698da25`.
12613```solidity
12614function domainSeparator() external view returns (bytes32);
12615```*/
12616    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12617    #[derive(Clone)]
12618    pub struct domainSeparatorCall {}
12619    #[derive(Default, Debug, PartialEq, Eq, Hash)]
12620    ///Container type for the return parameters of the [`domainSeparator()`](domainSeparatorCall) function.
12621    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12622    #[derive(Clone)]
12623    pub struct domainSeparatorReturn {
12624        #[allow(missing_docs)]
12625        pub _0: alloy::sol_types::private::FixedBytes<32>,
12626    }
12627    #[allow(
12628        non_camel_case_types,
12629        non_snake_case,
12630        clippy::pub_underscore_fields,
12631        clippy::style
12632    )]
12633    const _: () = {
12634        use alloy::sol_types as alloy_sol_types;
12635        {
12636            #[doc(hidden)]
12637            type UnderlyingSolTuple<'a> = ();
12638            #[doc(hidden)]
12639            type UnderlyingRustTuple<'a> = ();
12640            #[cfg(test)]
12641            #[allow(dead_code, unreachable_patterns)]
12642            fn _type_assertion(
12643                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
12644            ) {
12645                match _t {
12646                    alloy_sol_types::private::AssertTypeEq::<
12647                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12648                    >(_) => {}
12649                }
12650            }
12651            #[automatically_derived]
12652            #[doc(hidden)]
12653            impl ::core::convert::From<domainSeparatorCall> for UnderlyingRustTuple<'_> {
12654                fn from(value: domainSeparatorCall) -> Self {
12655                    ()
12656                }
12657            }
12658            #[automatically_derived]
12659            #[doc(hidden)]
12660            impl ::core::convert::From<UnderlyingRustTuple<'_>> for domainSeparatorCall {
12661                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12662                    Self {}
12663                }
12664            }
12665        }
12666        {
12667            #[doc(hidden)]
12668            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
12669            #[doc(hidden)]
12670            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
12671            #[cfg(test)]
12672            #[allow(dead_code, unreachable_patterns)]
12673            fn _type_assertion(
12674                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
12675            ) {
12676                match _t {
12677                    alloy_sol_types::private::AssertTypeEq::<
12678                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12679                    >(_) => {}
12680                }
12681            }
12682            #[automatically_derived]
12683            #[doc(hidden)]
12684            impl ::core::convert::From<domainSeparatorReturn>
12685            for UnderlyingRustTuple<'_> {
12686                fn from(value: domainSeparatorReturn) -> Self {
12687                    (value._0,)
12688                }
12689            }
12690            #[automatically_derived]
12691            #[doc(hidden)]
12692            impl ::core::convert::From<UnderlyingRustTuple<'_>>
12693            for domainSeparatorReturn {
12694                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12695                    Self { _0: tuple.0 }
12696                }
12697            }
12698        }
12699        #[automatically_derived]
12700        impl alloy_sol_types::SolCall for domainSeparatorCall {
12701            type Parameters<'a> = ();
12702            type Token<'a> = <Self::Parameters<
12703                'a,
12704            > as alloy_sol_types::SolType>::Token<'a>;
12705            type Return = domainSeparatorReturn;
12706            type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
12707            type ReturnToken<'a> = <Self::ReturnTuple<
12708                'a,
12709            > as alloy_sol_types::SolType>::Token<'a>;
12710            const SIGNATURE: &'static str = "domainSeparator()";
12711            const SELECTOR: [u8; 4] = [246u8, 152u8, 218u8, 37u8];
12712            #[inline]
12713            fn new<'a>(
12714                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
12715            ) -> Self {
12716                tuple.into()
12717            }
12718            #[inline]
12719            fn tokenize(&self) -> Self::Token<'_> {
12720                ()
12721            }
12722            #[inline]
12723            fn abi_decode_returns(
12724                data: &[u8],
12725                validate: bool,
12726            ) -> alloy_sol_types::Result<Self::Return> {
12727                <Self::ReturnTuple<
12728                    '_,
12729                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
12730                    .map(Into::into)
12731            }
12732        }
12733    };
12734    #[derive(Default, Debug, PartialEq, Eq, Hash)]
12735    /**Function with signature `eip712Domain()` and selector `0x84b0196e`.
12736```solidity
12737function eip712Domain() external view returns (bytes1 fields, string memory name, string memory version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] memory extensions);
12738```*/
12739    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12740    #[derive(Clone)]
12741    pub struct eip712DomainCall {}
12742    #[derive(Default, Debug, PartialEq, Eq, Hash)]
12743    ///Container type for the return parameters of the [`eip712Domain()`](eip712DomainCall) function.
12744    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12745    #[derive(Clone)]
12746    pub struct eip712DomainReturn {
12747        #[allow(missing_docs)]
12748        pub fields: alloy::sol_types::private::FixedBytes<1>,
12749        #[allow(missing_docs)]
12750        pub name: alloy::sol_types::private::String,
12751        #[allow(missing_docs)]
12752        pub version: alloy::sol_types::private::String,
12753        #[allow(missing_docs)]
12754        pub chainId: alloy::sol_types::private::primitives::aliases::U256,
12755        #[allow(missing_docs)]
12756        pub verifyingContract: alloy::sol_types::private::Address,
12757        #[allow(missing_docs)]
12758        pub salt: alloy::sol_types::private::FixedBytes<32>,
12759        #[allow(missing_docs)]
12760        pub extensions: alloy::sol_types::private::Vec<
12761            alloy::sol_types::private::primitives::aliases::U256,
12762        >,
12763    }
12764    #[allow(
12765        non_camel_case_types,
12766        non_snake_case,
12767        clippy::pub_underscore_fields,
12768        clippy::style
12769    )]
12770    const _: () = {
12771        use alloy::sol_types as alloy_sol_types;
12772        {
12773            #[doc(hidden)]
12774            type UnderlyingSolTuple<'a> = ();
12775            #[doc(hidden)]
12776            type UnderlyingRustTuple<'a> = ();
12777            #[cfg(test)]
12778            #[allow(dead_code, unreachable_patterns)]
12779            fn _type_assertion(
12780                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
12781            ) {
12782                match _t {
12783                    alloy_sol_types::private::AssertTypeEq::<
12784                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12785                    >(_) => {}
12786                }
12787            }
12788            #[automatically_derived]
12789            #[doc(hidden)]
12790            impl ::core::convert::From<eip712DomainCall> for UnderlyingRustTuple<'_> {
12791                fn from(value: eip712DomainCall) -> Self {
12792                    ()
12793                }
12794            }
12795            #[automatically_derived]
12796            #[doc(hidden)]
12797            impl ::core::convert::From<UnderlyingRustTuple<'_>> for eip712DomainCall {
12798                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12799                    Self {}
12800                }
12801            }
12802        }
12803        {
12804            #[doc(hidden)]
12805            type UnderlyingSolTuple<'a> = (
12806                alloy::sol_types::sol_data::FixedBytes<1>,
12807                alloy::sol_types::sol_data::String,
12808                alloy::sol_types::sol_data::String,
12809                alloy::sol_types::sol_data::Uint<256>,
12810                alloy::sol_types::sol_data::Address,
12811                alloy::sol_types::sol_data::FixedBytes<32>,
12812                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
12813            );
12814            #[doc(hidden)]
12815            type UnderlyingRustTuple<'a> = (
12816                alloy::sol_types::private::FixedBytes<1>,
12817                alloy::sol_types::private::String,
12818                alloy::sol_types::private::String,
12819                alloy::sol_types::private::primitives::aliases::U256,
12820                alloy::sol_types::private::Address,
12821                alloy::sol_types::private::FixedBytes<32>,
12822                alloy::sol_types::private::Vec<
12823                    alloy::sol_types::private::primitives::aliases::U256,
12824                >,
12825            );
12826            #[cfg(test)]
12827            #[allow(dead_code, unreachable_patterns)]
12828            fn _type_assertion(
12829                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
12830            ) {
12831                match _t {
12832                    alloy_sol_types::private::AssertTypeEq::<
12833                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12834                    >(_) => {}
12835                }
12836            }
12837            #[automatically_derived]
12838            #[doc(hidden)]
12839            impl ::core::convert::From<eip712DomainReturn> for UnderlyingRustTuple<'_> {
12840                fn from(value: eip712DomainReturn) -> Self {
12841                    (
12842                        value.fields,
12843                        value.name,
12844                        value.version,
12845                        value.chainId,
12846                        value.verifyingContract,
12847                        value.salt,
12848                        value.extensions,
12849                    )
12850                }
12851            }
12852            #[automatically_derived]
12853            #[doc(hidden)]
12854            impl ::core::convert::From<UnderlyingRustTuple<'_>> for eip712DomainReturn {
12855                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12856                    Self {
12857                        fields: tuple.0,
12858                        name: tuple.1,
12859                        version: tuple.2,
12860                        chainId: tuple.3,
12861                        verifyingContract: tuple.4,
12862                        salt: tuple.5,
12863                        extensions: tuple.6,
12864                    }
12865                }
12866            }
12867        }
12868        #[automatically_derived]
12869        impl alloy_sol_types::SolCall for eip712DomainCall {
12870            type Parameters<'a> = ();
12871            type Token<'a> = <Self::Parameters<
12872                'a,
12873            > as alloy_sol_types::SolType>::Token<'a>;
12874            type Return = eip712DomainReturn;
12875            type ReturnTuple<'a> = (
12876                alloy::sol_types::sol_data::FixedBytes<1>,
12877                alloy::sol_types::sol_data::String,
12878                alloy::sol_types::sol_data::String,
12879                alloy::sol_types::sol_data::Uint<256>,
12880                alloy::sol_types::sol_data::Address,
12881                alloy::sol_types::sol_data::FixedBytes<32>,
12882                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
12883            );
12884            type ReturnToken<'a> = <Self::ReturnTuple<
12885                'a,
12886            > as alloy_sol_types::SolType>::Token<'a>;
12887            const SIGNATURE: &'static str = "eip712Domain()";
12888            const SELECTOR: [u8; 4] = [132u8, 176u8, 25u8, 110u8];
12889            #[inline]
12890            fn new<'a>(
12891                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
12892            ) -> Self {
12893                tuple.into()
12894            }
12895            #[inline]
12896            fn tokenize(&self) -> Self::Token<'_> {
12897                ()
12898            }
12899            #[inline]
12900            fn abi_decode_returns(
12901                data: &[u8],
12902                validate: bool,
12903            ) -> alloy_sol_types::Result<Self::Return> {
12904                <Self::ReturnTuple<
12905                    '_,
12906                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
12907                    .map(Into::into)
12908            }
12909        }
12910    };
12911    #[derive(Default, Debug, PartialEq, Eq, Hash)]
12912    /**Function with signature `ejectOperator(address,bytes)` and selector `0x6e3b17db`.
12913```solidity
12914function ejectOperator(address operator, bytes memory quorumNumbers) external;
12915```*/
12916    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12917    #[derive(Clone)]
12918    pub struct ejectOperatorCall {
12919        #[allow(missing_docs)]
12920        pub operator: alloy::sol_types::private::Address,
12921        #[allow(missing_docs)]
12922        pub quorumNumbers: alloy::sol_types::private::Bytes,
12923    }
12924    ///Container type for the return parameters of the [`ejectOperator(address,bytes)`](ejectOperatorCall) function.
12925    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12926    #[derive(Clone)]
12927    pub struct ejectOperatorReturn {}
12928    #[allow(
12929        non_camel_case_types,
12930        non_snake_case,
12931        clippy::pub_underscore_fields,
12932        clippy::style
12933    )]
12934    const _: () = {
12935        use alloy::sol_types as alloy_sol_types;
12936        {
12937            #[doc(hidden)]
12938            type UnderlyingSolTuple<'a> = (
12939                alloy::sol_types::sol_data::Address,
12940                alloy::sol_types::sol_data::Bytes,
12941            );
12942            #[doc(hidden)]
12943            type UnderlyingRustTuple<'a> = (
12944                alloy::sol_types::private::Address,
12945                alloy::sol_types::private::Bytes,
12946            );
12947            #[cfg(test)]
12948            #[allow(dead_code, unreachable_patterns)]
12949            fn _type_assertion(
12950                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
12951            ) {
12952                match _t {
12953                    alloy_sol_types::private::AssertTypeEq::<
12954                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12955                    >(_) => {}
12956                }
12957            }
12958            #[automatically_derived]
12959            #[doc(hidden)]
12960            impl ::core::convert::From<ejectOperatorCall> for UnderlyingRustTuple<'_> {
12961                fn from(value: ejectOperatorCall) -> Self {
12962                    (value.operator, value.quorumNumbers)
12963                }
12964            }
12965            #[automatically_derived]
12966            #[doc(hidden)]
12967            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ejectOperatorCall {
12968                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12969                    Self {
12970                        operator: tuple.0,
12971                        quorumNumbers: tuple.1,
12972                    }
12973                }
12974            }
12975        }
12976        {
12977            #[doc(hidden)]
12978            type UnderlyingSolTuple<'a> = ();
12979            #[doc(hidden)]
12980            type UnderlyingRustTuple<'a> = ();
12981            #[cfg(test)]
12982            #[allow(dead_code, unreachable_patterns)]
12983            fn _type_assertion(
12984                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
12985            ) {
12986                match _t {
12987                    alloy_sol_types::private::AssertTypeEq::<
12988                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12989                    >(_) => {}
12990                }
12991            }
12992            #[automatically_derived]
12993            #[doc(hidden)]
12994            impl ::core::convert::From<ejectOperatorReturn> for UnderlyingRustTuple<'_> {
12995                fn from(value: ejectOperatorReturn) -> Self {
12996                    ()
12997                }
12998            }
12999            #[automatically_derived]
13000            #[doc(hidden)]
13001            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ejectOperatorReturn {
13002                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13003                    Self {}
13004                }
13005            }
13006        }
13007        #[automatically_derived]
13008        impl alloy_sol_types::SolCall for ejectOperatorCall {
13009            type Parameters<'a> = (
13010                alloy::sol_types::sol_data::Address,
13011                alloy::sol_types::sol_data::Bytes,
13012            );
13013            type Token<'a> = <Self::Parameters<
13014                'a,
13015            > as alloy_sol_types::SolType>::Token<'a>;
13016            type Return = ejectOperatorReturn;
13017            type ReturnTuple<'a> = ();
13018            type ReturnToken<'a> = <Self::ReturnTuple<
13019                'a,
13020            > as alloy_sol_types::SolType>::Token<'a>;
13021            const SIGNATURE: &'static str = "ejectOperator(address,bytes)";
13022            const SELECTOR: [u8; 4] = [110u8, 59u8, 23u8, 219u8];
13023            #[inline]
13024            fn new<'a>(
13025                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
13026            ) -> Self {
13027                tuple.into()
13028            }
13029            #[inline]
13030            fn tokenize(&self) -> Self::Token<'_> {
13031                (
13032                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
13033                        &self.operator,
13034                    ),
13035                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
13036                        &self.quorumNumbers,
13037                    ),
13038                )
13039            }
13040            #[inline]
13041            fn abi_decode_returns(
13042                data: &[u8],
13043                validate: bool,
13044            ) -> alloy_sol_types::Result<Self::Return> {
13045                <Self::ReturnTuple<
13046                    '_,
13047                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
13048                    .map(Into::into)
13049            }
13050        }
13051    };
13052    #[derive(Default, Debug, PartialEq, Eq, Hash)]
13053    /**Function with signature `ejectionCooldown()` and selector `0xa96f783e`.
13054```solidity
13055function ejectionCooldown() external view returns (uint256);
13056```*/
13057    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13058    #[derive(Clone)]
13059    pub struct ejectionCooldownCall {}
13060    #[derive(Default, Debug, PartialEq, Eq, Hash)]
13061    ///Container type for the return parameters of the [`ejectionCooldown()`](ejectionCooldownCall) function.
13062    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13063    #[derive(Clone)]
13064    pub struct ejectionCooldownReturn {
13065        #[allow(missing_docs)]
13066        pub _0: alloy::sol_types::private::primitives::aliases::U256,
13067    }
13068    #[allow(
13069        non_camel_case_types,
13070        non_snake_case,
13071        clippy::pub_underscore_fields,
13072        clippy::style
13073    )]
13074    const _: () = {
13075        use alloy::sol_types as alloy_sol_types;
13076        {
13077            #[doc(hidden)]
13078            type UnderlyingSolTuple<'a> = ();
13079            #[doc(hidden)]
13080            type UnderlyingRustTuple<'a> = ();
13081            #[cfg(test)]
13082            #[allow(dead_code, unreachable_patterns)]
13083            fn _type_assertion(
13084                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
13085            ) {
13086                match _t {
13087                    alloy_sol_types::private::AssertTypeEq::<
13088                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13089                    >(_) => {}
13090                }
13091            }
13092            #[automatically_derived]
13093            #[doc(hidden)]
13094            impl ::core::convert::From<ejectionCooldownCall>
13095            for UnderlyingRustTuple<'_> {
13096                fn from(value: ejectionCooldownCall) -> Self {
13097                    ()
13098                }
13099            }
13100            #[automatically_derived]
13101            #[doc(hidden)]
13102            impl ::core::convert::From<UnderlyingRustTuple<'_>>
13103            for ejectionCooldownCall {
13104                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13105                    Self {}
13106                }
13107            }
13108        }
13109        {
13110            #[doc(hidden)]
13111            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
13112            #[doc(hidden)]
13113            type UnderlyingRustTuple<'a> = (
13114                alloy::sol_types::private::primitives::aliases::U256,
13115            );
13116            #[cfg(test)]
13117            #[allow(dead_code, unreachable_patterns)]
13118            fn _type_assertion(
13119                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
13120            ) {
13121                match _t {
13122                    alloy_sol_types::private::AssertTypeEq::<
13123                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13124                    >(_) => {}
13125                }
13126            }
13127            #[automatically_derived]
13128            #[doc(hidden)]
13129            impl ::core::convert::From<ejectionCooldownReturn>
13130            for UnderlyingRustTuple<'_> {
13131                fn from(value: ejectionCooldownReturn) -> Self {
13132                    (value._0,)
13133                }
13134            }
13135            #[automatically_derived]
13136            #[doc(hidden)]
13137            impl ::core::convert::From<UnderlyingRustTuple<'_>>
13138            for ejectionCooldownReturn {
13139                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13140                    Self { _0: tuple.0 }
13141                }
13142            }
13143        }
13144        #[automatically_derived]
13145        impl alloy_sol_types::SolCall for ejectionCooldownCall {
13146            type Parameters<'a> = ();
13147            type Token<'a> = <Self::Parameters<
13148                'a,
13149            > as alloy_sol_types::SolType>::Token<'a>;
13150            type Return = ejectionCooldownReturn;
13151            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
13152            type ReturnToken<'a> = <Self::ReturnTuple<
13153                'a,
13154            > as alloy_sol_types::SolType>::Token<'a>;
13155            const SIGNATURE: &'static str = "ejectionCooldown()";
13156            const SELECTOR: [u8; 4] = [169u8, 111u8, 120u8, 62u8];
13157            #[inline]
13158            fn new<'a>(
13159                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
13160            ) -> Self {
13161                tuple.into()
13162            }
13163            #[inline]
13164            fn tokenize(&self) -> Self::Token<'_> {
13165                ()
13166            }
13167            #[inline]
13168            fn abi_decode_returns(
13169                data: &[u8],
13170                validate: bool,
13171            ) -> alloy_sol_types::Result<Self::Return> {
13172                <Self::ReturnTuple<
13173                    '_,
13174                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
13175                    .map(Into::into)
13176            }
13177        }
13178    };
13179    #[derive(Default, Debug, PartialEq, Eq, Hash)]
13180    /**Function with signature `ejector()` and selector `0x28f61b31`.
13181```solidity
13182function ejector() external view returns (address);
13183```*/
13184    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13185    #[derive(Clone)]
13186    pub struct ejectorCall {}
13187    #[derive(Default, Debug, PartialEq, Eq, Hash)]
13188    ///Container type for the return parameters of the [`ejector()`](ejectorCall) function.
13189    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13190    #[derive(Clone)]
13191    pub struct ejectorReturn {
13192        #[allow(missing_docs)]
13193        pub _0: alloy::sol_types::private::Address,
13194    }
13195    #[allow(
13196        non_camel_case_types,
13197        non_snake_case,
13198        clippy::pub_underscore_fields,
13199        clippy::style
13200    )]
13201    const _: () = {
13202        use alloy::sol_types as alloy_sol_types;
13203        {
13204            #[doc(hidden)]
13205            type UnderlyingSolTuple<'a> = ();
13206            #[doc(hidden)]
13207            type UnderlyingRustTuple<'a> = ();
13208            #[cfg(test)]
13209            #[allow(dead_code, unreachable_patterns)]
13210            fn _type_assertion(
13211                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
13212            ) {
13213                match _t {
13214                    alloy_sol_types::private::AssertTypeEq::<
13215                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13216                    >(_) => {}
13217                }
13218            }
13219            #[automatically_derived]
13220            #[doc(hidden)]
13221            impl ::core::convert::From<ejectorCall> for UnderlyingRustTuple<'_> {
13222                fn from(value: ejectorCall) -> Self {
13223                    ()
13224                }
13225            }
13226            #[automatically_derived]
13227            #[doc(hidden)]
13228            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ejectorCall {
13229                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13230                    Self {}
13231                }
13232            }
13233        }
13234        {
13235            #[doc(hidden)]
13236            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
13237            #[doc(hidden)]
13238            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
13239            #[cfg(test)]
13240            #[allow(dead_code, unreachable_patterns)]
13241            fn _type_assertion(
13242                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
13243            ) {
13244                match _t {
13245                    alloy_sol_types::private::AssertTypeEq::<
13246                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13247                    >(_) => {}
13248                }
13249            }
13250            #[automatically_derived]
13251            #[doc(hidden)]
13252            impl ::core::convert::From<ejectorReturn> for UnderlyingRustTuple<'_> {
13253                fn from(value: ejectorReturn) -> Self {
13254                    (value._0,)
13255                }
13256            }
13257            #[automatically_derived]
13258            #[doc(hidden)]
13259            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ejectorReturn {
13260                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13261                    Self { _0: tuple.0 }
13262                }
13263            }
13264        }
13265        #[automatically_derived]
13266        impl alloy_sol_types::SolCall for ejectorCall {
13267            type Parameters<'a> = ();
13268            type Token<'a> = <Self::Parameters<
13269                'a,
13270            > as alloy_sol_types::SolType>::Token<'a>;
13271            type Return = ejectorReturn;
13272            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
13273            type ReturnToken<'a> = <Self::ReturnTuple<
13274                'a,
13275            > as alloy_sol_types::SolType>::Token<'a>;
13276            const SIGNATURE: &'static str = "ejector()";
13277            const SELECTOR: [u8; 4] = [40u8, 246u8, 27u8, 49u8];
13278            #[inline]
13279            fn new<'a>(
13280                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
13281            ) -> Self {
13282                tuple.into()
13283            }
13284            #[inline]
13285            fn tokenize(&self) -> Self::Token<'_> {
13286                ()
13287            }
13288            #[inline]
13289            fn abi_decode_returns(
13290                data: &[u8],
13291                validate: bool,
13292            ) -> alloy_sol_types::Result<Self::Return> {
13293                <Self::ReturnTuple<
13294                    '_,
13295                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
13296                    .map(Into::into)
13297            }
13298        }
13299    };
13300    #[derive(Default, Debug, PartialEq, Eq, Hash)]
13301    /**Function with signature `getCurrentQuorumBitmap(bytes32)` and selector `0x871ef049`.
13302```solidity
13303function getCurrentQuorumBitmap(bytes32 operatorId) external view returns (uint192);
13304```*/
13305    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13306    #[derive(Clone)]
13307    pub struct getCurrentQuorumBitmapCall {
13308        #[allow(missing_docs)]
13309        pub operatorId: alloy::sol_types::private::FixedBytes<32>,
13310    }
13311    #[derive(Default, Debug, PartialEq, Eq, Hash)]
13312    ///Container type for the return parameters of the [`getCurrentQuorumBitmap(bytes32)`](getCurrentQuorumBitmapCall) function.
13313    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13314    #[derive(Clone)]
13315    pub struct getCurrentQuorumBitmapReturn {
13316        #[allow(missing_docs)]
13317        pub _0: alloy::sol_types::private::primitives::aliases::U192,
13318    }
13319    #[allow(
13320        non_camel_case_types,
13321        non_snake_case,
13322        clippy::pub_underscore_fields,
13323        clippy::style
13324    )]
13325    const _: () = {
13326        use alloy::sol_types as alloy_sol_types;
13327        {
13328            #[doc(hidden)]
13329            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
13330            #[doc(hidden)]
13331            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
13332            #[cfg(test)]
13333            #[allow(dead_code, unreachable_patterns)]
13334            fn _type_assertion(
13335                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
13336            ) {
13337                match _t {
13338                    alloy_sol_types::private::AssertTypeEq::<
13339                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13340                    >(_) => {}
13341                }
13342            }
13343            #[automatically_derived]
13344            #[doc(hidden)]
13345            impl ::core::convert::From<getCurrentQuorumBitmapCall>
13346            for UnderlyingRustTuple<'_> {
13347                fn from(value: getCurrentQuorumBitmapCall) -> Self {
13348                    (value.operatorId,)
13349                }
13350            }
13351            #[automatically_derived]
13352            #[doc(hidden)]
13353            impl ::core::convert::From<UnderlyingRustTuple<'_>>
13354            for getCurrentQuorumBitmapCall {
13355                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13356                    Self { operatorId: tuple.0 }
13357                }
13358            }
13359        }
13360        {
13361            #[doc(hidden)]
13362            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<192>,);
13363            #[doc(hidden)]
13364            type UnderlyingRustTuple<'a> = (
13365                alloy::sol_types::private::primitives::aliases::U192,
13366            );
13367            #[cfg(test)]
13368            #[allow(dead_code, unreachable_patterns)]
13369            fn _type_assertion(
13370                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
13371            ) {
13372                match _t {
13373                    alloy_sol_types::private::AssertTypeEq::<
13374                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13375                    >(_) => {}
13376                }
13377            }
13378            #[automatically_derived]
13379            #[doc(hidden)]
13380            impl ::core::convert::From<getCurrentQuorumBitmapReturn>
13381            for UnderlyingRustTuple<'_> {
13382                fn from(value: getCurrentQuorumBitmapReturn) -> Self {
13383                    (value._0,)
13384                }
13385            }
13386            #[automatically_derived]
13387            #[doc(hidden)]
13388            impl ::core::convert::From<UnderlyingRustTuple<'_>>
13389            for getCurrentQuorumBitmapReturn {
13390                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13391                    Self { _0: tuple.0 }
13392                }
13393            }
13394        }
13395        #[automatically_derived]
13396        impl alloy_sol_types::SolCall for getCurrentQuorumBitmapCall {
13397            type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
13398            type Token<'a> = <Self::Parameters<
13399                'a,
13400            > as alloy_sol_types::SolType>::Token<'a>;
13401            type Return = getCurrentQuorumBitmapReturn;
13402            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<192>,);
13403            type ReturnToken<'a> = <Self::ReturnTuple<
13404                'a,
13405            > as alloy_sol_types::SolType>::Token<'a>;
13406            const SIGNATURE: &'static str = "getCurrentQuorumBitmap(bytes32)";
13407            const SELECTOR: [u8; 4] = [135u8, 30u8, 240u8, 73u8];
13408            #[inline]
13409            fn new<'a>(
13410                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
13411            ) -> Self {
13412                tuple.into()
13413            }
13414            #[inline]
13415            fn tokenize(&self) -> Self::Token<'_> {
13416                (
13417                    <alloy::sol_types::sol_data::FixedBytes<
13418                        32,
13419                    > as alloy_sol_types::SolType>::tokenize(&self.operatorId),
13420                )
13421            }
13422            #[inline]
13423            fn abi_decode_returns(
13424                data: &[u8],
13425                validate: bool,
13426            ) -> alloy_sol_types::Result<Self::Return> {
13427                <Self::ReturnTuple<
13428                    '_,
13429                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
13430                    .map(Into::into)
13431            }
13432        }
13433    };
13434    #[derive(Default, Debug, PartialEq, Eq, Hash)]
13435    /**Function with signature `getOperator(address)` and selector `0x5865c60c`.
13436```solidity
13437function getOperator(address operator) external view returns (ISlashingRegistryCoordinatorTypes.OperatorInfo memory);
13438```*/
13439    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13440    #[derive(Clone)]
13441    pub struct getOperatorCall {
13442        #[allow(missing_docs)]
13443        pub operator: alloy::sol_types::private::Address,
13444    }
13445    #[derive()]
13446    ///Container type for the return parameters of the [`getOperator(address)`](getOperatorCall) function.
13447    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13448    #[derive(Clone)]
13449    pub struct getOperatorReturn {
13450        #[allow(missing_docs)]
13451        pub _0: <ISlashingRegistryCoordinatorTypes::OperatorInfo as alloy::sol_types::SolType>::RustType,
13452    }
13453    #[allow(
13454        non_camel_case_types,
13455        non_snake_case,
13456        clippy::pub_underscore_fields,
13457        clippy::style
13458    )]
13459    const _: () = {
13460        use alloy::sol_types as alloy_sol_types;
13461        {
13462            #[doc(hidden)]
13463            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
13464            #[doc(hidden)]
13465            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
13466            #[cfg(test)]
13467            #[allow(dead_code, unreachable_patterns)]
13468            fn _type_assertion(
13469                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
13470            ) {
13471                match _t {
13472                    alloy_sol_types::private::AssertTypeEq::<
13473                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13474                    >(_) => {}
13475                }
13476            }
13477            #[automatically_derived]
13478            #[doc(hidden)]
13479            impl ::core::convert::From<getOperatorCall> for UnderlyingRustTuple<'_> {
13480                fn from(value: getOperatorCall) -> Self {
13481                    (value.operator,)
13482                }
13483            }
13484            #[automatically_derived]
13485            #[doc(hidden)]
13486            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOperatorCall {
13487                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13488                    Self { operator: tuple.0 }
13489                }
13490            }
13491        }
13492        {
13493            #[doc(hidden)]
13494            type UnderlyingSolTuple<'a> = (
13495                ISlashingRegistryCoordinatorTypes::OperatorInfo,
13496            );
13497            #[doc(hidden)]
13498            type UnderlyingRustTuple<'a> = (
13499                <ISlashingRegistryCoordinatorTypes::OperatorInfo as alloy::sol_types::SolType>::RustType,
13500            );
13501            #[cfg(test)]
13502            #[allow(dead_code, unreachable_patterns)]
13503            fn _type_assertion(
13504                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
13505            ) {
13506                match _t {
13507                    alloy_sol_types::private::AssertTypeEq::<
13508                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13509                    >(_) => {}
13510                }
13511            }
13512            #[automatically_derived]
13513            #[doc(hidden)]
13514            impl ::core::convert::From<getOperatorReturn> for UnderlyingRustTuple<'_> {
13515                fn from(value: getOperatorReturn) -> Self {
13516                    (value._0,)
13517                }
13518            }
13519            #[automatically_derived]
13520            #[doc(hidden)]
13521            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOperatorReturn {
13522                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13523                    Self { _0: tuple.0 }
13524                }
13525            }
13526        }
13527        #[automatically_derived]
13528        impl alloy_sol_types::SolCall for getOperatorCall {
13529            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
13530            type Token<'a> = <Self::Parameters<
13531                'a,
13532            > as alloy_sol_types::SolType>::Token<'a>;
13533            type Return = getOperatorReturn;
13534            type ReturnTuple<'a> = (ISlashingRegistryCoordinatorTypes::OperatorInfo,);
13535            type ReturnToken<'a> = <Self::ReturnTuple<
13536                'a,
13537            > as alloy_sol_types::SolType>::Token<'a>;
13538            const SIGNATURE: &'static str = "getOperator(address)";
13539            const SELECTOR: [u8; 4] = [88u8, 101u8, 198u8, 12u8];
13540            #[inline]
13541            fn new<'a>(
13542                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
13543            ) -> Self {
13544                tuple.into()
13545            }
13546            #[inline]
13547            fn tokenize(&self) -> Self::Token<'_> {
13548                (
13549                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
13550                        &self.operator,
13551                    ),
13552                )
13553            }
13554            #[inline]
13555            fn abi_decode_returns(
13556                data: &[u8],
13557                validate: bool,
13558            ) -> alloy_sol_types::Result<Self::Return> {
13559                <Self::ReturnTuple<
13560                    '_,
13561                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
13562                    .map(Into::into)
13563            }
13564        }
13565    };
13566    #[derive(Default, Debug, PartialEq, Eq, Hash)]
13567    /**Function with signature `getOperatorFromId(bytes32)` and selector `0x296bb064`.
13568```solidity
13569function getOperatorFromId(bytes32 operatorId) external view returns (address);
13570```*/
13571    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13572    #[derive(Clone)]
13573    pub struct getOperatorFromIdCall {
13574        #[allow(missing_docs)]
13575        pub operatorId: alloy::sol_types::private::FixedBytes<32>,
13576    }
13577    #[derive(Default, Debug, PartialEq, Eq, Hash)]
13578    ///Container type for the return parameters of the [`getOperatorFromId(bytes32)`](getOperatorFromIdCall) function.
13579    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13580    #[derive(Clone)]
13581    pub struct getOperatorFromIdReturn {
13582        #[allow(missing_docs)]
13583        pub _0: alloy::sol_types::private::Address,
13584    }
13585    #[allow(
13586        non_camel_case_types,
13587        non_snake_case,
13588        clippy::pub_underscore_fields,
13589        clippy::style
13590    )]
13591    const _: () = {
13592        use alloy::sol_types as alloy_sol_types;
13593        {
13594            #[doc(hidden)]
13595            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
13596            #[doc(hidden)]
13597            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
13598            #[cfg(test)]
13599            #[allow(dead_code, unreachable_patterns)]
13600            fn _type_assertion(
13601                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
13602            ) {
13603                match _t {
13604                    alloy_sol_types::private::AssertTypeEq::<
13605                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13606                    >(_) => {}
13607                }
13608            }
13609            #[automatically_derived]
13610            #[doc(hidden)]
13611            impl ::core::convert::From<getOperatorFromIdCall>
13612            for UnderlyingRustTuple<'_> {
13613                fn from(value: getOperatorFromIdCall) -> Self {
13614                    (value.operatorId,)
13615                }
13616            }
13617            #[automatically_derived]
13618            #[doc(hidden)]
13619            impl ::core::convert::From<UnderlyingRustTuple<'_>>
13620            for getOperatorFromIdCall {
13621                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13622                    Self { operatorId: tuple.0 }
13623                }
13624            }
13625        }
13626        {
13627            #[doc(hidden)]
13628            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
13629            #[doc(hidden)]
13630            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
13631            #[cfg(test)]
13632            #[allow(dead_code, unreachable_patterns)]
13633            fn _type_assertion(
13634                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
13635            ) {
13636                match _t {
13637                    alloy_sol_types::private::AssertTypeEq::<
13638                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13639                    >(_) => {}
13640                }
13641            }
13642            #[automatically_derived]
13643            #[doc(hidden)]
13644            impl ::core::convert::From<getOperatorFromIdReturn>
13645            for UnderlyingRustTuple<'_> {
13646                fn from(value: getOperatorFromIdReturn) -> Self {
13647                    (value._0,)
13648                }
13649            }
13650            #[automatically_derived]
13651            #[doc(hidden)]
13652            impl ::core::convert::From<UnderlyingRustTuple<'_>>
13653            for getOperatorFromIdReturn {
13654                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13655                    Self { _0: tuple.0 }
13656                }
13657            }
13658        }
13659        #[automatically_derived]
13660        impl alloy_sol_types::SolCall for getOperatorFromIdCall {
13661            type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
13662            type Token<'a> = <Self::Parameters<
13663                'a,
13664            > as alloy_sol_types::SolType>::Token<'a>;
13665            type Return = getOperatorFromIdReturn;
13666            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
13667            type ReturnToken<'a> = <Self::ReturnTuple<
13668                'a,
13669            > as alloy_sol_types::SolType>::Token<'a>;
13670            const SIGNATURE: &'static str = "getOperatorFromId(bytes32)";
13671            const SELECTOR: [u8; 4] = [41u8, 107u8, 176u8, 100u8];
13672            #[inline]
13673            fn new<'a>(
13674                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
13675            ) -> Self {
13676                tuple.into()
13677            }
13678            #[inline]
13679            fn tokenize(&self) -> Self::Token<'_> {
13680                (
13681                    <alloy::sol_types::sol_data::FixedBytes<
13682                        32,
13683                    > as alloy_sol_types::SolType>::tokenize(&self.operatorId),
13684                )
13685            }
13686            #[inline]
13687            fn abi_decode_returns(
13688                data: &[u8],
13689                validate: bool,
13690            ) -> alloy_sol_types::Result<Self::Return> {
13691                <Self::ReturnTuple<
13692                    '_,
13693                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
13694                    .map(Into::into)
13695            }
13696        }
13697    };
13698    #[derive(Default, Debug, PartialEq, Eq, Hash)]
13699    /**Function with signature `getOperatorId(address)` and selector `0x13542a4e`.
13700```solidity
13701function getOperatorId(address operator) external view returns (bytes32);
13702```*/
13703    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13704    #[derive(Clone)]
13705    pub struct getOperatorIdCall {
13706        #[allow(missing_docs)]
13707        pub operator: alloy::sol_types::private::Address,
13708    }
13709    #[derive(Default, Debug, PartialEq, Eq, Hash)]
13710    ///Container type for the return parameters of the [`getOperatorId(address)`](getOperatorIdCall) function.
13711    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13712    #[derive(Clone)]
13713    pub struct getOperatorIdReturn {
13714        #[allow(missing_docs)]
13715        pub _0: alloy::sol_types::private::FixedBytes<32>,
13716    }
13717    #[allow(
13718        non_camel_case_types,
13719        non_snake_case,
13720        clippy::pub_underscore_fields,
13721        clippy::style
13722    )]
13723    const _: () = {
13724        use alloy::sol_types as alloy_sol_types;
13725        {
13726            #[doc(hidden)]
13727            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
13728            #[doc(hidden)]
13729            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
13730            #[cfg(test)]
13731            #[allow(dead_code, unreachable_patterns)]
13732            fn _type_assertion(
13733                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
13734            ) {
13735                match _t {
13736                    alloy_sol_types::private::AssertTypeEq::<
13737                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13738                    >(_) => {}
13739                }
13740            }
13741            #[automatically_derived]
13742            #[doc(hidden)]
13743            impl ::core::convert::From<getOperatorIdCall> for UnderlyingRustTuple<'_> {
13744                fn from(value: getOperatorIdCall) -> Self {
13745                    (value.operator,)
13746                }
13747            }
13748            #[automatically_derived]
13749            #[doc(hidden)]
13750            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOperatorIdCall {
13751                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13752                    Self { operator: tuple.0 }
13753                }
13754            }
13755        }
13756        {
13757            #[doc(hidden)]
13758            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
13759            #[doc(hidden)]
13760            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
13761            #[cfg(test)]
13762            #[allow(dead_code, unreachable_patterns)]
13763            fn _type_assertion(
13764                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
13765            ) {
13766                match _t {
13767                    alloy_sol_types::private::AssertTypeEq::<
13768                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13769                    >(_) => {}
13770                }
13771            }
13772            #[automatically_derived]
13773            #[doc(hidden)]
13774            impl ::core::convert::From<getOperatorIdReturn> for UnderlyingRustTuple<'_> {
13775                fn from(value: getOperatorIdReturn) -> Self {
13776                    (value._0,)
13777                }
13778            }
13779            #[automatically_derived]
13780            #[doc(hidden)]
13781            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOperatorIdReturn {
13782                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13783                    Self { _0: tuple.0 }
13784                }
13785            }
13786        }
13787        #[automatically_derived]
13788        impl alloy_sol_types::SolCall for getOperatorIdCall {
13789            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
13790            type Token<'a> = <Self::Parameters<
13791                'a,
13792            > as alloy_sol_types::SolType>::Token<'a>;
13793            type Return = getOperatorIdReturn;
13794            type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
13795            type ReturnToken<'a> = <Self::ReturnTuple<
13796                'a,
13797            > as alloy_sol_types::SolType>::Token<'a>;
13798            const SIGNATURE: &'static str = "getOperatorId(address)";
13799            const SELECTOR: [u8; 4] = [19u8, 84u8, 42u8, 78u8];
13800            #[inline]
13801            fn new<'a>(
13802                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
13803            ) -> Self {
13804                tuple.into()
13805            }
13806            #[inline]
13807            fn tokenize(&self) -> Self::Token<'_> {
13808                (
13809                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
13810                        &self.operator,
13811                    ),
13812                )
13813            }
13814            #[inline]
13815            fn abi_decode_returns(
13816                data: &[u8],
13817                validate: bool,
13818            ) -> alloy_sol_types::Result<Self::Return> {
13819                <Self::ReturnTuple<
13820                    '_,
13821                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
13822                    .map(Into::into)
13823            }
13824        }
13825    };
13826    #[derive(Default, Debug, PartialEq, Eq, Hash)]
13827    /**Function with signature `getOperatorSetParams(uint8)` and selector `0xe65797ad`.
13828```solidity
13829function getOperatorSetParams(uint8 quorumNumber) external view returns (ISlashingRegistryCoordinatorTypes.OperatorSetParam memory);
13830```*/
13831    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13832    #[derive(Clone)]
13833    pub struct getOperatorSetParamsCall {
13834        #[allow(missing_docs)]
13835        pub quorumNumber: u8,
13836    }
13837    #[derive(Default, Debug, PartialEq, Eq, Hash)]
13838    ///Container type for the return parameters of the [`getOperatorSetParams(uint8)`](getOperatorSetParamsCall) function.
13839    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13840    #[derive(Clone)]
13841    pub struct getOperatorSetParamsReturn {
13842        #[allow(missing_docs)]
13843        pub _0: <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
13844    }
13845    #[allow(
13846        non_camel_case_types,
13847        non_snake_case,
13848        clippy::pub_underscore_fields,
13849        clippy::style
13850    )]
13851    const _: () = {
13852        use alloy::sol_types as alloy_sol_types;
13853        {
13854            #[doc(hidden)]
13855            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
13856            #[doc(hidden)]
13857            type UnderlyingRustTuple<'a> = (u8,);
13858            #[cfg(test)]
13859            #[allow(dead_code, unreachable_patterns)]
13860            fn _type_assertion(
13861                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
13862            ) {
13863                match _t {
13864                    alloy_sol_types::private::AssertTypeEq::<
13865                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13866                    >(_) => {}
13867                }
13868            }
13869            #[automatically_derived]
13870            #[doc(hidden)]
13871            impl ::core::convert::From<getOperatorSetParamsCall>
13872            for UnderlyingRustTuple<'_> {
13873                fn from(value: getOperatorSetParamsCall) -> Self {
13874                    (value.quorumNumber,)
13875                }
13876            }
13877            #[automatically_derived]
13878            #[doc(hidden)]
13879            impl ::core::convert::From<UnderlyingRustTuple<'_>>
13880            for getOperatorSetParamsCall {
13881                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13882                    Self { quorumNumber: tuple.0 }
13883                }
13884            }
13885        }
13886        {
13887            #[doc(hidden)]
13888            type UnderlyingSolTuple<'a> = (
13889                ISlashingRegistryCoordinatorTypes::OperatorSetParam,
13890            );
13891            #[doc(hidden)]
13892            type UnderlyingRustTuple<'a> = (
13893                <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
13894            );
13895            #[cfg(test)]
13896            #[allow(dead_code, unreachable_patterns)]
13897            fn _type_assertion(
13898                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
13899            ) {
13900                match _t {
13901                    alloy_sol_types::private::AssertTypeEq::<
13902                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13903                    >(_) => {}
13904                }
13905            }
13906            #[automatically_derived]
13907            #[doc(hidden)]
13908            impl ::core::convert::From<getOperatorSetParamsReturn>
13909            for UnderlyingRustTuple<'_> {
13910                fn from(value: getOperatorSetParamsReturn) -> Self {
13911                    (value._0,)
13912                }
13913            }
13914            #[automatically_derived]
13915            #[doc(hidden)]
13916            impl ::core::convert::From<UnderlyingRustTuple<'_>>
13917            for getOperatorSetParamsReturn {
13918                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13919                    Self { _0: tuple.0 }
13920                }
13921            }
13922        }
13923        #[automatically_derived]
13924        impl alloy_sol_types::SolCall for getOperatorSetParamsCall {
13925            type Parameters<'a> = (alloy::sol_types::sol_data::Uint<8>,);
13926            type Token<'a> = <Self::Parameters<
13927                'a,
13928            > as alloy_sol_types::SolType>::Token<'a>;
13929            type Return = getOperatorSetParamsReturn;
13930            type ReturnTuple<'a> = (
13931                ISlashingRegistryCoordinatorTypes::OperatorSetParam,
13932            );
13933            type ReturnToken<'a> = <Self::ReturnTuple<
13934                'a,
13935            > as alloy_sol_types::SolType>::Token<'a>;
13936            const SIGNATURE: &'static str = "getOperatorSetParams(uint8)";
13937            const SELECTOR: [u8; 4] = [230u8, 87u8, 151u8, 173u8];
13938            #[inline]
13939            fn new<'a>(
13940                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
13941            ) -> Self {
13942                tuple.into()
13943            }
13944            #[inline]
13945            fn tokenize(&self) -> Self::Token<'_> {
13946                (
13947                    <alloy::sol_types::sol_data::Uint<
13948                        8,
13949                    > as alloy_sol_types::SolType>::tokenize(&self.quorumNumber),
13950                )
13951            }
13952            #[inline]
13953            fn abi_decode_returns(
13954                data: &[u8],
13955                validate: bool,
13956            ) -> alloy_sol_types::Result<Self::Return> {
13957                <Self::ReturnTuple<
13958                    '_,
13959                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
13960                    .map(Into::into)
13961            }
13962        }
13963    };
13964    #[derive(Default, Debug, PartialEq, Eq, Hash)]
13965    /**Function with signature `getOperatorStatus(address)` and selector `0xfd39105a`.
13966```solidity
13967function getOperatorStatus(address operator) external view returns (ISlashingRegistryCoordinatorTypes.OperatorStatus);
13968```*/
13969    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13970    #[derive(Clone)]
13971    pub struct getOperatorStatusCall {
13972        #[allow(missing_docs)]
13973        pub operator: alloy::sol_types::private::Address,
13974    }
13975    #[derive(Default, Debug, PartialEq, Eq, Hash)]
13976    ///Container type for the return parameters of the [`getOperatorStatus(address)`](getOperatorStatusCall) function.
13977    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13978    #[derive(Clone)]
13979    pub struct getOperatorStatusReturn {
13980        #[allow(missing_docs)]
13981        pub _0: <ISlashingRegistryCoordinatorTypes::OperatorStatus as alloy::sol_types::SolType>::RustType,
13982    }
13983    #[allow(
13984        non_camel_case_types,
13985        non_snake_case,
13986        clippy::pub_underscore_fields,
13987        clippy::style
13988    )]
13989    const _: () = {
13990        use alloy::sol_types as alloy_sol_types;
13991        {
13992            #[doc(hidden)]
13993            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
13994            #[doc(hidden)]
13995            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
13996            #[cfg(test)]
13997            #[allow(dead_code, unreachable_patterns)]
13998            fn _type_assertion(
13999                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
14000            ) {
14001                match _t {
14002                    alloy_sol_types::private::AssertTypeEq::<
14003                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14004                    >(_) => {}
14005                }
14006            }
14007            #[automatically_derived]
14008            #[doc(hidden)]
14009            impl ::core::convert::From<getOperatorStatusCall>
14010            for UnderlyingRustTuple<'_> {
14011                fn from(value: getOperatorStatusCall) -> Self {
14012                    (value.operator,)
14013                }
14014            }
14015            #[automatically_derived]
14016            #[doc(hidden)]
14017            impl ::core::convert::From<UnderlyingRustTuple<'_>>
14018            for getOperatorStatusCall {
14019                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14020                    Self { operator: tuple.0 }
14021                }
14022            }
14023        }
14024        {
14025            #[doc(hidden)]
14026            type UnderlyingSolTuple<'a> = (
14027                ISlashingRegistryCoordinatorTypes::OperatorStatus,
14028            );
14029            #[doc(hidden)]
14030            type UnderlyingRustTuple<'a> = (
14031                <ISlashingRegistryCoordinatorTypes::OperatorStatus as alloy::sol_types::SolType>::RustType,
14032            );
14033            #[cfg(test)]
14034            #[allow(dead_code, unreachable_patterns)]
14035            fn _type_assertion(
14036                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
14037            ) {
14038                match _t {
14039                    alloy_sol_types::private::AssertTypeEq::<
14040                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14041                    >(_) => {}
14042                }
14043            }
14044            #[automatically_derived]
14045            #[doc(hidden)]
14046            impl ::core::convert::From<getOperatorStatusReturn>
14047            for UnderlyingRustTuple<'_> {
14048                fn from(value: getOperatorStatusReturn) -> Self {
14049                    (value._0,)
14050                }
14051            }
14052            #[automatically_derived]
14053            #[doc(hidden)]
14054            impl ::core::convert::From<UnderlyingRustTuple<'_>>
14055            for getOperatorStatusReturn {
14056                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14057                    Self { _0: tuple.0 }
14058                }
14059            }
14060        }
14061        #[automatically_derived]
14062        impl alloy_sol_types::SolCall for getOperatorStatusCall {
14063            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
14064            type Token<'a> = <Self::Parameters<
14065                'a,
14066            > as alloy_sol_types::SolType>::Token<'a>;
14067            type Return = getOperatorStatusReturn;
14068            type ReturnTuple<'a> = (ISlashingRegistryCoordinatorTypes::OperatorStatus,);
14069            type ReturnToken<'a> = <Self::ReturnTuple<
14070                'a,
14071            > as alloy_sol_types::SolType>::Token<'a>;
14072            const SIGNATURE: &'static str = "getOperatorStatus(address)";
14073            const SELECTOR: [u8; 4] = [253u8, 57u8, 16u8, 90u8];
14074            #[inline]
14075            fn new<'a>(
14076                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
14077            ) -> Self {
14078                tuple.into()
14079            }
14080            #[inline]
14081            fn tokenize(&self) -> Self::Token<'_> {
14082                (
14083                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
14084                        &self.operator,
14085                    ),
14086                )
14087            }
14088            #[inline]
14089            fn abi_decode_returns(
14090                data: &[u8],
14091                validate: bool,
14092            ) -> alloy_sol_types::Result<Self::Return> {
14093                <Self::ReturnTuple<
14094                    '_,
14095                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
14096                    .map(Into::into)
14097            }
14098        }
14099    };
14100    #[derive(Default, Debug, PartialEq, Eq, Hash)]
14101    /**Function with signature `getQuorumBitmapAtBlockNumberByIndex(bytes32,uint32,uint256)` and selector `0x04ec6351`.
14102```solidity
14103function getQuorumBitmapAtBlockNumberByIndex(bytes32 operatorId, uint32 blockNumber, uint256 index) external view returns (uint192);
14104```*/
14105    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14106    #[derive(Clone)]
14107    pub struct getQuorumBitmapAtBlockNumberByIndexCall {
14108        #[allow(missing_docs)]
14109        pub operatorId: alloy::sol_types::private::FixedBytes<32>,
14110        #[allow(missing_docs)]
14111        pub blockNumber: u32,
14112        #[allow(missing_docs)]
14113        pub index: alloy::sol_types::private::primitives::aliases::U256,
14114    }
14115    #[derive(Default, Debug, PartialEq, Eq, Hash)]
14116    ///Container type for the return parameters of the [`getQuorumBitmapAtBlockNumberByIndex(bytes32,uint32,uint256)`](getQuorumBitmapAtBlockNumberByIndexCall) function.
14117    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14118    #[derive(Clone)]
14119    pub struct getQuorumBitmapAtBlockNumberByIndexReturn {
14120        #[allow(missing_docs)]
14121        pub _0: alloy::sol_types::private::primitives::aliases::U192,
14122    }
14123    #[allow(
14124        non_camel_case_types,
14125        non_snake_case,
14126        clippy::pub_underscore_fields,
14127        clippy::style
14128    )]
14129    const _: () = {
14130        use alloy::sol_types as alloy_sol_types;
14131        {
14132            #[doc(hidden)]
14133            type UnderlyingSolTuple<'a> = (
14134                alloy::sol_types::sol_data::FixedBytes<32>,
14135                alloy::sol_types::sol_data::Uint<32>,
14136                alloy::sol_types::sol_data::Uint<256>,
14137            );
14138            #[doc(hidden)]
14139            type UnderlyingRustTuple<'a> = (
14140                alloy::sol_types::private::FixedBytes<32>,
14141                u32,
14142                alloy::sol_types::private::primitives::aliases::U256,
14143            );
14144            #[cfg(test)]
14145            #[allow(dead_code, unreachable_patterns)]
14146            fn _type_assertion(
14147                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
14148            ) {
14149                match _t {
14150                    alloy_sol_types::private::AssertTypeEq::<
14151                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14152                    >(_) => {}
14153                }
14154            }
14155            #[automatically_derived]
14156            #[doc(hidden)]
14157            impl ::core::convert::From<getQuorumBitmapAtBlockNumberByIndexCall>
14158            for UnderlyingRustTuple<'_> {
14159                fn from(value: getQuorumBitmapAtBlockNumberByIndexCall) -> Self {
14160                    (value.operatorId, value.blockNumber, value.index)
14161                }
14162            }
14163            #[automatically_derived]
14164            #[doc(hidden)]
14165            impl ::core::convert::From<UnderlyingRustTuple<'_>>
14166            for getQuorumBitmapAtBlockNumberByIndexCall {
14167                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14168                    Self {
14169                        operatorId: tuple.0,
14170                        blockNumber: tuple.1,
14171                        index: tuple.2,
14172                    }
14173                }
14174            }
14175        }
14176        {
14177            #[doc(hidden)]
14178            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<192>,);
14179            #[doc(hidden)]
14180            type UnderlyingRustTuple<'a> = (
14181                alloy::sol_types::private::primitives::aliases::U192,
14182            );
14183            #[cfg(test)]
14184            #[allow(dead_code, unreachable_patterns)]
14185            fn _type_assertion(
14186                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
14187            ) {
14188                match _t {
14189                    alloy_sol_types::private::AssertTypeEq::<
14190                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14191                    >(_) => {}
14192                }
14193            }
14194            #[automatically_derived]
14195            #[doc(hidden)]
14196            impl ::core::convert::From<getQuorumBitmapAtBlockNumberByIndexReturn>
14197            for UnderlyingRustTuple<'_> {
14198                fn from(value: getQuorumBitmapAtBlockNumberByIndexReturn) -> Self {
14199                    (value._0,)
14200                }
14201            }
14202            #[automatically_derived]
14203            #[doc(hidden)]
14204            impl ::core::convert::From<UnderlyingRustTuple<'_>>
14205            for getQuorumBitmapAtBlockNumberByIndexReturn {
14206                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14207                    Self { _0: tuple.0 }
14208                }
14209            }
14210        }
14211        #[automatically_derived]
14212        impl alloy_sol_types::SolCall for getQuorumBitmapAtBlockNumberByIndexCall {
14213            type Parameters<'a> = (
14214                alloy::sol_types::sol_data::FixedBytes<32>,
14215                alloy::sol_types::sol_data::Uint<32>,
14216                alloy::sol_types::sol_data::Uint<256>,
14217            );
14218            type Token<'a> = <Self::Parameters<
14219                'a,
14220            > as alloy_sol_types::SolType>::Token<'a>;
14221            type Return = getQuorumBitmapAtBlockNumberByIndexReturn;
14222            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<192>,);
14223            type ReturnToken<'a> = <Self::ReturnTuple<
14224                'a,
14225            > as alloy_sol_types::SolType>::Token<'a>;
14226            const SIGNATURE: &'static str = "getQuorumBitmapAtBlockNumberByIndex(bytes32,uint32,uint256)";
14227            const SELECTOR: [u8; 4] = [4u8, 236u8, 99u8, 81u8];
14228            #[inline]
14229            fn new<'a>(
14230                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
14231            ) -> Self {
14232                tuple.into()
14233            }
14234            #[inline]
14235            fn tokenize(&self) -> Self::Token<'_> {
14236                (
14237                    <alloy::sol_types::sol_data::FixedBytes<
14238                        32,
14239                    > as alloy_sol_types::SolType>::tokenize(&self.operatorId),
14240                    <alloy::sol_types::sol_data::Uint<
14241                        32,
14242                    > as alloy_sol_types::SolType>::tokenize(&self.blockNumber),
14243                    <alloy::sol_types::sol_data::Uint<
14244                        256,
14245                    > as alloy_sol_types::SolType>::tokenize(&self.index),
14246                )
14247            }
14248            #[inline]
14249            fn abi_decode_returns(
14250                data: &[u8],
14251                validate: bool,
14252            ) -> alloy_sol_types::Result<Self::Return> {
14253                <Self::ReturnTuple<
14254                    '_,
14255                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
14256                    .map(Into::into)
14257            }
14258        }
14259    };
14260    #[derive(Default, Debug, PartialEq, Eq, Hash)]
14261    /**Function with signature `getQuorumBitmapHistoryLength(bytes32)` and selector `0x03fd3492`.
14262```solidity
14263function getQuorumBitmapHistoryLength(bytes32 operatorId) external view returns (uint256);
14264```*/
14265    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14266    #[derive(Clone)]
14267    pub struct getQuorumBitmapHistoryLengthCall {
14268        #[allow(missing_docs)]
14269        pub operatorId: alloy::sol_types::private::FixedBytes<32>,
14270    }
14271    #[derive(Default, Debug, PartialEq, Eq, Hash)]
14272    ///Container type for the return parameters of the [`getQuorumBitmapHistoryLength(bytes32)`](getQuorumBitmapHistoryLengthCall) function.
14273    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14274    #[derive(Clone)]
14275    pub struct getQuorumBitmapHistoryLengthReturn {
14276        #[allow(missing_docs)]
14277        pub _0: alloy::sol_types::private::primitives::aliases::U256,
14278    }
14279    #[allow(
14280        non_camel_case_types,
14281        non_snake_case,
14282        clippy::pub_underscore_fields,
14283        clippy::style
14284    )]
14285    const _: () = {
14286        use alloy::sol_types as alloy_sol_types;
14287        {
14288            #[doc(hidden)]
14289            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
14290            #[doc(hidden)]
14291            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
14292            #[cfg(test)]
14293            #[allow(dead_code, unreachable_patterns)]
14294            fn _type_assertion(
14295                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
14296            ) {
14297                match _t {
14298                    alloy_sol_types::private::AssertTypeEq::<
14299                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14300                    >(_) => {}
14301                }
14302            }
14303            #[automatically_derived]
14304            #[doc(hidden)]
14305            impl ::core::convert::From<getQuorumBitmapHistoryLengthCall>
14306            for UnderlyingRustTuple<'_> {
14307                fn from(value: getQuorumBitmapHistoryLengthCall) -> Self {
14308                    (value.operatorId,)
14309                }
14310            }
14311            #[automatically_derived]
14312            #[doc(hidden)]
14313            impl ::core::convert::From<UnderlyingRustTuple<'_>>
14314            for getQuorumBitmapHistoryLengthCall {
14315                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14316                    Self { operatorId: tuple.0 }
14317                }
14318            }
14319        }
14320        {
14321            #[doc(hidden)]
14322            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
14323            #[doc(hidden)]
14324            type UnderlyingRustTuple<'a> = (
14325                alloy::sol_types::private::primitives::aliases::U256,
14326            );
14327            #[cfg(test)]
14328            #[allow(dead_code, unreachable_patterns)]
14329            fn _type_assertion(
14330                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
14331            ) {
14332                match _t {
14333                    alloy_sol_types::private::AssertTypeEq::<
14334                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14335                    >(_) => {}
14336                }
14337            }
14338            #[automatically_derived]
14339            #[doc(hidden)]
14340            impl ::core::convert::From<getQuorumBitmapHistoryLengthReturn>
14341            for UnderlyingRustTuple<'_> {
14342                fn from(value: getQuorumBitmapHistoryLengthReturn) -> Self {
14343                    (value._0,)
14344                }
14345            }
14346            #[automatically_derived]
14347            #[doc(hidden)]
14348            impl ::core::convert::From<UnderlyingRustTuple<'_>>
14349            for getQuorumBitmapHistoryLengthReturn {
14350                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14351                    Self { _0: tuple.0 }
14352                }
14353            }
14354        }
14355        #[automatically_derived]
14356        impl alloy_sol_types::SolCall for getQuorumBitmapHistoryLengthCall {
14357            type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
14358            type Token<'a> = <Self::Parameters<
14359                'a,
14360            > as alloy_sol_types::SolType>::Token<'a>;
14361            type Return = getQuorumBitmapHistoryLengthReturn;
14362            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
14363            type ReturnToken<'a> = <Self::ReturnTuple<
14364                'a,
14365            > as alloy_sol_types::SolType>::Token<'a>;
14366            const SIGNATURE: &'static str = "getQuorumBitmapHistoryLength(bytes32)";
14367            const SELECTOR: [u8; 4] = [3u8, 253u8, 52u8, 146u8];
14368            #[inline]
14369            fn new<'a>(
14370                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
14371            ) -> Self {
14372                tuple.into()
14373            }
14374            #[inline]
14375            fn tokenize(&self) -> Self::Token<'_> {
14376                (
14377                    <alloy::sol_types::sol_data::FixedBytes<
14378                        32,
14379                    > as alloy_sol_types::SolType>::tokenize(&self.operatorId),
14380                )
14381            }
14382            #[inline]
14383            fn abi_decode_returns(
14384                data: &[u8],
14385                validate: bool,
14386            ) -> alloy_sol_types::Result<Self::Return> {
14387                <Self::ReturnTuple<
14388                    '_,
14389                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
14390                    .map(Into::into)
14391            }
14392        }
14393    };
14394    #[derive(Default, Debug, PartialEq, Eq, Hash)]
14395    /**Function with signature `getQuorumBitmapIndicesAtBlockNumber(uint32,bytes32[])` and selector `0xc391425e`.
14396```solidity
14397function getQuorumBitmapIndicesAtBlockNumber(uint32 blockNumber, bytes32[] memory operatorIds) external view returns (uint32[] memory);
14398```*/
14399    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14400    #[derive(Clone)]
14401    pub struct getQuorumBitmapIndicesAtBlockNumberCall {
14402        #[allow(missing_docs)]
14403        pub blockNumber: u32,
14404        #[allow(missing_docs)]
14405        pub operatorIds: alloy::sol_types::private::Vec<
14406            alloy::sol_types::private::FixedBytes<32>,
14407        >,
14408    }
14409    #[derive(Default, Debug, PartialEq, Eq, Hash)]
14410    ///Container type for the return parameters of the [`getQuorumBitmapIndicesAtBlockNumber(uint32,bytes32[])`](getQuorumBitmapIndicesAtBlockNumberCall) function.
14411    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14412    #[derive(Clone)]
14413    pub struct getQuorumBitmapIndicesAtBlockNumberReturn {
14414        #[allow(missing_docs)]
14415        pub _0: alloy::sol_types::private::Vec<u32>,
14416    }
14417    #[allow(
14418        non_camel_case_types,
14419        non_snake_case,
14420        clippy::pub_underscore_fields,
14421        clippy::style
14422    )]
14423    const _: () = {
14424        use alloy::sol_types as alloy_sol_types;
14425        {
14426            #[doc(hidden)]
14427            type UnderlyingSolTuple<'a> = (
14428                alloy::sol_types::sol_data::Uint<32>,
14429                alloy::sol_types::sol_data::Array<
14430                    alloy::sol_types::sol_data::FixedBytes<32>,
14431                >,
14432            );
14433            #[doc(hidden)]
14434            type UnderlyingRustTuple<'a> = (
14435                u32,
14436                alloy::sol_types::private::Vec<alloy::sol_types::private::FixedBytes<32>>,
14437            );
14438            #[cfg(test)]
14439            #[allow(dead_code, unreachable_patterns)]
14440            fn _type_assertion(
14441                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
14442            ) {
14443                match _t {
14444                    alloy_sol_types::private::AssertTypeEq::<
14445                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14446                    >(_) => {}
14447                }
14448            }
14449            #[automatically_derived]
14450            #[doc(hidden)]
14451            impl ::core::convert::From<getQuorumBitmapIndicesAtBlockNumberCall>
14452            for UnderlyingRustTuple<'_> {
14453                fn from(value: getQuorumBitmapIndicesAtBlockNumberCall) -> Self {
14454                    (value.blockNumber, value.operatorIds)
14455                }
14456            }
14457            #[automatically_derived]
14458            #[doc(hidden)]
14459            impl ::core::convert::From<UnderlyingRustTuple<'_>>
14460            for getQuorumBitmapIndicesAtBlockNumberCall {
14461                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14462                    Self {
14463                        blockNumber: tuple.0,
14464                        operatorIds: tuple.1,
14465                    }
14466                }
14467            }
14468        }
14469        {
14470            #[doc(hidden)]
14471            type UnderlyingSolTuple<'a> = (
14472                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
14473            );
14474            #[doc(hidden)]
14475            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Vec<u32>,);
14476            #[cfg(test)]
14477            #[allow(dead_code, unreachable_patterns)]
14478            fn _type_assertion(
14479                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
14480            ) {
14481                match _t {
14482                    alloy_sol_types::private::AssertTypeEq::<
14483                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14484                    >(_) => {}
14485                }
14486            }
14487            #[automatically_derived]
14488            #[doc(hidden)]
14489            impl ::core::convert::From<getQuorumBitmapIndicesAtBlockNumberReturn>
14490            for UnderlyingRustTuple<'_> {
14491                fn from(value: getQuorumBitmapIndicesAtBlockNumberReturn) -> Self {
14492                    (value._0,)
14493                }
14494            }
14495            #[automatically_derived]
14496            #[doc(hidden)]
14497            impl ::core::convert::From<UnderlyingRustTuple<'_>>
14498            for getQuorumBitmapIndicesAtBlockNumberReturn {
14499                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14500                    Self { _0: tuple.0 }
14501                }
14502            }
14503        }
14504        #[automatically_derived]
14505        impl alloy_sol_types::SolCall for getQuorumBitmapIndicesAtBlockNumberCall {
14506            type Parameters<'a> = (
14507                alloy::sol_types::sol_data::Uint<32>,
14508                alloy::sol_types::sol_data::Array<
14509                    alloy::sol_types::sol_data::FixedBytes<32>,
14510                >,
14511            );
14512            type Token<'a> = <Self::Parameters<
14513                'a,
14514            > as alloy_sol_types::SolType>::Token<'a>;
14515            type Return = getQuorumBitmapIndicesAtBlockNumberReturn;
14516            type ReturnTuple<'a> = (
14517                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
14518            );
14519            type ReturnToken<'a> = <Self::ReturnTuple<
14520                'a,
14521            > as alloy_sol_types::SolType>::Token<'a>;
14522            const SIGNATURE: &'static str = "getQuorumBitmapIndicesAtBlockNumber(uint32,bytes32[])";
14523            const SELECTOR: [u8; 4] = [195u8, 145u8, 66u8, 94u8];
14524            #[inline]
14525            fn new<'a>(
14526                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
14527            ) -> Self {
14528                tuple.into()
14529            }
14530            #[inline]
14531            fn tokenize(&self) -> Self::Token<'_> {
14532                (
14533                    <alloy::sol_types::sol_data::Uint<
14534                        32,
14535                    > as alloy_sol_types::SolType>::tokenize(&self.blockNumber),
14536                    <alloy::sol_types::sol_data::Array<
14537                        alloy::sol_types::sol_data::FixedBytes<32>,
14538                    > as alloy_sol_types::SolType>::tokenize(&self.operatorIds),
14539                )
14540            }
14541            #[inline]
14542            fn abi_decode_returns(
14543                data: &[u8],
14544                validate: bool,
14545            ) -> alloy_sol_types::Result<Self::Return> {
14546                <Self::ReturnTuple<
14547                    '_,
14548                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
14549                    .map(Into::into)
14550            }
14551        }
14552    };
14553    #[derive(Default, Debug, PartialEq, Eq, Hash)]
14554    /**Function with signature `getQuorumBitmapUpdateByIndex(bytes32,uint256)` and selector `0x1eb812da`.
14555```solidity
14556function getQuorumBitmapUpdateByIndex(bytes32 operatorId, uint256 index) external view returns (ISlashingRegistryCoordinatorTypes.QuorumBitmapUpdate memory);
14557```*/
14558    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14559    #[derive(Clone)]
14560    pub struct getQuorumBitmapUpdateByIndexCall {
14561        #[allow(missing_docs)]
14562        pub operatorId: alloy::sol_types::private::FixedBytes<32>,
14563        #[allow(missing_docs)]
14564        pub index: alloy::sol_types::private::primitives::aliases::U256,
14565    }
14566    #[derive(Default, Debug, PartialEq, Eq, Hash)]
14567    ///Container type for the return parameters of the [`getQuorumBitmapUpdateByIndex(bytes32,uint256)`](getQuorumBitmapUpdateByIndexCall) function.
14568    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14569    #[derive(Clone)]
14570    pub struct getQuorumBitmapUpdateByIndexReturn {
14571        #[allow(missing_docs)]
14572        pub _0: <ISlashingRegistryCoordinatorTypes::QuorumBitmapUpdate as alloy::sol_types::SolType>::RustType,
14573    }
14574    #[allow(
14575        non_camel_case_types,
14576        non_snake_case,
14577        clippy::pub_underscore_fields,
14578        clippy::style
14579    )]
14580    const _: () = {
14581        use alloy::sol_types as alloy_sol_types;
14582        {
14583            #[doc(hidden)]
14584            type UnderlyingSolTuple<'a> = (
14585                alloy::sol_types::sol_data::FixedBytes<32>,
14586                alloy::sol_types::sol_data::Uint<256>,
14587            );
14588            #[doc(hidden)]
14589            type UnderlyingRustTuple<'a> = (
14590                alloy::sol_types::private::FixedBytes<32>,
14591                alloy::sol_types::private::primitives::aliases::U256,
14592            );
14593            #[cfg(test)]
14594            #[allow(dead_code, unreachable_patterns)]
14595            fn _type_assertion(
14596                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
14597            ) {
14598                match _t {
14599                    alloy_sol_types::private::AssertTypeEq::<
14600                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14601                    >(_) => {}
14602                }
14603            }
14604            #[automatically_derived]
14605            #[doc(hidden)]
14606            impl ::core::convert::From<getQuorumBitmapUpdateByIndexCall>
14607            for UnderlyingRustTuple<'_> {
14608                fn from(value: getQuorumBitmapUpdateByIndexCall) -> Self {
14609                    (value.operatorId, value.index)
14610                }
14611            }
14612            #[automatically_derived]
14613            #[doc(hidden)]
14614            impl ::core::convert::From<UnderlyingRustTuple<'_>>
14615            for getQuorumBitmapUpdateByIndexCall {
14616                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14617                    Self {
14618                        operatorId: tuple.0,
14619                        index: tuple.1,
14620                    }
14621                }
14622            }
14623        }
14624        {
14625            #[doc(hidden)]
14626            type UnderlyingSolTuple<'a> = (
14627                ISlashingRegistryCoordinatorTypes::QuorumBitmapUpdate,
14628            );
14629            #[doc(hidden)]
14630            type UnderlyingRustTuple<'a> = (
14631                <ISlashingRegistryCoordinatorTypes::QuorumBitmapUpdate as alloy::sol_types::SolType>::RustType,
14632            );
14633            #[cfg(test)]
14634            #[allow(dead_code, unreachable_patterns)]
14635            fn _type_assertion(
14636                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
14637            ) {
14638                match _t {
14639                    alloy_sol_types::private::AssertTypeEq::<
14640                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14641                    >(_) => {}
14642                }
14643            }
14644            #[automatically_derived]
14645            #[doc(hidden)]
14646            impl ::core::convert::From<getQuorumBitmapUpdateByIndexReturn>
14647            for UnderlyingRustTuple<'_> {
14648                fn from(value: getQuorumBitmapUpdateByIndexReturn) -> Self {
14649                    (value._0,)
14650                }
14651            }
14652            #[automatically_derived]
14653            #[doc(hidden)]
14654            impl ::core::convert::From<UnderlyingRustTuple<'_>>
14655            for getQuorumBitmapUpdateByIndexReturn {
14656                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14657                    Self { _0: tuple.0 }
14658                }
14659            }
14660        }
14661        #[automatically_derived]
14662        impl alloy_sol_types::SolCall for getQuorumBitmapUpdateByIndexCall {
14663            type Parameters<'a> = (
14664                alloy::sol_types::sol_data::FixedBytes<32>,
14665                alloy::sol_types::sol_data::Uint<256>,
14666            );
14667            type Token<'a> = <Self::Parameters<
14668                'a,
14669            > as alloy_sol_types::SolType>::Token<'a>;
14670            type Return = getQuorumBitmapUpdateByIndexReturn;
14671            type ReturnTuple<'a> = (
14672                ISlashingRegistryCoordinatorTypes::QuorumBitmapUpdate,
14673            );
14674            type ReturnToken<'a> = <Self::ReturnTuple<
14675                'a,
14676            > as alloy_sol_types::SolType>::Token<'a>;
14677            const SIGNATURE: &'static str = "getQuorumBitmapUpdateByIndex(bytes32,uint256)";
14678            const SELECTOR: [u8; 4] = [30u8, 184u8, 18u8, 218u8];
14679            #[inline]
14680            fn new<'a>(
14681                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
14682            ) -> Self {
14683                tuple.into()
14684            }
14685            #[inline]
14686            fn tokenize(&self) -> Self::Token<'_> {
14687                (
14688                    <alloy::sol_types::sol_data::FixedBytes<
14689                        32,
14690                    > as alloy_sol_types::SolType>::tokenize(&self.operatorId),
14691                    <alloy::sol_types::sol_data::Uint<
14692                        256,
14693                    > as alloy_sol_types::SolType>::tokenize(&self.index),
14694                )
14695            }
14696            #[inline]
14697            fn abi_decode_returns(
14698                data: &[u8],
14699                validate: bool,
14700            ) -> alloy_sol_types::Result<Self::Return> {
14701                <Self::ReturnTuple<
14702                    '_,
14703                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
14704                    .map(Into::into)
14705            }
14706        }
14707    };
14708    #[derive(Default, Debug, PartialEq, Eq, Hash)]
14709    /**Function with signature `indexRegistry()` and selector `0x9e9923c2`.
14710```solidity
14711function indexRegistry() external view returns (address);
14712```*/
14713    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14714    #[derive(Clone)]
14715    pub struct indexRegistryCall {}
14716    #[derive(Default, Debug, PartialEq, Eq, Hash)]
14717    ///Container type for the return parameters of the [`indexRegistry()`](indexRegistryCall) function.
14718    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14719    #[derive(Clone)]
14720    pub struct indexRegistryReturn {
14721        #[allow(missing_docs)]
14722        pub _0: alloy::sol_types::private::Address,
14723    }
14724    #[allow(
14725        non_camel_case_types,
14726        non_snake_case,
14727        clippy::pub_underscore_fields,
14728        clippy::style
14729    )]
14730    const _: () = {
14731        use alloy::sol_types as alloy_sol_types;
14732        {
14733            #[doc(hidden)]
14734            type UnderlyingSolTuple<'a> = ();
14735            #[doc(hidden)]
14736            type UnderlyingRustTuple<'a> = ();
14737            #[cfg(test)]
14738            #[allow(dead_code, unreachable_patterns)]
14739            fn _type_assertion(
14740                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
14741            ) {
14742                match _t {
14743                    alloy_sol_types::private::AssertTypeEq::<
14744                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14745                    >(_) => {}
14746                }
14747            }
14748            #[automatically_derived]
14749            #[doc(hidden)]
14750            impl ::core::convert::From<indexRegistryCall> for UnderlyingRustTuple<'_> {
14751                fn from(value: indexRegistryCall) -> Self {
14752                    ()
14753                }
14754            }
14755            #[automatically_derived]
14756            #[doc(hidden)]
14757            impl ::core::convert::From<UnderlyingRustTuple<'_>> for indexRegistryCall {
14758                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14759                    Self {}
14760                }
14761            }
14762        }
14763        {
14764            #[doc(hidden)]
14765            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
14766            #[doc(hidden)]
14767            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
14768            #[cfg(test)]
14769            #[allow(dead_code, unreachable_patterns)]
14770            fn _type_assertion(
14771                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
14772            ) {
14773                match _t {
14774                    alloy_sol_types::private::AssertTypeEq::<
14775                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14776                    >(_) => {}
14777                }
14778            }
14779            #[automatically_derived]
14780            #[doc(hidden)]
14781            impl ::core::convert::From<indexRegistryReturn> for UnderlyingRustTuple<'_> {
14782                fn from(value: indexRegistryReturn) -> Self {
14783                    (value._0,)
14784                }
14785            }
14786            #[automatically_derived]
14787            #[doc(hidden)]
14788            impl ::core::convert::From<UnderlyingRustTuple<'_>> for indexRegistryReturn {
14789                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14790                    Self { _0: tuple.0 }
14791                }
14792            }
14793        }
14794        #[automatically_derived]
14795        impl alloy_sol_types::SolCall for indexRegistryCall {
14796            type Parameters<'a> = ();
14797            type Token<'a> = <Self::Parameters<
14798                'a,
14799            > as alloy_sol_types::SolType>::Token<'a>;
14800            type Return = indexRegistryReturn;
14801            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
14802            type ReturnToken<'a> = <Self::ReturnTuple<
14803                'a,
14804            > as alloy_sol_types::SolType>::Token<'a>;
14805            const SIGNATURE: &'static str = "indexRegistry()";
14806            const SELECTOR: [u8; 4] = [158u8, 153u8, 35u8, 194u8];
14807            #[inline]
14808            fn new<'a>(
14809                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
14810            ) -> Self {
14811                tuple.into()
14812            }
14813            #[inline]
14814            fn tokenize(&self) -> Self::Token<'_> {
14815                ()
14816            }
14817            #[inline]
14818            fn abi_decode_returns(
14819                data: &[u8],
14820                validate: bool,
14821            ) -> alloy_sol_types::Result<Self::Return> {
14822                <Self::ReturnTuple<
14823                    '_,
14824                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
14825                    .map(Into::into)
14826            }
14827        }
14828    };
14829    #[derive(Default, Debug, PartialEq, Eq, Hash)]
14830    /**Function with signature `initialize(address,address,address,uint256,address)` and selector `0x530b97a4`.
14831```solidity
14832function initialize(address initialOwner, address churnApprover, address ejector, uint256 initialPausedStatus, address avs) external;
14833```*/
14834    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14835    #[derive(Clone)]
14836    pub struct initializeCall {
14837        #[allow(missing_docs)]
14838        pub initialOwner: alloy::sol_types::private::Address,
14839        #[allow(missing_docs)]
14840        pub churnApprover: alloy::sol_types::private::Address,
14841        #[allow(missing_docs)]
14842        pub ejector: alloy::sol_types::private::Address,
14843        #[allow(missing_docs)]
14844        pub initialPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
14845        #[allow(missing_docs)]
14846        pub avs: alloy::sol_types::private::Address,
14847    }
14848    ///Container type for the return parameters of the [`initialize(address,address,address,uint256,address)`](initializeCall) function.
14849    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14850    #[derive(Clone)]
14851    pub struct initializeReturn {}
14852    #[allow(
14853        non_camel_case_types,
14854        non_snake_case,
14855        clippy::pub_underscore_fields,
14856        clippy::style
14857    )]
14858    const _: () = {
14859        use alloy::sol_types as alloy_sol_types;
14860        {
14861            #[doc(hidden)]
14862            type UnderlyingSolTuple<'a> = (
14863                alloy::sol_types::sol_data::Address,
14864                alloy::sol_types::sol_data::Address,
14865                alloy::sol_types::sol_data::Address,
14866                alloy::sol_types::sol_data::Uint<256>,
14867                alloy::sol_types::sol_data::Address,
14868            );
14869            #[doc(hidden)]
14870            type UnderlyingRustTuple<'a> = (
14871                alloy::sol_types::private::Address,
14872                alloy::sol_types::private::Address,
14873                alloy::sol_types::private::Address,
14874                alloy::sol_types::private::primitives::aliases::U256,
14875                alloy::sol_types::private::Address,
14876            );
14877            #[cfg(test)]
14878            #[allow(dead_code, unreachable_patterns)]
14879            fn _type_assertion(
14880                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
14881            ) {
14882                match _t {
14883                    alloy_sol_types::private::AssertTypeEq::<
14884                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14885                    >(_) => {}
14886                }
14887            }
14888            #[automatically_derived]
14889            #[doc(hidden)]
14890            impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
14891                fn from(value: initializeCall) -> Self {
14892                    (
14893                        value.initialOwner,
14894                        value.churnApprover,
14895                        value.ejector,
14896                        value.initialPausedStatus,
14897                        value.avs,
14898                    )
14899                }
14900            }
14901            #[automatically_derived]
14902            #[doc(hidden)]
14903            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
14904                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14905                    Self {
14906                        initialOwner: tuple.0,
14907                        churnApprover: tuple.1,
14908                        ejector: tuple.2,
14909                        initialPausedStatus: tuple.3,
14910                        avs: tuple.4,
14911                    }
14912                }
14913            }
14914        }
14915        {
14916            #[doc(hidden)]
14917            type UnderlyingSolTuple<'a> = ();
14918            #[doc(hidden)]
14919            type UnderlyingRustTuple<'a> = ();
14920            #[cfg(test)]
14921            #[allow(dead_code, unreachable_patterns)]
14922            fn _type_assertion(
14923                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
14924            ) {
14925                match _t {
14926                    alloy_sol_types::private::AssertTypeEq::<
14927                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14928                    >(_) => {}
14929                }
14930            }
14931            #[automatically_derived]
14932            #[doc(hidden)]
14933            impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
14934                fn from(value: initializeReturn) -> Self {
14935                    ()
14936                }
14937            }
14938            #[automatically_derived]
14939            #[doc(hidden)]
14940            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
14941                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14942                    Self {}
14943                }
14944            }
14945        }
14946        #[automatically_derived]
14947        impl alloy_sol_types::SolCall for initializeCall {
14948            type Parameters<'a> = (
14949                alloy::sol_types::sol_data::Address,
14950                alloy::sol_types::sol_data::Address,
14951                alloy::sol_types::sol_data::Address,
14952                alloy::sol_types::sol_data::Uint<256>,
14953                alloy::sol_types::sol_data::Address,
14954            );
14955            type Token<'a> = <Self::Parameters<
14956                'a,
14957            > as alloy_sol_types::SolType>::Token<'a>;
14958            type Return = initializeReturn;
14959            type ReturnTuple<'a> = ();
14960            type ReturnToken<'a> = <Self::ReturnTuple<
14961                'a,
14962            > as alloy_sol_types::SolType>::Token<'a>;
14963            const SIGNATURE: &'static str = "initialize(address,address,address,uint256,address)";
14964            const SELECTOR: [u8; 4] = [83u8, 11u8, 151u8, 164u8];
14965            #[inline]
14966            fn new<'a>(
14967                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
14968            ) -> Self {
14969                tuple.into()
14970            }
14971            #[inline]
14972            fn tokenize(&self) -> Self::Token<'_> {
14973                (
14974                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
14975                        &self.initialOwner,
14976                    ),
14977                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
14978                        &self.churnApprover,
14979                    ),
14980                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
14981                        &self.ejector,
14982                    ),
14983                    <alloy::sol_types::sol_data::Uint<
14984                        256,
14985                    > as alloy_sol_types::SolType>::tokenize(&self.initialPausedStatus),
14986                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
14987                        &self.avs,
14988                    ),
14989                )
14990            }
14991            #[inline]
14992            fn abi_decode_returns(
14993                data: &[u8],
14994                validate: bool,
14995            ) -> alloy_sol_types::Result<Self::Return> {
14996                <Self::ReturnTuple<
14997                    '_,
14998                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
14999                    .map(Into::into)
15000            }
15001        }
15002    };
15003    #[derive(Default, Debug, PartialEq, Eq, Hash)]
15004    /**Function with signature `isChurnApproverSaltUsed(bytes32)` and selector `0x1478851f`.
15005```solidity
15006function isChurnApproverSaltUsed(bytes32) external view returns (bool);
15007```*/
15008    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
15009    #[derive(Clone)]
15010    pub struct isChurnApproverSaltUsedCall {
15011        #[allow(missing_docs)]
15012        pub _0: alloy::sol_types::private::FixedBytes<32>,
15013    }
15014    #[derive(Default, Debug, PartialEq, Eq, Hash)]
15015    ///Container type for the return parameters of the [`isChurnApproverSaltUsed(bytes32)`](isChurnApproverSaltUsedCall) function.
15016    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
15017    #[derive(Clone)]
15018    pub struct isChurnApproverSaltUsedReturn {
15019        #[allow(missing_docs)]
15020        pub _0: bool,
15021    }
15022    #[allow(
15023        non_camel_case_types,
15024        non_snake_case,
15025        clippy::pub_underscore_fields,
15026        clippy::style
15027    )]
15028    const _: () = {
15029        use alloy::sol_types as alloy_sol_types;
15030        {
15031            #[doc(hidden)]
15032            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
15033            #[doc(hidden)]
15034            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
15035            #[cfg(test)]
15036            #[allow(dead_code, unreachable_patterns)]
15037            fn _type_assertion(
15038                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
15039            ) {
15040                match _t {
15041                    alloy_sol_types::private::AssertTypeEq::<
15042                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
15043                    >(_) => {}
15044                }
15045            }
15046            #[automatically_derived]
15047            #[doc(hidden)]
15048            impl ::core::convert::From<isChurnApproverSaltUsedCall>
15049            for UnderlyingRustTuple<'_> {
15050                fn from(value: isChurnApproverSaltUsedCall) -> Self {
15051                    (value._0,)
15052                }
15053            }
15054            #[automatically_derived]
15055            #[doc(hidden)]
15056            impl ::core::convert::From<UnderlyingRustTuple<'_>>
15057            for isChurnApproverSaltUsedCall {
15058                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
15059                    Self { _0: tuple.0 }
15060                }
15061            }
15062        }
15063        {
15064            #[doc(hidden)]
15065            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
15066            #[doc(hidden)]
15067            type UnderlyingRustTuple<'a> = (bool,);
15068            #[cfg(test)]
15069            #[allow(dead_code, unreachable_patterns)]
15070            fn _type_assertion(
15071                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
15072            ) {
15073                match _t {
15074                    alloy_sol_types::private::AssertTypeEq::<
15075                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
15076                    >(_) => {}
15077                }
15078            }
15079            #[automatically_derived]
15080            #[doc(hidden)]
15081            impl ::core::convert::From<isChurnApproverSaltUsedReturn>
15082            for UnderlyingRustTuple<'_> {
15083                fn from(value: isChurnApproverSaltUsedReturn) -> Self {
15084                    (value._0,)
15085                }
15086            }
15087            #[automatically_derived]
15088            #[doc(hidden)]
15089            impl ::core::convert::From<UnderlyingRustTuple<'_>>
15090            for isChurnApproverSaltUsedReturn {
15091                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
15092                    Self { _0: tuple.0 }
15093                }
15094            }
15095        }
15096        #[automatically_derived]
15097        impl alloy_sol_types::SolCall for isChurnApproverSaltUsedCall {
15098            type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
15099            type Token<'a> = <Self::Parameters<
15100                'a,
15101            > as alloy_sol_types::SolType>::Token<'a>;
15102            type Return = isChurnApproverSaltUsedReturn;
15103            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
15104            type ReturnToken<'a> = <Self::ReturnTuple<
15105                'a,
15106            > as alloy_sol_types::SolType>::Token<'a>;
15107            const SIGNATURE: &'static str = "isChurnApproverSaltUsed(bytes32)";
15108            const SELECTOR: [u8; 4] = [20u8, 120u8, 133u8, 31u8];
15109            #[inline]
15110            fn new<'a>(
15111                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
15112            ) -> Self {
15113                tuple.into()
15114            }
15115            #[inline]
15116            fn tokenize(&self) -> Self::Token<'_> {
15117                (
15118                    <alloy::sol_types::sol_data::FixedBytes<
15119                        32,
15120                    > as alloy_sol_types::SolType>::tokenize(&self._0),
15121                )
15122            }
15123            #[inline]
15124            fn abi_decode_returns(
15125                data: &[u8],
15126                validate: bool,
15127            ) -> alloy_sol_types::Result<Self::Return> {
15128                <Self::ReturnTuple<
15129                    '_,
15130                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
15131                    .map(Into::into)
15132            }
15133        }
15134    };
15135    #[derive(Default, Debug, PartialEq, Eq, Hash)]
15136    /**Function with signature `isM2Quorum(uint8)` and selector `0xa4d7871f`.
15137```solidity
15138function isM2Quorum(uint8 quorumNumber) external view returns (bool);
15139```*/
15140    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
15141    #[derive(Clone)]
15142    pub struct isM2QuorumCall {
15143        #[allow(missing_docs)]
15144        pub quorumNumber: u8,
15145    }
15146    #[derive(Default, Debug, PartialEq, Eq, Hash)]
15147    ///Container type for the return parameters of the [`isM2Quorum(uint8)`](isM2QuorumCall) function.
15148    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
15149    #[derive(Clone)]
15150    pub struct isM2QuorumReturn {
15151        #[allow(missing_docs)]
15152        pub _0: bool,
15153    }
15154    #[allow(
15155        non_camel_case_types,
15156        non_snake_case,
15157        clippy::pub_underscore_fields,
15158        clippy::style
15159    )]
15160    const _: () = {
15161        use alloy::sol_types as alloy_sol_types;
15162        {
15163            #[doc(hidden)]
15164            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
15165            #[doc(hidden)]
15166            type UnderlyingRustTuple<'a> = (u8,);
15167            #[cfg(test)]
15168            #[allow(dead_code, unreachable_patterns)]
15169            fn _type_assertion(
15170                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
15171            ) {
15172                match _t {
15173                    alloy_sol_types::private::AssertTypeEq::<
15174                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
15175                    >(_) => {}
15176                }
15177            }
15178            #[automatically_derived]
15179            #[doc(hidden)]
15180            impl ::core::convert::From<isM2QuorumCall> for UnderlyingRustTuple<'_> {
15181                fn from(value: isM2QuorumCall) -> Self {
15182                    (value.quorumNumber,)
15183                }
15184            }
15185            #[automatically_derived]
15186            #[doc(hidden)]
15187            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isM2QuorumCall {
15188                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
15189                    Self { quorumNumber: tuple.0 }
15190                }
15191            }
15192        }
15193        {
15194            #[doc(hidden)]
15195            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
15196            #[doc(hidden)]
15197            type UnderlyingRustTuple<'a> = (bool,);
15198            #[cfg(test)]
15199            #[allow(dead_code, unreachable_patterns)]
15200            fn _type_assertion(
15201                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
15202            ) {
15203                match _t {
15204                    alloy_sol_types::private::AssertTypeEq::<
15205                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
15206                    >(_) => {}
15207                }
15208            }
15209            #[automatically_derived]
15210            #[doc(hidden)]
15211            impl ::core::convert::From<isM2QuorumReturn> for UnderlyingRustTuple<'_> {
15212                fn from(value: isM2QuorumReturn) -> Self {
15213                    (value._0,)
15214                }
15215            }
15216            #[automatically_derived]
15217            #[doc(hidden)]
15218            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isM2QuorumReturn {
15219                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
15220                    Self { _0: tuple.0 }
15221                }
15222            }
15223        }
15224        #[automatically_derived]
15225        impl alloy_sol_types::SolCall for isM2QuorumCall {
15226            type Parameters<'a> = (alloy::sol_types::sol_data::Uint<8>,);
15227            type Token<'a> = <Self::Parameters<
15228                'a,
15229            > as alloy_sol_types::SolType>::Token<'a>;
15230            type Return = isM2QuorumReturn;
15231            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
15232            type ReturnToken<'a> = <Self::ReturnTuple<
15233                'a,
15234            > as alloy_sol_types::SolType>::Token<'a>;
15235            const SIGNATURE: &'static str = "isM2Quorum(uint8)";
15236            const SELECTOR: [u8; 4] = [164u8, 215u8, 135u8, 31u8];
15237            #[inline]
15238            fn new<'a>(
15239                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
15240            ) -> Self {
15241                tuple.into()
15242            }
15243            #[inline]
15244            fn tokenize(&self) -> Self::Token<'_> {
15245                (
15246                    <alloy::sol_types::sol_data::Uint<
15247                        8,
15248                    > as alloy_sol_types::SolType>::tokenize(&self.quorumNumber),
15249                )
15250            }
15251            #[inline]
15252            fn abi_decode_returns(
15253                data: &[u8],
15254                validate: bool,
15255            ) -> alloy_sol_types::Result<Self::Return> {
15256                <Self::ReturnTuple<
15257                    '_,
15258                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
15259                    .map(Into::into)
15260            }
15261        }
15262    };
15263    #[derive(Default, Debug, PartialEq, Eq, Hash)]
15264    /**Function with signature `isM2QuorumRegistrationDisabled()` and selector `0xe814ca9d`.
15265```solidity
15266function isM2QuorumRegistrationDisabled() external view returns (bool);
15267```*/
15268    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
15269    #[derive(Clone)]
15270    pub struct isM2QuorumRegistrationDisabledCall {}
15271    #[derive(Default, Debug, PartialEq, Eq, Hash)]
15272    ///Container type for the return parameters of the [`isM2QuorumRegistrationDisabled()`](isM2QuorumRegistrationDisabledCall) function.
15273    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
15274    #[derive(Clone)]
15275    pub struct isM2QuorumRegistrationDisabledReturn {
15276        #[allow(missing_docs)]
15277        pub _0: bool,
15278    }
15279    #[allow(
15280        non_camel_case_types,
15281        non_snake_case,
15282        clippy::pub_underscore_fields,
15283        clippy::style
15284    )]
15285    const _: () = {
15286        use alloy::sol_types as alloy_sol_types;
15287        {
15288            #[doc(hidden)]
15289            type UnderlyingSolTuple<'a> = ();
15290            #[doc(hidden)]
15291            type UnderlyingRustTuple<'a> = ();
15292            #[cfg(test)]
15293            #[allow(dead_code, unreachable_patterns)]
15294            fn _type_assertion(
15295                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
15296            ) {
15297                match _t {
15298                    alloy_sol_types::private::AssertTypeEq::<
15299                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
15300                    >(_) => {}
15301                }
15302            }
15303            #[automatically_derived]
15304            #[doc(hidden)]
15305            impl ::core::convert::From<isM2QuorumRegistrationDisabledCall>
15306            for UnderlyingRustTuple<'_> {
15307                fn from(value: isM2QuorumRegistrationDisabledCall) -> Self {
15308                    ()
15309                }
15310            }
15311            #[automatically_derived]
15312            #[doc(hidden)]
15313            impl ::core::convert::From<UnderlyingRustTuple<'_>>
15314            for isM2QuorumRegistrationDisabledCall {
15315                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
15316                    Self {}
15317                }
15318            }
15319        }
15320        {
15321            #[doc(hidden)]
15322            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
15323            #[doc(hidden)]
15324            type UnderlyingRustTuple<'a> = (bool,);
15325            #[cfg(test)]
15326            #[allow(dead_code, unreachable_patterns)]
15327            fn _type_assertion(
15328                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
15329            ) {
15330                match _t {
15331                    alloy_sol_types::private::AssertTypeEq::<
15332                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
15333                    >(_) => {}
15334                }
15335            }
15336            #[automatically_derived]
15337            #[doc(hidden)]
15338            impl ::core::convert::From<isM2QuorumRegistrationDisabledReturn>
15339            for UnderlyingRustTuple<'_> {
15340                fn from(value: isM2QuorumRegistrationDisabledReturn) -> Self {
15341                    (value._0,)
15342                }
15343            }
15344            #[automatically_derived]
15345            #[doc(hidden)]
15346            impl ::core::convert::From<UnderlyingRustTuple<'_>>
15347            for isM2QuorumRegistrationDisabledReturn {
15348                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
15349                    Self { _0: tuple.0 }
15350                }
15351            }
15352        }
15353        #[automatically_derived]
15354        impl alloy_sol_types::SolCall for isM2QuorumRegistrationDisabledCall {
15355            type Parameters<'a> = ();
15356            type Token<'a> = <Self::Parameters<
15357                'a,
15358            > as alloy_sol_types::SolType>::Token<'a>;
15359            type Return = isM2QuorumRegistrationDisabledReturn;
15360            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
15361            type ReturnToken<'a> = <Self::ReturnTuple<
15362                'a,
15363            > as alloy_sol_types::SolType>::Token<'a>;
15364            const SIGNATURE: &'static str = "isM2QuorumRegistrationDisabled()";
15365            const SELECTOR: [u8; 4] = [232u8, 20u8, 202u8, 157u8];
15366            #[inline]
15367            fn new<'a>(
15368                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
15369            ) -> Self {
15370                tuple.into()
15371            }
15372            #[inline]
15373            fn tokenize(&self) -> Self::Token<'_> {
15374                ()
15375            }
15376            #[inline]
15377            fn abi_decode_returns(
15378                data: &[u8],
15379                validate: bool,
15380            ) -> alloy_sol_types::Result<Self::Return> {
15381                <Self::ReturnTuple<
15382                    '_,
15383                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
15384                    .map(Into::into)
15385            }
15386        }
15387    };
15388    #[derive(Default, Debug, PartialEq, Eq, Hash)]
15389    /**Function with signature `lastEjectionTimestamp(address)` and selector `0x125e0584`.
15390```solidity
15391function lastEjectionTimestamp(address) external view returns (uint256);
15392```*/
15393    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
15394    #[derive(Clone)]
15395    pub struct lastEjectionTimestampCall {
15396        #[allow(missing_docs)]
15397        pub _0: alloy::sol_types::private::Address,
15398    }
15399    #[derive(Default, Debug, PartialEq, Eq, Hash)]
15400    ///Container type for the return parameters of the [`lastEjectionTimestamp(address)`](lastEjectionTimestampCall) function.
15401    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
15402    #[derive(Clone)]
15403    pub struct lastEjectionTimestampReturn {
15404        #[allow(missing_docs)]
15405        pub _0: alloy::sol_types::private::primitives::aliases::U256,
15406    }
15407    #[allow(
15408        non_camel_case_types,
15409        non_snake_case,
15410        clippy::pub_underscore_fields,
15411        clippy::style
15412    )]
15413    const _: () = {
15414        use alloy::sol_types as alloy_sol_types;
15415        {
15416            #[doc(hidden)]
15417            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
15418            #[doc(hidden)]
15419            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
15420            #[cfg(test)]
15421            #[allow(dead_code, unreachable_patterns)]
15422            fn _type_assertion(
15423                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
15424            ) {
15425                match _t {
15426                    alloy_sol_types::private::AssertTypeEq::<
15427                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
15428                    >(_) => {}
15429                }
15430            }
15431            #[automatically_derived]
15432            #[doc(hidden)]
15433            impl ::core::convert::From<lastEjectionTimestampCall>
15434            for UnderlyingRustTuple<'_> {
15435                fn from(value: lastEjectionTimestampCall) -> Self {
15436                    (value._0,)
15437                }
15438            }
15439            #[automatically_derived]
15440            #[doc(hidden)]
15441            impl ::core::convert::From<UnderlyingRustTuple<'_>>
15442            for lastEjectionTimestampCall {
15443                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
15444                    Self { _0: tuple.0 }
15445                }
15446            }
15447        }
15448        {
15449            #[doc(hidden)]
15450            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
15451            #[doc(hidden)]
15452            type UnderlyingRustTuple<'a> = (
15453                alloy::sol_types::private::primitives::aliases::U256,
15454            );
15455            #[cfg(test)]
15456            #[allow(dead_code, unreachable_patterns)]
15457            fn _type_assertion(
15458                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
15459            ) {
15460                match _t {
15461                    alloy_sol_types::private::AssertTypeEq::<
15462                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
15463                    >(_) => {}
15464                }
15465            }
15466            #[automatically_derived]
15467            #[doc(hidden)]
15468            impl ::core::convert::From<lastEjectionTimestampReturn>
15469            for UnderlyingRustTuple<'_> {
15470                fn from(value: lastEjectionTimestampReturn) -> Self {
15471                    (value._0,)
15472                }
15473            }
15474            #[automatically_derived]
15475            #[doc(hidden)]
15476            impl ::core::convert::From<UnderlyingRustTuple<'_>>
15477            for lastEjectionTimestampReturn {
15478                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
15479                    Self { _0: tuple.0 }
15480                }
15481            }
15482        }
15483        #[automatically_derived]
15484        impl alloy_sol_types::SolCall for lastEjectionTimestampCall {
15485            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
15486            type Token<'a> = <Self::Parameters<
15487                'a,
15488            > as alloy_sol_types::SolType>::Token<'a>;
15489            type Return = lastEjectionTimestampReturn;
15490            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
15491            type ReturnToken<'a> = <Self::ReturnTuple<
15492                'a,
15493            > as alloy_sol_types::SolType>::Token<'a>;
15494            const SIGNATURE: &'static str = "lastEjectionTimestamp(address)";
15495            const SELECTOR: [u8; 4] = [18u8, 94u8, 5u8, 132u8];
15496            #[inline]
15497            fn new<'a>(
15498                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
15499            ) -> Self {
15500                tuple.into()
15501            }
15502            #[inline]
15503            fn tokenize(&self) -> Self::Token<'_> {
15504                (
15505                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
15506                        &self._0,
15507                    ),
15508                )
15509            }
15510            #[inline]
15511            fn abi_decode_returns(
15512                data: &[u8],
15513                validate: bool,
15514            ) -> alloy_sol_types::Result<Self::Return> {
15515                <Self::ReturnTuple<
15516                    '_,
15517                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
15518                    .map(Into::into)
15519            }
15520        }
15521    };
15522    #[derive(Default, Debug, PartialEq, Eq, Hash)]
15523    /**Function with signature `m2QuorumBitmap()` and selector `0xec8c3a1e`.
15524```solidity
15525function m2QuorumBitmap() external view returns (uint256);
15526```*/
15527    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
15528    #[derive(Clone)]
15529    pub struct m2QuorumBitmapCall {}
15530    #[derive(Default, Debug, PartialEq, Eq, Hash)]
15531    ///Container type for the return parameters of the [`m2QuorumBitmap()`](m2QuorumBitmapCall) function.
15532    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
15533    #[derive(Clone)]
15534    pub struct m2QuorumBitmapReturn {
15535        #[allow(missing_docs)]
15536        pub _0: alloy::sol_types::private::primitives::aliases::U256,
15537    }
15538    #[allow(
15539        non_camel_case_types,
15540        non_snake_case,
15541        clippy::pub_underscore_fields,
15542        clippy::style
15543    )]
15544    const _: () = {
15545        use alloy::sol_types as alloy_sol_types;
15546        {
15547            #[doc(hidden)]
15548            type UnderlyingSolTuple<'a> = ();
15549            #[doc(hidden)]
15550            type UnderlyingRustTuple<'a> = ();
15551            #[cfg(test)]
15552            #[allow(dead_code, unreachable_patterns)]
15553            fn _type_assertion(
15554                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
15555            ) {
15556                match _t {
15557                    alloy_sol_types::private::AssertTypeEq::<
15558                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
15559                    >(_) => {}
15560                }
15561            }
15562            #[automatically_derived]
15563            #[doc(hidden)]
15564            impl ::core::convert::From<m2QuorumBitmapCall> for UnderlyingRustTuple<'_> {
15565                fn from(value: m2QuorumBitmapCall) -> Self {
15566                    ()
15567                }
15568            }
15569            #[automatically_derived]
15570            #[doc(hidden)]
15571            impl ::core::convert::From<UnderlyingRustTuple<'_>> for m2QuorumBitmapCall {
15572                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
15573                    Self {}
15574                }
15575            }
15576        }
15577        {
15578            #[doc(hidden)]
15579            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
15580            #[doc(hidden)]
15581            type UnderlyingRustTuple<'a> = (
15582                alloy::sol_types::private::primitives::aliases::U256,
15583            );
15584            #[cfg(test)]
15585            #[allow(dead_code, unreachable_patterns)]
15586            fn _type_assertion(
15587                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
15588            ) {
15589                match _t {
15590                    alloy_sol_types::private::AssertTypeEq::<
15591                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
15592                    >(_) => {}
15593                }
15594            }
15595            #[automatically_derived]
15596            #[doc(hidden)]
15597            impl ::core::convert::From<m2QuorumBitmapReturn>
15598            for UnderlyingRustTuple<'_> {
15599                fn from(value: m2QuorumBitmapReturn) -> Self {
15600                    (value._0,)
15601                }
15602            }
15603            #[automatically_derived]
15604            #[doc(hidden)]
15605            impl ::core::convert::From<UnderlyingRustTuple<'_>>
15606            for m2QuorumBitmapReturn {
15607                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
15608                    Self { _0: tuple.0 }
15609                }
15610            }
15611        }
15612        #[automatically_derived]
15613        impl alloy_sol_types::SolCall for m2QuorumBitmapCall {
15614            type Parameters<'a> = ();
15615            type Token<'a> = <Self::Parameters<
15616                'a,
15617            > as alloy_sol_types::SolType>::Token<'a>;
15618            type Return = m2QuorumBitmapReturn;
15619            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
15620            type ReturnToken<'a> = <Self::ReturnTuple<
15621                'a,
15622            > as alloy_sol_types::SolType>::Token<'a>;
15623            const SIGNATURE: &'static str = "m2QuorumBitmap()";
15624            const SELECTOR: [u8; 4] = [236u8, 140u8, 58u8, 30u8];
15625            #[inline]
15626            fn new<'a>(
15627                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
15628            ) -> Self {
15629                tuple.into()
15630            }
15631            #[inline]
15632            fn tokenize(&self) -> Self::Token<'_> {
15633                ()
15634            }
15635            #[inline]
15636            fn abi_decode_returns(
15637                data: &[u8],
15638                validate: bool,
15639            ) -> alloy_sol_types::Result<Self::Return> {
15640                <Self::ReturnTuple<
15641                    '_,
15642                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
15643                    .map(Into::into)
15644            }
15645        }
15646    };
15647    #[derive(Default, Debug, PartialEq, Eq, Hash)]
15648    /**Function with signature `operatorSetsEnabled()` and selector `0x81f936d2`.
15649```solidity
15650function operatorSetsEnabled() external view returns (bool);
15651```*/
15652    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
15653    #[derive(Clone)]
15654    pub struct operatorSetsEnabledCall {}
15655    #[derive(Default, Debug, PartialEq, Eq, Hash)]
15656    ///Container type for the return parameters of the [`operatorSetsEnabled()`](operatorSetsEnabledCall) function.
15657    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
15658    #[derive(Clone)]
15659    pub struct operatorSetsEnabledReturn {
15660        #[allow(missing_docs)]
15661        pub _0: bool,
15662    }
15663    #[allow(
15664        non_camel_case_types,
15665        non_snake_case,
15666        clippy::pub_underscore_fields,
15667        clippy::style
15668    )]
15669    const _: () = {
15670        use alloy::sol_types as alloy_sol_types;
15671        {
15672            #[doc(hidden)]
15673            type UnderlyingSolTuple<'a> = ();
15674            #[doc(hidden)]
15675            type UnderlyingRustTuple<'a> = ();
15676            #[cfg(test)]
15677            #[allow(dead_code, unreachable_patterns)]
15678            fn _type_assertion(
15679                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
15680            ) {
15681                match _t {
15682                    alloy_sol_types::private::AssertTypeEq::<
15683                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
15684                    >(_) => {}
15685                }
15686            }
15687            #[automatically_derived]
15688            #[doc(hidden)]
15689            impl ::core::convert::From<operatorSetsEnabledCall>
15690            for UnderlyingRustTuple<'_> {
15691                fn from(value: operatorSetsEnabledCall) -> Self {
15692                    ()
15693                }
15694            }
15695            #[automatically_derived]
15696            #[doc(hidden)]
15697            impl ::core::convert::From<UnderlyingRustTuple<'_>>
15698            for operatorSetsEnabledCall {
15699                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
15700                    Self {}
15701                }
15702            }
15703        }
15704        {
15705            #[doc(hidden)]
15706            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
15707            #[doc(hidden)]
15708            type UnderlyingRustTuple<'a> = (bool,);
15709            #[cfg(test)]
15710            #[allow(dead_code, unreachable_patterns)]
15711            fn _type_assertion(
15712                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
15713            ) {
15714                match _t {
15715                    alloy_sol_types::private::AssertTypeEq::<
15716                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
15717                    >(_) => {}
15718                }
15719            }
15720            #[automatically_derived]
15721            #[doc(hidden)]
15722            impl ::core::convert::From<operatorSetsEnabledReturn>
15723            for UnderlyingRustTuple<'_> {
15724                fn from(value: operatorSetsEnabledReturn) -> Self {
15725                    (value._0,)
15726                }
15727            }
15728            #[automatically_derived]
15729            #[doc(hidden)]
15730            impl ::core::convert::From<UnderlyingRustTuple<'_>>
15731            for operatorSetsEnabledReturn {
15732                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
15733                    Self { _0: tuple.0 }
15734                }
15735            }
15736        }
15737        #[automatically_derived]
15738        impl alloy_sol_types::SolCall for operatorSetsEnabledCall {
15739            type Parameters<'a> = ();
15740            type Token<'a> = <Self::Parameters<
15741                'a,
15742            > as alloy_sol_types::SolType>::Token<'a>;
15743            type Return = operatorSetsEnabledReturn;
15744            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
15745            type ReturnToken<'a> = <Self::ReturnTuple<
15746                'a,
15747            > as alloy_sol_types::SolType>::Token<'a>;
15748            const SIGNATURE: &'static str = "operatorSetsEnabled()";
15749            const SELECTOR: [u8; 4] = [129u8, 249u8, 54u8, 210u8];
15750            #[inline]
15751            fn new<'a>(
15752                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
15753            ) -> Self {
15754                tuple.into()
15755            }
15756            #[inline]
15757            fn tokenize(&self) -> Self::Token<'_> {
15758                ()
15759            }
15760            #[inline]
15761            fn abi_decode_returns(
15762                data: &[u8],
15763                validate: bool,
15764            ) -> alloy_sol_types::Result<Self::Return> {
15765                <Self::ReturnTuple<
15766                    '_,
15767                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
15768                    .map(Into::into)
15769            }
15770        }
15771    };
15772    #[derive(Default, Debug, PartialEq, Eq, Hash)]
15773    /**Function with signature `owner()` and selector `0x8da5cb5b`.
15774```solidity
15775function owner() external view returns (address);
15776```*/
15777    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
15778    #[derive(Clone)]
15779    pub struct ownerCall {}
15780    #[derive(Default, Debug, PartialEq, Eq, Hash)]
15781    ///Container type for the return parameters of the [`owner()`](ownerCall) function.
15782    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
15783    #[derive(Clone)]
15784    pub struct ownerReturn {
15785        #[allow(missing_docs)]
15786        pub _0: alloy::sol_types::private::Address,
15787    }
15788    #[allow(
15789        non_camel_case_types,
15790        non_snake_case,
15791        clippy::pub_underscore_fields,
15792        clippy::style
15793    )]
15794    const _: () = {
15795        use alloy::sol_types as alloy_sol_types;
15796        {
15797            #[doc(hidden)]
15798            type UnderlyingSolTuple<'a> = ();
15799            #[doc(hidden)]
15800            type UnderlyingRustTuple<'a> = ();
15801            #[cfg(test)]
15802            #[allow(dead_code, unreachable_patterns)]
15803            fn _type_assertion(
15804                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
15805            ) {
15806                match _t {
15807                    alloy_sol_types::private::AssertTypeEq::<
15808                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
15809                    >(_) => {}
15810                }
15811            }
15812            #[automatically_derived]
15813            #[doc(hidden)]
15814            impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
15815                fn from(value: ownerCall) -> Self {
15816                    ()
15817                }
15818            }
15819            #[automatically_derived]
15820            #[doc(hidden)]
15821            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
15822                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
15823                    Self {}
15824                }
15825            }
15826        }
15827        {
15828            #[doc(hidden)]
15829            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
15830            #[doc(hidden)]
15831            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
15832            #[cfg(test)]
15833            #[allow(dead_code, unreachable_patterns)]
15834            fn _type_assertion(
15835                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
15836            ) {
15837                match _t {
15838                    alloy_sol_types::private::AssertTypeEq::<
15839                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
15840                    >(_) => {}
15841                }
15842            }
15843            #[automatically_derived]
15844            #[doc(hidden)]
15845            impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
15846                fn from(value: ownerReturn) -> Self {
15847                    (value._0,)
15848                }
15849            }
15850            #[automatically_derived]
15851            #[doc(hidden)]
15852            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
15853                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
15854                    Self { _0: tuple.0 }
15855                }
15856            }
15857        }
15858        #[automatically_derived]
15859        impl alloy_sol_types::SolCall for ownerCall {
15860            type Parameters<'a> = ();
15861            type Token<'a> = <Self::Parameters<
15862                'a,
15863            > as alloy_sol_types::SolType>::Token<'a>;
15864            type Return = ownerReturn;
15865            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
15866            type ReturnToken<'a> = <Self::ReturnTuple<
15867                'a,
15868            > as alloy_sol_types::SolType>::Token<'a>;
15869            const SIGNATURE: &'static str = "owner()";
15870            const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
15871            #[inline]
15872            fn new<'a>(
15873                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
15874            ) -> Self {
15875                tuple.into()
15876            }
15877            #[inline]
15878            fn tokenize(&self) -> Self::Token<'_> {
15879                ()
15880            }
15881            #[inline]
15882            fn abi_decode_returns(
15883                data: &[u8],
15884                validate: bool,
15885            ) -> alloy_sol_types::Result<Self::Return> {
15886                <Self::ReturnTuple<
15887                    '_,
15888                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
15889                    .map(Into::into)
15890            }
15891        }
15892    };
15893    #[derive(Default, Debug, PartialEq, Eq, Hash)]
15894    /**Function with signature `pause(uint256)` and selector `0x136439dd`.
15895```solidity
15896function pause(uint256 newPausedStatus) external;
15897```*/
15898    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
15899    #[derive(Clone)]
15900    pub struct pauseCall {
15901        #[allow(missing_docs)]
15902        pub newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
15903    }
15904    ///Container type for the return parameters of the [`pause(uint256)`](pauseCall) function.
15905    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
15906    #[derive(Clone)]
15907    pub struct pauseReturn {}
15908    #[allow(
15909        non_camel_case_types,
15910        non_snake_case,
15911        clippy::pub_underscore_fields,
15912        clippy::style
15913    )]
15914    const _: () = {
15915        use alloy::sol_types as alloy_sol_types;
15916        {
15917            #[doc(hidden)]
15918            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
15919            #[doc(hidden)]
15920            type UnderlyingRustTuple<'a> = (
15921                alloy::sol_types::private::primitives::aliases::U256,
15922            );
15923            #[cfg(test)]
15924            #[allow(dead_code, unreachable_patterns)]
15925            fn _type_assertion(
15926                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
15927            ) {
15928                match _t {
15929                    alloy_sol_types::private::AssertTypeEq::<
15930                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
15931                    >(_) => {}
15932                }
15933            }
15934            #[automatically_derived]
15935            #[doc(hidden)]
15936            impl ::core::convert::From<pauseCall> for UnderlyingRustTuple<'_> {
15937                fn from(value: pauseCall) -> Self {
15938                    (value.newPausedStatus,)
15939                }
15940            }
15941            #[automatically_derived]
15942            #[doc(hidden)]
15943            impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseCall {
15944                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
15945                    Self { newPausedStatus: tuple.0 }
15946                }
15947            }
15948        }
15949        {
15950            #[doc(hidden)]
15951            type UnderlyingSolTuple<'a> = ();
15952            #[doc(hidden)]
15953            type UnderlyingRustTuple<'a> = ();
15954            #[cfg(test)]
15955            #[allow(dead_code, unreachable_patterns)]
15956            fn _type_assertion(
15957                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
15958            ) {
15959                match _t {
15960                    alloy_sol_types::private::AssertTypeEq::<
15961                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
15962                    >(_) => {}
15963                }
15964            }
15965            #[automatically_derived]
15966            #[doc(hidden)]
15967            impl ::core::convert::From<pauseReturn> for UnderlyingRustTuple<'_> {
15968                fn from(value: pauseReturn) -> Self {
15969                    ()
15970                }
15971            }
15972            #[automatically_derived]
15973            #[doc(hidden)]
15974            impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseReturn {
15975                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
15976                    Self {}
15977                }
15978            }
15979        }
15980        #[automatically_derived]
15981        impl alloy_sol_types::SolCall for pauseCall {
15982            type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
15983            type Token<'a> = <Self::Parameters<
15984                'a,
15985            > as alloy_sol_types::SolType>::Token<'a>;
15986            type Return = pauseReturn;
15987            type ReturnTuple<'a> = ();
15988            type ReturnToken<'a> = <Self::ReturnTuple<
15989                'a,
15990            > as alloy_sol_types::SolType>::Token<'a>;
15991            const SIGNATURE: &'static str = "pause(uint256)";
15992            const SELECTOR: [u8; 4] = [19u8, 100u8, 57u8, 221u8];
15993            #[inline]
15994            fn new<'a>(
15995                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
15996            ) -> Self {
15997                tuple.into()
15998            }
15999            #[inline]
16000            fn tokenize(&self) -> Self::Token<'_> {
16001                (
16002                    <alloy::sol_types::sol_data::Uint<
16003                        256,
16004                    > as alloy_sol_types::SolType>::tokenize(&self.newPausedStatus),
16005                )
16006            }
16007            #[inline]
16008            fn abi_decode_returns(
16009                data: &[u8],
16010                validate: bool,
16011            ) -> alloy_sol_types::Result<Self::Return> {
16012                <Self::ReturnTuple<
16013                    '_,
16014                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
16015                    .map(Into::into)
16016            }
16017        }
16018    };
16019    #[derive(Default, Debug, PartialEq, Eq, Hash)]
16020    /**Function with signature `pauseAll()` and selector `0x595c6a67`.
16021```solidity
16022function pauseAll() external;
16023```*/
16024    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
16025    #[derive(Clone)]
16026    pub struct pauseAllCall {}
16027    ///Container type for the return parameters of the [`pauseAll()`](pauseAllCall) function.
16028    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
16029    #[derive(Clone)]
16030    pub struct pauseAllReturn {}
16031    #[allow(
16032        non_camel_case_types,
16033        non_snake_case,
16034        clippy::pub_underscore_fields,
16035        clippy::style
16036    )]
16037    const _: () = {
16038        use alloy::sol_types as alloy_sol_types;
16039        {
16040            #[doc(hidden)]
16041            type UnderlyingSolTuple<'a> = ();
16042            #[doc(hidden)]
16043            type UnderlyingRustTuple<'a> = ();
16044            #[cfg(test)]
16045            #[allow(dead_code, unreachable_patterns)]
16046            fn _type_assertion(
16047                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
16048            ) {
16049                match _t {
16050                    alloy_sol_types::private::AssertTypeEq::<
16051                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
16052                    >(_) => {}
16053                }
16054            }
16055            #[automatically_derived]
16056            #[doc(hidden)]
16057            impl ::core::convert::From<pauseAllCall> for UnderlyingRustTuple<'_> {
16058                fn from(value: pauseAllCall) -> Self {
16059                    ()
16060                }
16061            }
16062            #[automatically_derived]
16063            #[doc(hidden)]
16064            impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseAllCall {
16065                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
16066                    Self {}
16067                }
16068            }
16069        }
16070        {
16071            #[doc(hidden)]
16072            type UnderlyingSolTuple<'a> = ();
16073            #[doc(hidden)]
16074            type UnderlyingRustTuple<'a> = ();
16075            #[cfg(test)]
16076            #[allow(dead_code, unreachable_patterns)]
16077            fn _type_assertion(
16078                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
16079            ) {
16080                match _t {
16081                    alloy_sol_types::private::AssertTypeEq::<
16082                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
16083                    >(_) => {}
16084                }
16085            }
16086            #[automatically_derived]
16087            #[doc(hidden)]
16088            impl ::core::convert::From<pauseAllReturn> for UnderlyingRustTuple<'_> {
16089                fn from(value: pauseAllReturn) -> Self {
16090                    ()
16091                }
16092            }
16093            #[automatically_derived]
16094            #[doc(hidden)]
16095            impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseAllReturn {
16096                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
16097                    Self {}
16098                }
16099            }
16100        }
16101        #[automatically_derived]
16102        impl alloy_sol_types::SolCall for pauseAllCall {
16103            type Parameters<'a> = ();
16104            type Token<'a> = <Self::Parameters<
16105                'a,
16106            > as alloy_sol_types::SolType>::Token<'a>;
16107            type Return = pauseAllReturn;
16108            type ReturnTuple<'a> = ();
16109            type ReturnToken<'a> = <Self::ReturnTuple<
16110                'a,
16111            > as alloy_sol_types::SolType>::Token<'a>;
16112            const SIGNATURE: &'static str = "pauseAll()";
16113            const SELECTOR: [u8; 4] = [89u8, 92u8, 106u8, 103u8];
16114            #[inline]
16115            fn new<'a>(
16116                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
16117            ) -> Self {
16118                tuple.into()
16119            }
16120            #[inline]
16121            fn tokenize(&self) -> Self::Token<'_> {
16122                ()
16123            }
16124            #[inline]
16125            fn abi_decode_returns(
16126                data: &[u8],
16127                validate: bool,
16128            ) -> alloy_sol_types::Result<Self::Return> {
16129                <Self::ReturnTuple<
16130                    '_,
16131                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
16132                    .map(Into::into)
16133            }
16134        }
16135    };
16136    #[derive(Default, Debug, PartialEq, Eq, Hash)]
16137    /**Function with signature `paused(uint8)` and selector `0x5ac86ab7`.
16138```solidity
16139function paused(uint8 index) external view returns (bool);
16140```*/
16141    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
16142    #[derive(Clone)]
16143    pub struct paused_0Call {
16144        #[allow(missing_docs)]
16145        pub index: u8,
16146    }
16147    #[derive(Default, Debug, PartialEq, Eq, Hash)]
16148    ///Container type for the return parameters of the [`paused(uint8)`](paused_0Call) function.
16149    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
16150    #[derive(Clone)]
16151    pub struct paused_0Return {
16152        #[allow(missing_docs)]
16153        pub _0: bool,
16154    }
16155    #[allow(
16156        non_camel_case_types,
16157        non_snake_case,
16158        clippy::pub_underscore_fields,
16159        clippy::style
16160    )]
16161    const _: () = {
16162        use alloy::sol_types as alloy_sol_types;
16163        {
16164            #[doc(hidden)]
16165            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
16166            #[doc(hidden)]
16167            type UnderlyingRustTuple<'a> = (u8,);
16168            #[cfg(test)]
16169            #[allow(dead_code, unreachable_patterns)]
16170            fn _type_assertion(
16171                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
16172            ) {
16173                match _t {
16174                    alloy_sol_types::private::AssertTypeEq::<
16175                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
16176                    >(_) => {}
16177                }
16178            }
16179            #[automatically_derived]
16180            #[doc(hidden)]
16181            impl ::core::convert::From<paused_0Call> for UnderlyingRustTuple<'_> {
16182                fn from(value: paused_0Call) -> Self {
16183                    (value.index,)
16184                }
16185            }
16186            #[automatically_derived]
16187            #[doc(hidden)]
16188            impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_0Call {
16189                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
16190                    Self { index: tuple.0 }
16191                }
16192            }
16193        }
16194        {
16195            #[doc(hidden)]
16196            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
16197            #[doc(hidden)]
16198            type UnderlyingRustTuple<'a> = (bool,);
16199            #[cfg(test)]
16200            #[allow(dead_code, unreachable_patterns)]
16201            fn _type_assertion(
16202                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
16203            ) {
16204                match _t {
16205                    alloy_sol_types::private::AssertTypeEq::<
16206                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
16207                    >(_) => {}
16208                }
16209            }
16210            #[automatically_derived]
16211            #[doc(hidden)]
16212            impl ::core::convert::From<paused_0Return> for UnderlyingRustTuple<'_> {
16213                fn from(value: paused_0Return) -> Self {
16214                    (value._0,)
16215                }
16216            }
16217            #[automatically_derived]
16218            #[doc(hidden)]
16219            impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_0Return {
16220                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
16221                    Self { _0: tuple.0 }
16222                }
16223            }
16224        }
16225        #[automatically_derived]
16226        impl alloy_sol_types::SolCall for paused_0Call {
16227            type Parameters<'a> = (alloy::sol_types::sol_data::Uint<8>,);
16228            type Token<'a> = <Self::Parameters<
16229                'a,
16230            > as alloy_sol_types::SolType>::Token<'a>;
16231            type Return = paused_0Return;
16232            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
16233            type ReturnToken<'a> = <Self::ReturnTuple<
16234                'a,
16235            > as alloy_sol_types::SolType>::Token<'a>;
16236            const SIGNATURE: &'static str = "paused(uint8)";
16237            const SELECTOR: [u8; 4] = [90u8, 200u8, 106u8, 183u8];
16238            #[inline]
16239            fn new<'a>(
16240                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
16241            ) -> Self {
16242                tuple.into()
16243            }
16244            #[inline]
16245            fn tokenize(&self) -> Self::Token<'_> {
16246                (
16247                    <alloy::sol_types::sol_data::Uint<
16248                        8,
16249                    > as alloy_sol_types::SolType>::tokenize(&self.index),
16250                )
16251            }
16252            #[inline]
16253            fn abi_decode_returns(
16254                data: &[u8],
16255                validate: bool,
16256            ) -> alloy_sol_types::Result<Self::Return> {
16257                <Self::ReturnTuple<
16258                    '_,
16259                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
16260                    .map(Into::into)
16261            }
16262        }
16263    };
16264    #[derive(Default, Debug, PartialEq, Eq, Hash)]
16265    /**Function with signature `paused()` and selector `0x5c975abb`.
16266```solidity
16267function paused() external view returns (uint256);
16268```*/
16269    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
16270    #[derive(Clone)]
16271    pub struct paused_1Call {}
16272    #[derive(Default, Debug, PartialEq, Eq, Hash)]
16273    ///Container type for the return parameters of the [`paused()`](paused_1Call) function.
16274    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
16275    #[derive(Clone)]
16276    pub struct paused_1Return {
16277        #[allow(missing_docs)]
16278        pub _0: alloy::sol_types::private::primitives::aliases::U256,
16279    }
16280    #[allow(
16281        non_camel_case_types,
16282        non_snake_case,
16283        clippy::pub_underscore_fields,
16284        clippy::style
16285    )]
16286    const _: () = {
16287        use alloy::sol_types as alloy_sol_types;
16288        {
16289            #[doc(hidden)]
16290            type UnderlyingSolTuple<'a> = ();
16291            #[doc(hidden)]
16292            type UnderlyingRustTuple<'a> = ();
16293            #[cfg(test)]
16294            #[allow(dead_code, unreachable_patterns)]
16295            fn _type_assertion(
16296                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
16297            ) {
16298                match _t {
16299                    alloy_sol_types::private::AssertTypeEq::<
16300                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
16301                    >(_) => {}
16302                }
16303            }
16304            #[automatically_derived]
16305            #[doc(hidden)]
16306            impl ::core::convert::From<paused_1Call> for UnderlyingRustTuple<'_> {
16307                fn from(value: paused_1Call) -> Self {
16308                    ()
16309                }
16310            }
16311            #[automatically_derived]
16312            #[doc(hidden)]
16313            impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_1Call {
16314                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
16315                    Self {}
16316                }
16317            }
16318        }
16319        {
16320            #[doc(hidden)]
16321            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
16322            #[doc(hidden)]
16323            type UnderlyingRustTuple<'a> = (
16324                alloy::sol_types::private::primitives::aliases::U256,
16325            );
16326            #[cfg(test)]
16327            #[allow(dead_code, unreachable_patterns)]
16328            fn _type_assertion(
16329                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
16330            ) {
16331                match _t {
16332                    alloy_sol_types::private::AssertTypeEq::<
16333                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
16334                    >(_) => {}
16335                }
16336            }
16337            #[automatically_derived]
16338            #[doc(hidden)]
16339            impl ::core::convert::From<paused_1Return> for UnderlyingRustTuple<'_> {
16340                fn from(value: paused_1Return) -> Self {
16341                    (value._0,)
16342                }
16343            }
16344            #[automatically_derived]
16345            #[doc(hidden)]
16346            impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_1Return {
16347                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
16348                    Self { _0: tuple.0 }
16349                }
16350            }
16351        }
16352        #[automatically_derived]
16353        impl alloy_sol_types::SolCall for paused_1Call {
16354            type Parameters<'a> = ();
16355            type Token<'a> = <Self::Parameters<
16356                'a,
16357            > as alloy_sol_types::SolType>::Token<'a>;
16358            type Return = paused_1Return;
16359            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
16360            type ReturnToken<'a> = <Self::ReturnTuple<
16361                'a,
16362            > as alloy_sol_types::SolType>::Token<'a>;
16363            const SIGNATURE: &'static str = "paused()";
16364            const SELECTOR: [u8; 4] = [92u8, 151u8, 90u8, 187u8];
16365            #[inline]
16366            fn new<'a>(
16367                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
16368            ) -> Self {
16369                tuple.into()
16370            }
16371            #[inline]
16372            fn tokenize(&self) -> Self::Token<'_> {
16373                ()
16374            }
16375            #[inline]
16376            fn abi_decode_returns(
16377                data: &[u8],
16378                validate: bool,
16379            ) -> alloy_sol_types::Result<Self::Return> {
16380                <Self::ReturnTuple<
16381                    '_,
16382                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
16383                    .map(Into::into)
16384            }
16385        }
16386    };
16387    #[derive(Default, Debug, PartialEq, Eq, Hash)]
16388    /**Function with signature `pauserRegistry()` and selector `0x886f1195`.
16389```solidity
16390function pauserRegistry() external view returns (address);
16391```*/
16392    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
16393    #[derive(Clone)]
16394    pub struct pauserRegistryCall {}
16395    #[derive(Default, Debug, PartialEq, Eq, Hash)]
16396    ///Container type for the return parameters of the [`pauserRegistry()`](pauserRegistryCall) function.
16397    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
16398    #[derive(Clone)]
16399    pub struct pauserRegistryReturn {
16400        #[allow(missing_docs)]
16401        pub _0: alloy::sol_types::private::Address,
16402    }
16403    #[allow(
16404        non_camel_case_types,
16405        non_snake_case,
16406        clippy::pub_underscore_fields,
16407        clippy::style
16408    )]
16409    const _: () = {
16410        use alloy::sol_types as alloy_sol_types;
16411        {
16412            #[doc(hidden)]
16413            type UnderlyingSolTuple<'a> = ();
16414            #[doc(hidden)]
16415            type UnderlyingRustTuple<'a> = ();
16416            #[cfg(test)]
16417            #[allow(dead_code, unreachable_patterns)]
16418            fn _type_assertion(
16419                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
16420            ) {
16421                match _t {
16422                    alloy_sol_types::private::AssertTypeEq::<
16423                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
16424                    >(_) => {}
16425                }
16426            }
16427            #[automatically_derived]
16428            #[doc(hidden)]
16429            impl ::core::convert::From<pauserRegistryCall> for UnderlyingRustTuple<'_> {
16430                fn from(value: pauserRegistryCall) -> Self {
16431                    ()
16432                }
16433            }
16434            #[automatically_derived]
16435            #[doc(hidden)]
16436            impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauserRegistryCall {
16437                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
16438                    Self {}
16439                }
16440            }
16441        }
16442        {
16443            #[doc(hidden)]
16444            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
16445            #[doc(hidden)]
16446            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
16447            #[cfg(test)]
16448            #[allow(dead_code, unreachable_patterns)]
16449            fn _type_assertion(
16450                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
16451            ) {
16452                match _t {
16453                    alloy_sol_types::private::AssertTypeEq::<
16454                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
16455                    >(_) => {}
16456                }
16457            }
16458            #[automatically_derived]
16459            #[doc(hidden)]
16460            impl ::core::convert::From<pauserRegistryReturn>
16461            for UnderlyingRustTuple<'_> {
16462                fn from(value: pauserRegistryReturn) -> Self {
16463                    (value._0,)
16464                }
16465            }
16466            #[automatically_derived]
16467            #[doc(hidden)]
16468            impl ::core::convert::From<UnderlyingRustTuple<'_>>
16469            for pauserRegistryReturn {
16470                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
16471                    Self { _0: tuple.0 }
16472                }
16473            }
16474        }
16475        #[automatically_derived]
16476        impl alloy_sol_types::SolCall for pauserRegistryCall {
16477            type Parameters<'a> = ();
16478            type Token<'a> = <Self::Parameters<
16479                'a,
16480            > as alloy_sol_types::SolType>::Token<'a>;
16481            type Return = pauserRegistryReturn;
16482            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
16483            type ReturnToken<'a> = <Self::ReturnTuple<
16484                'a,
16485            > as alloy_sol_types::SolType>::Token<'a>;
16486            const SIGNATURE: &'static str = "pauserRegistry()";
16487            const SELECTOR: [u8; 4] = [136u8, 111u8, 17u8, 149u8];
16488            #[inline]
16489            fn new<'a>(
16490                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
16491            ) -> Self {
16492                tuple.into()
16493            }
16494            #[inline]
16495            fn tokenize(&self) -> Self::Token<'_> {
16496                ()
16497            }
16498            #[inline]
16499            fn abi_decode_returns(
16500                data: &[u8],
16501                validate: bool,
16502            ) -> alloy_sol_types::Result<Self::Return> {
16503                <Self::ReturnTuple<
16504                    '_,
16505                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
16506                    .map(Into::into)
16507            }
16508        }
16509    };
16510    #[derive(Default, Debug, PartialEq, Eq, Hash)]
16511    /**Function with signature `pubkeyRegistrationMessageHash(address)` and selector `0x3c2a7f4c`.
16512```solidity
16513function pubkeyRegistrationMessageHash(address operator) external view returns (BN254.G1Point memory);
16514```*/
16515    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
16516    #[derive(Clone)]
16517    pub struct pubkeyRegistrationMessageHashCall {
16518        #[allow(missing_docs)]
16519        pub operator: alloy::sol_types::private::Address,
16520    }
16521    #[derive(Default, Debug, PartialEq, Eq, Hash)]
16522    ///Container type for the return parameters of the [`pubkeyRegistrationMessageHash(address)`](pubkeyRegistrationMessageHashCall) function.
16523    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
16524    #[derive(Clone)]
16525    pub struct pubkeyRegistrationMessageHashReturn {
16526        #[allow(missing_docs)]
16527        pub _0: <BN254::G1Point as alloy::sol_types::SolType>::RustType,
16528    }
16529    #[allow(
16530        non_camel_case_types,
16531        non_snake_case,
16532        clippy::pub_underscore_fields,
16533        clippy::style
16534    )]
16535    const _: () = {
16536        use alloy::sol_types as alloy_sol_types;
16537        {
16538            #[doc(hidden)]
16539            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
16540            #[doc(hidden)]
16541            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
16542            #[cfg(test)]
16543            #[allow(dead_code, unreachable_patterns)]
16544            fn _type_assertion(
16545                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
16546            ) {
16547                match _t {
16548                    alloy_sol_types::private::AssertTypeEq::<
16549                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
16550                    >(_) => {}
16551                }
16552            }
16553            #[automatically_derived]
16554            #[doc(hidden)]
16555            impl ::core::convert::From<pubkeyRegistrationMessageHashCall>
16556            for UnderlyingRustTuple<'_> {
16557                fn from(value: pubkeyRegistrationMessageHashCall) -> Self {
16558                    (value.operator,)
16559                }
16560            }
16561            #[automatically_derived]
16562            #[doc(hidden)]
16563            impl ::core::convert::From<UnderlyingRustTuple<'_>>
16564            for pubkeyRegistrationMessageHashCall {
16565                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
16566                    Self { operator: tuple.0 }
16567                }
16568            }
16569        }
16570        {
16571            #[doc(hidden)]
16572            type UnderlyingSolTuple<'a> = (BN254::G1Point,);
16573            #[doc(hidden)]
16574            type UnderlyingRustTuple<'a> = (
16575                <BN254::G1Point as alloy::sol_types::SolType>::RustType,
16576            );
16577            #[cfg(test)]
16578            #[allow(dead_code, unreachable_patterns)]
16579            fn _type_assertion(
16580                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
16581            ) {
16582                match _t {
16583                    alloy_sol_types::private::AssertTypeEq::<
16584                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
16585                    >(_) => {}
16586                }
16587            }
16588            #[automatically_derived]
16589            #[doc(hidden)]
16590            impl ::core::convert::From<pubkeyRegistrationMessageHashReturn>
16591            for UnderlyingRustTuple<'_> {
16592                fn from(value: pubkeyRegistrationMessageHashReturn) -> Self {
16593                    (value._0,)
16594                }
16595            }
16596            #[automatically_derived]
16597            #[doc(hidden)]
16598            impl ::core::convert::From<UnderlyingRustTuple<'_>>
16599            for pubkeyRegistrationMessageHashReturn {
16600                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
16601                    Self { _0: tuple.0 }
16602                }
16603            }
16604        }
16605        #[automatically_derived]
16606        impl alloy_sol_types::SolCall for pubkeyRegistrationMessageHashCall {
16607            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
16608            type Token<'a> = <Self::Parameters<
16609                'a,
16610            > as alloy_sol_types::SolType>::Token<'a>;
16611            type Return = pubkeyRegistrationMessageHashReturn;
16612            type ReturnTuple<'a> = (BN254::G1Point,);
16613            type ReturnToken<'a> = <Self::ReturnTuple<
16614                'a,
16615            > as alloy_sol_types::SolType>::Token<'a>;
16616            const SIGNATURE: &'static str = "pubkeyRegistrationMessageHash(address)";
16617            const SELECTOR: [u8; 4] = [60u8, 42u8, 127u8, 76u8];
16618            #[inline]
16619            fn new<'a>(
16620                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
16621            ) -> Self {
16622                tuple.into()
16623            }
16624            #[inline]
16625            fn tokenize(&self) -> Self::Token<'_> {
16626                (
16627                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
16628                        &self.operator,
16629                    ),
16630                )
16631            }
16632            #[inline]
16633            fn abi_decode_returns(
16634                data: &[u8],
16635                validate: bool,
16636            ) -> alloy_sol_types::Result<Self::Return> {
16637                <Self::ReturnTuple<
16638                    '_,
16639                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
16640                    .map(Into::into)
16641            }
16642        }
16643    };
16644    #[derive(Default, Debug, PartialEq, Eq, Hash)]
16645    /**Function with signature `quorumCount()` and selector `0x9aa1653d`.
16646```solidity
16647function quorumCount() external view returns (uint8);
16648```*/
16649    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
16650    #[derive(Clone)]
16651    pub struct quorumCountCall {}
16652    #[derive(Default, Debug, PartialEq, Eq, Hash)]
16653    ///Container type for the return parameters of the [`quorumCount()`](quorumCountCall) function.
16654    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
16655    #[derive(Clone)]
16656    pub struct quorumCountReturn {
16657        #[allow(missing_docs)]
16658        pub _0: u8,
16659    }
16660    #[allow(
16661        non_camel_case_types,
16662        non_snake_case,
16663        clippy::pub_underscore_fields,
16664        clippy::style
16665    )]
16666    const _: () = {
16667        use alloy::sol_types as alloy_sol_types;
16668        {
16669            #[doc(hidden)]
16670            type UnderlyingSolTuple<'a> = ();
16671            #[doc(hidden)]
16672            type UnderlyingRustTuple<'a> = ();
16673            #[cfg(test)]
16674            #[allow(dead_code, unreachable_patterns)]
16675            fn _type_assertion(
16676                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
16677            ) {
16678                match _t {
16679                    alloy_sol_types::private::AssertTypeEq::<
16680                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
16681                    >(_) => {}
16682                }
16683            }
16684            #[automatically_derived]
16685            #[doc(hidden)]
16686            impl ::core::convert::From<quorumCountCall> for UnderlyingRustTuple<'_> {
16687                fn from(value: quorumCountCall) -> Self {
16688                    ()
16689                }
16690            }
16691            #[automatically_derived]
16692            #[doc(hidden)]
16693            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quorumCountCall {
16694                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
16695                    Self {}
16696                }
16697            }
16698        }
16699        {
16700            #[doc(hidden)]
16701            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
16702            #[doc(hidden)]
16703            type UnderlyingRustTuple<'a> = (u8,);
16704            #[cfg(test)]
16705            #[allow(dead_code, unreachable_patterns)]
16706            fn _type_assertion(
16707                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
16708            ) {
16709                match _t {
16710                    alloy_sol_types::private::AssertTypeEq::<
16711                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
16712                    >(_) => {}
16713                }
16714            }
16715            #[automatically_derived]
16716            #[doc(hidden)]
16717            impl ::core::convert::From<quorumCountReturn> for UnderlyingRustTuple<'_> {
16718                fn from(value: quorumCountReturn) -> Self {
16719                    (value._0,)
16720                }
16721            }
16722            #[automatically_derived]
16723            #[doc(hidden)]
16724            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quorumCountReturn {
16725                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
16726                    Self { _0: tuple.0 }
16727                }
16728            }
16729        }
16730        #[automatically_derived]
16731        impl alloy_sol_types::SolCall for quorumCountCall {
16732            type Parameters<'a> = ();
16733            type Token<'a> = <Self::Parameters<
16734                'a,
16735            > as alloy_sol_types::SolType>::Token<'a>;
16736            type Return = quorumCountReturn;
16737            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
16738            type ReturnToken<'a> = <Self::ReturnTuple<
16739                'a,
16740            > as alloy_sol_types::SolType>::Token<'a>;
16741            const SIGNATURE: &'static str = "quorumCount()";
16742            const SELECTOR: [u8; 4] = [154u8, 161u8, 101u8, 61u8];
16743            #[inline]
16744            fn new<'a>(
16745                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
16746            ) -> Self {
16747                tuple.into()
16748            }
16749            #[inline]
16750            fn tokenize(&self) -> Self::Token<'_> {
16751                ()
16752            }
16753            #[inline]
16754            fn abi_decode_returns(
16755                data: &[u8],
16756                validate: bool,
16757            ) -> alloy_sol_types::Result<Self::Return> {
16758                <Self::ReturnTuple<
16759                    '_,
16760                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
16761                    .map(Into::into)
16762            }
16763        }
16764    };
16765    #[derive(Default, Debug, PartialEq, Eq, Hash)]
16766    /**Function with signature `quorumUpdateBlockNumber(uint8)` and selector `0x249a0c42`.
16767```solidity
16768function quorumUpdateBlockNumber(uint8) external view returns (uint256);
16769```*/
16770    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
16771    #[derive(Clone)]
16772    pub struct quorumUpdateBlockNumberCall {
16773        #[allow(missing_docs)]
16774        pub _0: u8,
16775    }
16776    #[derive(Default, Debug, PartialEq, Eq, Hash)]
16777    ///Container type for the return parameters of the [`quorumUpdateBlockNumber(uint8)`](quorumUpdateBlockNumberCall) function.
16778    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
16779    #[derive(Clone)]
16780    pub struct quorumUpdateBlockNumberReturn {
16781        #[allow(missing_docs)]
16782        pub _0: alloy::sol_types::private::primitives::aliases::U256,
16783    }
16784    #[allow(
16785        non_camel_case_types,
16786        non_snake_case,
16787        clippy::pub_underscore_fields,
16788        clippy::style
16789    )]
16790    const _: () = {
16791        use alloy::sol_types as alloy_sol_types;
16792        {
16793            #[doc(hidden)]
16794            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
16795            #[doc(hidden)]
16796            type UnderlyingRustTuple<'a> = (u8,);
16797            #[cfg(test)]
16798            #[allow(dead_code, unreachable_patterns)]
16799            fn _type_assertion(
16800                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
16801            ) {
16802                match _t {
16803                    alloy_sol_types::private::AssertTypeEq::<
16804                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
16805                    >(_) => {}
16806                }
16807            }
16808            #[automatically_derived]
16809            #[doc(hidden)]
16810            impl ::core::convert::From<quorumUpdateBlockNumberCall>
16811            for UnderlyingRustTuple<'_> {
16812                fn from(value: quorumUpdateBlockNumberCall) -> Self {
16813                    (value._0,)
16814                }
16815            }
16816            #[automatically_derived]
16817            #[doc(hidden)]
16818            impl ::core::convert::From<UnderlyingRustTuple<'_>>
16819            for quorumUpdateBlockNumberCall {
16820                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
16821                    Self { _0: tuple.0 }
16822                }
16823            }
16824        }
16825        {
16826            #[doc(hidden)]
16827            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
16828            #[doc(hidden)]
16829            type UnderlyingRustTuple<'a> = (
16830                alloy::sol_types::private::primitives::aliases::U256,
16831            );
16832            #[cfg(test)]
16833            #[allow(dead_code, unreachable_patterns)]
16834            fn _type_assertion(
16835                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
16836            ) {
16837                match _t {
16838                    alloy_sol_types::private::AssertTypeEq::<
16839                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
16840                    >(_) => {}
16841                }
16842            }
16843            #[automatically_derived]
16844            #[doc(hidden)]
16845            impl ::core::convert::From<quorumUpdateBlockNumberReturn>
16846            for UnderlyingRustTuple<'_> {
16847                fn from(value: quorumUpdateBlockNumberReturn) -> Self {
16848                    (value._0,)
16849                }
16850            }
16851            #[automatically_derived]
16852            #[doc(hidden)]
16853            impl ::core::convert::From<UnderlyingRustTuple<'_>>
16854            for quorumUpdateBlockNumberReturn {
16855                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
16856                    Self { _0: tuple.0 }
16857                }
16858            }
16859        }
16860        #[automatically_derived]
16861        impl alloy_sol_types::SolCall for quorumUpdateBlockNumberCall {
16862            type Parameters<'a> = (alloy::sol_types::sol_data::Uint<8>,);
16863            type Token<'a> = <Self::Parameters<
16864                'a,
16865            > as alloy_sol_types::SolType>::Token<'a>;
16866            type Return = quorumUpdateBlockNumberReturn;
16867            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
16868            type ReturnToken<'a> = <Self::ReturnTuple<
16869                'a,
16870            > as alloy_sol_types::SolType>::Token<'a>;
16871            const SIGNATURE: &'static str = "quorumUpdateBlockNumber(uint8)";
16872            const SELECTOR: [u8; 4] = [36u8, 154u8, 12u8, 66u8];
16873            #[inline]
16874            fn new<'a>(
16875                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
16876            ) -> Self {
16877                tuple.into()
16878            }
16879            #[inline]
16880            fn tokenize(&self) -> Self::Token<'_> {
16881                (
16882                    <alloy::sol_types::sol_data::Uint<
16883                        8,
16884                    > as alloy_sol_types::SolType>::tokenize(&self._0),
16885                )
16886            }
16887            #[inline]
16888            fn abi_decode_returns(
16889                data: &[u8],
16890                validate: bool,
16891            ) -> alloy_sol_types::Result<Self::Return> {
16892                <Self::ReturnTuple<
16893                    '_,
16894                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
16895                    .map(Into::into)
16896            }
16897        }
16898    };
16899    #[derive(Default, Debug, PartialEq, Eq, Hash)]
16900    /**Function with signature `registerOperator(bytes,string,((uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])),(bytes,bytes32,uint256))` and selector `0xa50857bf`.
16901```solidity
16902function registerOperator(bytes memory quorumNumbers, string memory socket, IBLSApkRegistryTypes.PubkeyRegistrationParams memory params, ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry memory operatorSignature) external;
16903```*/
16904    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
16905    #[derive(Clone)]
16906    pub struct registerOperator_0Call {
16907        #[allow(missing_docs)]
16908        pub quorumNumbers: alloy::sol_types::private::Bytes,
16909        #[allow(missing_docs)]
16910        pub socket: alloy::sol_types::private::String,
16911        #[allow(missing_docs)]
16912        pub params: <IBLSApkRegistryTypes::PubkeyRegistrationParams as alloy::sol_types::SolType>::RustType,
16913        #[allow(missing_docs)]
16914        pub operatorSignature: <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy::sol_types::SolType>::RustType,
16915    }
16916    ///Container type for the return parameters of the [`registerOperator(bytes,string,((uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])),(bytes,bytes32,uint256))`](registerOperator_0Call) function.
16917    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
16918    #[derive(Clone)]
16919    pub struct registerOperator_0Return {}
16920    #[allow(
16921        non_camel_case_types,
16922        non_snake_case,
16923        clippy::pub_underscore_fields,
16924        clippy::style
16925    )]
16926    const _: () = {
16927        use alloy::sol_types as alloy_sol_types;
16928        {
16929            #[doc(hidden)]
16930            type UnderlyingSolTuple<'a> = (
16931                alloy::sol_types::sol_data::Bytes,
16932                alloy::sol_types::sol_data::String,
16933                IBLSApkRegistryTypes::PubkeyRegistrationParams,
16934                ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry,
16935            );
16936            #[doc(hidden)]
16937            type UnderlyingRustTuple<'a> = (
16938                alloy::sol_types::private::Bytes,
16939                alloy::sol_types::private::String,
16940                <IBLSApkRegistryTypes::PubkeyRegistrationParams as alloy::sol_types::SolType>::RustType,
16941                <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy::sol_types::SolType>::RustType,
16942            );
16943            #[cfg(test)]
16944            #[allow(dead_code, unreachable_patterns)]
16945            fn _type_assertion(
16946                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
16947            ) {
16948                match _t {
16949                    alloy_sol_types::private::AssertTypeEq::<
16950                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
16951                    >(_) => {}
16952                }
16953            }
16954            #[automatically_derived]
16955            #[doc(hidden)]
16956            impl ::core::convert::From<registerOperator_0Call>
16957            for UnderlyingRustTuple<'_> {
16958                fn from(value: registerOperator_0Call) -> Self {
16959                    (
16960                        value.quorumNumbers,
16961                        value.socket,
16962                        value.params,
16963                        value.operatorSignature,
16964                    )
16965                }
16966            }
16967            #[automatically_derived]
16968            #[doc(hidden)]
16969            impl ::core::convert::From<UnderlyingRustTuple<'_>>
16970            for registerOperator_0Call {
16971                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
16972                    Self {
16973                        quorumNumbers: tuple.0,
16974                        socket: tuple.1,
16975                        params: tuple.2,
16976                        operatorSignature: tuple.3,
16977                    }
16978                }
16979            }
16980        }
16981        {
16982            #[doc(hidden)]
16983            type UnderlyingSolTuple<'a> = ();
16984            #[doc(hidden)]
16985            type UnderlyingRustTuple<'a> = ();
16986            #[cfg(test)]
16987            #[allow(dead_code, unreachable_patterns)]
16988            fn _type_assertion(
16989                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
16990            ) {
16991                match _t {
16992                    alloy_sol_types::private::AssertTypeEq::<
16993                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
16994                    >(_) => {}
16995                }
16996            }
16997            #[automatically_derived]
16998            #[doc(hidden)]
16999            impl ::core::convert::From<registerOperator_0Return>
17000            for UnderlyingRustTuple<'_> {
17001                fn from(value: registerOperator_0Return) -> Self {
17002                    ()
17003                }
17004            }
17005            #[automatically_derived]
17006            #[doc(hidden)]
17007            impl ::core::convert::From<UnderlyingRustTuple<'_>>
17008            for registerOperator_0Return {
17009                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
17010                    Self {}
17011                }
17012            }
17013        }
17014        #[automatically_derived]
17015        impl alloy_sol_types::SolCall for registerOperator_0Call {
17016            type Parameters<'a> = (
17017                alloy::sol_types::sol_data::Bytes,
17018                alloy::sol_types::sol_data::String,
17019                IBLSApkRegistryTypes::PubkeyRegistrationParams,
17020                ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry,
17021            );
17022            type Token<'a> = <Self::Parameters<
17023                'a,
17024            > as alloy_sol_types::SolType>::Token<'a>;
17025            type Return = registerOperator_0Return;
17026            type ReturnTuple<'a> = ();
17027            type ReturnToken<'a> = <Self::ReturnTuple<
17028                'a,
17029            > as alloy_sol_types::SolType>::Token<'a>;
17030            const SIGNATURE: &'static str = "registerOperator(bytes,string,((uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])),(bytes,bytes32,uint256))";
17031            const SELECTOR: [u8; 4] = [165u8, 8u8, 87u8, 191u8];
17032            #[inline]
17033            fn new<'a>(
17034                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
17035            ) -> Self {
17036                tuple.into()
17037            }
17038            #[inline]
17039            fn tokenize(&self) -> Self::Token<'_> {
17040                (
17041                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
17042                        &self.quorumNumbers,
17043                    ),
17044                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
17045                        &self.socket,
17046                    ),
17047                    <IBLSApkRegistryTypes::PubkeyRegistrationParams as alloy_sol_types::SolType>::tokenize(
17048                        &self.params,
17049                    ),
17050                    <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy_sol_types::SolType>::tokenize(
17051                        &self.operatorSignature,
17052                    ),
17053                )
17054            }
17055            #[inline]
17056            fn abi_decode_returns(
17057                data: &[u8],
17058                validate: bool,
17059            ) -> alloy_sol_types::Result<Self::Return> {
17060                <Self::ReturnTuple<
17061                    '_,
17062                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
17063                    .map(Into::into)
17064            }
17065        }
17066    };
17067    #[derive(Default, Debug, PartialEq, Eq, Hash)]
17068    /**Function with signature `registerOperator(address,address,uint32[],bytes)` and selector `0xc63fd502`.
17069```solidity
17070function registerOperator(address operator, address avs, uint32[] memory operatorSetIds, bytes memory data) external;
17071```*/
17072    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
17073    #[derive(Clone)]
17074    pub struct registerOperator_1Call {
17075        #[allow(missing_docs)]
17076        pub operator: alloy::sol_types::private::Address,
17077        #[allow(missing_docs)]
17078        pub avs: alloy::sol_types::private::Address,
17079        #[allow(missing_docs)]
17080        pub operatorSetIds: alloy::sol_types::private::Vec<u32>,
17081        #[allow(missing_docs)]
17082        pub data: alloy::sol_types::private::Bytes,
17083    }
17084    ///Container type for the return parameters of the [`registerOperator(address,address,uint32[],bytes)`](registerOperator_1Call) function.
17085    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
17086    #[derive(Clone)]
17087    pub struct registerOperator_1Return {}
17088    #[allow(
17089        non_camel_case_types,
17090        non_snake_case,
17091        clippy::pub_underscore_fields,
17092        clippy::style
17093    )]
17094    const _: () = {
17095        use alloy::sol_types as alloy_sol_types;
17096        {
17097            #[doc(hidden)]
17098            type UnderlyingSolTuple<'a> = (
17099                alloy::sol_types::sol_data::Address,
17100                alloy::sol_types::sol_data::Address,
17101                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
17102                alloy::sol_types::sol_data::Bytes,
17103            );
17104            #[doc(hidden)]
17105            type UnderlyingRustTuple<'a> = (
17106                alloy::sol_types::private::Address,
17107                alloy::sol_types::private::Address,
17108                alloy::sol_types::private::Vec<u32>,
17109                alloy::sol_types::private::Bytes,
17110            );
17111            #[cfg(test)]
17112            #[allow(dead_code, unreachable_patterns)]
17113            fn _type_assertion(
17114                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
17115            ) {
17116                match _t {
17117                    alloy_sol_types::private::AssertTypeEq::<
17118                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
17119                    >(_) => {}
17120                }
17121            }
17122            #[automatically_derived]
17123            #[doc(hidden)]
17124            impl ::core::convert::From<registerOperator_1Call>
17125            for UnderlyingRustTuple<'_> {
17126                fn from(value: registerOperator_1Call) -> Self {
17127                    (value.operator, value.avs, value.operatorSetIds, value.data)
17128                }
17129            }
17130            #[automatically_derived]
17131            #[doc(hidden)]
17132            impl ::core::convert::From<UnderlyingRustTuple<'_>>
17133            for registerOperator_1Call {
17134                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
17135                    Self {
17136                        operator: tuple.0,
17137                        avs: tuple.1,
17138                        operatorSetIds: tuple.2,
17139                        data: tuple.3,
17140                    }
17141                }
17142            }
17143        }
17144        {
17145            #[doc(hidden)]
17146            type UnderlyingSolTuple<'a> = ();
17147            #[doc(hidden)]
17148            type UnderlyingRustTuple<'a> = ();
17149            #[cfg(test)]
17150            #[allow(dead_code, unreachable_patterns)]
17151            fn _type_assertion(
17152                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
17153            ) {
17154                match _t {
17155                    alloy_sol_types::private::AssertTypeEq::<
17156                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
17157                    >(_) => {}
17158                }
17159            }
17160            #[automatically_derived]
17161            #[doc(hidden)]
17162            impl ::core::convert::From<registerOperator_1Return>
17163            for UnderlyingRustTuple<'_> {
17164                fn from(value: registerOperator_1Return) -> Self {
17165                    ()
17166                }
17167            }
17168            #[automatically_derived]
17169            #[doc(hidden)]
17170            impl ::core::convert::From<UnderlyingRustTuple<'_>>
17171            for registerOperator_1Return {
17172                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
17173                    Self {}
17174                }
17175            }
17176        }
17177        #[automatically_derived]
17178        impl alloy_sol_types::SolCall for registerOperator_1Call {
17179            type Parameters<'a> = (
17180                alloy::sol_types::sol_data::Address,
17181                alloy::sol_types::sol_data::Address,
17182                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
17183                alloy::sol_types::sol_data::Bytes,
17184            );
17185            type Token<'a> = <Self::Parameters<
17186                'a,
17187            > as alloy_sol_types::SolType>::Token<'a>;
17188            type Return = registerOperator_1Return;
17189            type ReturnTuple<'a> = ();
17190            type ReturnToken<'a> = <Self::ReturnTuple<
17191                'a,
17192            > as alloy_sol_types::SolType>::Token<'a>;
17193            const SIGNATURE: &'static str = "registerOperator(address,address,uint32[],bytes)";
17194            const SELECTOR: [u8; 4] = [198u8, 63u8, 213u8, 2u8];
17195            #[inline]
17196            fn new<'a>(
17197                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
17198            ) -> Self {
17199                tuple.into()
17200            }
17201            #[inline]
17202            fn tokenize(&self) -> Self::Token<'_> {
17203                (
17204                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
17205                        &self.operator,
17206                    ),
17207                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
17208                        &self.avs,
17209                    ),
17210                    <alloy::sol_types::sol_data::Array<
17211                        alloy::sol_types::sol_data::Uint<32>,
17212                    > as alloy_sol_types::SolType>::tokenize(&self.operatorSetIds),
17213                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
17214                        &self.data,
17215                    ),
17216                )
17217            }
17218            #[inline]
17219            fn abi_decode_returns(
17220                data: &[u8],
17221                validate: bool,
17222            ) -> alloy_sol_types::Result<Self::Return> {
17223                <Self::ReturnTuple<
17224                    '_,
17225                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
17226                    .map(Into::into)
17227            }
17228        }
17229    };
17230    #[derive(Default, Debug, PartialEq, Eq, Hash)]
17231    /**Function with signature `registerOperatorWithChurn(bytes,string,((uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])),(uint8,address)[],(bytes,bytes32,uint256),(bytes,bytes32,uint256))` and selector `0x9b5d177b`.
17232```solidity
17233function registerOperatorWithChurn(bytes memory quorumNumbers, string memory socket, IBLSApkRegistryTypes.PubkeyRegistrationParams memory params, ISlashingRegistryCoordinatorTypes.OperatorKickParam[] memory operatorKickParams, ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry memory churnApproverSignature, ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry memory operatorSignature) external;
17234```*/
17235    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
17236    #[derive(Clone)]
17237    pub struct registerOperatorWithChurnCall {
17238        #[allow(missing_docs)]
17239        pub quorumNumbers: alloy::sol_types::private::Bytes,
17240        #[allow(missing_docs)]
17241        pub socket: alloy::sol_types::private::String,
17242        #[allow(missing_docs)]
17243        pub params: <IBLSApkRegistryTypes::PubkeyRegistrationParams as alloy::sol_types::SolType>::RustType,
17244        #[allow(missing_docs)]
17245        pub operatorKickParams: alloy::sol_types::private::Vec<
17246            <ISlashingRegistryCoordinatorTypes::OperatorKickParam as alloy::sol_types::SolType>::RustType,
17247        >,
17248        #[allow(missing_docs)]
17249        pub churnApproverSignature: <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy::sol_types::SolType>::RustType,
17250        #[allow(missing_docs)]
17251        pub operatorSignature: <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy::sol_types::SolType>::RustType,
17252    }
17253    ///Container type for the return parameters of the [`registerOperatorWithChurn(bytes,string,((uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])),(uint8,address)[],(bytes,bytes32,uint256),(bytes,bytes32,uint256))`](registerOperatorWithChurnCall) function.
17254    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
17255    #[derive(Clone)]
17256    pub struct registerOperatorWithChurnReturn {}
17257    #[allow(
17258        non_camel_case_types,
17259        non_snake_case,
17260        clippy::pub_underscore_fields,
17261        clippy::style
17262    )]
17263    const _: () = {
17264        use alloy::sol_types as alloy_sol_types;
17265        {
17266            #[doc(hidden)]
17267            type UnderlyingSolTuple<'a> = (
17268                alloy::sol_types::sol_data::Bytes,
17269                alloy::sol_types::sol_data::String,
17270                IBLSApkRegistryTypes::PubkeyRegistrationParams,
17271                alloy::sol_types::sol_data::Array<
17272                    ISlashingRegistryCoordinatorTypes::OperatorKickParam,
17273                >,
17274                ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry,
17275                ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry,
17276            );
17277            #[doc(hidden)]
17278            type UnderlyingRustTuple<'a> = (
17279                alloy::sol_types::private::Bytes,
17280                alloy::sol_types::private::String,
17281                <IBLSApkRegistryTypes::PubkeyRegistrationParams as alloy::sol_types::SolType>::RustType,
17282                alloy::sol_types::private::Vec<
17283                    <ISlashingRegistryCoordinatorTypes::OperatorKickParam as alloy::sol_types::SolType>::RustType,
17284                >,
17285                <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy::sol_types::SolType>::RustType,
17286                <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy::sol_types::SolType>::RustType,
17287            );
17288            #[cfg(test)]
17289            #[allow(dead_code, unreachable_patterns)]
17290            fn _type_assertion(
17291                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
17292            ) {
17293                match _t {
17294                    alloy_sol_types::private::AssertTypeEq::<
17295                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
17296                    >(_) => {}
17297                }
17298            }
17299            #[automatically_derived]
17300            #[doc(hidden)]
17301            impl ::core::convert::From<registerOperatorWithChurnCall>
17302            for UnderlyingRustTuple<'_> {
17303                fn from(value: registerOperatorWithChurnCall) -> Self {
17304                    (
17305                        value.quorumNumbers,
17306                        value.socket,
17307                        value.params,
17308                        value.operatorKickParams,
17309                        value.churnApproverSignature,
17310                        value.operatorSignature,
17311                    )
17312                }
17313            }
17314            #[automatically_derived]
17315            #[doc(hidden)]
17316            impl ::core::convert::From<UnderlyingRustTuple<'_>>
17317            for registerOperatorWithChurnCall {
17318                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
17319                    Self {
17320                        quorumNumbers: tuple.0,
17321                        socket: tuple.1,
17322                        params: tuple.2,
17323                        operatorKickParams: tuple.3,
17324                        churnApproverSignature: tuple.4,
17325                        operatorSignature: tuple.5,
17326                    }
17327                }
17328            }
17329        }
17330        {
17331            #[doc(hidden)]
17332            type UnderlyingSolTuple<'a> = ();
17333            #[doc(hidden)]
17334            type UnderlyingRustTuple<'a> = ();
17335            #[cfg(test)]
17336            #[allow(dead_code, unreachable_patterns)]
17337            fn _type_assertion(
17338                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
17339            ) {
17340                match _t {
17341                    alloy_sol_types::private::AssertTypeEq::<
17342                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
17343                    >(_) => {}
17344                }
17345            }
17346            #[automatically_derived]
17347            #[doc(hidden)]
17348            impl ::core::convert::From<registerOperatorWithChurnReturn>
17349            for UnderlyingRustTuple<'_> {
17350                fn from(value: registerOperatorWithChurnReturn) -> Self {
17351                    ()
17352                }
17353            }
17354            #[automatically_derived]
17355            #[doc(hidden)]
17356            impl ::core::convert::From<UnderlyingRustTuple<'_>>
17357            for registerOperatorWithChurnReturn {
17358                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
17359                    Self {}
17360                }
17361            }
17362        }
17363        #[automatically_derived]
17364        impl alloy_sol_types::SolCall for registerOperatorWithChurnCall {
17365            type Parameters<'a> = (
17366                alloy::sol_types::sol_data::Bytes,
17367                alloy::sol_types::sol_data::String,
17368                IBLSApkRegistryTypes::PubkeyRegistrationParams,
17369                alloy::sol_types::sol_data::Array<
17370                    ISlashingRegistryCoordinatorTypes::OperatorKickParam,
17371                >,
17372                ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry,
17373                ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry,
17374            );
17375            type Token<'a> = <Self::Parameters<
17376                'a,
17377            > as alloy_sol_types::SolType>::Token<'a>;
17378            type Return = registerOperatorWithChurnReturn;
17379            type ReturnTuple<'a> = ();
17380            type ReturnToken<'a> = <Self::ReturnTuple<
17381                'a,
17382            > as alloy_sol_types::SolType>::Token<'a>;
17383            const SIGNATURE: &'static str = "registerOperatorWithChurn(bytes,string,((uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])),(uint8,address)[],(bytes,bytes32,uint256),(bytes,bytes32,uint256))";
17384            const SELECTOR: [u8; 4] = [155u8, 93u8, 23u8, 123u8];
17385            #[inline]
17386            fn new<'a>(
17387                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
17388            ) -> Self {
17389                tuple.into()
17390            }
17391            #[inline]
17392            fn tokenize(&self) -> Self::Token<'_> {
17393                (
17394                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
17395                        &self.quorumNumbers,
17396                    ),
17397                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
17398                        &self.socket,
17399                    ),
17400                    <IBLSApkRegistryTypes::PubkeyRegistrationParams as alloy_sol_types::SolType>::tokenize(
17401                        &self.params,
17402                    ),
17403                    <alloy::sol_types::sol_data::Array<
17404                        ISlashingRegistryCoordinatorTypes::OperatorKickParam,
17405                    > as alloy_sol_types::SolType>::tokenize(&self.operatorKickParams),
17406                    <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy_sol_types::SolType>::tokenize(
17407                        &self.churnApproverSignature,
17408                    ),
17409                    <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy_sol_types::SolType>::tokenize(
17410                        &self.operatorSignature,
17411                    ),
17412                )
17413            }
17414            #[inline]
17415            fn abi_decode_returns(
17416                data: &[u8],
17417                validate: bool,
17418            ) -> alloy_sol_types::Result<Self::Return> {
17419                <Self::ReturnTuple<
17420                    '_,
17421                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
17422                    .map(Into::into)
17423            }
17424        }
17425    };
17426    #[derive(Default, Debug, PartialEq, Eq, Hash)]
17427    /**Function with signature `renounceOwnership()` and selector `0x715018a6`.
17428```solidity
17429function renounceOwnership() external;
17430```*/
17431    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
17432    #[derive(Clone)]
17433    pub struct renounceOwnershipCall {}
17434    ///Container type for the return parameters of the [`renounceOwnership()`](renounceOwnershipCall) function.
17435    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
17436    #[derive(Clone)]
17437    pub struct renounceOwnershipReturn {}
17438    #[allow(
17439        non_camel_case_types,
17440        non_snake_case,
17441        clippy::pub_underscore_fields,
17442        clippy::style
17443    )]
17444    const _: () = {
17445        use alloy::sol_types as alloy_sol_types;
17446        {
17447            #[doc(hidden)]
17448            type UnderlyingSolTuple<'a> = ();
17449            #[doc(hidden)]
17450            type UnderlyingRustTuple<'a> = ();
17451            #[cfg(test)]
17452            #[allow(dead_code, unreachable_patterns)]
17453            fn _type_assertion(
17454                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
17455            ) {
17456                match _t {
17457                    alloy_sol_types::private::AssertTypeEq::<
17458                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
17459                    >(_) => {}
17460                }
17461            }
17462            #[automatically_derived]
17463            #[doc(hidden)]
17464            impl ::core::convert::From<renounceOwnershipCall>
17465            for UnderlyingRustTuple<'_> {
17466                fn from(value: renounceOwnershipCall) -> Self {
17467                    ()
17468                }
17469            }
17470            #[automatically_derived]
17471            #[doc(hidden)]
17472            impl ::core::convert::From<UnderlyingRustTuple<'_>>
17473            for renounceOwnershipCall {
17474                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
17475                    Self {}
17476                }
17477            }
17478        }
17479        {
17480            #[doc(hidden)]
17481            type UnderlyingSolTuple<'a> = ();
17482            #[doc(hidden)]
17483            type UnderlyingRustTuple<'a> = ();
17484            #[cfg(test)]
17485            #[allow(dead_code, unreachable_patterns)]
17486            fn _type_assertion(
17487                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
17488            ) {
17489                match _t {
17490                    alloy_sol_types::private::AssertTypeEq::<
17491                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
17492                    >(_) => {}
17493                }
17494            }
17495            #[automatically_derived]
17496            #[doc(hidden)]
17497            impl ::core::convert::From<renounceOwnershipReturn>
17498            for UnderlyingRustTuple<'_> {
17499                fn from(value: renounceOwnershipReturn) -> Self {
17500                    ()
17501                }
17502            }
17503            #[automatically_derived]
17504            #[doc(hidden)]
17505            impl ::core::convert::From<UnderlyingRustTuple<'_>>
17506            for renounceOwnershipReturn {
17507                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
17508                    Self {}
17509                }
17510            }
17511        }
17512        #[automatically_derived]
17513        impl alloy_sol_types::SolCall for renounceOwnershipCall {
17514            type Parameters<'a> = ();
17515            type Token<'a> = <Self::Parameters<
17516                'a,
17517            > as alloy_sol_types::SolType>::Token<'a>;
17518            type Return = renounceOwnershipReturn;
17519            type ReturnTuple<'a> = ();
17520            type ReturnToken<'a> = <Self::ReturnTuple<
17521                'a,
17522            > as alloy_sol_types::SolType>::Token<'a>;
17523            const SIGNATURE: &'static str = "renounceOwnership()";
17524            const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
17525            #[inline]
17526            fn new<'a>(
17527                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
17528            ) -> Self {
17529                tuple.into()
17530            }
17531            #[inline]
17532            fn tokenize(&self) -> Self::Token<'_> {
17533                ()
17534            }
17535            #[inline]
17536            fn abi_decode_returns(
17537                data: &[u8],
17538                validate: bool,
17539            ) -> alloy_sol_types::Result<Self::Return> {
17540                <Self::ReturnTuple<
17541                    '_,
17542                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
17543                    .map(Into::into)
17544            }
17545        }
17546    };
17547    #[derive(Default, Debug, PartialEq, Eq, Hash)]
17548    /**Function with signature `serviceManager()` and selector `0x3998fdd3`.
17549```solidity
17550function serviceManager() external view returns (address);
17551```*/
17552    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
17553    #[derive(Clone)]
17554    pub struct serviceManagerCall {}
17555    #[derive(Default, Debug, PartialEq, Eq, Hash)]
17556    ///Container type for the return parameters of the [`serviceManager()`](serviceManagerCall) function.
17557    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
17558    #[derive(Clone)]
17559    pub struct serviceManagerReturn {
17560        #[allow(missing_docs)]
17561        pub _0: alloy::sol_types::private::Address,
17562    }
17563    #[allow(
17564        non_camel_case_types,
17565        non_snake_case,
17566        clippy::pub_underscore_fields,
17567        clippy::style
17568    )]
17569    const _: () = {
17570        use alloy::sol_types as alloy_sol_types;
17571        {
17572            #[doc(hidden)]
17573            type UnderlyingSolTuple<'a> = ();
17574            #[doc(hidden)]
17575            type UnderlyingRustTuple<'a> = ();
17576            #[cfg(test)]
17577            #[allow(dead_code, unreachable_patterns)]
17578            fn _type_assertion(
17579                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
17580            ) {
17581                match _t {
17582                    alloy_sol_types::private::AssertTypeEq::<
17583                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
17584                    >(_) => {}
17585                }
17586            }
17587            #[automatically_derived]
17588            #[doc(hidden)]
17589            impl ::core::convert::From<serviceManagerCall> for UnderlyingRustTuple<'_> {
17590                fn from(value: serviceManagerCall) -> Self {
17591                    ()
17592                }
17593            }
17594            #[automatically_derived]
17595            #[doc(hidden)]
17596            impl ::core::convert::From<UnderlyingRustTuple<'_>> for serviceManagerCall {
17597                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
17598                    Self {}
17599                }
17600            }
17601        }
17602        {
17603            #[doc(hidden)]
17604            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
17605            #[doc(hidden)]
17606            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
17607            #[cfg(test)]
17608            #[allow(dead_code, unreachable_patterns)]
17609            fn _type_assertion(
17610                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
17611            ) {
17612                match _t {
17613                    alloy_sol_types::private::AssertTypeEq::<
17614                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
17615                    >(_) => {}
17616                }
17617            }
17618            #[automatically_derived]
17619            #[doc(hidden)]
17620            impl ::core::convert::From<serviceManagerReturn>
17621            for UnderlyingRustTuple<'_> {
17622                fn from(value: serviceManagerReturn) -> Self {
17623                    (value._0,)
17624                }
17625            }
17626            #[automatically_derived]
17627            #[doc(hidden)]
17628            impl ::core::convert::From<UnderlyingRustTuple<'_>>
17629            for serviceManagerReturn {
17630                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
17631                    Self { _0: tuple.0 }
17632                }
17633            }
17634        }
17635        #[automatically_derived]
17636        impl alloy_sol_types::SolCall for serviceManagerCall {
17637            type Parameters<'a> = ();
17638            type Token<'a> = <Self::Parameters<
17639                'a,
17640            > as alloy_sol_types::SolType>::Token<'a>;
17641            type Return = serviceManagerReturn;
17642            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
17643            type ReturnToken<'a> = <Self::ReturnTuple<
17644                'a,
17645            > as alloy_sol_types::SolType>::Token<'a>;
17646            const SIGNATURE: &'static str = "serviceManager()";
17647            const SELECTOR: [u8; 4] = [57u8, 152u8, 253u8, 211u8];
17648            #[inline]
17649            fn new<'a>(
17650                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
17651            ) -> Self {
17652                tuple.into()
17653            }
17654            #[inline]
17655            fn tokenize(&self) -> Self::Token<'_> {
17656                ()
17657            }
17658            #[inline]
17659            fn abi_decode_returns(
17660                data: &[u8],
17661                validate: bool,
17662            ) -> alloy_sol_types::Result<Self::Return> {
17663                <Self::ReturnTuple<
17664                    '_,
17665                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
17666                    .map(Into::into)
17667            }
17668        }
17669    };
17670    #[derive(Default, Debug, PartialEq, Eq, Hash)]
17671    /**Function with signature `setAVS(address)` and selector `0xa65497c6`.
17672```solidity
17673function setAVS(address _avs) external;
17674```*/
17675    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
17676    #[derive(Clone)]
17677    pub struct setAVSCall {
17678        #[allow(missing_docs)]
17679        pub _avs: alloy::sol_types::private::Address,
17680    }
17681    ///Container type for the return parameters of the [`setAVS(address)`](setAVSCall) function.
17682    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
17683    #[derive(Clone)]
17684    pub struct setAVSReturn {}
17685    #[allow(
17686        non_camel_case_types,
17687        non_snake_case,
17688        clippy::pub_underscore_fields,
17689        clippy::style
17690    )]
17691    const _: () = {
17692        use alloy::sol_types as alloy_sol_types;
17693        {
17694            #[doc(hidden)]
17695            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
17696            #[doc(hidden)]
17697            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
17698            #[cfg(test)]
17699            #[allow(dead_code, unreachable_patterns)]
17700            fn _type_assertion(
17701                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
17702            ) {
17703                match _t {
17704                    alloy_sol_types::private::AssertTypeEq::<
17705                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
17706                    >(_) => {}
17707                }
17708            }
17709            #[automatically_derived]
17710            #[doc(hidden)]
17711            impl ::core::convert::From<setAVSCall> for UnderlyingRustTuple<'_> {
17712                fn from(value: setAVSCall) -> Self {
17713                    (value._avs,)
17714                }
17715            }
17716            #[automatically_derived]
17717            #[doc(hidden)]
17718            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAVSCall {
17719                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
17720                    Self { _avs: tuple.0 }
17721                }
17722            }
17723        }
17724        {
17725            #[doc(hidden)]
17726            type UnderlyingSolTuple<'a> = ();
17727            #[doc(hidden)]
17728            type UnderlyingRustTuple<'a> = ();
17729            #[cfg(test)]
17730            #[allow(dead_code, unreachable_patterns)]
17731            fn _type_assertion(
17732                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
17733            ) {
17734                match _t {
17735                    alloy_sol_types::private::AssertTypeEq::<
17736                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
17737                    >(_) => {}
17738                }
17739            }
17740            #[automatically_derived]
17741            #[doc(hidden)]
17742            impl ::core::convert::From<setAVSReturn> for UnderlyingRustTuple<'_> {
17743                fn from(value: setAVSReturn) -> Self {
17744                    ()
17745                }
17746            }
17747            #[automatically_derived]
17748            #[doc(hidden)]
17749            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAVSReturn {
17750                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
17751                    Self {}
17752                }
17753            }
17754        }
17755        #[automatically_derived]
17756        impl alloy_sol_types::SolCall for setAVSCall {
17757            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
17758            type Token<'a> = <Self::Parameters<
17759                'a,
17760            > as alloy_sol_types::SolType>::Token<'a>;
17761            type Return = setAVSReturn;
17762            type ReturnTuple<'a> = ();
17763            type ReturnToken<'a> = <Self::ReturnTuple<
17764                'a,
17765            > as alloy_sol_types::SolType>::Token<'a>;
17766            const SIGNATURE: &'static str = "setAVS(address)";
17767            const SELECTOR: [u8; 4] = [166u8, 84u8, 151u8, 198u8];
17768            #[inline]
17769            fn new<'a>(
17770                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
17771            ) -> Self {
17772                tuple.into()
17773            }
17774            #[inline]
17775            fn tokenize(&self) -> Self::Token<'_> {
17776                (
17777                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
17778                        &self._avs,
17779                    ),
17780                )
17781            }
17782            #[inline]
17783            fn abi_decode_returns(
17784                data: &[u8],
17785                validate: bool,
17786            ) -> alloy_sol_types::Result<Self::Return> {
17787                <Self::ReturnTuple<
17788                    '_,
17789                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
17790                    .map(Into::into)
17791            }
17792        }
17793    };
17794    #[derive(Default, Debug, PartialEq, Eq, Hash)]
17795    /**Function with signature `setChurnApprover(address)` and selector `0x29d1e0c3`.
17796```solidity
17797function setChurnApprover(address _churnApprover) external;
17798```*/
17799    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
17800    #[derive(Clone)]
17801    pub struct setChurnApproverCall {
17802        #[allow(missing_docs)]
17803        pub _churnApprover: alloy::sol_types::private::Address,
17804    }
17805    ///Container type for the return parameters of the [`setChurnApprover(address)`](setChurnApproverCall) function.
17806    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
17807    #[derive(Clone)]
17808    pub struct setChurnApproverReturn {}
17809    #[allow(
17810        non_camel_case_types,
17811        non_snake_case,
17812        clippy::pub_underscore_fields,
17813        clippy::style
17814    )]
17815    const _: () = {
17816        use alloy::sol_types as alloy_sol_types;
17817        {
17818            #[doc(hidden)]
17819            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
17820            #[doc(hidden)]
17821            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
17822            #[cfg(test)]
17823            #[allow(dead_code, unreachable_patterns)]
17824            fn _type_assertion(
17825                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
17826            ) {
17827                match _t {
17828                    alloy_sol_types::private::AssertTypeEq::<
17829                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
17830                    >(_) => {}
17831                }
17832            }
17833            #[automatically_derived]
17834            #[doc(hidden)]
17835            impl ::core::convert::From<setChurnApproverCall>
17836            for UnderlyingRustTuple<'_> {
17837                fn from(value: setChurnApproverCall) -> Self {
17838                    (value._churnApprover,)
17839                }
17840            }
17841            #[automatically_derived]
17842            #[doc(hidden)]
17843            impl ::core::convert::From<UnderlyingRustTuple<'_>>
17844            for setChurnApproverCall {
17845                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
17846                    Self { _churnApprover: tuple.0 }
17847                }
17848            }
17849        }
17850        {
17851            #[doc(hidden)]
17852            type UnderlyingSolTuple<'a> = ();
17853            #[doc(hidden)]
17854            type UnderlyingRustTuple<'a> = ();
17855            #[cfg(test)]
17856            #[allow(dead_code, unreachable_patterns)]
17857            fn _type_assertion(
17858                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
17859            ) {
17860                match _t {
17861                    alloy_sol_types::private::AssertTypeEq::<
17862                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
17863                    >(_) => {}
17864                }
17865            }
17866            #[automatically_derived]
17867            #[doc(hidden)]
17868            impl ::core::convert::From<setChurnApproverReturn>
17869            for UnderlyingRustTuple<'_> {
17870                fn from(value: setChurnApproverReturn) -> Self {
17871                    ()
17872                }
17873            }
17874            #[automatically_derived]
17875            #[doc(hidden)]
17876            impl ::core::convert::From<UnderlyingRustTuple<'_>>
17877            for setChurnApproverReturn {
17878                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
17879                    Self {}
17880                }
17881            }
17882        }
17883        #[automatically_derived]
17884        impl alloy_sol_types::SolCall for setChurnApproverCall {
17885            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
17886            type Token<'a> = <Self::Parameters<
17887                'a,
17888            > as alloy_sol_types::SolType>::Token<'a>;
17889            type Return = setChurnApproverReturn;
17890            type ReturnTuple<'a> = ();
17891            type ReturnToken<'a> = <Self::ReturnTuple<
17892                'a,
17893            > as alloy_sol_types::SolType>::Token<'a>;
17894            const SIGNATURE: &'static str = "setChurnApprover(address)";
17895            const SELECTOR: [u8; 4] = [41u8, 209u8, 224u8, 195u8];
17896            #[inline]
17897            fn new<'a>(
17898                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
17899            ) -> Self {
17900                tuple.into()
17901            }
17902            #[inline]
17903            fn tokenize(&self) -> Self::Token<'_> {
17904                (
17905                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
17906                        &self._churnApprover,
17907                    ),
17908                )
17909            }
17910            #[inline]
17911            fn abi_decode_returns(
17912                data: &[u8],
17913                validate: bool,
17914            ) -> alloy_sol_types::Result<Self::Return> {
17915                <Self::ReturnTuple<
17916                    '_,
17917                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
17918                    .map(Into::into)
17919            }
17920        }
17921    };
17922    #[derive(Default, Debug, PartialEq, Eq, Hash)]
17923    /**Function with signature `setEjectionCooldown(uint256)` and selector `0x0d3f2134`.
17924```solidity
17925function setEjectionCooldown(uint256 _ejectionCooldown) external;
17926```*/
17927    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
17928    #[derive(Clone)]
17929    pub struct setEjectionCooldownCall {
17930        #[allow(missing_docs)]
17931        pub _ejectionCooldown: alloy::sol_types::private::primitives::aliases::U256,
17932    }
17933    ///Container type for the return parameters of the [`setEjectionCooldown(uint256)`](setEjectionCooldownCall) function.
17934    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
17935    #[derive(Clone)]
17936    pub struct setEjectionCooldownReturn {}
17937    #[allow(
17938        non_camel_case_types,
17939        non_snake_case,
17940        clippy::pub_underscore_fields,
17941        clippy::style
17942    )]
17943    const _: () = {
17944        use alloy::sol_types as alloy_sol_types;
17945        {
17946            #[doc(hidden)]
17947            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
17948            #[doc(hidden)]
17949            type UnderlyingRustTuple<'a> = (
17950                alloy::sol_types::private::primitives::aliases::U256,
17951            );
17952            #[cfg(test)]
17953            #[allow(dead_code, unreachable_patterns)]
17954            fn _type_assertion(
17955                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
17956            ) {
17957                match _t {
17958                    alloy_sol_types::private::AssertTypeEq::<
17959                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
17960                    >(_) => {}
17961                }
17962            }
17963            #[automatically_derived]
17964            #[doc(hidden)]
17965            impl ::core::convert::From<setEjectionCooldownCall>
17966            for UnderlyingRustTuple<'_> {
17967                fn from(value: setEjectionCooldownCall) -> Self {
17968                    (value._ejectionCooldown,)
17969                }
17970            }
17971            #[automatically_derived]
17972            #[doc(hidden)]
17973            impl ::core::convert::From<UnderlyingRustTuple<'_>>
17974            for setEjectionCooldownCall {
17975                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
17976                    Self { _ejectionCooldown: tuple.0 }
17977                }
17978            }
17979        }
17980        {
17981            #[doc(hidden)]
17982            type UnderlyingSolTuple<'a> = ();
17983            #[doc(hidden)]
17984            type UnderlyingRustTuple<'a> = ();
17985            #[cfg(test)]
17986            #[allow(dead_code, unreachable_patterns)]
17987            fn _type_assertion(
17988                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
17989            ) {
17990                match _t {
17991                    alloy_sol_types::private::AssertTypeEq::<
17992                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
17993                    >(_) => {}
17994                }
17995            }
17996            #[automatically_derived]
17997            #[doc(hidden)]
17998            impl ::core::convert::From<setEjectionCooldownReturn>
17999            for UnderlyingRustTuple<'_> {
18000                fn from(value: setEjectionCooldownReturn) -> Self {
18001                    ()
18002                }
18003            }
18004            #[automatically_derived]
18005            #[doc(hidden)]
18006            impl ::core::convert::From<UnderlyingRustTuple<'_>>
18007            for setEjectionCooldownReturn {
18008                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
18009                    Self {}
18010                }
18011            }
18012        }
18013        #[automatically_derived]
18014        impl alloy_sol_types::SolCall for setEjectionCooldownCall {
18015            type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
18016            type Token<'a> = <Self::Parameters<
18017                'a,
18018            > as alloy_sol_types::SolType>::Token<'a>;
18019            type Return = setEjectionCooldownReturn;
18020            type ReturnTuple<'a> = ();
18021            type ReturnToken<'a> = <Self::ReturnTuple<
18022                'a,
18023            > as alloy_sol_types::SolType>::Token<'a>;
18024            const SIGNATURE: &'static str = "setEjectionCooldown(uint256)";
18025            const SELECTOR: [u8; 4] = [13u8, 63u8, 33u8, 52u8];
18026            #[inline]
18027            fn new<'a>(
18028                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
18029            ) -> Self {
18030                tuple.into()
18031            }
18032            #[inline]
18033            fn tokenize(&self) -> Self::Token<'_> {
18034                (
18035                    <alloy::sol_types::sol_data::Uint<
18036                        256,
18037                    > as alloy_sol_types::SolType>::tokenize(&self._ejectionCooldown),
18038                )
18039            }
18040            #[inline]
18041            fn abi_decode_returns(
18042                data: &[u8],
18043                validate: bool,
18044            ) -> alloy_sol_types::Result<Self::Return> {
18045                <Self::ReturnTuple<
18046                    '_,
18047                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
18048                    .map(Into::into)
18049            }
18050        }
18051    };
18052    #[derive(Default, Debug, PartialEq, Eq, Hash)]
18053    /**Function with signature `setEjector(address)` and selector `0x2cdd1e86`.
18054```solidity
18055function setEjector(address _ejector) external;
18056```*/
18057    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
18058    #[derive(Clone)]
18059    pub struct setEjectorCall {
18060        #[allow(missing_docs)]
18061        pub _ejector: alloy::sol_types::private::Address,
18062    }
18063    ///Container type for the return parameters of the [`setEjector(address)`](setEjectorCall) function.
18064    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
18065    #[derive(Clone)]
18066    pub struct setEjectorReturn {}
18067    #[allow(
18068        non_camel_case_types,
18069        non_snake_case,
18070        clippy::pub_underscore_fields,
18071        clippy::style
18072    )]
18073    const _: () = {
18074        use alloy::sol_types as alloy_sol_types;
18075        {
18076            #[doc(hidden)]
18077            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
18078            #[doc(hidden)]
18079            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
18080            #[cfg(test)]
18081            #[allow(dead_code, unreachable_patterns)]
18082            fn _type_assertion(
18083                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
18084            ) {
18085                match _t {
18086                    alloy_sol_types::private::AssertTypeEq::<
18087                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
18088                    >(_) => {}
18089                }
18090            }
18091            #[automatically_derived]
18092            #[doc(hidden)]
18093            impl ::core::convert::From<setEjectorCall> for UnderlyingRustTuple<'_> {
18094                fn from(value: setEjectorCall) -> Self {
18095                    (value._ejector,)
18096                }
18097            }
18098            #[automatically_derived]
18099            #[doc(hidden)]
18100            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setEjectorCall {
18101                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
18102                    Self { _ejector: tuple.0 }
18103                }
18104            }
18105        }
18106        {
18107            #[doc(hidden)]
18108            type UnderlyingSolTuple<'a> = ();
18109            #[doc(hidden)]
18110            type UnderlyingRustTuple<'a> = ();
18111            #[cfg(test)]
18112            #[allow(dead_code, unreachable_patterns)]
18113            fn _type_assertion(
18114                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
18115            ) {
18116                match _t {
18117                    alloy_sol_types::private::AssertTypeEq::<
18118                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
18119                    >(_) => {}
18120                }
18121            }
18122            #[automatically_derived]
18123            #[doc(hidden)]
18124            impl ::core::convert::From<setEjectorReturn> for UnderlyingRustTuple<'_> {
18125                fn from(value: setEjectorReturn) -> Self {
18126                    ()
18127                }
18128            }
18129            #[automatically_derived]
18130            #[doc(hidden)]
18131            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setEjectorReturn {
18132                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
18133                    Self {}
18134                }
18135            }
18136        }
18137        #[automatically_derived]
18138        impl alloy_sol_types::SolCall for setEjectorCall {
18139            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
18140            type Token<'a> = <Self::Parameters<
18141                'a,
18142            > as alloy_sol_types::SolType>::Token<'a>;
18143            type Return = setEjectorReturn;
18144            type ReturnTuple<'a> = ();
18145            type ReturnToken<'a> = <Self::ReturnTuple<
18146                'a,
18147            > as alloy_sol_types::SolType>::Token<'a>;
18148            const SIGNATURE: &'static str = "setEjector(address)";
18149            const SELECTOR: [u8; 4] = [44u8, 221u8, 30u8, 134u8];
18150            #[inline]
18151            fn new<'a>(
18152                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
18153            ) -> Self {
18154                tuple.into()
18155            }
18156            #[inline]
18157            fn tokenize(&self) -> Self::Token<'_> {
18158                (
18159                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
18160                        &self._ejector,
18161                    ),
18162                )
18163            }
18164            #[inline]
18165            fn abi_decode_returns(
18166                data: &[u8],
18167                validate: bool,
18168            ) -> alloy_sol_types::Result<Self::Return> {
18169                <Self::ReturnTuple<
18170                    '_,
18171                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
18172                    .map(Into::into)
18173            }
18174        }
18175    };
18176    #[derive(Default, Debug, PartialEq, Eq, Hash)]
18177    /**Function with signature `setOperatorSetParams(uint8,(uint32,uint16,uint16))` and selector `0x5b0b829f`.
18178```solidity
18179function setOperatorSetParams(uint8 quorumNumber, ISlashingRegistryCoordinatorTypes.OperatorSetParam memory operatorSetParams) external;
18180```*/
18181    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
18182    #[derive(Clone)]
18183    pub struct setOperatorSetParamsCall {
18184        #[allow(missing_docs)]
18185        pub quorumNumber: u8,
18186        #[allow(missing_docs)]
18187        pub operatorSetParams: <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
18188    }
18189    ///Container type for the return parameters of the [`setOperatorSetParams(uint8,(uint32,uint16,uint16))`](setOperatorSetParamsCall) function.
18190    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
18191    #[derive(Clone)]
18192    pub struct setOperatorSetParamsReturn {}
18193    #[allow(
18194        non_camel_case_types,
18195        non_snake_case,
18196        clippy::pub_underscore_fields,
18197        clippy::style
18198    )]
18199    const _: () = {
18200        use alloy::sol_types as alloy_sol_types;
18201        {
18202            #[doc(hidden)]
18203            type UnderlyingSolTuple<'a> = (
18204                alloy::sol_types::sol_data::Uint<8>,
18205                ISlashingRegistryCoordinatorTypes::OperatorSetParam,
18206            );
18207            #[doc(hidden)]
18208            type UnderlyingRustTuple<'a> = (
18209                u8,
18210                <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
18211            );
18212            #[cfg(test)]
18213            #[allow(dead_code, unreachable_patterns)]
18214            fn _type_assertion(
18215                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
18216            ) {
18217                match _t {
18218                    alloy_sol_types::private::AssertTypeEq::<
18219                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
18220                    >(_) => {}
18221                }
18222            }
18223            #[automatically_derived]
18224            #[doc(hidden)]
18225            impl ::core::convert::From<setOperatorSetParamsCall>
18226            for UnderlyingRustTuple<'_> {
18227                fn from(value: setOperatorSetParamsCall) -> Self {
18228                    (value.quorumNumber, value.operatorSetParams)
18229                }
18230            }
18231            #[automatically_derived]
18232            #[doc(hidden)]
18233            impl ::core::convert::From<UnderlyingRustTuple<'_>>
18234            for setOperatorSetParamsCall {
18235                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
18236                    Self {
18237                        quorumNumber: tuple.0,
18238                        operatorSetParams: tuple.1,
18239                    }
18240                }
18241            }
18242        }
18243        {
18244            #[doc(hidden)]
18245            type UnderlyingSolTuple<'a> = ();
18246            #[doc(hidden)]
18247            type UnderlyingRustTuple<'a> = ();
18248            #[cfg(test)]
18249            #[allow(dead_code, unreachable_patterns)]
18250            fn _type_assertion(
18251                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
18252            ) {
18253                match _t {
18254                    alloy_sol_types::private::AssertTypeEq::<
18255                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
18256                    >(_) => {}
18257                }
18258            }
18259            #[automatically_derived]
18260            #[doc(hidden)]
18261            impl ::core::convert::From<setOperatorSetParamsReturn>
18262            for UnderlyingRustTuple<'_> {
18263                fn from(value: setOperatorSetParamsReturn) -> Self {
18264                    ()
18265                }
18266            }
18267            #[automatically_derived]
18268            #[doc(hidden)]
18269            impl ::core::convert::From<UnderlyingRustTuple<'_>>
18270            for setOperatorSetParamsReturn {
18271                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
18272                    Self {}
18273                }
18274            }
18275        }
18276        #[automatically_derived]
18277        impl alloy_sol_types::SolCall for setOperatorSetParamsCall {
18278            type Parameters<'a> = (
18279                alloy::sol_types::sol_data::Uint<8>,
18280                ISlashingRegistryCoordinatorTypes::OperatorSetParam,
18281            );
18282            type Token<'a> = <Self::Parameters<
18283                'a,
18284            > as alloy_sol_types::SolType>::Token<'a>;
18285            type Return = setOperatorSetParamsReturn;
18286            type ReturnTuple<'a> = ();
18287            type ReturnToken<'a> = <Self::ReturnTuple<
18288                'a,
18289            > as alloy_sol_types::SolType>::Token<'a>;
18290            const SIGNATURE: &'static str = "setOperatorSetParams(uint8,(uint32,uint16,uint16))";
18291            const SELECTOR: [u8; 4] = [91u8, 11u8, 130u8, 159u8];
18292            #[inline]
18293            fn new<'a>(
18294                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
18295            ) -> Self {
18296                tuple.into()
18297            }
18298            #[inline]
18299            fn tokenize(&self) -> Self::Token<'_> {
18300                (
18301                    <alloy::sol_types::sol_data::Uint<
18302                        8,
18303                    > as alloy_sol_types::SolType>::tokenize(&self.quorumNumber),
18304                    <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy_sol_types::SolType>::tokenize(
18305                        &self.operatorSetParams,
18306                    ),
18307                )
18308            }
18309            #[inline]
18310            fn abi_decode_returns(
18311                data: &[u8],
18312                validate: bool,
18313            ) -> alloy_sol_types::Result<Self::Return> {
18314                <Self::ReturnTuple<
18315                    '_,
18316                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
18317                    .map(Into::into)
18318            }
18319        }
18320    };
18321    #[derive(Default, Debug, PartialEq, Eq, Hash)]
18322    /**Function with signature `socketRegistry()` and selector `0xea32afae`.
18323```solidity
18324function socketRegistry() external view returns (address);
18325```*/
18326    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
18327    #[derive(Clone)]
18328    pub struct socketRegistryCall {}
18329    #[derive(Default, Debug, PartialEq, Eq, Hash)]
18330    ///Container type for the return parameters of the [`socketRegistry()`](socketRegistryCall) function.
18331    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
18332    #[derive(Clone)]
18333    pub struct socketRegistryReturn {
18334        #[allow(missing_docs)]
18335        pub _0: alloy::sol_types::private::Address,
18336    }
18337    #[allow(
18338        non_camel_case_types,
18339        non_snake_case,
18340        clippy::pub_underscore_fields,
18341        clippy::style
18342    )]
18343    const _: () = {
18344        use alloy::sol_types as alloy_sol_types;
18345        {
18346            #[doc(hidden)]
18347            type UnderlyingSolTuple<'a> = ();
18348            #[doc(hidden)]
18349            type UnderlyingRustTuple<'a> = ();
18350            #[cfg(test)]
18351            #[allow(dead_code, unreachable_patterns)]
18352            fn _type_assertion(
18353                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
18354            ) {
18355                match _t {
18356                    alloy_sol_types::private::AssertTypeEq::<
18357                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
18358                    >(_) => {}
18359                }
18360            }
18361            #[automatically_derived]
18362            #[doc(hidden)]
18363            impl ::core::convert::From<socketRegistryCall> for UnderlyingRustTuple<'_> {
18364                fn from(value: socketRegistryCall) -> Self {
18365                    ()
18366                }
18367            }
18368            #[automatically_derived]
18369            #[doc(hidden)]
18370            impl ::core::convert::From<UnderlyingRustTuple<'_>> for socketRegistryCall {
18371                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
18372                    Self {}
18373                }
18374            }
18375        }
18376        {
18377            #[doc(hidden)]
18378            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
18379            #[doc(hidden)]
18380            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
18381            #[cfg(test)]
18382            #[allow(dead_code, unreachable_patterns)]
18383            fn _type_assertion(
18384                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
18385            ) {
18386                match _t {
18387                    alloy_sol_types::private::AssertTypeEq::<
18388                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
18389                    >(_) => {}
18390                }
18391            }
18392            #[automatically_derived]
18393            #[doc(hidden)]
18394            impl ::core::convert::From<socketRegistryReturn>
18395            for UnderlyingRustTuple<'_> {
18396                fn from(value: socketRegistryReturn) -> Self {
18397                    (value._0,)
18398                }
18399            }
18400            #[automatically_derived]
18401            #[doc(hidden)]
18402            impl ::core::convert::From<UnderlyingRustTuple<'_>>
18403            for socketRegistryReturn {
18404                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
18405                    Self { _0: tuple.0 }
18406                }
18407            }
18408        }
18409        #[automatically_derived]
18410        impl alloy_sol_types::SolCall for socketRegistryCall {
18411            type Parameters<'a> = ();
18412            type Token<'a> = <Self::Parameters<
18413                'a,
18414            > as alloy_sol_types::SolType>::Token<'a>;
18415            type Return = socketRegistryReturn;
18416            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
18417            type ReturnToken<'a> = <Self::ReturnTuple<
18418                'a,
18419            > as alloy_sol_types::SolType>::Token<'a>;
18420            const SIGNATURE: &'static str = "socketRegistry()";
18421            const SELECTOR: [u8; 4] = [234u8, 50u8, 175u8, 174u8];
18422            #[inline]
18423            fn new<'a>(
18424                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
18425            ) -> Self {
18426                tuple.into()
18427            }
18428            #[inline]
18429            fn tokenize(&self) -> Self::Token<'_> {
18430                ()
18431            }
18432            #[inline]
18433            fn abi_decode_returns(
18434                data: &[u8],
18435                validate: bool,
18436            ) -> alloy_sol_types::Result<Self::Return> {
18437                <Self::ReturnTuple<
18438                    '_,
18439                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
18440                    .map(Into::into)
18441            }
18442        }
18443    };
18444    #[derive(Default, Debug, PartialEq, Eq, Hash)]
18445    /**Function with signature `stakeRegistry()` and selector `0x68304835`.
18446```solidity
18447function stakeRegistry() external view returns (address);
18448```*/
18449    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
18450    #[derive(Clone)]
18451    pub struct stakeRegistryCall {}
18452    #[derive(Default, Debug, PartialEq, Eq, Hash)]
18453    ///Container type for the return parameters of the [`stakeRegistry()`](stakeRegistryCall) function.
18454    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
18455    #[derive(Clone)]
18456    pub struct stakeRegistryReturn {
18457        #[allow(missing_docs)]
18458        pub _0: alloy::sol_types::private::Address,
18459    }
18460    #[allow(
18461        non_camel_case_types,
18462        non_snake_case,
18463        clippy::pub_underscore_fields,
18464        clippy::style
18465    )]
18466    const _: () = {
18467        use alloy::sol_types as alloy_sol_types;
18468        {
18469            #[doc(hidden)]
18470            type UnderlyingSolTuple<'a> = ();
18471            #[doc(hidden)]
18472            type UnderlyingRustTuple<'a> = ();
18473            #[cfg(test)]
18474            #[allow(dead_code, unreachable_patterns)]
18475            fn _type_assertion(
18476                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
18477            ) {
18478                match _t {
18479                    alloy_sol_types::private::AssertTypeEq::<
18480                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
18481                    >(_) => {}
18482                }
18483            }
18484            #[automatically_derived]
18485            #[doc(hidden)]
18486            impl ::core::convert::From<stakeRegistryCall> for UnderlyingRustTuple<'_> {
18487                fn from(value: stakeRegistryCall) -> Self {
18488                    ()
18489                }
18490            }
18491            #[automatically_derived]
18492            #[doc(hidden)]
18493            impl ::core::convert::From<UnderlyingRustTuple<'_>> for stakeRegistryCall {
18494                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
18495                    Self {}
18496                }
18497            }
18498        }
18499        {
18500            #[doc(hidden)]
18501            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
18502            #[doc(hidden)]
18503            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
18504            #[cfg(test)]
18505            #[allow(dead_code, unreachable_patterns)]
18506            fn _type_assertion(
18507                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
18508            ) {
18509                match _t {
18510                    alloy_sol_types::private::AssertTypeEq::<
18511                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
18512                    >(_) => {}
18513                }
18514            }
18515            #[automatically_derived]
18516            #[doc(hidden)]
18517            impl ::core::convert::From<stakeRegistryReturn> for UnderlyingRustTuple<'_> {
18518                fn from(value: stakeRegistryReturn) -> Self {
18519                    (value._0,)
18520                }
18521            }
18522            #[automatically_derived]
18523            #[doc(hidden)]
18524            impl ::core::convert::From<UnderlyingRustTuple<'_>> for stakeRegistryReturn {
18525                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
18526                    Self { _0: tuple.0 }
18527                }
18528            }
18529        }
18530        #[automatically_derived]
18531        impl alloy_sol_types::SolCall for stakeRegistryCall {
18532            type Parameters<'a> = ();
18533            type Token<'a> = <Self::Parameters<
18534                'a,
18535            > as alloy_sol_types::SolType>::Token<'a>;
18536            type Return = stakeRegistryReturn;
18537            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
18538            type ReturnToken<'a> = <Self::ReturnTuple<
18539                'a,
18540            > as alloy_sol_types::SolType>::Token<'a>;
18541            const SIGNATURE: &'static str = "stakeRegistry()";
18542            const SELECTOR: [u8; 4] = [104u8, 48u8, 72u8, 53u8];
18543            #[inline]
18544            fn new<'a>(
18545                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
18546            ) -> Self {
18547                tuple.into()
18548            }
18549            #[inline]
18550            fn tokenize(&self) -> Self::Token<'_> {
18551                ()
18552            }
18553            #[inline]
18554            fn abi_decode_returns(
18555                data: &[u8],
18556                validate: bool,
18557            ) -> alloy_sol_types::Result<Self::Return> {
18558                <Self::ReturnTuple<
18559                    '_,
18560                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
18561                    .map(Into::into)
18562            }
18563        }
18564    };
18565    #[derive(Default, Debug, PartialEq, Eq, Hash)]
18566    /**Function with signature `supportsAVS(address)` and selector `0xb5265787`.
18567```solidity
18568function supportsAVS(address _avs) external view returns (bool);
18569```*/
18570    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
18571    #[derive(Clone)]
18572    pub struct supportsAVSCall {
18573        #[allow(missing_docs)]
18574        pub _avs: alloy::sol_types::private::Address,
18575    }
18576    #[derive(Default, Debug, PartialEq, Eq, Hash)]
18577    ///Container type for the return parameters of the [`supportsAVS(address)`](supportsAVSCall) function.
18578    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
18579    #[derive(Clone)]
18580    pub struct supportsAVSReturn {
18581        #[allow(missing_docs)]
18582        pub _0: bool,
18583    }
18584    #[allow(
18585        non_camel_case_types,
18586        non_snake_case,
18587        clippy::pub_underscore_fields,
18588        clippy::style
18589    )]
18590    const _: () = {
18591        use alloy::sol_types as alloy_sol_types;
18592        {
18593            #[doc(hidden)]
18594            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
18595            #[doc(hidden)]
18596            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
18597            #[cfg(test)]
18598            #[allow(dead_code, unreachable_patterns)]
18599            fn _type_assertion(
18600                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
18601            ) {
18602                match _t {
18603                    alloy_sol_types::private::AssertTypeEq::<
18604                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
18605                    >(_) => {}
18606                }
18607            }
18608            #[automatically_derived]
18609            #[doc(hidden)]
18610            impl ::core::convert::From<supportsAVSCall> for UnderlyingRustTuple<'_> {
18611                fn from(value: supportsAVSCall) -> Self {
18612                    (value._avs,)
18613                }
18614            }
18615            #[automatically_derived]
18616            #[doc(hidden)]
18617            impl ::core::convert::From<UnderlyingRustTuple<'_>> for supportsAVSCall {
18618                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
18619                    Self { _avs: tuple.0 }
18620                }
18621            }
18622        }
18623        {
18624            #[doc(hidden)]
18625            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
18626            #[doc(hidden)]
18627            type UnderlyingRustTuple<'a> = (bool,);
18628            #[cfg(test)]
18629            #[allow(dead_code, unreachable_patterns)]
18630            fn _type_assertion(
18631                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
18632            ) {
18633                match _t {
18634                    alloy_sol_types::private::AssertTypeEq::<
18635                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
18636                    >(_) => {}
18637                }
18638            }
18639            #[automatically_derived]
18640            #[doc(hidden)]
18641            impl ::core::convert::From<supportsAVSReturn> for UnderlyingRustTuple<'_> {
18642                fn from(value: supportsAVSReturn) -> Self {
18643                    (value._0,)
18644                }
18645            }
18646            #[automatically_derived]
18647            #[doc(hidden)]
18648            impl ::core::convert::From<UnderlyingRustTuple<'_>> for supportsAVSReturn {
18649                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
18650                    Self { _0: tuple.0 }
18651                }
18652            }
18653        }
18654        #[automatically_derived]
18655        impl alloy_sol_types::SolCall for supportsAVSCall {
18656            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
18657            type Token<'a> = <Self::Parameters<
18658                'a,
18659            > as alloy_sol_types::SolType>::Token<'a>;
18660            type Return = supportsAVSReturn;
18661            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
18662            type ReturnToken<'a> = <Self::ReturnTuple<
18663                'a,
18664            > as alloy_sol_types::SolType>::Token<'a>;
18665            const SIGNATURE: &'static str = "supportsAVS(address)";
18666            const SELECTOR: [u8; 4] = [181u8, 38u8, 87u8, 135u8];
18667            #[inline]
18668            fn new<'a>(
18669                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
18670            ) -> Self {
18671                tuple.into()
18672            }
18673            #[inline]
18674            fn tokenize(&self) -> Self::Token<'_> {
18675                (
18676                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
18677                        &self._avs,
18678                    ),
18679                )
18680            }
18681            #[inline]
18682            fn abi_decode_returns(
18683                data: &[u8],
18684                validate: bool,
18685            ) -> alloy_sol_types::Result<Self::Return> {
18686                <Self::ReturnTuple<
18687                    '_,
18688                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
18689                    .map(Into::into)
18690            }
18691        }
18692    };
18693    #[derive(Default, Debug, PartialEq, Eq, Hash)]
18694    /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`.
18695```solidity
18696function transferOwnership(address newOwner) external;
18697```*/
18698    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
18699    #[derive(Clone)]
18700    pub struct transferOwnershipCall {
18701        #[allow(missing_docs)]
18702        pub newOwner: alloy::sol_types::private::Address,
18703    }
18704    ///Container type for the return parameters of the [`transferOwnership(address)`](transferOwnershipCall) function.
18705    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
18706    #[derive(Clone)]
18707    pub struct transferOwnershipReturn {}
18708    #[allow(
18709        non_camel_case_types,
18710        non_snake_case,
18711        clippy::pub_underscore_fields,
18712        clippy::style
18713    )]
18714    const _: () = {
18715        use alloy::sol_types as alloy_sol_types;
18716        {
18717            #[doc(hidden)]
18718            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
18719            #[doc(hidden)]
18720            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
18721            #[cfg(test)]
18722            #[allow(dead_code, unreachable_patterns)]
18723            fn _type_assertion(
18724                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
18725            ) {
18726                match _t {
18727                    alloy_sol_types::private::AssertTypeEq::<
18728                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
18729                    >(_) => {}
18730                }
18731            }
18732            #[automatically_derived]
18733            #[doc(hidden)]
18734            impl ::core::convert::From<transferOwnershipCall>
18735            for UnderlyingRustTuple<'_> {
18736                fn from(value: transferOwnershipCall) -> Self {
18737                    (value.newOwner,)
18738                }
18739            }
18740            #[automatically_derived]
18741            #[doc(hidden)]
18742            impl ::core::convert::From<UnderlyingRustTuple<'_>>
18743            for transferOwnershipCall {
18744                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
18745                    Self { newOwner: tuple.0 }
18746                }
18747            }
18748        }
18749        {
18750            #[doc(hidden)]
18751            type UnderlyingSolTuple<'a> = ();
18752            #[doc(hidden)]
18753            type UnderlyingRustTuple<'a> = ();
18754            #[cfg(test)]
18755            #[allow(dead_code, unreachable_patterns)]
18756            fn _type_assertion(
18757                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
18758            ) {
18759                match _t {
18760                    alloy_sol_types::private::AssertTypeEq::<
18761                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
18762                    >(_) => {}
18763                }
18764            }
18765            #[automatically_derived]
18766            #[doc(hidden)]
18767            impl ::core::convert::From<transferOwnershipReturn>
18768            for UnderlyingRustTuple<'_> {
18769                fn from(value: transferOwnershipReturn) -> Self {
18770                    ()
18771                }
18772            }
18773            #[automatically_derived]
18774            #[doc(hidden)]
18775            impl ::core::convert::From<UnderlyingRustTuple<'_>>
18776            for transferOwnershipReturn {
18777                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
18778                    Self {}
18779                }
18780            }
18781        }
18782        #[automatically_derived]
18783        impl alloy_sol_types::SolCall for transferOwnershipCall {
18784            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
18785            type Token<'a> = <Self::Parameters<
18786                'a,
18787            > as alloy_sol_types::SolType>::Token<'a>;
18788            type Return = transferOwnershipReturn;
18789            type ReturnTuple<'a> = ();
18790            type ReturnToken<'a> = <Self::ReturnTuple<
18791                'a,
18792            > as alloy_sol_types::SolType>::Token<'a>;
18793            const SIGNATURE: &'static str = "transferOwnership(address)";
18794            const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
18795            #[inline]
18796            fn new<'a>(
18797                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
18798            ) -> Self {
18799                tuple.into()
18800            }
18801            #[inline]
18802            fn tokenize(&self) -> Self::Token<'_> {
18803                (
18804                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
18805                        &self.newOwner,
18806                    ),
18807                )
18808            }
18809            #[inline]
18810            fn abi_decode_returns(
18811                data: &[u8],
18812                validate: bool,
18813            ) -> alloy_sol_types::Result<Self::Return> {
18814                <Self::ReturnTuple<
18815                    '_,
18816                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
18817                    .map(Into::into)
18818            }
18819        }
18820    };
18821    #[derive(Default, Debug, PartialEq, Eq, Hash)]
18822    /**Function with signature `unpause(uint256)` and selector `0xfabc1cbc`.
18823```solidity
18824function unpause(uint256 newPausedStatus) external;
18825```*/
18826    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
18827    #[derive(Clone)]
18828    pub struct unpauseCall {
18829        #[allow(missing_docs)]
18830        pub newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
18831    }
18832    ///Container type for the return parameters of the [`unpause(uint256)`](unpauseCall) function.
18833    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
18834    #[derive(Clone)]
18835    pub struct unpauseReturn {}
18836    #[allow(
18837        non_camel_case_types,
18838        non_snake_case,
18839        clippy::pub_underscore_fields,
18840        clippy::style
18841    )]
18842    const _: () = {
18843        use alloy::sol_types as alloy_sol_types;
18844        {
18845            #[doc(hidden)]
18846            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
18847            #[doc(hidden)]
18848            type UnderlyingRustTuple<'a> = (
18849                alloy::sol_types::private::primitives::aliases::U256,
18850            );
18851            #[cfg(test)]
18852            #[allow(dead_code, unreachable_patterns)]
18853            fn _type_assertion(
18854                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
18855            ) {
18856                match _t {
18857                    alloy_sol_types::private::AssertTypeEq::<
18858                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
18859                    >(_) => {}
18860                }
18861            }
18862            #[automatically_derived]
18863            #[doc(hidden)]
18864            impl ::core::convert::From<unpauseCall> for UnderlyingRustTuple<'_> {
18865                fn from(value: unpauseCall) -> Self {
18866                    (value.newPausedStatus,)
18867                }
18868            }
18869            #[automatically_derived]
18870            #[doc(hidden)]
18871            impl ::core::convert::From<UnderlyingRustTuple<'_>> for unpauseCall {
18872                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
18873                    Self { newPausedStatus: tuple.0 }
18874                }
18875            }
18876        }
18877        {
18878            #[doc(hidden)]
18879            type UnderlyingSolTuple<'a> = ();
18880            #[doc(hidden)]
18881            type UnderlyingRustTuple<'a> = ();
18882            #[cfg(test)]
18883            #[allow(dead_code, unreachable_patterns)]
18884            fn _type_assertion(
18885                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
18886            ) {
18887                match _t {
18888                    alloy_sol_types::private::AssertTypeEq::<
18889                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
18890                    >(_) => {}
18891                }
18892            }
18893            #[automatically_derived]
18894            #[doc(hidden)]
18895            impl ::core::convert::From<unpauseReturn> for UnderlyingRustTuple<'_> {
18896                fn from(value: unpauseReturn) -> Self {
18897                    ()
18898                }
18899            }
18900            #[automatically_derived]
18901            #[doc(hidden)]
18902            impl ::core::convert::From<UnderlyingRustTuple<'_>> for unpauseReturn {
18903                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
18904                    Self {}
18905                }
18906            }
18907        }
18908        #[automatically_derived]
18909        impl alloy_sol_types::SolCall for unpauseCall {
18910            type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
18911            type Token<'a> = <Self::Parameters<
18912                'a,
18913            > as alloy_sol_types::SolType>::Token<'a>;
18914            type Return = unpauseReturn;
18915            type ReturnTuple<'a> = ();
18916            type ReturnToken<'a> = <Self::ReturnTuple<
18917                'a,
18918            > as alloy_sol_types::SolType>::Token<'a>;
18919            const SIGNATURE: &'static str = "unpause(uint256)";
18920            const SELECTOR: [u8; 4] = [250u8, 188u8, 28u8, 188u8];
18921            #[inline]
18922            fn new<'a>(
18923                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
18924            ) -> Self {
18925                tuple.into()
18926            }
18927            #[inline]
18928            fn tokenize(&self) -> Self::Token<'_> {
18929                (
18930                    <alloy::sol_types::sol_data::Uint<
18931                        256,
18932                    > as alloy_sol_types::SolType>::tokenize(&self.newPausedStatus),
18933                )
18934            }
18935            #[inline]
18936            fn abi_decode_returns(
18937                data: &[u8],
18938                validate: bool,
18939            ) -> alloy_sol_types::Result<Self::Return> {
18940                <Self::ReturnTuple<
18941                    '_,
18942                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
18943                    .map(Into::into)
18944            }
18945        }
18946    };
18947    #[derive(Default, Debug, PartialEq, Eq, Hash)]
18948    /**Function with signature `updateOperators(address[])` and selector `0x00cf2ab5`.
18949```solidity
18950function updateOperators(address[] memory operators) external;
18951```*/
18952    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
18953    #[derive(Clone)]
18954    pub struct updateOperatorsCall {
18955        #[allow(missing_docs)]
18956        pub operators: alloy::sol_types::private::Vec<
18957            alloy::sol_types::private::Address,
18958        >,
18959    }
18960    ///Container type for the return parameters of the [`updateOperators(address[])`](updateOperatorsCall) function.
18961    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
18962    #[derive(Clone)]
18963    pub struct updateOperatorsReturn {}
18964    #[allow(
18965        non_camel_case_types,
18966        non_snake_case,
18967        clippy::pub_underscore_fields,
18968        clippy::style
18969    )]
18970    const _: () = {
18971        use alloy::sol_types as alloy_sol_types;
18972        {
18973            #[doc(hidden)]
18974            type UnderlyingSolTuple<'a> = (
18975                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
18976            );
18977            #[doc(hidden)]
18978            type UnderlyingRustTuple<'a> = (
18979                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
18980            );
18981            #[cfg(test)]
18982            #[allow(dead_code, unreachable_patterns)]
18983            fn _type_assertion(
18984                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
18985            ) {
18986                match _t {
18987                    alloy_sol_types::private::AssertTypeEq::<
18988                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
18989                    >(_) => {}
18990                }
18991            }
18992            #[automatically_derived]
18993            #[doc(hidden)]
18994            impl ::core::convert::From<updateOperatorsCall> for UnderlyingRustTuple<'_> {
18995                fn from(value: updateOperatorsCall) -> Self {
18996                    (value.operators,)
18997                }
18998            }
18999            #[automatically_derived]
19000            #[doc(hidden)]
19001            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateOperatorsCall {
19002                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
19003                    Self { operators: tuple.0 }
19004                }
19005            }
19006        }
19007        {
19008            #[doc(hidden)]
19009            type UnderlyingSolTuple<'a> = ();
19010            #[doc(hidden)]
19011            type UnderlyingRustTuple<'a> = ();
19012            #[cfg(test)]
19013            #[allow(dead_code, unreachable_patterns)]
19014            fn _type_assertion(
19015                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
19016            ) {
19017                match _t {
19018                    alloy_sol_types::private::AssertTypeEq::<
19019                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
19020                    >(_) => {}
19021                }
19022            }
19023            #[automatically_derived]
19024            #[doc(hidden)]
19025            impl ::core::convert::From<updateOperatorsReturn>
19026            for UnderlyingRustTuple<'_> {
19027                fn from(value: updateOperatorsReturn) -> Self {
19028                    ()
19029                }
19030            }
19031            #[automatically_derived]
19032            #[doc(hidden)]
19033            impl ::core::convert::From<UnderlyingRustTuple<'_>>
19034            for updateOperatorsReturn {
19035                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
19036                    Self {}
19037                }
19038            }
19039        }
19040        #[automatically_derived]
19041        impl alloy_sol_types::SolCall for updateOperatorsCall {
19042            type Parameters<'a> = (
19043                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
19044            );
19045            type Token<'a> = <Self::Parameters<
19046                'a,
19047            > as alloy_sol_types::SolType>::Token<'a>;
19048            type Return = updateOperatorsReturn;
19049            type ReturnTuple<'a> = ();
19050            type ReturnToken<'a> = <Self::ReturnTuple<
19051                'a,
19052            > as alloy_sol_types::SolType>::Token<'a>;
19053            const SIGNATURE: &'static str = "updateOperators(address[])";
19054            const SELECTOR: [u8; 4] = [0u8, 207u8, 42u8, 181u8];
19055            #[inline]
19056            fn new<'a>(
19057                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
19058            ) -> Self {
19059                tuple.into()
19060            }
19061            #[inline]
19062            fn tokenize(&self) -> Self::Token<'_> {
19063                (
19064                    <alloy::sol_types::sol_data::Array<
19065                        alloy::sol_types::sol_data::Address,
19066                    > as alloy_sol_types::SolType>::tokenize(&self.operators),
19067                )
19068            }
19069            #[inline]
19070            fn abi_decode_returns(
19071                data: &[u8],
19072                validate: bool,
19073            ) -> alloy_sol_types::Result<Self::Return> {
19074                <Self::ReturnTuple<
19075                    '_,
19076                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
19077                    .map(Into::into)
19078            }
19079        }
19080    };
19081    #[derive(Default, Debug, PartialEq, Eq, Hash)]
19082    /**Function with signature `updateOperatorsForQuorum(address[][],bytes)` and selector `0x5140a548`.
19083```solidity
19084function updateOperatorsForQuorum(address[][] memory operatorsPerQuorum, bytes memory quorumNumbers) external;
19085```*/
19086    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
19087    #[derive(Clone)]
19088    pub struct updateOperatorsForQuorumCall {
19089        #[allow(missing_docs)]
19090        pub operatorsPerQuorum: alloy::sol_types::private::Vec<
19091            alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
19092        >,
19093        #[allow(missing_docs)]
19094        pub quorumNumbers: alloy::sol_types::private::Bytes,
19095    }
19096    ///Container type for the return parameters of the [`updateOperatorsForQuorum(address[][],bytes)`](updateOperatorsForQuorumCall) function.
19097    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
19098    #[derive(Clone)]
19099    pub struct updateOperatorsForQuorumReturn {}
19100    #[allow(
19101        non_camel_case_types,
19102        non_snake_case,
19103        clippy::pub_underscore_fields,
19104        clippy::style
19105    )]
19106    const _: () = {
19107        use alloy::sol_types as alloy_sol_types;
19108        {
19109            #[doc(hidden)]
19110            type UnderlyingSolTuple<'a> = (
19111                alloy::sol_types::sol_data::Array<
19112                    alloy::sol_types::sol_data::Array<
19113                        alloy::sol_types::sol_data::Address,
19114                    >,
19115                >,
19116                alloy::sol_types::sol_data::Bytes,
19117            );
19118            #[doc(hidden)]
19119            type UnderlyingRustTuple<'a> = (
19120                alloy::sol_types::private::Vec<
19121                    alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
19122                >,
19123                alloy::sol_types::private::Bytes,
19124            );
19125            #[cfg(test)]
19126            #[allow(dead_code, unreachable_patterns)]
19127            fn _type_assertion(
19128                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
19129            ) {
19130                match _t {
19131                    alloy_sol_types::private::AssertTypeEq::<
19132                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
19133                    >(_) => {}
19134                }
19135            }
19136            #[automatically_derived]
19137            #[doc(hidden)]
19138            impl ::core::convert::From<updateOperatorsForQuorumCall>
19139            for UnderlyingRustTuple<'_> {
19140                fn from(value: updateOperatorsForQuorumCall) -> Self {
19141                    (value.operatorsPerQuorum, value.quorumNumbers)
19142                }
19143            }
19144            #[automatically_derived]
19145            #[doc(hidden)]
19146            impl ::core::convert::From<UnderlyingRustTuple<'_>>
19147            for updateOperatorsForQuorumCall {
19148                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
19149                    Self {
19150                        operatorsPerQuorum: tuple.0,
19151                        quorumNumbers: tuple.1,
19152                    }
19153                }
19154            }
19155        }
19156        {
19157            #[doc(hidden)]
19158            type UnderlyingSolTuple<'a> = ();
19159            #[doc(hidden)]
19160            type UnderlyingRustTuple<'a> = ();
19161            #[cfg(test)]
19162            #[allow(dead_code, unreachable_patterns)]
19163            fn _type_assertion(
19164                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
19165            ) {
19166                match _t {
19167                    alloy_sol_types::private::AssertTypeEq::<
19168                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
19169                    >(_) => {}
19170                }
19171            }
19172            #[automatically_derived]
19173            #[doc(hidden)]
19174            impl ::core::convert::From<updateOperatorsForQuorumReturn>
19175            for UnderlyingRustTuple<'_> {
19176                fn from(value: updateOperatorsForQuorumReturn) -> Self {
19177                    ()
19178                }
19179            }
19180            #[automatically_derived]
19181            #[doc(hidden)]
19182            impl ::core::convert::From<UnderlyingRustTuple<'_>>
19183            for updateOperatorsForQuorumReturn {
19184                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
19185                    Self {}
19186                }
19187            }
19188        }
19189        #[automatically_derived]
19190        impl alloy_sol_types::SolCall for updateOperatorsForQuorumCall {
19191            type Parameters<'a> = (
19192                alloy::sol_types::sol_data::Array<
19193                    alloy::sol_types::sol_data::Array<
19194                        alloy::sol_types::sol_data::Address,
19195                    >,
19196                >,
19197                alloy::sol_types::sol_data::Bytes,
19198            );
19199            type Token<'a> = <Self::Parameters<
19200                'a,
19201            > as alloy_sol_types::SolType>::Token<'a>;
19202            type Return = updateOperatorsForQuorumReturn;
19203            type ReturnTuple<'a> = ();
19204            type ReturnToken<'a> = <Self::ReturnTuple<
19205                'a,
19206            > as alloy_sol_types::SolType>::Token<'a>;
19207            const SIGNATURE: &'static str = "updateOperatorsForQuorum(address[][],bytes)";
19208            const SELECTOR: [u8; 4] = [81u8, 64u8, 165u8, 72u8];
19209            #[inline]
19210            fn new<'a>(
19211                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
19212            ) -> Self {
19213                tuple.into()
19214            }
19215            #[inline]
19216            fn tokenize(&self) -> Self::Token<'_> {
19217                (
19218                    <alloy::sol_types::sol_data::Array<
19219                        alloy::sol_types::sol_data::Array<
19220                            alloy::sol_types::sol_data::Address,
19221                        >,
19222                    > as alloy_sol_types::SolType>::tokenize(&self.operatorsPerQuorum),
19223                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
19224                        &self.quorumNumbers,
19225                    ),
19226                )
19227            }
19228            #[inline]
19229            fn abi_decode_returns(
19230                data: &[u8],
19231                validate: bool,
19232            ) -> alloy_sol_types::Result<Self::Return> {
19233                <Self::ReturnTuple<
19234                    '_,
19235                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
19236                    .map(Into::into)
19237            }
19238        }
19239    };
19240    #[derive(Default, Debug, PartialEq, Eq, Hash)]
19241    /**Function with signature `updateSocket(string)` and selector `0x0cf4b767`.
19242```solidity
19243function updateSocket(string memory socket) external;
19244```*/
19245    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
19246    #[derive(Clone)]
19247    pub struct updateSocketCall {
19248        #[allow(missing_docs)]
19249        pub socket: alloy::sol_types::private::String,
19250    }
19251    ///Container type for the return parameters of the [`updateSocket(string)`](updateSocketCall) function.
19252    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
19253    #[derive(Clone)]
19254    pub struct updateSocketReturn {}
19255    #[allow(
19256        non_camel_case_types,
19257        non_snake_case,
19258        clippy::pub_underscore_fields,
19259        clippy::style
19260    )]
19261    const _: () = {
19262        use alloy::sol_types as alloy_sol_types;
19263        {
19264            #[doc(hidden)]
19265            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
19266            #[doc(hidden)]
19267            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
19268            #[cfg(test)]
19269            #[allow(dead_code, unreachable_patterns)]
19270            fn _type_assertion(
19271                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
19272            ) {
19273                match _t {
19274                    alloy_sol_types::private::AssertTypeEq::<
19275                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
19276                    >(_) => {}
19277                }
19278            }
19279            #[automatically_derived]
19280            #[doc(hidden)]
19281            impl ::core::convert::From<updateSocketCall> for UnderlyingRustTuple<'_> {
19282                fn from(value: updateSocketCall) -> Self {
19283                    (value.socket,)
19284                }
19285            }
19286            #[automatically_derived]
19287            #[doc(hidden)]
19288            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateSocketCall {
19289                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
19290                    Self { socket: tuple.0 }
19291                }
19292            }
19293        }
19294        {
19295            #[doc(hidden)]
19296            type UnderlyingSolTuple<'a> = ();
19297            #[doc(hidden)]
19298            type UnderlyingRustTuple<'a> = ();
19299            #[cfg(test)]
19300            #[allow(dead_code, unreachable_patterns)]
19301            fn _type_assertion(
19302                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
19303            ) {
19304                match _t {
19305                    alloy_sol_types::private::AssertTypeEq::<
19306                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
19307                    >(_) => {}
19308                }
19309            }
19310            #[automatically_derived]
19311            #[doc(hidden)]
19312            impl ::core::convert::From<updateSocketReturn> for UnderlyingRustTuple<'_> {
19313                fn from(value: updateSocketReturn) -> Self {
19314                    ()
19315                }
19316            }
19317            #[automatically_derived]
19318            #[doc(hidden)]
19319            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateSocketReturn {
19320                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
19321                    Self {}
19322                }
19323            }
19324        }
19325        #[automatically_derived]
19326        impl alloy_sol_types::SolCall for updateSocketCall {
19327            type Parameters<'a> = (alloy::sol_types::sol_data::String,);
19328            type Token<'a> = <Self::Parameters<
19329                'a,
19330            > as alloy_sol_types::SolType>::Token<'a>;
19331            type Return = updateSocketReturn;
19332            type ReturnTuple<'a> = ();
19333            type ReturnToken<'a> = <Self::ReturnTuple<
19334                'a,
19335            > as alloy_sol_types::SolType>::Token<'a>;
19336            const SIGNATURE: &'static str = "updateSocket(string)";
19337            const SELECTOR: [u8; 4] = [12u8, 244u8, 183u8, 103u8];
19338            #[inline]
19339            fn new<'a>(
19340                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
19341            ) -> Self {
19342                tuple.into()
19343            }
19344            #[inline]
19345            fn tokenize(&self) -> Self::Token<'_> {
19346                (
19347                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
19348                        &self.socket,
19349                    ),
19350                )
19351            }
19352            #[inline]
19353            fn abi_decode_returns(
19354                data: &[u8],
19355                validate: bool,
19356            ) -> alloy_sol_types::Result<Self::Return> {
19357                <Self::ReturnTuple<
19358                    '_,
19359                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
19360                    .map(Into::into)
19361            }
19362        }
19363    };
19364    #[derive(Default, Debug, PartialEq, Eq, Hash)]
19365    /**Function with signature `version()` and selector `0x54fd4d50`.
19366```solidity
19367function version() external view returns (string memory);
19368```*/
19369    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
19370    #[derive(Clone)]
19371    pub struct versionCall {}
19372    #[derive(Default, Debug, PartialEq, Eq, Hash)]
19373    ///Container type for the return parameters of the [`version()`](versionCall) function.
19374    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
19375    #[derive(Clone)]
19376    pub struct versionReturn {
19377        #[allow(missing_docs)]
19378        pub _0: alloy::sol_types::private::String,
19379    }
19380    #[allow(
19381        non_camel_case_types,
19382        non_snake_case,
19383        clippy::pub_underscore_fields,
19384        clippy::style
19385    )]
19386    const _: () = {
19387        use alloy::sol_types as alloy_sol_types;
19388        {
19389            #[doc(hidden)]
19390            type UnderlyingSolTuple<'a> = ();
19391            #[doc(hidden)]
19392            type UnderlyingRustTuple<'a> = ();
19393            #[cfg(test)]
19394            #[allow(dead_code, unreachable_patterns)]
19395            fn _type_assertion(
19396                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
19397            ) {
19398                match _t {
19399                    alloy_sol_types::private::AssertTypeEq::<
19400                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
19401                    >(_) => {}
19402                }
19403            }
19404            #[automatically_derived]
19405            #[doc(hidden)]
19406            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
19407                fn from(value: versionCall) -> Self {
19408                    ()
19409                }
19410            }
19411            #[automatically_derived]
19412            #[doc(hidden)]
19413            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
19414                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
19415                    Self {}
19416                }
19417            }
19418        }
19419        {
19420            #[doc(hidden)]
19421            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
19422            #[doc(hidden)]
19423            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
19424            #[cfg(test)]
19425            #[allow(dead_code, unreachable_patterns)]
19426            fn _type_assertion(
19427                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
19428            ) {
19429                match _t {
19430                    alloy_sol_types::private::AssertTypeEq::<
19431                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
19432                    >(_) => {}
19433                }
19434            }
19435            #[automatically_derived]
19436            #[doc(hidden)]
19437            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
19438                fn from(value: versionReturn) -> Self {
19439                    (value._0,)
19440                }
19441            }
19442            #[automatically_derived]
19443            #[doc(hidden)]
19444            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
19445                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
19446                    Self { _0: tuple.0 }
19447                }
19448            }
19449        }
19450        #[automatically_derived]
19451        impl alloy_sol_types::SolCall for versionCall {
19452            type Parameters<'a> = ();
19453            type Token<'a> = <Self::Parameters<
19454                'a,
19455            > as alloy_sol_types::SolType>::Token<'a>;
19456            type Return = versionReturn;
19457            type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
19458            type ReturnToken<'a> = <Self::ReturnTuple<
19459                'a,
19460            > as alloy_sol_types::SolType>::Token<'a>;
19461            const SIGNATURE: &'static str = "version()";
19462            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
19463            #[inline]
19464            fn new<'a>(
19465                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
19466            ) -> Self {
19467                tuple.into()
19468            }
19469            #[inline]
19470            fn tokenize(&self) -> Self::Token<'_> {
19471                ()
19472            }
19473            #[inline]
19474            fn abi_decode_returns(
19475                data: &[u8],
19476                validate: bool,
19477            ) -> alloy_sol_types::Result<Self::Return> {
19478                <Self::ReturnTuple<
19479                    '_,
19480                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
19481                    .map(Into::into)
19482            }
19483        }
19484    };
19485    ///Container for all the [`RegistryCoordinator`](self) function calls.
19486    #[derive()]
19487    pub enum RegistryCoordinatorCalls {
19488        #[allow(missing_docs)]
19489        OPERATOR_CHURN_APPROVAL_TYPEHASH(OPERATOR_CHURN_APPROVAL_TYPEHASHCall),
19490        #[allow(missing_docs)]
19491        PUBKEY_REGISTRATION_TYPEHASH(PUBKEY_REGISTRATION_TYPEHASHCall),
19492        #[allow(missing_docs)]
19493        allocationManager(allocationManagerCall),
19494        #[allow(missing_docs)]
19495        avs(avsCall),
19496        #[allow(missing_docs)]
19497        blsApkRegistry(blsApkRegistryCall),
19498        #[allow(missing_docs)]
19499        calculateOperatorChurnApprovalDigestHash(
19500            calculateOperatorChurnApprovalDigestHashCall,
19501        ),
19502        #[allow(missing_docs)]
19503        calculatePubkeyRegistrationMessageHash(
19504            calculatePubkeyRegistrationMessageHashCall,
19505        ),
19506        #[allow(missing_docs)]
19507        churnApprover(churnApproverCall),
19508        #[allow(missing_docs)]
19509        createSlashableStakeQuorum(createSlashableStakeQuorumCall),
19510        #[allow(missing_docs)]
19511        createTotalDelegatedStakeQuorum(createTotalDelegatedStakeQuorumCall),
19512        #[allow(missing_docs)]
19513        deregisterOperator_0(deregisterOperator_0Call),
19514        #[allow(missing_docs)]
19515        deregisterOperator_1(deregisterOperator_1Call),
19516        #[allow(missing_docs)]
19517        disableM2QuorumRegistration(disableM2QuorumRegistrationCall),
19518        #[allow(missing_docs)]
19519        domainSeparator(domainSeparatorCall),
19520        #[allow(missing_docs)]
19521        eip712Domain(eip712DomainCall),
19522        #[allow(missing_docs)]
19523        ejectOperator(ejectOperatorCall),
19524        #[allow(missing_docs)]
19525        ejectionCooldown(ejectionCooldownCall),
19526        #[allow(missing_docs)]
19527        ejector(ejectorCall),
19528        #[allow(missing_docs)]
19529        getCurrentQuorumBitmap(getCurrentQuorumBitmapCall),
19530        #[allow(missing_docs)]
19531        getOperator(getOperatorCall),
19532        #[allow(missing_docs)]
19533        getOperatorFromId(getOperatorFromIdCall),
19534        #[allow(missing_docs)]
19535        getOperatorId(getOperatorIdCall),
19536        #[allow(missing_docs)]
19537        getOperatorSetParams(getOperatorSetParamsCall),
19538        #[allow(missing_docs)]
19539        getOperatorStatus(getOperatorStatusCall),
19540        #[allow(missing_docs)]
19541        getQuorumBitmapAtBlockNumberByIndex(getQuorumBitmapAtBlockNumberByIndexCall),
19542        #[allow(missing_docs)]
19543        getQuorumBitmapHistoryLength(getQuorumBitmapHistoryLengthCall),
19544        #[allow(missing_docs)]
19545        getQuorumBitmapIndicesAtBlockNumber(getQuorumBitmapIndicesAtBlockNumberCall),
19546        #[allow(missing_docs)]
19547        getQuorumBitmapUpdateByIndex(getQuorumBitmapUpdateByIndexCall),
19548        #[allow(missing_docs)]
19549        indexRegistry(indexRegistryCall),
19550        #[allow(missing_docs)]
19551        initialize(initializeCall),
19552        #[allow(missing_docs)]
19553        isChurnApproverSaltUsed(isChurnApproverSaltUsedCall),
19554        #[allow(missing_docs)]
19555        isM2Quorum(isM2QuorumCall),
19556        #[allow(missing_docs)]
19557        isM2QuorumRegistrationDisabled(isM2QuorumRegistrationDisabledCall),
19558        #[allow(missing_docs)]
19559        lastEjectionTimestamp(lastEjectionTimestampCall),
19560        #[allow(missing_docs)]
19561        m2QuorumBitmap(m2QuorumBitmapCall),
19562        #[allow(missing_docs)]
19563        operatorSetsEnabled(operatorSetsEnabledCall),
19564        #[allow(missing_docs)]
19565        owner(ownerCall),
19566        #[allow(missing_docs)]
19567        pause(pauseCall),
19568        #[allow(missing_docs)]
19569        pauseAll(pauseAllCall),
19570        #[allow(missing_docs)]
19571        paused_0(paused_0Call),
19572        #[allow(missing_docs)]
19573        paused_1(paused_1Call),
19574        #[allow(missing_docs)]
19575        pauserRegistry(pauserRegistryCall),
19576        #[allow(missing_docs)]
19577        pubkeyRegistrationMessageHash(pubkeyRegistrationMessageHashCall),
19578        #[allow(missing_docs)]
19579        quorumCount(quorumCountCall),
19580        #[allow(missing_docs)]
19581        quorumUpdateBlockNumber(quorumUpdateBlockNumberCall),
19582        #[allow(missing_docs)]
19583        registerOperator_0(registerOperator_0Call),
19584        #[allow(missing_docs)]
19585        registerOperator_1(registerOperator_1Call),
19586        #[allow(missing_docs)]
19587        registerOperatorWithChurn(registerOperatorWithChurnCall),
19588        #[allow(missing_docs)]
19589        renounceOwnership(renounceOwnershipCall),
19590        #[allow(missing_docs)]
19591        serviceManager(serviceManagerCall),
19592        #[allow(missing_docs)]
19593        setAVS(setAVSCall),
19594        #[allow(missing_docs)]
19595        setChurnApprover(setChurnApproverCall),
19596        #[allow(missing_docs)]
19597        setEjectionCooldown(setEjectionCooldownCall),
19598        #[allow(missing_docs)]
19599        setEjector(setEjectorCall),
19600        #[allow(missing_docs)]
19601        setOperatorSetParams(setOperatorSetParamsCall),
19602        #[allow(missing_docs)]
19603        socketRegistry(socketRegistryCall),
19604        #[allow(missing_docs)]
19605        stakeRegistry(stakeRegistryCall),
19606        #[allow(missing_docs)]
19607        supportsAVS(supportsAVSCall),
19608        #[allow(missing_docs)]
19609        transferOwnership(transferOwnershipCall),
19610        #[allow(missing_docs)]
19611        unpause(unpauseCall),
19612        #[allow(missing_docs)]
19613        updateOperators(updateOperatorsCall),
19614        #[allow(missing_docs)]
19615        updateOperatorsForQuorum(updateOperatorsForQuorumCall),
19616        #[allow(missing_docs)]
19617        updateSocket(updateSocketCall),
19618        #[allow(missing_docs)]
19619        version(versionCall),
19620    }
19621    #[automatically_derived]
19622    impl RegistryCoordinatorCalls {
19623        /// All the selectors of this enum.
19624        ///
19625        /// Note that the selectors might not be in the same order as the variants.
19626        /// No guarantees are made about the order of the selectors.
19627        ///
19628        /// Prefer using `SolInterface` methods instead.
19629        pub const SELECTORS: &'static [[u8; 4usize]] = &[
19630            [0u8, 207u8, 42u8, 181u8],
19631            [3u8, 253u8, 52u8, 146u8],
19632            [4u8, 236u8, 99u8, 81u8],
19633            [5u8, 67u8, 16u8, 230u8],
19634            [12u8, 244u8, 183u8, 103u8],
19635            [13u8, 63u8, 33u8, 52u8],
19636            [18u8, 94u8, 5u8, 132u8],
19637            [19u8, 84u8, 42u8, 78u8],
19638            [19u8, 100u8, 57u8, 221u8],
19639            [20u8, 120u8, 133u8, 31u8],
19640            [30u8, 184u8, 18u8, 218u8],
19641            [36u8, 154u8, 12u8, 66u8],
19642            [40u8, 246u8, 27u8, 49u8],
19643            [41u8, 107u8, 176u8, 100u8],
19644            [41u8, 209u8, 224u8, 195u8],
19645            [44u8, 221u8, 30u8, 134u8],
19646            [48u8, 60u8, 169u8, 86u8],
19647            [57u8, 152u8, 253u8, 211u8],
19648            [60u8, 42u8, 127u8, 76u8],
19649            [62u8, 239u8, 58u8, 81u8],
19650            [81u8, 64u8, 165u8, 72u8],
19651            [83u8, 11u8, 151u8, 164u8],
19652            [84u8, 253u8, 77u8, 80u8],
19653            [88u8, 101u8, 198u8, 12u8],
19654            [89u8, 92u8, 106u8, 103u8],
19655            [90u8, 200u8, 106u8, 183u8],
19656            [91u8, 11u8, 130u8, 159u8],
19657            [92u8, 151u8, 90u8, 187u8],
19658            [93u8, 244u8, 89u8, 70u8],
19659            [104u8, 48u8, 72u8, 53u8],
19660            [110u8, 59u8, 23u8, 219u8],
19661            [113u8, 80u8, 24u8, 166u8],
19662            [115u8, 59u8, 117u8, 7u8],
19663            [115u8, 68u8, 121u8, 146u8],
19664            [129u8, 249u8, 54u8, 210u8],
19665            [130u8, 129u8, 171u8, 117u8],
19666            [132u8, 176u8, 25u8, 110u8],
19667            [132u8, 202u8, 82u8, 19u8],
19668            [135u8, 30u8, 240u8, 73u8],
19669            [136u8, 111u8, 17u8, 149u8],
19670            [141u8, 165u8, 203u8, 91u8],
19671            [154u8, 161u8, 101u8, 61u8],
19672            [155u8, 93u8, 23u8, 123u8],
19673            [158u8, 153u8, 35u8, 194u8],
19674            [159u8, 234u8, 184u8, 89u8],
19675            [164u8, 215u8, 135u8, 31u8],
19676            [165u8, 8u8, 87u8, 191u8],
19677            [166u8, 84u8, 151u8, 198u8],
19678            [169u8, 111u8, 120u8, 62u8],
19679            [181u8, 38u8, 87u8, 135u8],
19680            [195u8, 145u8, 66u8, 94u8],
19681            [198u8, 63u8, 213u8, 2u8],
19682            [202u8, 13u8, 232u8, 130u8],
19683            [202u8, 79u8, 45u8, 151u8],
19684            [202u8, 138u8, 167u8, 199u8],
19685            [222u8, 17u8, 100u8, 187u8],
19686            [230u8, 87u8, 151u8, 173u8],
19687            [232u8, 20u8, 202u8, 157u8],
19688            [234u8, 50u8, 175u8, 174u8],
19689            [236u8, 140u8, 58u8, 30u8],
19690            [242u8, 253u8, 227u8, 139u8],
19691            [246u8, 152u8, 218u8, 37u8],
19692            [250u8, 188u8, 28u8, 188u8],
19693            [253u8, 57u8, 16u8, 90u8],
19694        ];
19695    }
19696    #[automatically_derived]
19697    impl alloy_sol_types::SolInterface for RegistryCoordinatorCalls {
19698        const NAME: &'static str = "RegistryCoordinatorCalls";
19699        const MIN_DATA_LENGTH: usize = 0usize;
19700        const COUNT: usize = 64usize;
19701        #[inline]
19702        fn selector(&self) -> [u8; 4] {
19703            match self {
19704                Self::OPERATOR_CHURN_APPROVAL_TYPEHASH(_) => {
19705                    <OPERATOR_CHURN_APPROVAL_TYPEHASHCall as alloy_sol_types::SolCall>::SELECTOR
19706                }
19707                Self::PUBKEY_REGISTRATION_TYPEHASH(_) => {
19708                    <PUBKEY_REGISTRATION_TYPEHASHCall as alloy_sol_types::SolCall>::SELECTOR
19709                }
19710                Self::allocationManager(_) => {
19711                    <allocationManagerCall as alloy_sol_types::SolCall>::SELECTOR
19712                }
19713                Self::avs(_) => <avsCall as alloy_sol_types::SolCall>::SELECTOR,
19714                Self::blsApkRegistry(_) => {
19715                    <blsApkRegistryCall as alloy_sol_types::SolCall>::SELECTOR
19716                }
19717                Self::calculateOperatorChurnApprovalDigestHash(_) => {
19718                    <calculateOperatorChurnApprovalDigestHashCall as alloy_sol_types::SolCall>::SELECTOR
19719                }
19720                Self::calculatePubkeyRegistrationMessageHash(_) => {
19721                    <calculatePubkeyRegistrationMessageHashCall as alloy_sol_types::SolCall>::SELECTOR
19722                }
19723                Self::churnApprover(_) => {
19724                    <churnApproverCall as alloy_sol_types::SolCall>::SELECTOR
19725                }
19726                Self::createSlashableStakeQuorum(_) => {
19727                    <createSlashableStakeQuorumCall as alloy_sol_types::SolCall>::SELECTOR
19728                }
19729                Self::createTotalDelegatedStakeQuorum(_) => {
19730                    <createTotalDelegatedStakeQuorumCall as alloy_sol_types::SolCall>::SELECTOR
19731                }
19732                Self::deregisterOperator_0(_) => {
19733                    <deregisterOperator_0Call as alloy_sol_types::SolCall>::SELECTOR
19734                }
19735                Self::deregisterOperator_1(_) => {
19736                    <deregisterOperator_1Call as alloy_sol_types::SolCall>::SELECTOR
19737                }
19738                Self::disableM2QuorumRegistration(_) => {
19739                    <disableM2QuorumRegistrationCall as alloy_sol_types::SolCall>::SELECTOR
19740                }
19741                Self::domainSeparator(_) => {
19742                    <domainSeparatorCall as alloy_sol_types::SolCall>::SELECTOR
19743                }
19744                Self::eip712Domain(_) => {
19745                    <eip712DomainCall as alloy_sol_types::SolCall>::SELECTOR
19746                }
19747                Self::ejectOperator(_) => {
19748                    <ejectOperatorCall as alloy_sol_types::SolCall>::SELECTOR
19749                }
19750                Self::ejectionCooldown(_) => {
19751                    <ejectionCooldownCall as alloy_sol_types::SolCall>::SELECTOR
19752                }
19753                Self::ejector(_) => <ejectorCall as alloy_sol_types::SolCall>::SELECTOR,
19754                Self::getCurrentQuorumBitmap(_) => {
19755                    <getCurrentQuorumBitmapCall as alloy_sol_types::SolCall>::SELECTOR
19756                }
19757                Self::getOperator(_) => {
19758                    <getOperatorCall as alloy_sol_types::SolCall>::SELECTOR
19759                }
19760                Self::getOperatorFromId(_) => {
19761                    <getOperatorFromIdCall as alloy_sol_types::SolCall>::SELECTOR
19762                }
19763                Self::getOperatorId(_) => {
19764                    <getOperatorIdCall as alloy_sol_types::SolCall>::SELECTOR
19765                }
19766                Self::getOperatorSetParams(_) => {
19767                    <getOperatorSetParamsCall as alloy_sol_types::SolCall>::SELECTOR
19768                }
19769                Self::getOperatorStatus(_) => {
19770                    <getOperatorStatusCall as alloy_sol_types::SolCall>::SELECTOR
19771                }
19772                Self::getQuorumBitmapAtBlockNumberByIndex(_) => {
19773                    <getQuorumBitmapAtBlockNumberByIndexCall as alloy_sol_types::SolCall>::SELECTOR
19774                }
19775                Self::getQuorumBitmapHistoryLength(_) => {
19776                    <getQuorumBitmapHistoryLengthCall as alloy_sol_types::SolCall>::SELECTOR
19777                }
19778                Self::getQuorumBitmapIndicesAtBlockNumber(_) => {
19779                    <getQuorumBitmapIndicesAtBlockNumberCall as alloy_sol_types::SolCall>::SELECTOR
19780                }
19781                Self::getQuorumBitmapUpdateByIndex(_) => {
19782                    <getQuorumBitmapUpdateByIndexCall as alloy_sol_types::SolCall>::SELECTOR
19783                }
19784                Self::indexRegistry(_) => {
19785                    <indexRegistryCall as alloy_sol_types::SolCall>::SELECTOR
19786                }
19787                Self::initialize(_) => {
19788                    <initializeCall as alloy_sol_types::SolCall>::SELECTOR
19789                }
19790                Self::isChurnApproverSaltUsed(_) => {
19791                    <isChurnApproverSaltUsedCall as alloy_sol_types::SolCall>::SELECTOR
19792                }
19793                Self::isM2Quorum(_) => {
19794                    <isM2QuorumCall as alloy_sol_types::SolCall>::SELECTOR
19795                }
19796                Self::isM2QuorumRegistrationDisabled(_) => {
19797                    <isM2QuorumRegistrationDisabledCall as alloy_sol_types::SolCall>::SELECTOR
19798                }
19799                Self::lastEjectionTimestamp(_) => {
19800                    <lastEjectionTimestampCall as alloy_sol_types::SolCall>::SELECTOR
19801                }
19802                Self::m2QuorumBitmap(_) => {
19803                    <m2QuorumBitmapCall as alloy_sol_types::SolCall>::SELECTOR
19804                }
19805                Self::operatorSetsEnabled(_) => {
19806                    <operatorSetsEnabledCall as alloy_sol_types::SolCall>::SELECTOR
19807                }
19808                Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
19809                Self::pause(_) => <pauseCall as alloy_sol_types::SolCall>::SELECTOR,
19810                Self::pauseAll(_) => <pauseAllCall as alloy_sol_types::SolCall>::SELECTOR,
19811                Self::paused_0(_) => <paused_0Call as alloy_sol_types::SolCall>::SELECTOR,
19812                Self::paused_1(_) => <paused_1Call as alloy_sol_types::SolCall>::SELECTOR,
19813                Self::pauserRegistry(_) => {
19814                    <pauserRegistryCall as alloy_sol_types::SolCall>::SELECTOR
19815                }
19816                Self::pubkeyRegistrationMessageHash(_) => {
19817                    <pubkeyRegistrationMessageHashCall as alloy_sol_types::SolCall>::SELECTOR
19818                }
19819                Self::quorumCount(_) => {
19820                    <quorumCountCall as alloy_sol_types::SolCall>::SELECTOR
19821                }
19822                Self::quorumUpdateBlockNumber(_) => {
19823                    <quorumUpdateBlockNumberCall as alloy_sol_types::SolCall>::SELECTOR
19824                }
19825                Self::registerOperator_0(_) => {
19826                    <registerOperator_0Call as alloy_sol_types::SolCall>::SELECTOR
19827                }
19828                Self::registerOperator_1(_) => {
19829                    <registerOperator_1Call as alloy_sol_types::SolCall>::SELECTOR
19830                }
19831                Self::registerOperatorWithChurn(_) => {
19832                    <registerOperatorWithChurnCall as alloy_sol_types::SolCall>::SELECTOR
19833                }
19834                Self::renounceOwnership(_) => {
19835                    <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
19836                }
19837                Self::serviceManager(_) => {
19838                    <serviceManagerCall as alloy_sol_types::SolCall>::SELECTOR
19839                }
19840                Self::setAVS(_) => <setAVSCall as alloy_sol_types::SolCall>::SELECTOR,
19841                Self::setChurnApprover(_) => {
19842                    <setChurnApproverCall as alloy_sol_types::SolCall>::SELECTOR
19843                }
19844                Self::setEjectionCooldown(_) => {
19845                    <setEjectionCooldownCall as alloy_sol_types::SolCall>::SELECTOR
19846                }
19847                Self::setEjector(_) => {
19848                    <setEjectorCall as alloy_sol_types::SolCall>::SELECTOR
19849                }
19850                Self::setOperatorSetParams(_) => {
19851                    <setOperatorSetParamsCall as alloy_sol_types::SolCall>::SELECTOR
19852                }
19853                Self::socketRegistry(_) => {
19854                    <socketRegistryCall as alloy_sol_types::SolCall>::SELECTOR
19855                }
19856                Self::stakeRegistry(_) => {
19857                    <stakeRegistryCall as alloy_sol_types::SolCall>::SELECTOR
19858                }
19859                Self::supportsAVS(_) => {
19860                    <supportsAVSCall as alloy_sol_types::SolCall>::SELECTOR
19861                }
19862                Self::transferOwnership(_) => {
19863                    <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
19864                }
19865                Self::unpause(_) => <unpauseCall as alloy_sol_types::SolCall>::SELECTOR,
19866                Self::updateOperators(_) => {
19867                    <updateOperatorsCall as alloy_sol_types::SolCall>::SELECTOR
19868                }
19869                Self::updateOperatorsForQuorum(_) => {
19870                    <updateOperatorsForQuorumCall as alloy_sol_types::SolCall>::SELECTOR
19871                }
19872                Self::updateSocket(_) => {
19873                    <updateSocketCall as alloy_sol_types::SolCall>::SELECTOR
19874                }
19875                Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
19876            }
19877        }
19878        #[inline]
19879        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
19880            Self::SELECTORS.get(i).copied()
19881        }
19882        #[inline]
19883        fn valid_selector(selector: [u8; 4]) -> bool {
19884            Self::SELECTORS.binary_search(&selector).is_ok()
19885        }
19886        #[inline]
19887        #[allow(non_snake_case)]
19888        fn abi_decode_raw(
19889            selector: [u8; 4],
19890            data: &[u8],
19891            validate: bool,
19892        ) -> alloy_sol_types::Result<Self> {
19893            static DECODE_SHIMS: &[fn(
19894                &[u8],
19895                bool,
19896            ) -> alloy_sol_types::Result<RegistryCoordinatorCalls>] = &[
19897                {
19898                    fn updateOperators(
19899                        data: &[u8],
19900                        validate: bool,
19901                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
19902                        <updateOperatorsCall as alloy_sol_types::SolCall>::abi_decode_raw(
19903                                data,
19904                                validate,
19905                            )
19906                            .map(RegistryCoordinatorCalls::updateOperators)
19907                    }
19908                    updateOperators
19909                },
19910                {
19911                    fn getQuorumBitmapHistoryLength(
19912                        data: &[u8],
19913                        validate: bool,
19914                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
19915                        <getQuorumBitmapHistoryLengthCall as alloy_sol_types::SolCall>::abi_decode_raw(
19916                                data,
19917                                validate,
19918                            )
19919                            .map(RegistryCoordinatorCalls::getQuorumBitmapHistoryLength)
19920                    }
19921                    getQuorumBitmapHistoryLength
19922                },
19923                {
19924                    fn getQuorumBitmapAtBlockNumberByIndex(
19925                        data: &[u8],
19926                        validate: bool,
19927                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
19928                        <getQuorumBitmapAtBlockNumberByIndexCall as alloy_sol_types::SolCall>::abi_decode_raw(
19929                                data,
19930                                validate,
19931                            )
19932                            .map(
19933                                RegistryCoordinatorCalls::getQuorumBitmapAtBlockNumberByIndex,
19934                            )
19935                    }
19936                    getQuorumBitmapAtBlockNumberByIndex
19937                },
19938                {
19939                    fn churnApprover(
19940                        data: &[u8],
19941                        validate: bool,
19942                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
19943                        <churnApproverCall as alloy_sol_types::SolCall>::abi_decode_raw(
19944                                data,
19945                                validate,
19946                            )
19947                            .map(RegistryCoordinatorCalls::churnApprover)
19948                    }
19949                    churnApprover
19950                },
19951                {
19952                    fn updateSocket(
19953                        data: &[u8],
19954                        validate: bool,
19955                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
19956                        <updateSocketCall as alloy_sol_types::SolCall>::abi_decode_raw(
19957                                data,
19958                                validate,
19959                            )
19960                            .map(RegistryCoordinatorCalls::updateSocket)
19961                    }
19962                    updateSocket
19963                },
19964                {
19965                    fn setEjectionCooldown(
19966                        data: &[u8],
19967                        validate: bool,
19968                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
19969                        <setEjectionCooldownCall as alloy_sol_types::SolCall>::abi_decode_raw(
19970                                data,
19971                                validate,
19972                            )
19973                            .map(RegistryCoordinatorCalls::setEjectionCooldown)
19974                    }
19975                    setEjectionCooldown
19976                },
19977                {
19978                    fn lastEjectionTimestamp(
19979                        data: &[u8],
19980                        validate: bool,
19981                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
19982                        <lastEjectionTimestampCall as alloy_sol_types::SolCall>::abi_decode_raw(
19983                                data,
19984                                validate,
19985                            )
19986                            .map(RegistryCoordinatorCalls::lastEjectionTimestamp)
19987                    }
19988                    lastEjectionTimestamp
19989                },
19990                {
19991                    fn getOperatorId(
19992                        data: &[u8],
19993                        validate: bool,
19994                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
19995                        <getOperatorIdCall as alloy_sol_types::SolCall>::abi_decode_raw(
19996                                data,
19997                                validate,
19998                            )
19999                            .map(RegistryCoordinatorCalls::getOperatorId)
20000                    }
20001                    getOperatorId
20002                },
20003                {
20004                    fn pause(
20005                        data: &[u8],
20006                        validate: bool,
20007                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20008                        <pauseCall as alloy_sol_types::SolCall>::abi_decode_raw(
20009                                data,
20010                                validate,
20011                            )
20012                            .map(RegistryCoordinatorCalls::pause)
20013                    }
20014                    pause
20015                },
20016                {
20017                    fn isChurnApproverSaltUsed(
20018                        data: &[u8],
20019                        validate: bool,
20020                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20021                        <isChurnApproverSaltUsedCall as alloy_sol_types::SolCall>::abi_decode_raw(
20022                                data,
20023                                validate,
20024                            )
20025                            .map(RegistryCoordinatorCalls::isChurnApproverSaltUsed)
20026                    }
20027                    isChurnApproverSaltUsed
20028                },
20029                {
20030                    fn getQuorumBitmapUpdateByIndex(
20031                        data: &[u8],
20032                        validate: bool,
20033                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20034                        <getQuorumBitmapUpdateByIndexCall as alloy_sol_types::SolCall>::abi_decode_raw(
20035                                data,
20036                                validate,
20037                            )
20038                            .map(RegistryCoordinatorCalls::getQuorumBitmapUpdateByIndex)
20039                    }
20040                    getQuorumBitmapUpdateByIndex
20041                },
20042                {
20043                    fn quorumUpdateBlockNumber(
20044                        data: &[u8],
20045                        validate: bool,
20046                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20047                        <quorumUpdateBlockNumberCall as alloy_sol_types::SolCall>::abi_decode_raw(
20048                                data,
20049                                validate,
20050                            )
20051                            .map(RegistryCoordinatorCalls::quorumUpdateBlockNumber)
20052                    }
20053                    quorumUpdateBlockNumber
20054                },
20055                {
20056                    fn ejector(
20057                        data: &[u8],
20058                        validate: bool,
20059                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20060                        <ejectorCall as alloy_sol_types::SolCall>::abi_decode_raw(
20061                                data,
20062                                validate,
20063                            )
20064                            .map(RegistryCoordinatorCalls::ejector)
20065                    }
20066                    ejector
20067                },
20068                {
20069                    fn getOperatorFromId(
20070                        data: &[u8],
20071                        validate: bool,
20072                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20073                        <getOperatorFromIdCall as alloy_sol_types::SolCall>::abi_decode_raw(
20074                                data,
20075                                validate,
20076                            )
20077                            .map(RegistryCoordinatorCalls::getOperatorFromId)
20078                    }
20079                    getOperatorFromId
20080                },
20081                {
20082                    fn setChurnApprover(
20083                        data: &[u8],
20084                        validate: bool,
20085                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20086                        <setChurnApproverCall as alloy_sol_types::SolCall>::abi_decode_raw(
20087                                data,
20088                                validate,
20089                            )
20090                            .map(RegistryCoordinatorCalls::setChurnApprover)
20091                    }
20092                    setChurnApprover
20093                },
20094                {
20095                    fn setEjector(
20096                        data: &[u8],
20097                        validate: bool,
20098                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20099                        <setEjectorCall as alloy_sol_types::SolCall>::abi_decode_raw(
20100                                data,
20101                                validate,
20102                            )
20103                            .map(RegistryCoordinatorCalls::setEjector)
20104                    }
20105                    setEjector
20106                },
20107                {
20108                    fn deregisterOperator_0(
20109                        data: &[u8],
20110                        validate: bool,
20111                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20112                        <deregisterOperator_0Call as alloy_sol_types::SolCall>::abi_decode_raw(
20113                                data,
20114                                validate,
20115                            )
20116                            .map(RegistryCoordinatorCalls::deregisterOperator_0)
20117                    }
20118                    deregisterOperator_0
20119                },
20120                {
20121                    fn serviceManager(
20122                        data: &[u8],
20123                        validate: bool,
20124                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20125                        <serviceManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(
20126                                data,
20127                                validate,
20128                            )
20129                            .map(RegistryCoordinatorCalls::serviceManager)
20130                    }
20131                    serviceManager
20132                },
20133                {
20134                    fn pubkeyRegistrationMessageHash(
20135                        data: &[u8],
20136                        validate: bool,
20137                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20138                        <pubkeyRegistrationMessageHashCall as alloy_sol_types::SolCall>::abi_decode_raw(
20139                                data,
20140                                validate,
20141                            )
20142                            .map(RegistryCoordinatorCalls::pubkeyRegistrationMessageHash)
20143                    }
20144                    pubkeyRegistrationMessageHash
20145                },
20146                {
20147                    fn createSlashableStakeQuorum(
20148                        data: &[u8],
20149                        validate: bool,
20150                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20151                        <createSlashableStakeQuorumCall as alloy_sol_types::SolCall>::abi_decode_raw(
20152                                data,
20153                                validate,
20154                            )
20155                            .map(RegistryCoordinatorCalls::createSlashableStakeQuorum)
20156                    }
20157                    createSlashableStakeQuorum
20158                },
20159                {
20160                    fn updateOperatorsForQuorum(
20161                        data: &[u8],
20162                        validate: bool,
20163                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20164                        <updateOperatorsForQuorumCall as alloy_sol_types::SolCall>::abi_decode_raw(
20165                                data,
20166                                validate,
20167                            )
20168                            .map(RegistryCoordinatorCalls::updateOperatorsForQuorum)
20169                    }
20170                    updateOperatorsForQuorum
20171                },
20172                {
20173                    fn initialize(
20174                        data: &[u8],
20175                        validate: bool,
20176                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20177                        <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw(
20178                                data,
20179                                validate,
20180                            )
20181                            .map(RegistryCoordinatorCalls::initialize)
20182                    }
20183                    initialize
20184                },
20185                {
20186                    fn version(
20187                        data: &[u8],
20188                        validate: bool,
20189                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20190                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(
20191                                data,
20192                                validate,
20193                            )
20194                            .map(RegistryCoordinatorCalls::version)
20195                    }
20196                    version
20197                },
20198                {
20199                    fn getOperator(
20200                        data: &[u8],
20201                        validate: bool,
20202                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20203                        <getOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
20204                                data,
20205                                validate,
20206                            )
20207                            .map(RegistryCoordinatorCalls::getOperator)
20208                    }
20209                    getOperator
20210                },
20211                {
20212                    fn pauseAll(
20213                        data: &[u8],
20214                        validate: bool,
20215                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20216                        <pauseAllCall as alloy_sol_types::SolCall>::abi_decode_raw(
20217                                data,
20218                                validate,
20219                            )
20220                            .map(RegistryCoordinatorCalls::pauseAll)
20221                    }
20222                    pauseAll
20223                },
20224                {
20225                    fn paused_0(
20226                        data: &[u8],
20227                        validate: bool,
20228                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20229                        <paused_0Call as alloy_sol_types::SolCall>::abi_decode_raw(
20230                                data,
20231                                validate,
20232                            )
20233                            .map(RegistryCoordinatorCalls::paused_0)
20234                    }
20235                    paused_0
20236                },
20237                {
20238                    fn setOperatorSetParams(
20239                        data: &[u8],
20240                        validate: bool,
20241                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20242                        <setOperatorSetParamsCall as alloy_sol_types::SolCall>::abi_decode_raw(
20243                                data,
20244                                validate,
20245                            )
20246                            .map(RegistryCoordinatorCalls::setOperatorSetParams)
20247                    }
20248                    setOperatorSetParams
20249                },
20250                {
20251                    fn paused_1(
20252                        data: &[u8],
20253                        validate: bool,
20254                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20255                        <paused_1Call as alloy_sol_types::SolCall>::abi_decode_raw(
20256                                data,
20257                                validate,
20258                            )
20259                            .map(RegistryCoordinatorCalls::paused_1)
20260                    }
20261                    paused_1
20262                },
20263                {
20264                    fn blsApkRegistry(
20265                        data: &[u8],
20266                        validate: bool,
20267                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20268                        <blsApkRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
20269                                data,
20270                                validate,
20271                            )
20272                            .map(RegistryCoordinatorCalls::blsApkRegistry)
20273                    }
20274                    blsApkRegistry
20275                },
20276                {
20277                    fn stakeRegistry(
20278                        data: &[u8],
20279                        validate: bool,
20280                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20281                        <stakeRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
20282                                data,
20283                                validate,
20284                            )
20285                            .map(RegistryCoordinatorCalls::stakeRegistry)
20286                    }
20287                    stakeRegistry
20288                },
20289                {
20290                    fn ejectOperator(
20291                        data: &[u8],
20292                        validate: bool,
20293                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20294                        <ejectOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
20295                                data,
20296                                validate,
20297                            )
20298                            .map(RegistryCoordinatorCalls::ejectOperator)
20299                    }
20300                    ejectOperator
20301                },
20302                {
20303                    fn renounceOwnership(
20304                        data: &[u8],
20305                        validate: bool,
20306                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20307                        <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
20308                                data,
20309                                validate,
20310                            )
20311                            .map(RegistryCoordinatorCalls::renounceOwnership)
20312                    }
20313                    renounceOwnership
20314                },
20315                {
20316                    fn disableM2QuorumRegistration(
20317                        data: &[u8],
20318                        validate: bool,
20319                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20320                        <disableM2QuorumRegistrationCall as alloy_sol_types::SolCall>::abi_decode_raw(
20321                                data,
20322                                validate,
20323                            )
20324                            .map(RegistryCoordinatorCalls::disableM2QuorumRegistration)
20325                    }
20326                    disableM2QuorumRegistration
20327                },
20328                {
20329                    fn calculatePubkeyRegistrationMessageHash(
20330                        data: &[u8],
20331                        validate: bool,
20332                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20333                        <calculatePubkeyRegistrationMessageHashCall as alloy_sol_types::SolCall>::abi_decode_raw(
20334                                data,
20335                                validate,
20336                            )
20337                            .map(
20338                                RegistryCoordinatorCalls::calculatePubkeyRegistrationMessageHash,
20339                            )
20340                    }
20341                    calculatePubkeyRegistrationMessageHash
20342                },
20343                {
20344                    fn operatorSetsEnabled(
20345                        data: &[u8],
20346                        validate: bool,
20347                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20348                        <operatorSetsEnabledCall as alloy_sol_types::SolCall>::abi_decode_raw(
20349                                data,
20350                                validate,
20351                            )
20352                            .map(RegistryCoordinatorCalls::operatorSetsEnabled)
20353                    }
20354                    operatorSetsEnabled
20355                },
20356                {
20357                    fn createTotalDelegatedStakeQuorum(
20358                        data: &[u8],
20359                        validate: bool,
20360                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20361                        <createTotalDelegatedStakeQuorumCall as alloy_sol_types::SolCall>::abi_decode_raw(
20362                                data,
20363                                validate,
20364                            )
20365                            .map(
20366                                RegistryCoordinatorCalls::createTotalDelegatedStakeQuorum,
20367                            )
20368                    }
20369                    createTotalDelegatedStakeQuorum
20370                },
20371                {
20372                    fn eip712Domain(
20373                        data: &[u8],
20374                        validate: bool,
20375                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20376                        <eip712DomainCall as alloy_sol_types::SolCall>::abi_decode_raw(
20377                                data,
20378                                validate,
20379                            )
20380                            .map(RegistryCoordinatorCalls::eip712Domain)
20381                    }
20382                    eip712Domain
20383                },
20384                {
20385                    fn calculateOperatorChurnApprovalDigestHash(
20386                        data: &[u8],
20387                        validate: bool,
20388                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20389                        <calculateOperatorChurnApprovalDigestHashCall as alloy_sol_types::SolCall>::abi_decode_raw(
20390                                data,
20391                                validate,
20392                            )
20393                            .map(
20394                                RegistryCoordinatorCalls::calculateOperatorChurnApprovalDigestHash,
20395                            )
20396                    }
20397                    calculateOperatorChurnApprovalDigestHash
20398                },
20399                {
20400                    fn getCurrentQuorumBitmap(
20401                        data: &[u8],
20402                        validate: bool,
20403                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20404                        <getCurrentQuorumBitmapCall as alloy_sol_types::SolCall>::abi_decode_raw(
20405                                data,
20406                                validate,
20407                            )
20408                            .map(RegistryCoordinatorCalls::getCurrentQuorumBitmap)
20409                    }
20410                    getCurrentQuorumBitmap
20411                },
20412                {
20413                    fn pauserRegistry(
20414                        data: &[u8],
20415                        validate: bool,
20416                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20417                        <pauserRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
20418                                data,
20419                                validate,
20420                            )
20421                            .map(RegistryCoordinatorCalls::pauserRegistry)
20422                    }
20423                    pauserRegistry
20424                },
20425                {
20426                    fn owner(
20427                        data: &[u8],
20428                        validate: bool,
20429                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20430                        <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(
20431                                data,
20432                                validate,
20433                            )
20434                            .map(RegistryCoordinatorCalls::owner)
20435                    }
20436                    owner
20437                },
20438                {
20439                    fn quorumCount(
20440                        data: &[u8],
20441                        validate: bool,
20442                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20443                        <quorumCountCall as alloy_sol_types::SolCall>::abi_decode_raw(
20444                                data,
20445                                validate,
20446                            )
20447                            .map(RegistryCoordinatorCalls::quorumCount)
20448                    }
20449                    quorumCount
20450                },
20451                {
20452                    fn registerOperatorWithChurn(
20453                        data: &[u8],
20454                        validate: bool,
20455                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20456                        <registerOperatorWithChurnCall as alloy_sol_types::SolCall>::abi_decode_raw(
20457                                data,
20458                                validate,
20459                            )
20460                            .map(RegistryCoordinatorCalls::registerOperatorWithChurn)
20461                    }
20462                    registerOperatorWithChurn
20463                },
20464                {
20465                    fn indexRegistry(
20466                        data: &[u8],
20467                        validate: bool,
20468                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20469                        <indexRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
20470                                data,
20471                                validate,
20472                            )
20473                            .map(RegistryCoordinatorCalls::indexRegistry)
20474                    }
20475                    indexRegistry
20476                },
20477                {
20478                    fn PUBKEY_REGISTRATION_TYPEHASH(
20479                        data: &[u8],
20480                        validate: bool,
20481                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20482                        <PUBKEY_REGISTRATION_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw(
20483                                data,
20484                                validate,
20485                            )
20486                            .map(RegistryCoordinatorCalls::PUBKEY_REGISTRATION_TYPEHASH)
20487                    }
20488                    PUBKEY_REGISTRATION_TYPEHASH
20489                },
20490                {
20491                    fn isM2Quorum(
20492                        data: &[u8],
20493                        validate: bool,
20494                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20495                        <isM2QuorumCall as alloy_sol_types::SolCall>::abi_decode_raw(
20496                                data,
20497                                validate,
20498                            )
20499                            .map(RegistryCoordinatorCalls::isM2Quorum)
20500                    }
20501                    isM2Quorum
20502                },
20503                {
20504                    fn registerOperator_0(
20505                        data: &[u8],
20506                        validate: bool,
20507                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20508                        <registerOperator_0Call as alloy_sol_types::SolCall>::abi_decode_raw(
20509                                data,
20510                                validate,
20511                            )
20512                            .map(RegistryCoordinatorCalls::registerOperator_0)
20513                    }
20514                    registerOperator_0
20515                },
20516                {
20517                    fn setAVS(
20518                        data: &[u8],
20519                        validate: bool,
20520                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20521                        <setAVSCall as alloy_sol_types::SolCall>::abi_decode_raw(
20522                                data,
20523                                validate,
20524                            )
20525                            .map(RegistryCoordinatorCalls::setAVS)
20526                    }
20527                    setAVS
20528                },
20529                {
20530                    fn ejectionCooldown(
20531                        data: &[u8],
20532                        validate: bool,
20533                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20534                        <ejectionCooldownCall as alloy_sol_types::SolCall>::abi_decode_raw(
20535                                data,
20536                                validate,
20537                            )
20538                            .map(RegistryCoordinatorCalls::ejectionCooldown)
20539                    }
20540                    ejectionCooldown
20541                },
20542                {
20543                    fn supportsAVS(
20544                        data: &[u8],
20545                        validate: bool,
20546                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20547                        <supportsAVSCall as alloy_sol_types::SolCall>::abi_decode_raw(
20548                                data,
20549                                validate,
20550                            )
20551                            .map(RegistryCoordinatorCalls::supportsAVS)
20552                    }
20553                    supportsAVS
20554                },
20555                {
20556                    fn getQuorumBitmapIndicesAtBlockNumber(
20557                        data: &[u8],
20558                        validate: bool,
20559                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20560                        <getQuorumBitmapIndicesAtBlockNumberCall as alloy_sol_types::SolCall>::abi_decode_raw(
20561                                data,
20562                                validate,
20563                            )
20564                            .map(
20565                                RegistryCoordinatorCalls::getQuorumBitmapIndicesAtBlockNumber,
20566                            )
20567                    }
20568                    getQuorumBitmapIndicesAtBlockNumber
20569                },
20570                {
20571                    fn registerOperator_1(
20572                        data: &[u8],
20573                        validate: bool,
20574                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20575                        <registerOperator_1Call as alloy_sol_types::SolCall>::abi_decode_raw(
20576                                data,
20577                                validate,
20578                            )
20579                            .map(RegistryCoordinatorCalls::registerOperator_1)
20580                    }
20581                    registerOperator_1
20582                },
20583                {
20584                    fn OPERATOR_CHURN_APPROVAL_TYPEHASH(
20585                        data: &[u8],
20586                        validate: bool,
20587                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20588                        <OPERATOR_CHURN_APPROVAL_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw(
20589                                data,
20590                                validate,
20591                            )
20592                            .map(
20593                                RegistryCoordinatorCalls::OPERATOR_CHURN_APPROVAL_TYPEHASH,
20594                            )
20595                    }
20596                    OPERATOR_CHURN_APPROVAL_TYPEHASH
20597                },
20598                {
20599                    fn deregisterOperator_1(
20600                        data: &[u8],
20601                        validate: bool,
20602                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20603                        <deregisterOperator_1Call as alloy_sol_types::SolCall>::abi_decode_raw(
20604                                data,
20605                                validate,
20606                            )
20607                            .map(RegistryCoordinatorCalls::deregisterOperator_1)
20608                    }
20609                    deregisterOperator_1
20610                },
20611                {
20612                    fn allocationManager(
20613                        data: &[u8],
20614                        validate: bool,
20615                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20616                        <allocationManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(
20617                                data,
20618                                validate,
20619                            )
20620                            .map(RegistryCoordinatorCalls::allocationManager)
20621                    }
20622                    allocationManager
20623                },
20624                {
20625                    fn avs(
20626                        data: &[u8],
20627                        validate: bool,
20628                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20629                        <avsCall as alloy_sol_types::SolCall>::abi_decode_raw(
20630                                data,
20631                                validate,
20632                            )
20633                            .map(RegistryCoordinatorCalls::avs)
20634                    }
20635                    avs
20636                },
20637                {
20638                    fn getOperatorSetParams(
20639                        data: &[u8],
20640                        validate: bool,
20641                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20642                        <getOperatorSetParamsCall as alloy_sol_types::SolCall>::abi_decode_raw(
20643                                data,
20644                                validate,
20645                            )
20646                            .map(RegistryCoordinatorCalls::getOperatorSetParams)
20647                    }
20648                    getOperatorSetParams
20649                },
20650                {
20651                    fn isM2QuorumRegistrationDisabled(
20652                        data: &[u8],
20653                        validate: bool,
20654                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20655                        <isM2QuorumRegistrationDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw(
20656                                data,
20657                                validate,
20658                            )
20659                            .map(
20660                                RegistryCoordinatorCalls::isM2QuorumRegistrationDisabled,
20661                            )
20662                    }
20663                    isM2QuorumRegistrationDisabled
20664                },
20665                {
20666                    fn socketRegistry(
20667                        data: &[u8],
20668                        validate: bool,
20669                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20670                        <socketRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
20671                                data,
20672                                validate,
20673                            )
20674                            .map(RegistryCoordinatorCalls::socketRegistry)
20675                    }
20676                    socketRegistry
20677                },
20678                {
20679                    fn m2QuorumBitmap(
20680                        data: &[u8],
20681                        validate: bool,
20682                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20683                        <m2QuorumBitmapCall as alloy_sol_types::SolCall>::abi_decode_raw(
20684                                data,
20685                                validate,
20686                            )
20687                            .map(RegistryCoordinatorCalls::m2QuorumBitmap)
20688                    }
20689                    m2QuorumBitmap
20690                },
20691                {
20692                    fn transferOwnership(
20693                        data: &[u8],
20694                        validate: bool,
20695                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20696                        <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
20697                                data,
20698                                validate,
20699                            )
20700                            .map(RegistryCoordinatorCalls::transferOwnership)
20701                    }
20702                    transferOwnership
20703                },
20704                {
20705                    fn domainSeparator(
20706                        data: &[u8],
20707                        validate: bool,
20708                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20709                        <domainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
20710                                data,
20711                                validate,
20712                            )
20713                            .map(RegistryCoordinatorCalls::domainSeparator)
20714                    }
20715                    domainSeparator
20716                },
20717                {
20718                    fn unpause(
20719                        data: &[u8],
20720                        validate: bool,
20721                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20722                        <unpauseCall as alloy_sol_types::SolCall>::abi_decode_raw(
20723                                data,
20724                                validate,
20725                            )
20726                            .map(RegistryCoordinatorCalls::unpause)
20727                    }
20728                    unpause
20729                },
20730                {
20731                    fn getOperatorStatus(
20732                        data: &[u8],
20733                        validate: bool,
20734                    ) -> alloy_sol_types::Result<RegistryCoordinatorCalls> {
20735                        <getOperatorStatusCall as alloy_sol_types::SolCall>::abi_decode_raw(
20736                                data,
20737                                validate,
20738                            )
20739                            .map(RegistryCoordinatorCalls::getOperatorStatus)
20740                    }
20741                    getOperatorStatus
20742                },
20743            ];
20744            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
20745                return Err(
20746                    alloy_sol_types::Error::unknown_selector(
20747                        <Self as alloy_sol_types::SolInterface>::NAME,
20748                        selector,
20749                    ),
20750                );
20751            };
20752            DECODE_SHIMS[idx](data, validate)
20753        }
20754        #[inline]
20755        fn abi_encoded_size(&self) -> usize {
20756            match self {
20757                Self::OPERATOR_CHURN_APPROVAL_TYPEHASH(inner) => {
20758                    <OPERATOR_CHURN_APPROVAL_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encoded_size(
20759                        inner,
20760                    )
20761                }
20762                Self::PUBKEY_REGISTRATION_TYPEHASH(inner) => {
20763                    <PUBKEY_REGISTRATION_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encoded_size(
20764                        inner,
20765                    )
20766                }
20767                Self::allocationManager(inner) => {
20768                    <allocationManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(
20769                        inner,
20770                    )
20771                }
20772                Self::avs(inner) => {
20773                    <avsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
20774                }
20775                Self::blsApkRegistry(inner) => {
20776                    <blsApkRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
20777                        inner,
20778                    )
20779                }
20780                Self::calculateOperatorChurnApprovalDigestHash(inner) => {
20781                    <calculateOperatorChurnApprovalDigestHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
20782                        inner,
20783                    )
20784                }
20785                Self::calculatePubkeyRegistrationMessageHash(inner) => {
20786                    <calculatePubkeyRegistrationMessageHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
20787                        inner,
20788                    )
20789                }
20790                Self::churnApprover(inner) => {
20791                    <churnApproverCall as alloy_sol_types::SolCall>::abi_encoded_size(
20792                        inner,
20793                    )
20794                }
20795                Self::createSlashableStakeQuorum(inner) => {
20796                    <createSlashableStakeQuorumCall as alloy_sol_types::SolCall>::abi_encoded_size(
20797                        inner,
20798                    )
20799                }
20800                Self::createTotalDelegatedStakeQuorum(inner) => {
20801                    <createTotalDelegatedStakeQuorumCall as alloy_sol_types::SolCall>::abi_encoded_size(
20802                        inner,
20803                    )
20804                }
20805                Self::deregisterOperator_0(inner) => {
20806                    <deregisterOperator_0Call as alloy_sol_types::SolCall>::abi_encoded_size(
20807                        inner,
20808                    )
20809                }
20810                Self::deregisterOperator_1(inner) => {
20811                    <deregisterOperator_1Call as alloy_sol_types::SolCall>::abi_encoded_size(
20812                        inner,
20813                    )
20814                }
20815                Self::disableM2QuorumRegistration(inner) => {
20816                    <disableM2QuorumRegistrationCall as alloy_sol_types::SolCall>::abi_encoded_size(
20817                        inner,
20818                    )
20819                }
20820                Self::domainSeparator(inner) => {
20821                    <domainSeparatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
20822                        inner,
20823                    )
20824                }
20825                Self::eip712Domain(inner) => {
20826                    <eip712DomainCall as alloy_sol_types::SolCall>::abi_encoded_size(
20827                        inner,
20828                    )
20829                }
20830                Self::ejectOperator(inner) => {
20831                    <ejectOperatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
20832                        inner,
20833                    )
20834                }
20835                Self::ejectionCooldown(inner) => {
20836                    <ejectionCooldownCall as alloy_sol_types::SolCall>::abi_encoded_size(
20837                        inner,
20838                    )
20839                }
20840                Self::ejector(inner) => {
20841                    <ejectorCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
20842                }
20843                Self::getCurrentQuorumBitmap(inner) => {
20844                    <getCurrentQuorumBitmapCall as alloy_sol_types::SolCall>::abi_encoded_size(
20845                        inner,
20846                    )
20847                }
20848                Self::getOperator(inner) => {
20849                    <getOperatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
20850                        inner,
20851                    )
20852                }
20853                Self::getOperatorFromId(inner) => {
20854                    <getOperatorFromIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
20855                        inner,
20856                    )
20857                }
20858                Self::getOperatorId(inner) => {
20859                    <getOperatorIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
20860                        inner,
20861                    )
20862                }
20863                Self::getOperatorSetParams(inner) => {
20864                    <getOperatorSetParamsCall as alloy_sol_types::SolCall>::abi_encoded_size(
20865                        inner,
20866                    )
20867                }
20868                Self::getOperatorStatus(inner) => {
20869                    <getOperatorStatusCall as alloy_sol_types::SolCall>::abi_encoded_size(
20870                        inner,
20871                    )
20872                }
20873                Self::getQuorumBitmapAtBlockNumberByIndex(inner) => {
20874                    <getQuorumBitmapAtBlockNumberByIndexCall as alloy_sol_types::SolCall>::abi_encoded_size(
20875                        inner,
20876                    )
20877                }
20878                Self::getQuorumBitmapHistoryLength(inner) => {
20879                    <getQuorumBitmapHistoryLengthCall as alloy_sol_types::SolCall>::abi_encoded_size(
20880                        inner,
20881                    )
20882                }
20883                Self::getQuorumBitmapIndicesAtBlockNumber(inner) => {
20884                    <getQuorumBitmapIndicesAtBlockNumberCall as alloy_sol_types::SolCall>::abi_encoded_size(
20885                        inner,
20886                    )
20887                }
20888                Self::getQuorumBitmapUpdateByIndex(inner) => {
20889                    <getQuorumBitmapUpdateByIndexCall as alloy_sol_types::SolCall>::abi_encoded_size(
20890                        inner,
20891                    )
20892                }
20893                Self::indexRegistry(inner) => {
20894                    <indexRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
20895                        inner,
20896                    )
20897                }
20898                Self::initialize(inner) => {
20899                    <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
20900                }
20901                Self::isChurnApproverSaltUsed(inner) => {
20902                    <isChurnApproverSaltUsedCall as alloy_sol_types::SolCall>::abi_encoded_size(
20903                        inner,
20904                    )
20905                }
20906                Self::isM2Quorum(inner) => {
20907                    <isM2QuorumCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
20908                }
20909                Self::isM2QuorumRegistrationDisabled(inner) => {
20910                    <isM2QuorumRegistrationDisabledCall as alloy_sol_types::SolCall>::abi_encoded_size(
20911                        inner,
20912                    )
20913                }
20914                Self::lastEjectionTimestamp(inner) => {
20915                    <lastEjectionTimestampCall as alloy_sol_types::SolCall>::abi_encoded_size(
20916                        inner,
20917                    )
20918                }
20919                Self::m2QuorumBitmap(inner) => {
20920                    <m2QuorumBitmapCall as alloy_sol_types::SolCall>::abi_encoded_size(
20921                        inner,
20922                    )
20923                }
20924                Self::operatorSetsEnabled(inner) => {
20925                    <operatorSetsEnabledCall as alloy_sol_types::SolCall>::abi_encoded_size(
20926                        inner,
20927                    )
20928                }
20929                Self::owner(inner) => {
20930                    <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
20931                }
20932                Self::pause(inner) => {
20933                    <pauseCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
20934                }
20935                Self::pauseAll(inner) => {
20936                    <pauseAllCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
20937                }
20938                Self::paused_0(inner) => {
20939                    <paused_0Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
20940                }
20941                Self::paused_1(inner) => {
20942                    <paused_1Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
20943                }
20944                Self::pauserRegistry(inner) => {
20945                    <pauserRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
20946                        inner,
20947                    )
20948                }
20949                Self::pubkeyRegistrationMessageHash(inner) => {
20950                    <pubkeyRegistrationMessageHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
20951                        inner,
20952                    )
20953                }
20954                Self::quorumCount(inner) => {
20955                    <quorumCountCall as alloy_sol_types::SolCall>::abi_encoded_size(
20956                        inner,
20957                    )
20958                }
20959                Self::quorumUpdateBlockNumber(inner) => {
20960                    <quorumUpdateBlockNumberCall as alloy_sol_types::SolCall>::abi_encoded_size(
20961                        inner,
20962                    )
20963                }
20964                Self::registerOperator_0(inner) => {
20965                    <registerOperator_0Call as alloy_sol_types::SolCall>::abi_encoded_size(
20966                        inner,
20967                    )
20968                }
20969                Self::registerOperator_1(inner) => {
20970                    <registerOperator_1Call as alloy_sol_types::SolCall>::abi_encoded_size(
20971                        inner,
20972                    )
20973                }
20974                Self::registerOperatorWithChurn(inner) => {
20975                    <registerOperatorWithChurnCall as alloy_sol_types::SolCall>::abi_encoded_size(
20976                        inner,
20977                    )
20978                }
20979                Self::renounceOwnership(inner) => {
20980                    <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
20981                        inner,
20982                    )
20983                }
20984                Self::serviceManager(inner) => {
20985                    <serviceManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(
20986                        inner,
20987                    )
20988                }
20989                Self::setAVS(inner) => {
20990                    <setAVSCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
20991                }
20992                Self::setChurnApprover(inner) => {
20993                    <setChurnApproverCall as alloy_sol_types::SolCall>::abi_encoded_size(
20994                        inner,
20995                    )
20996                }
20997                Self::setEjectionCooldown(inner) => {
20998                    <setEjectionCooldownCall as alloy_sol_types::SolCall>::abi_encoded_size(
20999                        inner,
21000                    )
21001                }
21002                Self::setEjector(inner) => {
21003                    <setEjectorCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
21004                }
21005                Self::setOperatorSetParams(inner) => {
21006                    <setOperatorSetParamsCall as alloy_sol_types::SolCall>::abi_encoded_size(
21007                        inner,
21008                    )
21009                }
21010                Self::socketRegistry(inner) => {
21011                    <socketRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
21012                        inner,
21013                    )
21014                }
21015                Self::stakeRegistry(inner) => {
21016                    <stakeRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
21017                        inner,
21018                    )
21019                }
21020                Self::supportsAVS(inner) => {
21021                    <supportsAVSCall as alloy_sol_types::SolCall>::abi_encoded_size(
21022                        inner,
21023                    )
21024                }
21025                Self::transferOwnership(inner) => {
21026                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
21027                        inner,
21028                    )
21029                }
21030                Self::unpause(inner) => {
21031                    <unpauseCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
21032                }
21033                Self::updateOperators(inner) => {
21034                    <updateOperatorsCall as alloy_sol_types::SolCall>::abi_encoded_size(
21035                        inner,
21036                    )
21037                }
21038                Self::updateOperatorsForQuorum(inner) => {
21039                    <updateOperatorsForQuorumCall as alloy_sol_types::SolCall>::abi_encoded_size(
21040                        inner,
21041                    )
21042                }
21043                Self::updateSocket(inner) => {
21044                    <updateSocketCall as alloy_sol_types::SolCall>::abi_encoded_size(
21045                        inner,
21046                    )
21047                }
21048                Self::version(inner) => {
21049                    <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
21050                }
21051            }
21052        }
21053        #[inline]
21054        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
21055            match self {
21056                Self::OPERATOR_CHURN_APPROVAL_TYPEHASH(inner) => {
21057                    <OPERATOR_CHURN_APPROVAL_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encode_raw(
21058                        inner,
21059                        out,
21060                    )
21061                }
21062                Self::PUBKEY_REGISTRATION_TYPEHASH(inner) => {
21063                    <PUBKEY_REGISTRATION_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encode_raw(
21064                        inner,
21065                        out,
21066                    )
21067                }
21068                Self::allocationManager(inner) => {
21069                    <allocationManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(
21070                        inner,
21071                        out,
21072                    )
21073                }
21074                Self::avs(inner) => {
21075                    <avsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
21076                }
21077                Self::blsApkRegistry(inner) => {
21078                    <blsApkRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
21079                        inner,
21080                        out,
21081                    )
21082                }
21083                Self::calculateOperatorChurnApprovalDigestHash(inner) => {
21084                    <calculateOperatorChurnApprovalDigestHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
21085                        inner,
21086                        out,
21087                    )
21088                }
21089                Self::calculatePubkeyRegistrationMessageHash(inner) => {
21090                    <calculatePubkeyRegistrationMessageHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
21091                        inner,
21092                        out,
21093                    )
21094                }
21095                Self::churnApprover(inner) => {
21096                    <churnApproverCall as alloy_sol_types::SolCall>::abi_encode_raw(
21097                        inner,
21098                        out,
21099                    )
21100                }
21101                Self::createSlashableStakeQuorum(inner) => {
21102                    <createSlashableStakeQuorumCall as alloy_sol_types::SolCall>::abi_encode_raw(
21103                        inner,
21104                        out,
21105                    )
21106                }
21107                Self::createTotalDelegatedStakeQuorum(inner) => {
21108                    <createTotalDelegatedStakeQuorumCall as alloy_sol_types::SolCall>::abi_encode_raw(
21109                        inner,
21110                        out,
21111                    )
21112                }
21113                Self::deregisterOperator_0(inner) => {
21114                    <deregisterOperator_0Call as alloy_sol_types::SolCall>::abi_encode_raw(
21115                        inner,
21116                        out,
21117                    )
21118                }
21119                Self::deregisterOperator_1(inner) => {
21120                    <deregisterOperator_1Call as alloy_sol_types::SolCall>::abi_encode_raw(
21121                        inner,
21122                        out,
21123                    )
21124                }
21125                Self::disableM2QuorumRegistration(inner) => {
21126                    <disableM2QuorumRegistrationCall as alloy_sol_types::SolCall>::abi_encode_raw(
21127                        inner,
21128                        out,
21129                    )
21130                }
21131                Self::domainSeparator(inner) => {
21132                    <domainSeparatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
21133                        inner,
21134                        out,
21135                    )
21136                }
21137                Self::eip712Domain(inner) => {
21138                    <eip712DomainCall as alloy_sol_types::SolCall>::abi_encode_raw(
21139                        inner,
21140                        out,
21141                    )
21142                }
21143                Self::ejectOperator(inner) => {
21144                    <ejectOperatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
21145                        inner,
21146                        out,
21147                    )
21148                }
21149                Self::ejectionCooldown(inner) => {
21150                    <ejectionCooldownCall as alloy_sol_types::SolCall>::abi_encode_raw(
21151                        inner,
21152                        out,
21153                    )
21154                }
21155                Self::ejector(inner) => {
21156                    <ejectorCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
21157                }
21158                Self::getCurrentQuorumBitmap(inner) => {
21159                    <getCurrentQuorumBitmapCall as alloy_sol_types::SolCall>::abi_encode_raw(
21160                        inner,
21161                        out,
21162                    )
21163                }
21164                Self::getOperator(inner) => {
21165                    <getOperatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
21166                        inner,
21167                        out,
21168                    )
21169                }
21170                Self::getOperatorFromId(inner) => {
21171                    <getOperatorFromIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
21172                        inner,
21173                        out,
21174                    )
21175                }
21176                Self::getOperatorId(inner) => {
21177                    <getOperatorIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
21178                        inner,
21179                        out,
21180                    )
21181                }
21182                Self::getOperatorSetParams(inner) => {
21183                    <getOperatorSetParamsCall as alloy_sol_types::SolCall>::abi_encode_raw(
21184                        inner,
21185                        out,
21186                    )
21187                }
21188                Self::getOperatorStatus(inner) => {
21189                    <getOperatorStatusCall as alloy_sol_types::SolCall>::abi_encode_raw(
21190                        inner,
21191                        out,
21192                    )
21193                }
21194                Self::getQuorumBitmapAtBlockNumberByIndex(inner) => {
21195                    <getQuorumBitmapAtBlockNumberByIndexCall as alloy_sol_types::SolCall>::abi_encode_raw(
21196                        inner,
21197                        out,
21198                    )
21199                }
21200                Self::getQuorumBitmapHistoryLength(inner) => {
21201                    <getQuorumBitmapHistoryLengthCall as alloy_sol_types::SolCall>::abi_encode_raw(
21202                        inner,
21203                        out,
21204                    )
21205                }
21206                Self::getQuorumBitmapIndicesAtBlockNumber(inner) => {
21207                    <getQuorumBitmapIndicesAtBlockNumberCall as alloy_sol_types::SolCall>::abi_encode_raw(
21208                        inner,
21209                        out,
21210                    )
21211                }
21212                Self::getQuorumBitmapUpdateByIndex(inner) => {
21213                    <getQuorumBitmapUpdateByIndexCall as alloy_sol_types::SolCall>::abi_encode_raw(
21214                        inner,
21215                        out,
21216                    )
21217                }
21218                Self::indexRegistry(inner) => {
21219                    <indexRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
21220                        inner,
21221                        out,
21222                    )
21223                }
21224                Self::initialize(inner) => {
21225                    <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(
21226                        inner,
21227                        out,
21228                    )
21229                }
21230                Self::isChurnApproverSaltUsed(inner) => {
21231                    <isChurnApproverSaltUsedCall as alloy_sol_types::SolCall>::abi_encode_raw(
21232                        inner,
21233                        out,
21234                    )
21235                }
21236                Self::isM2Quorum(inner) => {
21237                    <isM2QuorumCall as alloy_sol_types::SolCall>::abi_encode_raw(
21238                        inner,
21239                        out,
21240                    )
21241                }
21242                Self::isM2QuorumRegistrationDisabled(inner) => {
21243                    <isM2QuorumRegistrationDisabledCall as alloy_sol_types::SolCall>::abi_encode_raw(
21244                        inner,
21245                        out,
21246                    )
21247                }
21248                Self::lastEjectionTimestamp(inner) => {
21249                    <lastEjectionTimestampCall as alloy_sol_types::SolCall>::abi_encode_raw(
21250                        inner,
21251                        out,
21252                    )
21253                }
21254                Self::m2QuorumBitmap(inner) => {
21255                    <m2QuorumBitmapCall as alloy_sol_types::SolCall>::abi_encode_raw(
21256                        inner,
21257                        out,
21258                    )
21259                }
21260                Self::operatorSetsEnabled(inner) => {
21261                    <operatorSetsEnabledCall as alloy_sol_types::SolCall>::abi_encode_raw(
21262                        inner,
21263                        out,
21264                    )
21265                }
21266                Self::owner(inner) => {
21267                    <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
21268                }
21269                Self::pause(inner) => {
21270                    <pauseCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
21271                }
21272                Self::pauseAll(inner) => {
21273                    <pauseAllCall as alloy_sol_types::SolCall>::abi_encode_raw(
21274                        inner,
21275                        out,
21276                    )
21277                }
21278                Self::paused_0(inner) => {
21279                    <paused_0Call as alloy_sol_types::SolCall>::abi_encode_raw(
21280                        inner,
21281                        out,
21282                    )
21283                }
21284                Self::paused_1(inner) => {
21285                    <paused_1Call as alloy_sol_types::SolCall>::abi_encode_raw(
21286                        inner,
21287                        out,
21288                    )
21289                }
21290                Self::pauserRegistry(inner) => {
21291                    <pauserRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
21292                        inner,
21293                        out,
21294                    )
21295                }
21296                Self::pubkeyRegistrationMessageHash(inner) => {
21297                    <pubkeyRegistrationMessageHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
21298                        inner,
21299                        out,
21300                    )
21301                }
21302                Self::quorumCount(inner) => {
21303                    <quorumCountCall as alloy_sol_types::SolCall>::abi_encode_raw(
21304                        inner,
21305                        out,
21306                    )
21307                }
21308                Self::quorumUpdateBlockNumber(inner) => {
21309                    <quorumUpdateBlockNumberCall as alloy_sol_types::SolCall>::abi_encode_raw(
21310                        inner,
21311                        out,
21312                    )
21313                }
21314                Self::registerOperator_0(inner) => {
21315                    <registerOperator_0Call as alloy_sol_types::SolCall>::abi_encode_raw(
21316                        inner,
21317                        out,
21318                    )
21319                }
21320                Self::registerOperator_1(inner) => {
21321                    <registerOperator_1Call as alloy_sol_types::SolCall>::abi_encode_raw(
21322                        inner,
21323                        out,
21324                    )
21325                }
21326                Self::registerOperatorWithChurn(inner) => {
21327                    <registerOperatorWithChurnCall as alloy_sol_types::SolCall>::abi_encode_raw(
21328                        inner,
21329                        out,
21330                    )
21331                }
21332                Self::renounceOwnership(inner) => {
21333                    <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
21334                        inner,
21335                        out,
21336                    )
21337                }
21338                Self::serviceManager(inner) => {
21339                    <serviceManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(
21340                        inner,
21341                        out,
21342                    )
21343                }
21344                Self::setAVS(inner) => {
21345                    <setAVSCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
21346                }
21347                Self::setChurnApprover(inner) => {
21348                    <setChurnApproverCall as alloy_sol_types::SolCall>::abi_encode_raw(
21349                        inner,
21350                        out,
21351                    )
21352                }
21353                Self::setEjectionCooldown(inner) => {
21354                    <setEjectionCooldownCall as alloy_sol_types::SolCall>::abi_encode_raw(
21355                        inner,
21356                        out,
21357                    )
21358                }
21359                Self::setEjector(inner) => {
21360                    <setEjectorCall as alloy_sol_types::SolCall>::abi_encode_raw(
21361                        inner,
21362                        out,
21363                    )
21364                }
21365                Self::setOperatorSetParams(inner) => {
21366                    <setOperatorSetParamsCall as alloy_sol_types::SolCall>::abi_encode_raw(
21367                        inner,
21368                        out,
21369                    )
21370                }
21371                Self::socketRegistry(inner) => {
21372                    <socketRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
21373                        inner,
21374                        out,
21375                    )
21376                }
21377                Self::stakeRegistry(inner) => {
21378                    <stakeRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
21379                        inner,
21380                        out,
21381                    )
21382                }
21383                Self::supportsAVS(inner) => {
21384                    <supportsAVSCall as alloy_sol_types::SolCall>::abi_encode_raw(
21385                        inner,
21386                        out,
21387                    )
21388                }
21389                Self::transferOwnership(inner) => {
21390                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
21391                        inner,
21392                        out,
21393                    )
21394                }
21395                Self::unpause(inner) => {
21396                    <unpauseCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
21397                }
21398                Self::updateOperators(inner) => {
21399                    <updateOperatorsCall as alloy_sol_types::SolCall>::abi_encode_raw(
21400                        inner,
21401                        out,
21402                    )
21403                }
21404                Self::updateOperatorsForQuorum(inner) => {
21405                    <updateOperatorsForQuorumCall as alloy_sol_types::SolCall>::abi_encode_raw(
21406                        inner,
21407                        out,
21408                    )
21409                }
21410                Self::updateSocket(inner) => {
21411                    <updateSocketCall as alloy_sol_types::SolCall>::abi_encode_raw(
21412                        inner,
21413                        out,
21414                    )
21415                }
21416                Self::version(inner) => {
21417                    <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
21418                }
21419            }
21420        }
21421    }
21422    ///Container for all the [`RegistryCoordinator`](self) custom errors.
21423    #[derive(Debug, PartialEq, Eq, Hash)]
21424    pub enum RegistryCoordinatorErrors {
21425        #[allow(missing_docs)]
21426        AlreadyRegisteredForQuorums(AlreadyRegisteredForQuorums),
21427        #[allow(missing_docs)]
21428        BitmapCannotBeZero(BitmapCannotBeZero),
21429        #[allow(missing_docs)]
21430        BitmapEmpty(BitmapEmpty),
21431        #[allow(missing_docs)]
21432        BitmapUpdateIsAfterBlockNumber(BitmapUpdateIsAfterBlockNumber),
21433        #[allow(missing_docs)]
21434        BitmapValueTooLarge(BitmapValueTooLarge),
21435        #[allow(missing_docs)]
21436        BytesArrayLengthTooLong(BytesArrayLengthTooLong),
21437        #[allow(missing_docs)]
21438        BytesArrayNotOrdered(BytesArrayNotOrdered),
21439        #[allow(missing_docs)]
21440        CannotChurnSelf(CannotChurnSelf),
21441        #[allow(missing_docs)]
21442        CannotKickOperatorAboveThreshold(CannotKickOperatorAboveThreshold),
21443        #[allow(missing_docs)]
21444        CannotReregisterYet(CannotReregisterYet),
21445        #[allow(missing_docs)]
21446        ChurnApproverSaltUsed(ChurnApproverSaltUsed),
21447        #[allow(missing_docs)]
21448        CurrentlyPaused(CurrentlyPaused),
21449        #[allow(missing_docs)]
21450        ExpModFailed(ExpModFailed),
21451        #[allow(missing_docs)]
21452        InputAddressZero(InputAddressZero),
21453        #[allow(missing_docs)]
21454        InputLengthMismatch(InputLengthMismatch),
21455        #[allow(missing_docs)]
21456        InsufficientStakeForChurn(InsufficientStakeForChurn),
21457        #[allow(missing_docs)]
21458        InvalidAVS(InvalidAVS),
21459        #[allow(missing_docs)]
21460        InvalidNewPausedStatus(InvalidNewPausedStatus),
21461        #[allow(missing_docs)]
21462        InvalidRegistrationType(InvalidRegistrationType),
21463        #[allow(missing_docs)]
21464        InvalidSignature(InvalidSignature),
21465        #[allow(missing_docs)]
21466        LookAheadPeriodTooLong(LookAheadPeriodTooLong),
21467        #[allow(missing_docs)]
21468        M2QuorumRegistrationIsDisabled(M2QuorumRegistrationIsDisabled),
21469        #[allow(missing_docs)]
21470        MaxOperatorCountReached(MaxOperatorCountReached),
21471        #[allow(missing_docs)]
21472        MaxQuorumsReached(MaxQuorumsReached),
21473        #[allow(missing_docs)]
21474        NextBitmapUpdateIsBeforeBlockNumber(NextBitmapUpdateIsBeforeBlockNumber),
21475        #[allow(missing_docs)]
21476        NotRegistered(NotRegistered),
21477        #[allow(missing_docs)]
21478        NotRegisteredForQuorum(NotRegisteredForQuorum),
21479        #[allow(missing_docs)]
21480        NotSorted(NotSorted),
21481        #[allow(missing_docs)]
21482        OnlyAllocationManager(OnlyAllocationManager),
21483        #[allow(missing_docs)]
21484        OnlyEjector(OnlyEjector),
21485        #[allow(missing_docs)]
21486        OnlyM2QuorumsAllowed(OnlyM2QuorumsAllowed),
21487        #[allow(missing_docs)]
21488        OnlyPauser(OnlyPauser),
21489        #[allow(missing_docs)]
21490        OnlyUnpauser(OnlyUnpauser),
21491        #[allow(missing_docs)]
21492        OperatorNotRegistered(OperatorNotRegistered),
21493        #[allow(missing_docs)]
21494        OperatorSetQuorum(OperatorSetQuorum),
21495        #[allow(missing_docs)]
21496        OperatorSetsAlreadyEnabled(OperatorSetsAlreadyEnabled),
21497        #[allow(missing_docs)]
21498        OperatorSetsNotEnabled(OperatorSetsNotEnabled),
21499        #[allow(missing_docs)]
21500        QuorumDoesNotExist(QuorumDoesNotExist),
21501        #[allow(missing_docs)]
21502        QuorumOperatorCountMismatch(QuorumOperatorCountMismatch),
21503        #[allow(missing_docs)]
21504        SignatureExpired(SignatureExpired),
21505        #[allow(missing_docs)]
21506        StringTooLong(StringTooLong),
21507    }
21508    #[automatically_derived]
21509    impl RegistryCoordinatorErrors {
21510        /// All the selectors of this enum.
21511        ///
21512        /// Note that the selectors might not be in the same order as the variants.
21513        /// No guarantees are made about the order of the selectors.
21514        ///
21515        /// Prefer using `SolInterface` methods instead.
21516        pub const SELECTORS: &'static [[u8; 4usize]] = &[
21517            [8u8, 25u8, 189u8, 205u8],
21518            [12u8, 104u8, 22u8, 205u8],
21519            [19u8, 202u8, 70u8, 87u8],
21520            [33u8, 250u8, 145u8, 243u8],
21521            [35u8, 216u8, 113u8, 165u8],
21522            [37u8, 236u8, 108u8, 31u8],
21523            [47u8, 81u8, 6u8, 228u8],
21524            [48u8, 90u8, 39u8, 169u8],
21525            [50u8, 208u8, 206u8, 250u8],
21526            [53u8, 75u8, 184u8, 171u8],
21527            [60u8, 184u8, 156u8, 151u8],
21528            [76u8, 68u8, 153u8, 93u8],
21529            [91u8, 119u8, 144u8, 25u8],
21530            [102u8, 229u8, 101u8, 223u8],
21531            [108u8, 177u8, 154u8, 255u8],
21532            [115u8, 99u8, 33u8, 118u8],
21533            [117u8, 223u8, 81u8, 220u8],
21534            [121u8, 72u8, 33u8, 255u8],
21535            [128u8, 200u8, 131u8, 72u8],
21536            [132u8, 10u8, 72u8, 213u8],
21537            [139u8, 170u8, 87u8, 159u8],
21538            [142u8, 90u8, 238u8, 231u8],
21539            [146u8, 1u8, 56u8, 19u8],
21540            [170u8, 173u8, 19u8, 247u8],
21541            [171u8, 164u8, 115u8, 57u8],
21542            [172u8, 45u8, 22u8, 130u8],
21543            [175u8, 170u8, 112u8, 239u8],
21544            [177u8, 135u8, 232u8, 105u8],
21545            [178u8, 225u8, 142u8, 5u8],
21546            [186u8, 80u8, 249u8, 17u8],
21547            [187u8, 186u8, 96u8, 203u8],
21548            [198u8, 29u8, 202u8, 93u8],
21549            [198u8, 185u8, 231u8, 103u8],
21550            [202u8, 149u8, 115u8, 51u8],
21551            [208u8, 83u8, 170u8, 33u8],
21552            [209u8, 109u8, 80u8, 234u8],
21553            [213u8, 30u8, 218u8, 227u8],
21554            [223u8, 125u8, 253u8, 134u8],
21555            [230u8, 33u8, 159u8, 234u8],
21556            [237u8, 177u8, 86u8, 46u8],
21557            [251u8, 74u8, 156u8, 142u8],
21558        ];
21559    }
21560    #[automatically_derived]
21561    impl alloy_sol_types::SolInterface for RegistryCoordinatorErrors {
21562        const NAME: &'static str = "RegistryCoordinatorErrors";
21563        const MIN_DATA_LENGTH: usize = 0usize;
21564        const COUNT: usize = 41usize;
21565        #[inline]
21566        fn selector(&self) -> [u8; 4] {
21567            match self {
21568                Self::AlreadyRegisteredForQuorums(_) => {
21569                    <AlreadyRegisteredForQuorums as alloy_sol_types::SolError>::SELECTOR
21570                }
21571                Self::BitmapCannotBeZero(_) => {
21572                    <BitmapCannotBeZero as alloy_sol_types::SolError>::SELECTOR
21573                }
21574                Self::BitmapEmpty(_) => {
21575                    <BitmapEmpty as alloy_sol_types::SolError>::SELECTOR
21576                }
21577                Self::BitmapUpdateIsAfterBlockNumber(_) => {
21578                    <BitmapUpdateIsAfterBlockNumber as alloy_sol_types::SolError>::SELECTOR
21579                }
21580                Self::BitmapValueTooLarge(_) => {
21581                    <BitmapValueTooLarge as alloy_sol_types::SolError>::SELECTOR
21582                }
21583                Self::BytesArrayLengthTooLong(_) => {
21584                    <BytesArrayLengthTooLong as alloy_sol_types::SolError>::SELECTOR
21585                }
21586                Self::BytesArrayNotOrdered(_) => {
21587                    <BytesArrayNotOrdered as alloy_sol_types::SolError>::SELECTOR
21588                }
21589                Self::CannotChurnSelf(_) => {
21590                    <CannotChurnSelf as alloy_sol_types::SolError>::SELECTOR
21591                }
21592                Self::CannotKickOperatorAboveThreshold(_) => {
21593                    <CannotKickOperatorAboveThreshold as alloy_sol_types::SolError>::SELECTOR
21594                }
21595                Self::CannotReregisterYet(_) => {
21596                    <CannotReregisterYet as alloy_sol_types::SolError>::SELECTOR
21597                }
21598                Self::ChurnApproverSaltUsed(_) => {
21599                    <ChurnApproverSaltUsed as alloy_sol_types::SolError>::SELECTOR
21600                }
21601                Self::CurrentlyPaused(_) => {
21602                    <CurrentlyPaused as alloy_sol_types::SolError>::SELECTOR
21603                }
21604                Self::ExpModFailed(_) => {
21605                    <ExpModFailed as alloy_sol_types::SolError>::SELECTOR
21606                }
21607                Self::InputAddressZero(_) => {
21608                    <InputAddressZero as alloy_sol_types::SolError>::SELECTOR
21609                }
21610                Self::InputLengthMismatch(_) => {
21611                    <InputLengthMismatch as alloy_sol_types::SolError>::SELECTOR
21612                }
21613                Self::InsufficientStakeForChurn(_) => {
21614                    <InsufficientStakeForChurn as alloy_sol_types::SolError>::SELECTOR
21615                }
21616                Self::InvalidAVS(_) => {
21617                    <InvalidAVS as alloy_sol_types::SolError>::SELECTOR
21618                }
21619                Self::InvalidNewPausedStatus(_) => {
21620                    <InvalidNewPausedStatus as alloy_sol_types::SolError>::SELECTOR
21621                }
21622                Self::InvalidRegistrationType(_) => {
21623                    <InvalidRegistrationType as alloy_sol_types::SolError>::SELECTOR
21624                }
21625                Self::InvalidSignature(_) => {
21626                    <InvalidSignature as alloy_sol_types::SolError>::SELECTOR
21627                }
21628                Self::LookAheadPeriodTooLong(_) => {
21629                    <LookAheadPeriodTooLong as alloy_sol_types::SolError>::SELECTOR
21630                }
21631                Self::M2QuorumRegistrationIsDisabled(_) => {
21632                    <M2QuorumRegistrationIsDisabled as alloy_sol_types::SolError>::SELECTOR
21633                }
21634                Self::MaxOperatorCountReached(_) => {
21635                    <MaxOperatorCountReached as alloy_sol_types::SolError>::SELECTOR
21636                }
21637                Self::MaxQuorumsReached(_) => {
21638                    <MaxQuorumsReached as alloy_sol_types::SolError>::SELECTOR
21639                }
21640                Self::NextBitmapUpdateIsBeforeBlockNumber(_) => {
21641                    <NextBitmapUpdateIsBeforeBlockNumber as alloy_sol_types::SolError>::SELECTOR
21642                }
21643                Self::NotRegistered(_) => {
21644                    <NotRegistered as alloy_sol_types::SolError>::SELECTOR
21645                }
21646                Self::NotRegisteredForQuorum(_) => {
21647                    <NotRegisteredForQuorum as alloy_sol_types::SolError>::SELECTOR
21648                }
21649                Self::NotSorted(_) => <NotSorted as alloy_sol_types::SolError>::SELECTOR,
21650                Self::OnlyAllocationManager(_) => {
21651                    <OnlyAllocationManager as alloy_sol_types::SolError>::SELECTOR
21652                }
21653                Self::OnlyEjector(_) => {
21654                    <OnlyEjector as alloy_sol_types::SolError>::SELECTOR
21655                }
21656                Self::OnlyM2QuorumsAllowed(_) => {
21657                    <OnlyM2QuorumsAllowed as alloy_sol_types::SolError>::SELECTOR
21658                }
21659                Self::OnlyPauser(_) => {
21660                    <OnlyPauser as alloy_sol_types::SolError>::SELECTOR
21661                }
21662                Self::OnlyUnpauser(_) => {
21663                    <OnlyUnpauser as alloy_sol_types::SolError>::SELECTOR
21664                }
21665                Self::OperatorNotRegistered(_) => {
21666                    <OperatorNotRegistered as alloy_sol_types::SolError>::SELECTOR
21667                }
21668                Self::OperatorSetQuorum(_) => {
21669                    <OperatorSetQuorum as alloy_sol_types::SolError>::SELECTOR
21670                }
21671                Self::OperatorSetsAlreadyEnabled(_) => {
21672                    <OperatorSetsAlreadyEnabled as alloy_sol_types::SolError>::SELECTOR
21673                }
21674                Self::OperatorSetsNotEnabled(_) => {
21675                    <OperatorSetsNotEnabled as alloy_sol_types::SolError>::SELECTOR
21676                }
21677                Self::QuorumDoesNotExist(_) => {
21678                    <QuorumDoesNotExist as alloy_sol_types::SolError>::SELECTOR
21679                }
21680                Self::QuorumOperatorCountMismatch(_) => {
21681                    <QuorumOperatorCountMismatch as alloy_sol_types::SolError>::SELECTOR
21682                }
21683                Self::SignatureExpired(_) => {
21684                    <SignatureExpired as alloy_sol_types::SolError>::SELECTOR
21685                }
21686                Self::StringTooLong(_) => {
21687                    <StringTooLong as alloy_sol_types::SolError>::SELECTOR
21688                }
21689            }
21690        }
21691        #[inline]
21692        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
21693            Self::SELECTORS.get(i).copied()
21694        }
21695        #[inline]
21696        fn valid_selector(selector: [u8; 4]) -> bool {
21697            Self::SELECTORS.binary_search(&selector).is_ok()
21698        }
21699        #[inline]
21700        #[allow(non_snake_case)]
21701        fn abi_decode_raw(
21702            selector: [u8; 4],
21703            data: &[u8],
21704            validate: bool,
21705        ) -> alloy_sol_types::Result<Self> {
21706            static DECODE_SHIMS: &[fn(
21707                &[u8],
21708                bool,
21709            ) -> alloy_sol_types::Result<RegistryCoordinatorErrors>] = &[
21710                {
21711                    fn SignatureExpired(
21712                        data: &[u8],
21713                        validate: bool,
21714                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21715                        <SignatureExpired as alloy_sol_types::SolError>::abi_decode_raw(
21716                                data,
21717                                validate,
21718                            )
21719                            .map(RegistryCoordinatorErrors::SignatureExpired)
21720                    }
21721                    SignatureExpired
21722                },
21723                {
21724                    fn AlreadyRegisteredForQuorums(
21725                        data: &[u8],
21726                        validate: bool,
21727                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21728                        <AlreadyRegisteredForQuorums as alloy_sol_types::SolError>::abi_decode_raw(
21729                                data,
21730                                validate,
21731                            )
21732                            .map(RegistryCoordinatorErrors::AlreadyRegisteredForQuorums)
21733                    }
21734                    AlreadyRegisteredForQuorums
21735                },
21736                {
21737                    fn BitmapEmpty(
21738                        data: &[u8],
21739                        validate: bool,
21740                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21741                        <BitmapEmpty as alloy_sol_types::SolError>::abi_decode_raw(
21742                                data,
21743                                validate,
21744                            )
21745                            .map(RegistryCoordinatorErrors::BitmapEmpty)
21746                    }
21747                    BitmapEmpty
21748                },
21749                {
21750                    fn M2QuorumRegistrationIsDisabled(
21751                        data: &[u8],
21752                        validate: bool,
21753                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21754                        <M2QuorumRegistrationIsDisabled as alloy_sol_types::SolError>::abi_decode_raw(
21755                                data,
21756                                validate,
21757                            )
21758                            .map(
21759                                RegistryCoordinatorErrors::M2QuorumRegistrationIsDisabled,
21760                            )
21761                    }
21762                    M2QuorumRegistrationIsDisabled
21763                },
21764                {
21765                    fn OnlyAllocationManager(
21766                        data: &[u8],
21767                        validate: bool,
21768                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21769                        <OnlyAllocationManager as alloy_sol_types::SolError>::abi_decode_raw(
21770                                data,
21771                                validate,
21772                            )
21773                            .map(RegistryCoordinatorErrors::OnlyAllocationManager)
21774                    }
21775                    OnlyAllocationManager
21776                },
21777                {
21778                    fn OperatorNotRegistered(
21779                        data: &[u8],
21780                        validate: bool,
21781                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21782                        <OperatorNotRegistered as alloy_sol_types::SolError>::abi_decode_raw(
21783                                data,
21784                                validate,
21785                            )
21786                            .map(RegistryCoordinatorErrors::OperatorNotRegistered)
21787                    }
21788                    OperatorNotRegistered
21789                },
21790                {
21791                    fn LookAheadPeriodTooLong(
21792                        data: &[u8],
21793                        validate: bool,
21794                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21795                        <LookAheadPeriodTooLong as alloy_sol_types::SolError>::abi_decode_raw(
21796                                data,
21797                                validate,
21798                            )
21799                            .map(RegistryCoordinatorErrors::LookAheadPeriodTooLong)
21800                    }
21801                    LookAheadPeriodTooLong
21802                },
21803                {
21804                    fn StringTooLong(
21805                        data: &[u8],
21806                        validate: bool,
21807                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21808                        <StringTooLong as alloy_sol_types::SolError>::abi_decode_raw(
21809                                data,
21810                                validate,
21811                            )
21812                            .map(RegistryCoordinatorErrors::StringTooLong)
21813                    }
21814                    StringTooLong
21815                },
21816                {
21817                    fn CannotReregisterYet(
21818                        data: &[u8],
21819                        validate: bool,
21820                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21821                        <CannotReregisterYet as alloy_sol_types::SolError>::abi_decode_raw(
21822                                data,
21823                                validate,
21824                            )
21825                            .map(RegistryCoordinatorErrors::CannotReregisterYet)
21826                    }
21827                    CannotReregisterYet
21828                },
21829                {
21830                    fn InvalidRegistrationType(
21831                        data: &[u8],
21832                        validate: bool,
21833                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21834                        <InvalidRegistrationType as alloy_sol_types::SolError>::abi_decode_raw(
21835                                data,
21836                                validate,
21837                            )
21838                            .map(RegistryCoordinatorErrors::InvalidRegistrationType)
21839                    }
21840                    InvalidRegistrationType
21841                },
21842                {
21843                    fn MaxQuorumsReached(
21844                        data: &[u8],
21845                        validate: bool,
21846                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21847                        <MaxQuorumsReached as alloy_sol_types::SolError>::abi_decode_raw(
21848                                data,
21849                                validate,
21850                            )
21851                            .map(RegistryCoordinatorErrors::MaxQuorumsReached)
21852                    }
21853                    MaxQuorumsReached
21854                },
21855                {
21856                    fn InsufficientStakeForChurn(
21857                        data: &[u8],
21858                        validate: bool,
21859                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21860                        <InsufficientStakeForChurn as alloy_sol_types::SolError>::abi_decode_raw(
21861                                data,
21862                                validate,
21863                            )
21864                            .map(RegistryCoordinatorErrors::InsufficientStakeForChurn)
21865                    }
21866                    InsufficientStakeForChurn
21867                },
21868                {
21869                    fn OperatorSetsNotEnabled(
21870                        data: &[u8],
21871                        validate: bool,
21872                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21873                        <OperatorSetsNotEnabled as alloy_sol_types::SolError>::abi_decode_raw(
21874                                data,
21875                                validate,
21876                            )
21877                            .map(RegistryCoordinatorErrors::OperatorSetsNotEnabled)
21878                    }
21879                    OperatorSetsNotEnabled
21880                },
21881                {
21882                    fn InvalidAVS(
21883                        data: &[u8],
21884                        validate: bool,
21885                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21886                        <InvalidAVS as alloy_sol_types::SolError>::abi_decode_raw(
21887                                data,
21888                                validate,
21889                            )
21890                            .map(RegistryCoordinatorErrors::InvalidAVS)
21891                    }
21892                    InvalidAVS
21893                },
21894                {
21895                    fn BitmapUpdateIsAfterBlockNumber(
21896                        data: &[u8],
21897                        validate: bool,
21898                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21899                        <BitmapUpdateIsAfterBlockNumber as alloy_sol_types::SolError>::abi_decode_raw(
21900                                data,
21901                                validate,
21902                            )
21903                            .map(
21904                                RegistryCoordinatorErrors::BitmapUpdateIsAfterBlockNumber,
21905                            )
21906                    }
21907                    BitmapUpdateIsAfterBlockNumber
21908                },
21909                {
21910                    fn InputAddressZero(
21911                        data: &[u8],
21912                        validate: bool,
21913                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21914                        <InputAddressZero as alloy_sol_types::SolError>::abi_decode_raw(
21915                                data,
21916                                validate,
21917                            )
21918                            .map(RegistryCoordinatorErrors::InputAddressZero)
21919                    }
21920                    InputAddressZero
21921                },
21922                {
21923                    fn OnlyPauser(
21924                        data: &[u8],
21925                        validate: bool,
21926                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21927                        <OnlyPauser as alloy_sol_types::SolError>::abi_decode_raw(
21928                                data,
21929                                validate,
21930                            )
21931                            .map(RegistryCoordinatorErrors::OnlyPauser)
21932                    }
21933                    OnlyPauser
21934                },
21935                {
21936                    fn OnlyUnpauser(
21937                        data: &[u8],
21938                        validate: bool,
21939                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21940                        <OnlyUnpauser as alloy_sol_types::SolError>::abi_decode_raw(
21941                                data,
21942                                validate,
21943                            )
21944                            .map(RegistryCoordinatorErrors::OnlyUnpauser)
21945                    }
21946                    OnlyUnpauser
21947                },
21948                {
21949                    fn BytesArrayNotOrdered(
21950                        data: &[u8],
21951                        validate: bool,
21952                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21953                        <BytesArrayNotOrdered as alloy_sol_types::SolError>::abi_decode_raw(
21954                                data,
21955                                validate,
21956                            )
21957                            .map(RegistryCoordinatorErrors::BytesArrayNotOrdered)
21958                    }
21959                    BytesArrayNotOrdered
21960                },
21961                {
21962                    fn CurrentlyPaused(
21963                        data: &[u8],
21964                        validate: bool,
21965                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21966                        <CurrentlyPaused as alloy_sol_types::SolError>::abi_decode_raw(
21967                                data,
21968                                validate,
21969                            )
21970                            .map(RegistryCoordinatorErrors::CurrentlyPaused)
21971                    }
21972                    CurrentlyPaused
21973                },
21974                {
21975                    fn InvalidSignature(
21976                        data: &[u8],
21977                        validate: bool,
21978                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21979                        <InvalidSignature as alloy_sol_types::SolError>::abi_decode_raw(
21980                                data,
21981                                validate,
21982                            )
21983                            .map(RegistryCoordinatorErrors::InvalidSignature)
21984                    }
21985                    InvalidSignature
21986                },
21987                {
21988                    fn QuorumOperatorCountMismatch(
21989                        data: &[u8],
21990                        validate: bool,
21991                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
21992                        <QuorumOperatorCountMismatch as alloy_sol_types::SolError>::abi_decode_raw(
21993                                data,
21994                                validate,
21995                            )
21996                            .map(RegistryCoordinatorErrors::QuorumOperatorCountMismatch)
21997                    }
21998                    QuorumOperatorCountMismatch
21999                },
22000                {
22001                    fn OperatorSetQuorum(
22002                        data: &[u8],
22003                        validate: bool,
22004                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
22005                        <OperatorSetQuorum as alloy_sol_types::SolError>::abi_decode_raw(
22006                                data,
22007                                validate,
22008                            )
22009                            .map(RegistryCoordinatorErrors::OperatorSetQuorum)
22010                    }
22011                    OperatorSetQuorum
22012                },
22013                {
22014                    fn InputLengthMismatch(
22015                        data: &[u8],
22016                        validate: bool,
22017                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
22018                        <InputLengthMismatch as alloy_sol_types::SolError>::abi_decode_raw(
22019                                data,
22020                                validate,
22021                            )
22022                            .map(RegistryCoordinatorErrors::InputLengthMismatch)
22023                    }
22024                    InputLengthMismatch
22025                },
22026                {
22027                    fn NotRegistered(
22028                        data: &[u8],
22029                        validate: bool,
22030                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
22031                        <NotRegistered as alloy_sol_types::SolError>::abi_decode_raw(
22032                                data,
22033                                validate,
22034                            )
22035                            .map(RegistryCoordinatorErrors::NotRegistered)
22036                    }
22037                    NotRegistered
22038                },
22039                {
22040                    fn CannotChurnSelf(
22041                        data: &[u8],
22042                        validate: bool,
22043                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
22044                        <CannotChurnSelf as alloy_sol_types::SolError>::abi_decode_raw(
22045                                data,
22046                                validate,
22047                            )
22048                            .map(RegistryCoordinatorErrors::CannotChurnSelf)
22049                    }
22050                    CannotChurnSelf
22051                },
22052                {
22053                    fn OnlyM2QuorumsAllowed(
22054                        data: &[u8],
22055                        validate: bool,
22056                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
22057                        <OnlyM2QuorumsAllowed as alloy_sol_types::SolError>::abi_decode_raw(
22058                                data,
22059                                validate,
22060                            )
22061                            .map(RegistryCoordinatorErrors::OnlyM2QuorumsAllowed)
22062                    }
22063                    OnlyM2QuorumsAllowed
22064                },
22065                {
22066                    fn CannotKickOperatorAboveThreshold(
22067                        data: &[u8],
22068                        validate: bool,
22069                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
22070                        <CannotKickOperatorAboveThreshold as alloy_sol_types::SolError>::abi_decode_raw(
22071                                data,
22072                                validate,
22073                            )
22074                            .map(
22075                                RegistryCoordinatorErrors::CannotKickOperatorAboveThreshold,
22076                            )
22077                    }
22078                    CannotKickOperatorAboveThreshold
22079                },
22080                {
22081                    fn OperatorSetsAlreadyEnabled(
22082                        data: &[u8],
22083                        validate: bool,
22084                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
22085                        <OperatorSetsAlreadyEnabled as alloy_sol_types::SolError>::abi_decode_raw(
22086                                data,
22087                                validate,
22088                            )
22089                            .map(RegistryCoordinatorErrors::OperatorSetsAlreadyEnabled)
22090                    }
22091                    OperatorSetsAlreadyEnabled
22092                },
22093                {
22094                    fn NotSorted(
22095                        data: &[u8],
22096                        validate: bool,
22097                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
22098                        <NotSorted as alloy_sol_types::SolError>::abi_decode_raw(
22099                                data,
22100                                validate,
22101                            )
22102                            .map(RegistryCoordinatorErrors::NotSorted)
22103                    }
22104                    NotSorted
22105                },
22106                {
22107                    fn NextBitmapUpdateIsBeforeBlockNumber(
22108                        data: &[u8],
22109                        validate: bool,
22110                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
22111                        <NextBitmapUpdateIsBeforeBlockNumber as alloy_sol_types::SolError>::abi_decode_raw(
22112                                data,
22113                                validate,
22114                            )
22115                            .map(
22116                                RegistryCoordinatorErrors::NextBitmapUpdateIsBeforeBlockNumber,
22117                            )
22118                    }
22119                    NextBitmapUpdateIsBeforeBlockNumber
22120                },
22121                {
22122                    fn InvalidNewPausedStatus(
22123                        data: &[u8],
22124                        validate: bool,
22125                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
22126                        <InvalidNewPausedStatus as alloy_sol_types::SolError>::abi_decode_raw(
22127                                data,
22128                                validate,
22129                            )
22130                            .map(RegistryCoordinatorErrors::InvalidNewPausedStatus)
22131                    }
22132                    InvalidNewPausedStatus
22133                },
22134                {
22135                    fn MaxOperatorCountReached(
22136                        data: &[u8],
22137                        validate: bool,
22138                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
22139                        <MaxOperatorCountReached as alloy_sol_types::SolError>::abi_decode_raw(
22140                                data,
22141                                validate,
22142                            )
22143                            .map(RegistryCoordinatorErrors::MaxOperatorCountReached)
22144                    }
22145                    MaxOperatorCountReached
22146                },
22147                {
22148                    fn BitmapValueTooLarge(
22149                        data: &[u8],
22150                        validate: bool,
22151                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
22152                        <BitmapValueTooLarge as alloy_sol_types::SolError>::abi_decode_raw(
22153                                data,
22154                                validate,
22155                            )
22156                            .map(RegistryCoordinatorErrors::BitmapValueTooLarge)
22157                    }
22158                    BitmapValueTooLarge
22159                },
22160                {
22161                    fn NotRegisteredForQuorum(
22162                        data: &[u8],
22163                        validate: bool,
22164                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
22165                        <NotRegisteredForQuorum as alloy_sol_types::SolError>::abi_decode_raw(
22166                                data,
22167                                validate,
22168                            )
22169                            .map(RegistryCoordinatorErrors::NotRegisteredForQuorum)
22170                    }
22171                    NotRegisteredForQuorum
22172                },
22173                {
22174                    fn BitmapCannotBeZero(
22175                        data: &[u8],
22176                        validate: bool,
22177                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
22178                        <BitmapCannotBeZero as alloy_sol_types::SolError>::abi_decode_raw(
22179                                data,
22180                                validate,
22181                            )
22182                            .map(RegistryCoordinatorErrors::BitmapCannotBeZero)
22183                    }
22184                    BitmapCannotBeZero
22185                },
22186                {
22187                    fn ExpModFailed(
22188                        data: &[u8],
22189                        validate: bool,
22190                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
22191                        <ExpModFailed as alloy_sol_types::SolError>::abi_decode_raw(
22192                                data,
22193                                validate,
22194                            )
22195                            .map(RegistryCoordinatorErrors::ExpModFailed)
22196                    }
22197                    ExpModFailed
22198                },
22199                {
22200                    fn ChurnApproverSaltUsed(
22201                        data: &[u8],
22202                        validate: bool,
22203                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
22204                        <ChurnApproverSaltUsed as alloy_sol_types::SolError>::abi_decode_raw(
22205                                data,
22206                                validate,
22207                            )
22208                            .map(RegistryCoordinatorErrors::ChurnApproverSaltUsed)
22209                    }
22210                    ChurnApproverSaltUsed
22211                },
22212                {
22213                    fn QuorumDoesNotExist(
22214                        data: &[u8],
22215                        validate: bool,
22216                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
22217                        <QuorumDoesNotExist as alloy_sol_types::SolError>::abi_decode_raw(
22218                                data,
22219                                validate,
22220                            )
22221                            .map(RegistryCoordinatorErrors::QuorumDoesNotExist)
22222                    }
22223                    QuorumDoesNotExist
22224                },
22225                {
22226                    fn OnlyEjector(
22227                        data: &[u8],
22228                        validate: bool,
22229                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
22230                        <OnlyEjector as alloy_sol_types::SolError>::abi_decode_raw(
22231                                data,
22232                                validate,
22233                            )
22234                            .map(RegistryCoordinatorErrors::OnlyEjector)
22235                    }
22236                    OnlyEjector
22237                },
22238                {
22239                    fn BytesArrayLengthTooLong(
22240                        data: &[u8],
22241                        validate: bool,
22242                    ) -> alloy_sol_types::Result<RegistryCoordinatorErrors> {
22243                        <BytesArrayLengthTooLong as alloy_sol_types::SolError>::abi_decode_raw(
22244                                data,
22245                                validate,
22246                            )
22247                            .map(RegistryCoordinatorErrors::BytesArrayLengthTooLong)
22248                    }
22249                    BytesArrayLengthTooLong
22250                },
22251            ];
22252            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
22253                return Err(
22254                    alloy_sol_types::Error::unknown_selector(
22255                        <Self as alloy_sol_types::SolInterface>::NAME,
22256                        selector,
22257                    ),
22258                );
22259            };
22260            DECODE_SHIMS[idx](data, validate)
22261        }
22262        #[inline]
22263        fn abi_encoded_size(&self) -> usize {
22264            match self {
22265                Self::AlreadyRegisteredForQuorums(inner) => {
22266                    <AlreadyRegisteredForQuorums as alloy_sol_types::SolError>::abi_encoded_size(
22267                        inner,
22268                    )
22269                }
22270                Self::BitmapCannotBeZero(inner) => {
22271                    <BitmapCannotBeZero as alloy_sol_types::SolError>::abi_encoded_size(
22272                        inner,
22273                    )
22274                }
22275                Self::BitmapEmpty(inner) => {
22276                    <BitmapEmpty as alloy_sol_types::SolError>::abi_encoded_size(inner)
22277                }
22278                Self::BitmapUpdateIsAfterBlockNumber(inner) => {
22279                    <BitmapUpdateIsAfterBlockNumber as alloy_sol_types::SolError>::abi_encoded_size(
22280                        inner,
22281                    )
22282                }
22283                Self::BitmapValueTooLarge(inner) => {
22284                    <BitmapValueTooLarge as alloy_sol_types::SolError>::abi_encoded_size(
22285                        inner,
22286                    )
22287                }
22288                Self::BytesArrayLengthTooLong(inner) => {
22289                    <BytesArrayLengthTooLong as alloy_sol_types::SolError>::abi_encoded_size(
22290                        inner,
22291                    )
22292                }
22293                Self::BytesArrayNotOrdered(inner) => {
22294                    <BytesArrayNotOrdered as alloy_sol_types::SolError>::abi_encoded_size(
22295                        inner,
22296                    )
22297                }
22298                Self::CannotChurnSelf(inner) => {
22299                    <CannotChurnSelf as alloy_sol_types::SolError>::abi_encoded_size(
22300                        inner,
22301                    )
22302                }
22303                Self::CannotKickOperatorAboveThreshold(inner) => {
22304                    <CannotKickOperatorAboveThreshold as alloy_sol_types::SolError>::abi_encoded_size(
22305                        inner,
22306                    )
22307                }
22308                Self::CannotReregisterYet(inner) => {
22309                    <CannotReregisterYet as alloy_sol_types::SolError>::abi_encoded_size(
22310                        inner,
22311                    )
22312                }
22313                Self::ChurnApproverSaltUsed(inner) => {
22314                    <ChurnApproverSaltUsed as alloy_sol_types::SolError>::abi_encoded_size(
22315                        inner,
22316                    )
22317                }
22318                Self::CurrentlyPaused(inner) => {
22319                    <CurrentlyPaused as alloy_sol_types::SolError>::abi_encoded_size(
22320                        inner,
22321                    )
22322                }
22323                Self::ExpModFailed(inner) => {
22324                    <ExpModFailed as alloy_sol_types::SolError>::abi_encoded_size(inner)
22325                }
22326                Self::InputAddressZero(inner) => {
22327                    <InputAddressZero as alloy_sol_types::SolError>::abi_encoded_size(
22328                        inner,
22329                    )
22330                }
22331                Self::InputLengthMismatch(inner) => {
22332                    <InputLengthMismatch as alloy_sol_types::SolError>::abi_encoded_size(
22333                        inner,
22334                    )
22335                }
22336                Self::InsufficientStakeForChurn(inner) => {
22337                    <InsufficientStakeForChurn as alloy_sol_types::SolError>::abi_encoded_size(
22338                        inner,
22339                    )
22340                }
22341                Self::InvalidAVS(inner) => {
22342                    <InvalidAVS as alloy_sol_types::SolError>::abi_encoded_size(inner)
22343                }
22344                Self::InvalidNewPausedStatus(inner) => {
22345                    <InvalidNewPausedStatus as alloy_sol_types::SolError>::abi_encoded_size(
22346                        inner,
22347                    )
22348                }
22349                Self::InvalidRegistrationType(inner) => {
22350                    <InvalidRegistrationType as alloy_sol_types::SolError>::abi_encoded_size(
22351                        inner,
22352                    )
22353                }
22354                Self::InvalidSignature(inner) => {
22355                    <InvalidSignature as alloy_sol_types::SolError>::abi_encoded_size(
22356                        inner,
22357                    )
22358                }
22359                Self::LookAheadPeriodTooLong(inner) => {
22360                    <LookAheadPeriodTooLong as alloy_sol_types::SolError>::abi_encoded_size(
22361                        inner,
22362                    )
22363                }
22364                Self::M2QuorumRegistrationIsDisabled(inner) => {
22365                    <M2QuorumRegistrationIsDisabled as alloy_sol_types::SolError>::abi_encoded_size(
22366                        inner,
22367                    )
22368                }
22369                Self::MaxOperatorCountReached(inner) => {
22370                    <MaxOperatorCountReached as alloy_sol_types::SolError>::abi_encoded_size(
22371                        inner,
22372                    )
22373                }
22374                Self::MaxQuorumsReached(inner) => {
22375                    <MaxQuorumsReached as alloy_sol_types::SolError>::abi_encoded_size(
22376                        inner,
22377                    )
22378                }
22379                Self::NextBitmapUpdateIsBeforeBlockNumber(inner) => {
22380                    <NextBitmapUpdateIsBeforeBlockNumber as alloy_sol_types::SolError>::abi_encoded_size(
22381                        inner,
22382                    )
22383                }
22384                Self::NotRegistered(inner) => {
22385                    <NotRegistered as alloy_sol_types::SolError>::abi_encoded_size(inner)
22386                }
22387                Self::NotRegisteredForQuorum(inner) => {
22388                    <NotRegisteredForQuorum as alloy_sol_types::SolError>::abi_encoded_size(
22389                        inner,
22390                    )
22391                }
22392                Self::NotSorted(inner) => {
22393                    <NotSorted as alloy_sol_types::SolError>::abi_encoded_size(inner)
22394                }
22395                Self::OnlyAllocationManager(inner) => {
22396                    <OnlyAllocationManager as alloy_sol_types::SolError>::abi_encoded_size(
22397                        inner,
22398                    )
22399                }
22400                Self::OnlyEjector(inner) => {
22401                    <OnlyEjector as alloy_sol_types::SolError>::abi_encoded_size(inner)
22402                }
22403                Self::OnlyM2QuorumsAllowed(inner) => {
22404                    <OnlyM2QuorumsAllowed as alloy_sol_types::SolError>::abi_encoded_size(
22405                        inner,
22406                    )
22407                }
22408                Self::OnlyPauser(inner) => {
22409                    <OnlyPauser as alloy_sol_types::SolError>::abi_encoded_size(inner)
22410                }
22411                Self::OnlyUnpauser(inner) => {
22412                    <OnlyUnpauser as alloy_sol_types::SolError>::abi_encoded_size(inner)
22413                }
22414                Self::OperatorNotRegistered(inner) => {
22415                    <OperatorNotRegistered as alloy_sol_types::SolError>::abi_encoded_size(
22416                        inner,
22417                    )
22418                }
22419                Self::OperatorSetQuorum(inner) => {
22420                    <OperatorSetQuorum as alloy_sol_types::SolError>::abi_encoded_size(
22421                        inner,
22422                    )
22423                }
22424                Self::OperatorSetsAlreadyEnabled(inner) => {
22425                    <OperatorSetsAlreadyEnabled as alloy_sol_types::SolError>::abi_encoded_size(
22426                        inner,
22427                    )
22428                }
22429                Self::OperatorSetsNotEnabled(inner) => {
22430                    <OperatorSetsNotEnabled as alloy_sol_types::SolError>::abi_encoded_size(
22431                        inner,
22432                    )
22433                }
22434                Self::QuorumDoesNotExist(inner) => {
22435                    <QuorumDoesNotExist as alloy_sol_types::SolError>::abi_encoded_size(
22436                        inner,
22437                    )
22438                }
22439                Self::QuorumOperatorCountMismatch(inner) => {
22440                    <QuorumOperatorCountMismatch as alloy_sol_types::SolError>::abi_encoded_size(
22441                        inner,
22442                    )
22443                }
22444                Self::SignatureExpired(inner) => {
22445                    <SignatureExpired as alloy_sol_types::SolError>::abi_encoded_size(
22446                        inner,
22447                    )
22448                }
22449                Self::StringTooLong(inner) => {
22450                    <StringTooLong as alloy_sol_types::SolError>::abi_encoded_size(inner)
22451                }
22452            }
22453        }
22454        #[inline]
22455        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
22456            match self {
22457                Self::AlreadyRegisteredForQuorums(inner) => {
22458                    <AlreadyRegisteredForQuorums as alloy_sol_types::SolError>::abi_encode_raw(
22459                        inner,
22460                        out,
22461                    )
22462                }
22463                Self::BitmapCannotBeZero(inner) => {
22464                    <BitmapCannotBeZero as alloy_sol_types::SolError>::abi_encode_raw(
22465                        inner,
22466                        out,
22467                    )
22468                }
22469                Self::BitmapEmpty(inner) => {
22470                    <BitmapEmpty as alloy_sol_types::SolError>::abi_encode_raw(
22471                        inner,
22472                        out,
22473                    )
22474                }
22475                Self::BitmapUpdateIsAfterBlockNumber(inner) => {
22476                    <BitmapUpdateIsAfterBlockNumber as alloy_sol_types::SolError>::abi_encode_raw(
22477                        inner,
22478                        out,
22479                    )
22480                }
22481                Self::BitmapValueTooLarge(inner) => {
22482                    <BitmapValueTooLarge as alloy_sol_types::SolError>::abi_encode_raw(
22483                        inner,
22484                        out,
22485                    )
22486                }
22487                Self::BytesArrayLengthTooLong(inner) => {
22488                    <BytesArrayLengthTooLong as alloy_sol_types::SolError>::abi_encode_raw(
22489                        inner,
22490                        out,
22491                    )
22492                }
22493                Self::BytesArrayNotOrdered(inner) => {
22494                    <BytesArrayNotOrdered as alloy_sol_types::SolError>::abi_encode_raw(
22495                        inner,
22496                        out,
22497                    )
22498                }
22499                Self::CannotChurnSelf(inner) => {
22500                    <CannotChurnSelf as alloy_sol_types::SolError>::abi_encode_raw(
22501                        inner,
22502                        out,
22503                    )
22504                }
22505                Self::CannotKickOperatorAboveThreshold(inner) => {
22506                    <CannotKickOperatorAboveThreshold as alloy_sol_types::SolError>::abi_encode_raw(
22507                        inner,
22508                        out,
22509                    )
22510                }
22511                Self::CannotReregisterYet(inner) => {
22512                    <CannotReregisterYet as alloy_sol_types::SolError>::abi_encode_raw(
22513                        inner,
22514                        out,
22515                    )
22516                }
22517                Self::ChurnApproverSaltUsed(inner) => {
22518                    <ChurnApproverSaltUsed as alloy_sol_types::SolError>::abi_encode_raw(
22519                        inner,
22520                        out,
22521                    )
22522                }
22523                Self::CurrentlyPaused(inner) => {
22524                    <CurrentlyPaused as alloy_sol_types::SolError>::abi_encode_raw(
22525                        inner,
22526                        out,
22527                    )
22528                }
22529                Self::ExpModFailed(inner) => {
22530                    <ExpModFailed as alloy_sol_types::SolError>::abi_encode_raw(
22531                        inner,
22532                        out,
22533                    )
22534                }
22535                Self::InputAddressZero(inner) => {
22536                    <InputAddressZero as alloy_sol_types::SolError>::abi_encode_raw(
22537                        inner,
22538                        out,
22539                    )
22540                }
22541                Self::InputLengthMismatch(inner) => {
22542                    <InputLengthMismatch as alloy_sol_types::SolError>::abi_encode_raw(
22543                        inner,
22544                        out,
22545                    )
22546                }
22547                Self::InsufficientStakeForChurn(inner) => {
22548                    <InsufficientStakeForChurn as alloy_sol_types::SolError>::abi_encode_raw(
22549                        inner,
22550                        out,
22551                    )
22552                }
22553                Self::InvalidAVS(inner) => {
22554                    <InvalidAVS as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
22555                }
22556                Self::InvalidNewPausedStatus(inner) => {
22557                    <InvalidNewPausedStatus as alloy_sol_types::SolError>::abi_encode_raw(
22558                        inner,
22559                        out,
22560                    )
22561                }
22562                Self::InvalidRegistrationType(inner) => {
22563                    <InvalidRegistrationType as alloy_sol_types::SolError>::abi_encode_raw(
22564                        inner,
22565                        out,
22566                    )
22567                }
22568                Self::InvalidSignature(inner) => {
22569                    <InvalidSignature as alloy_sol_types::SolError>::abi_encode_raw(
22570                        inner,
22571                        out,
22572                    )
22573                }
22574                Self::LookAheadPeriodTooLong(inner) => {
22575                    <LookAheadPeriodTooLong as alloy_sol_types::SolError>::abi_encode_raw(
22576                        inner,
22577                        out,
22578                    )
22579                }
22580                Self::M2QuorumRegistrationIsDisabled(inner) => {
22581                    <M2QuorumRegistrationIsDisabled as alloy_sol_types::SolError>::abi_encode_raw(
22582                        inner,
22583                        out,
22584                    )
22585                }
22586                Self::MaxOperatorCountReached(inner) => {
22587                    <MaxOperatorCountReached as alloy_sol_types::SolError>::abi_encode_raw(
22588                        inner,
22589                        out,
22590                    )
22591                }
22592                Self::MaxQuorumsReached(inner) => {
22593                    <MaxQuorumsReached as alloy_sol_types::SolError>::abi_encode_raw(
22594                        inner,
22595                        out,
22596                    )
22597                }
22598                Self::NextBitmapUpdateIsBeforeBlockNumber(inner) => {
22599                    <NextBitmapUpdateIsBeforeBlockNumber as alloy_sol_types::SolError>::abi_encode_raw(
22600                        inner,
22601                        out,
22602                    )
22603                }
22604                Self::NotRegistered(inner) => {
22605                    <NotRegistered as alloy_sol_types::SolError>::abi_encode_raw(
22606                        inner,
22607                        out,
22608                    )
22609                }
22610                Self::NotRegisteredForQuorum(inner) => {
22611                    <NotRegisteredForQuorum as alloy_sol_types::SolError>::abi_encode_raw(
22612                        inner,
22613                        out,
22614                    )
22615                }
22616                Self::NotSorted(inner) => {
22617                    <NotSorted as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
22618                }
22619                Self::OnlyAllocationManager(inner) => {
22620                    <OnlyAllocationManager as alloy_sol_types::SolError>::abi_encode_raw(
22621                        inner,
22622                        out,
22623                    )
22624                }
22625                Self::OnlyEjector(inner) => {
22626                    <OnlyEjector as alloy_sol_types::SolError>::abi_encode_raw(
22627                        inner,
22628                        out,
22629                    )
22630                }
22631                Self::OnlyM2QuorumsAllowed(inner) => {
22632                    <OnlyM2QuorumsAllowed as alloy_sol_types::SolError>::abi_encode_raw(
22633                        inner,
22634                        out,
22635                    )
22636                }
22637                Self::OnlyPauser(inner) => {
22638                    <OnlyPauser as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
22639                }
22640                Self::OnlyUnpauser(inner) => {
22641                    <OnlyUnpauser as alloy_sol_types::SolError>::abi_encode_raw(
22642                        inner,
22643                        out,
22644                    )
22645                }
22646                Self::OperatorNotRegistered(inner) => {
22647                    <OperatorNotRegistered as alloy_sol_types::SolError>::abi_encode_raw(
22648                        inner,
22649                        out,
22650                    )
22651                }
22652                Self::OperatorSetQuorum(inner) => {
22653                    <OperatorSetQuorum as alloy_sol_types::SolError>::abi_encode_raw(
22654                        inner,
22655                        out,
22656                    )
22657                }
22658                Self::OperatorSetsAlreadyEnabled(inner) => {
22659                    <OperatorSetsAlreadyEnabled as alloy_sol_types::SolError>::abi_encode_raw(
22660                        inner,
22661                        out,
22662                    )
22663                }
22664                Self::OperatorSetsNotEnabled(inner) => {
22665                    <OperatorSetsNotEnabled as alloy_sol_types::SolError>::abi_encode_raw(
22666                        inner,
22667                        out,
22668                    )
22669                }
22670                Self::QuorumDoesNotExist(inner) => {
22671                    <QuorumDoesNotExist as alloy_sol_types::SolError>::abi_encode_raw(
22672                        inner,
22673                        out,
22674                    )
22675                }
22676                Self::QuorumOperatorCountMismatch(inner) => {
22677                    <QuorumOperatorCountMismatch as alloy_sol_types::SolError>::abi_encode_raw(
22678                        inner,
22679                        out,
22680                    )
22681                }
22682                Self::SignatureExpired(inner) => {
22683                    <SignatureExpired as alloy_sol_types::SolError>::abi_encode_raw(
22684                        inner,
22685                        out,
22686                    )
22687                }
22688                Self::StringTooLong(inner) => {
22689                    <StringTooLong as alloy_sol_types::SolError>::abi_encode_raw(
22690                        inner,
22691                        out,
22692                    )
22693                }
22694            }
22695        }
22696    }
22697    ///Container for all the [`RegistryCoordinator`](self) events.
22698    #[derive(Debug, PartialEq, Eq, Hash)]
22699    pub enum RegistryCoordinatorEvents {
22700        #[allow(missing_docs)]
22701        AVSUpdated(AVSUpdated),
22702        #[allow(missing_docs)]
22703        ChurnApproverUpdated(ChurnApproverUpdated),
22704        #[allow(missing_docs)]
22705        EIP712DomainChanged(EIP712DomainChanged),
22706        #[allow(missing_docs)]
22707        EjectionCooldownUpdated(EjectionCooldownUpdated),
22708        #[allow(missing_docs)]
22709        EjectorUpdated(EjectorUpdated),
22710        #[allow(missing_docs)]
22711        Initialized(Initialized),
22712        #[allow(missing_docs)]
22713        M2QuorumRegistrationDisabled(M2QuorumRegistrationDisabled),
22714        #[allow(missing_docs)]
22715        OperatorDeregistered(OperatorDeregistered),
22716        #[allow(missing_docs)]
22717        OperatorRegistered(OperatorRegistered),
22718        #[allow(missing_docs)]
22719        OperatorSetParamsUpdated(OperatorSetParamsUpdated),
22720        #[allow(missing_docs)]
22721        OperatorSetsEnabled(OperatorSetsEnabled),
22722        #[allow(missing_docs)]
22723        OperatorSocketUpdate(OperatorSocketUpdate),
22724        #[allow(missing_docs)]
22725        OwnershipTransferred(OwnershipTransferred),
22726        #[allow(missing_docs)]
22727        Paused(Paused),
22728        #[allow(missing_docs)]
22729        QuorumBlockNumberUpdated(QuorumBlockNumberUpdated),
22730        #[allow(missing_docs)]
22731        QuorumCreated(QuorumCreated),
22732        #[allow(missing_docs)]
22733        Unpaused(Unpaused),
22734    }
22735    #[automatically_derived]
22736    impl RegistryCoordinatorEvents {
22737        /// All the selectors of this enum.
22738        ///
22739        /// Note that the selectors might not be in the same order as the variants.
22740        /// No guarantees are made about the order of the selectors.
22741        ///
22742        /// Prefer using `SolInterface` methods instead.
22743        pub const SELECTORS: &'static [[u8; 32usize]] = &[
22744            [
22745                10u8, 99u8, 135u8, 201u8, 234u8, 54u8, 40u8, 184u8, 138u8, 99u8, 59u8,
22746                180u8, 243u8, 177u8, 81u8, 119u8, 15u8, 112u8, 8u8, 81u8, 23u8, 161u8,
22747                95u8, 155u8, 243u8, 120u8, 124u8, 218u8, 83u8, 241u8, 61u8, 49u8,
22748            ],
22749            [
22750                11u8, 136u8, 48u8, 111u8, 244u8, 98u8, 113u8, 33u8, 245u8, 179u8, 229u8,
22751                177u8, 197u8, 248u8, 143u8, 107u8, 30u8, 66u8, 253u8, 44u8, 4u8, 120u8,
22752                239u8, 28u8, 145u8, 102u8, 45u8, 73u8, 209u8, 240u8, 119u8, 85u8,
22753            ],
22754            [
22755                15u8, 195u8, 192u8, 230u8, 248u8, 180u8, 121u8, 95u8, 55u8, 30u8, 25u8,
22756                222u8, 127u8, 76u8, 87u8, 51u8, 221u8, 158u8, 84u8, 159u8, 168u8, 195u8,
22757                158u8, 88u8, 66u8, 235u8, 102u8, 195u8, 21u8, 114u8, 217u8, 158u8,
22758            ],
22759            [
22760                49u8, 84u8, 87u8, 216u8, 168u8, 254u8, 96u8, 240u8, 74u8, 241u8, 124u8,
22761                22u8, 226u8, 245u8, 165u8, 225u8, 219u8, 97u8, 43u8, 49u8, 100u8, 142u8,
22762                88u8, 3u8, 3u8, 96u8, 117u8, 158u8, 248u8, 243u8, 82u8, 140u8,
22763            ],
22764            [
22765                53u8, 130u8, 209u8, 130u8, 142u8, 38u8, 191u8, 86u8, 189u8, 128u8, 21u8,
22766                2u8, 188u8, 2u8, 26u8, 192u8, 188u8, 138u8, 251u8, 87u8, 200u8, 38u8,
22767                228u8, 152u8, 107u8, 69u8, 89u8, 60u8, 143u8, 173u8, 56u8, 156u8,
22768            ],
22769            [
22770                57u8, 111u8, 220u8, 177u8, 128u8, 203u8, 15u8, 234u8, 38u8, 146u8, 129u8,
22771                19u8, 251u8, 15u8, 209u8, 195u8, 84u8, 152u8, 99u8, 249u8, 205u8, 86u8,
22772                62u8, 106u8, 24u8, 79u8, 29u8, 87u8, 129u8, 22u8, 200u8, 228u8,
22773            ],
22774            [
22775                62u8, 230u8, 254u8, 141u8, 84u8, 97u8, 2u8, 68u8, 195u8, 233u8, 211u8,
22776                192u8, 102u8, 174u8, 74u8, 238u8, 153u8, 120u8, 132u8, 170u8, 40u8,
22777                241u8, 6u8, 22u8, 174u8, 130u8, 25u8, 37u8, 64u8, 19u8, 24u8, 172u8,
22778            ],
22779            [
22780                70u8, 7u8, 125u8, 85u8, 51u8, 7u8, 99u8, 241u8, 98u8, 105u8, 253u8,
22781                117u8, 229u8, 118u8, 22u8, 99u8, 244u8, 25u8, 45u8, 39u8, 145u8, 116u8,
22782                124u8, 1u8, 137u8, 177u8, 106u8, 211u8, 29u8, 176u8, 125u8, 180u8,
22783            ],
22784            [
22785                127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8,
22786                19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8,
22787                146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8,
22788            ],
22789            [
22790                139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
22791                31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
22792                218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
22793            ],
22794            [
22795                143u8, 48u8, 171u8, 9u8, 244u8, 58u8, 108u8, 21u8, 125u8, 127u8, 206u8,
22796                126u8, 10u8, 19u8, 192u8, 3u8, 4u8, 44u8, 28u8, 149u8, 232u8, 167u8,
22797                46u8, 122u8, 20u8, 106u8, 33u8, 192u8, 202u8, 162u8, 77u8, 201u8,
22798            ],
22799            [
22800                151u8, 112u8, 243u8, 202u8, 223u8, 220u8, 187u8, 111u8, 147u8, 175u8,
22801                147u8, 94u8, 134u8, 4u8, 113u8, 17u8, 89u8, 12u8, 55u8, 104u8, 39u8,
22802                29u8, 35u8, 126u8, 74u8, 43u8, 192u8, 184u8, 116u8, 190u8, 214u8, 147u8,
22803            ],
22804            [
22805                163u8, 72u8, 53u8, 188u8, 43u8, 103u8, 62u8, 195u8, 127u8, 207u8, 21u8,
22806                145u8, 169u8, 18u8, 149u8, 177u8, 99u8, 252u8, 46u8, 24u8, 30u8, 78u8,
22807                164u8, 231u8, 51u8, 190u8, 178u8, 125u8, 225u8, 206u8, 172u8, 76u8,
22808            ],
22809            [
22810                167u8, 122u8, 145u8, 190u8, 167u8, 182u8, 217u8, 90u8, 142u8, 181u8,
22811                165u8, 72u8, 120u8, 161u8, 217u8, 227u8, 200u8, 117u8, 226u8, 108u8,
22812                134u8, 169u8, 183u8, 14u8, 52u8, 32u8, 197u8, 197u8, 219u8, 25u8, 59u8,
22813                98u8,
22814            ],
22815            [
22816                171u8, 64u8, 163u8, 116u8, 188u8, 81u8, 222u8, 55u8, 34u8, 0u8, 168u8,
22817                188u8, 152u8, 26u8, 248u8, 201u8, 236u8, 220u8, 8u8, 223u8, 218u8, 239u8,
22818                11u8, 182u8, 224u8, 159u8, 136u8, 243u8, 198u8, 22u8, 239u8, 61u8,
22819            ],
22820            [
22821                232u8, 230u8, 140u8, 239u8, 28u8, 58u8, 118u8, 30u8, 215u8, 190u8, 126u8,
22822                132u8, 99u8, 163u8, 117u8, 242u8, 127u8, 123u8, 195u8, 53u8, 229u8, 24u8,
22823                36u8, 34u8, 60u8, 172u8, 206u8, 99u8, 110u8, 197u8, 195u8, 254u8,
22824            ],
22825            [
22826                236u8, 41u8, 99u8, 171u8, 33u8, 193u8, 229u8, 14u8, 30u8, 88u8, 42u8,
22827                165u8, 66u8, 175u8, 46u8, 75u8, 247u8, 191u8, 56u8, 230u8, 225u8, 64u8,
22828                60u8, 39u8, 180u8, 46u8, 28u8, 93u8, 110u8, 98u8, 30u8, 170u8,
22829            ],
22830        ];
22831    }
22832    #[automatically_derived]
22833    impl alloy_sol_types::SolEventInterface for RegistryCoordinatorEvents {
22834        const NAME: &'static str = "RegistryCoordinatorEvents";
22835        const COUNT: usize = 17usize;
22836        fn decode_raw_log(
22837            topics: &[alloy_sol_types::Word],
22838            data: &[u8],
22839            validate: bool,
22840        ) -> alloy_sol_types::Result<Self> {
22841            match topics.first().copied() {
22842                Some(<AVSUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
22843                    <AVSUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
22844                            topics,
22845                            data,
22846                            validate,
22847                        )
22848                        .map(Self::AVSUpdated)
22849                }
22850                Some(
22851                    <ChurnApproverUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
22852                ) => {
22853                    <ChurnApproverUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
22854                            topics,
22855                            data,
22856                            validate,
22857                        )
22858                        .map(Self::ChurnApproverUpdated)
22859                }
22860                Some(
22861                    <EIP712DomainChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
22862                ) => {
22863                    <EIP712DomainChanged as alloy_sol_types::SolEvent>::decode_raw_log(
22864                            topics,
22865                            data,
22866                            validate,
22867                        )
22868                        .map(Self::EIP712DomainChanged)
22869                }
22870                Some(
22871                    <EjectionCooldownUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
22872                ) => {
22873                    <EjectionCooldownUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
22874                            topics,
22875                            data,
22876                            validate,
22877                        )
22878                        .map(Self::EjectionCooldownUpdated)
22879                }
22880                Some(<EjectorUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
22881                    <EjectorUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
22882                            topics,
22883                            data,
22884                            validate,
22885                        )
22886                        .map(Self::EjectorUpdated)
22887                }
22888                Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
22889                    <Initialized as alloy_sol_types::SolEvent>::decode_raw_log(
22890                            topics,
22891                            data,
22892                            validate,
22893                        )
22894                        .map(Self::Initialized)
22895                }
22896                Some(
22897                    <M2QuorumRegistrationDisabled as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
22898                ) => {
22899                    <M2QuorumRegistrationDisabled as alloy_sol_types::SolEvent>::decode_raw_log(
22900                            topics,
22901                            data,
22902                            validate,
22903                        )
22904                        .map(Self::M2QuorumRegistrationDisabled)
22905                }
22906                Some(
22907                    <OperatorDeregistered as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
22908                ) => {
22909                    <OperatorDeregistered as alloy_sol_types::SolEvent>::decode_raw_log(
22910                            topics,
22911                            data,
22912                            validate,
22913                        )
22914                        .map(Self::OperatorDeregistered)
22915                }
22916                Some(
22917                    <OperatorRegistered as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
22918                ) => {
22919                    <OperatorRegistered as alloy_sol_types::SolEvent>::decode_raw_log(
22920                            topics,
22921                            data,
22922                            validate,
22923                        )
22924                        .map(Self::OperatorRegistered)
22925                }
22926                Some(
22927                    <OperatorSetParamsUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
22928                ) => {
22929                    <OperatorSetParamsUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
22930                            topics,
22931                            data,
22932                            validate,
22933                        )
22934                        .map(Self::OperatorSetParamsUpdated)
22935                }
22936                Some(
22937                    <OperatorSetsEnabled as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
22938                ) => {
22939                    <OperatorSetsEnabled as alloy_sol_types::SolEvent>::decode_raw_log(
22940                            topics,
22941                            data,
22942                            validate,
22943                        )
22944                        .map(Self::OperatorSetsEnabled)
22945                }
22946                Some(
22947                    <OperatorSocketUpdate as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
22948                ) => {
22949                    <OperatorSocketUpdate as alloy_sol_types::SolEvent>::decode_raw_log(
22950                            topics,
22951                            data,
22952                            validate,
22953                        )
22954                        .map(Self::OperatorSocketUpdate)
22955                }
22956                Some(
22957                    <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
22958                ) => {
22959                    <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
22960                            topics,
22961                            data,
22962                            validate,
22963                        )
22964                        .map(Self::OwnershipTransferred)
22965                }
22966                Some(<Paused as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
22967                    <Paused as alloy_sol_types::SolEvent>::decode_raw_log(
22968                            topics,
22969                            data,
22970                            validate,
22971                        )
22972                        .map(Self::Paused)
22973                }
22974                Some(
22975                    <QuorumBlockNumberUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
22976                ) => {
22977                    <QuorumBlockNumberUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
22978                            topics,
22979                            data,
22980                            validate,
22981                        )
22982                        .map(Self::QuorumBlockNumberUpdated)
22983                }
22984                Some(<QuorumCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
22985                    <QuorumCreated as alloy_sol_types::SolEvent>::decode_raw_log(
22986                            topics,
22987                            data,
22988                            validate,
22989                        )
22990                        .map(Self::QuorumCreated)
22991                }
22992                Some(<Unpaused as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
22993                    <Unpaused as alloy_sol_types::SolEvent>::decode_raw_log(
22994                            topics,
22995                            data,
22996                            validate,
22997                        )
22998                        .map(Self::Unpaused)
22999                }
23000                _ => {
23001                    alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
23002                        name: <Self as alloy_sol_types::SolEventInterface>::NAME,
23003                        log: alloy_sol_types::private::Box::new(
23004                            alloy_sol_types::private::LogData::new_unchecked(
23005                                topics.to_vec(),
23006                                data.to_vec().into(),
23007                            ),
23008                        ),
23009                    })
23010                }
23011            }
23012        }
23013    }
23014    #[automatically_derived]
23015    impl alloy_sol_types::private::IntoLogData for RegistryCoordinatorEvents {
23016        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
23017            match self {
23018                Self::AVSUpdated(inner) => {
23019                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
23020                }
23021                Self::ChurnApproverUpdated(inner) => {
23022                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
23023                }
23024                Self::EIP712DomainChanged(inner) => {
23025                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
23026                }
23027                Self::EjectionCooldownUpdated(inner) => {
23028                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
23029                }
23030                Self::EjectorUpdated(inner) => {
23031                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
23032                }
23033                Self::Initialized(inner) => {
23034                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
23035                }
23036                Self::M2QuorumRegistrationDisabled(inner) => {
23037                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
23038                }
23039                Self::OperatorDeregistered(inner) => {
23040                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
23041                }
23042                Self::OperatorRegistered(inner) => {
23043                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
23044                }
23045                Self::OperatorSetParamsUpdated(inner) => {
23046                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
23047                }
23048                Self::OperatorSetsEnabled(inner) => {
23049                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
23050                }
23051                Self::OperatorSocketUpdate(inner) => {
23052                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
23053                }
23054                Self::OwnershipTransferred(inner) => {
23055                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
23056                }
23057                Self::Paused(inner) => {
23058                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
23059                }
23060                Self::QuorumBlockNumberUpdated(inner) => {
23061                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
23062                }
23063                Self::QuorumCreated(inner) => {
23064                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
23065                }
23066                Self::Unpaused(inner) => {
23067                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
23068                }
23069            }
23070        }
23071        fn into_log_data(self) -> alloy_sol_types::private::LogData {
23072            match self {
23073                Self::AVSUpdated(inner) => {
23074                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
23075                }
23076                Self::ChurnApproverUpdated(inner) => {
23077                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
23078                }
23079                Self::EIP712DomainChanged(inner) => {
23080                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
23081                }
23082                Self::EjectionCooldownUpdated(inner) => {
23083                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
23084                }
23085                Self::EjectorUpdated(inner) => {
23086                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
23087                }
23088                Self::Initialized(inner) => {
23089                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
23090                }
23091                Self::M2QuorumRegistrationDisabled(inner) => {
23092                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
23093                }
23094                Self::OperatorDeregistered(inner) => {
23095                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
23096                }
23097                Self::OperatorRegistered(inner) => {
23098                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
23099                }
23100                Self::OperatorSetParamsUpdated(inner) => {
23101                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
23102                }
23103                Self::OperatorSetsEnabled(inner) => {
23104                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
23105                }
23106                Self::OperatorSocketUpdate(inner) => {
23107                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
23108                }
23109                Self::OwnershipTransferred(inner) => {
23110                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
23111                }
23112                Self::Paused(inner) => {
23113                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
23114                }
23115                Self::QuorumBlockNumberUpdated(inner) => {
23116                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
23117                }
23118                Self::QuorumCreated(inner) => {
23119                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
23120                }
23121                Self::Unpaused(inner) => {
23122                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
23123                }
23124            }
23125        }
23126    }
23127    use alloy::contract as alloy_contract;
23128    /**Creates a new wrapper around an on-chain [`RegistryCoordinator`](self) contract instance.
23129
23130See the [wrapper's documentation](`RegistryCoordinatorInstance`) for more details.*/
23131    #[inline]
23132    pub const fn new<
23133        T: alloy_contract::private::Transport + ::core::clone::Clone,
23134        P: alloy_contract::private::Provider<T, N>,
23135        N: alloy_contract::private::Network,
23136    >(
23137        address: alloy_sol_types::private::Address,
23138        provider: P,
23139    ) -> RegistryCoordinatorInstance<T, P, N> {
23140        RegistryCoordinatorInstance::<T, P, N>::new(address, provider)
23141    }
23142    /**Deploys this contract using the given `provider` and constructor arguments, if any.
23143
23144Returns a new instance of the contract, if the deployment was successful.
23145
23146For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
23147    #[inline]
23148    pub fn deploy<
23149        T: alloy_contract::private::Transport + ::core::clone::Clone,
23150        P: alloy_contract::private::Provider<T, N>,
23151        N: alloy_contract::private::Network,
23152    >(
23153        provider: P,
23154        params: <IRegistryCoordinatorTypes::RegistryCoordinatorParams as alloy::sol_types::SolType>::RustType,
23155    ) -> impl ::core::future::Future<
23156        Output = alloy_contract::Result<RegistryCoordinatorInstance<T, P, N>>,
23157    > {
23158        RegistryCoordinatorInstance::<T, P, N>::deploy(provider, params)
23159    }
23160    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
23161and constructor arguments, if any.
23162
23163This is a simple wrapper around creating a `RawCallBuilder` with the data set to
23164the bytecode concatenated with the constructor's ABI-encoded arguments.*/
23165    #[inline]
23166    pub fn deploy_builder<
23167        T: alloy_contract::private::Transport + ::core::clone::Clone,
23168        P: alloy_contract::private::Provider<T, N>,
23169        N: alloy_contract::private::Network,
23170    >(
23171        provider: P,
23172        params: <IRegistryCoordinatorTypes::RegistryCoordinatorParams as alloy::sol_types::SolType>::RustType,
23173    ) -> alloy_contract::RawCallBuilder<T, P, N> {
23174        RegistryCoordinatorInstance::<T, P, N>::deploy_builder(provider, params)
23175    }
23176    /**A [`RegistryCoordinator`](self) instance.
23177
23178Contains type-safe methods for interacting with an on-chain instance of the
23179[`RegistryCoordinator`](self) contract located at a given `address`, using a given
23180provider `P`.
23181
23182If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
23183documentation on how to provide it), the `deploy` and `deploy_builder` methods can
23184be used to deploy a new instance of the contract.
23185
23186See the [module-level documentation](self) for all the available methods.*/
23187    #[derive(Clone)]
23188    pub struct RegistryCoordinatorInstance<T, P, N = alloy_contract::private::Ethereum> {
23189        address: alloy_sol_types::private::Address,
23190        provider: P,
23191        _network_transport: ::core::marker::PhantomData<(N, T)>,
23192    }
23193    #[automatically_derived]
23194    impl<T, P, N> ::core::fmt::Debug for RegistryCoordinatorInstance<T, P, N> {
23195        #[inline]
23196        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
23197            f.debug_tuple("RegistryCoordinatorInstance").field(&self.address).finish()
23198        }
23199    }
23200    /// Instantiation and getters/setters.
23201    #[automatically_derived]
23202    impl<
23203        T: alloy_contract::private::Transport + ::core::clone::Clone,
23204        P: alloy_contract::private::Provider<T, N>,
23205        N: alloy_contract::private::Network,
23206    > RegistryCoordinatorInstance<T, P, N> {
23207        /**Creates a new wrapper around an on-chain [`RegistryCoordinator`](self) contract instance.
23208
23209See the [wrapper's documentation](`RegistryCoordinatorInstance`) for more details.*/
23210        #[inline]
23211        pub const fn new(
23212            address: alloy_sol_types::private::Address,
23213            provider: P,
23214        ) -> Self {
23215            Self {
23216                address,
23217                provider,
23218                _network_transport: ::core::marker::PhantomData,
23219            }
23220        }
23221        /**Deploys this contract using the given `provider` and constructor arguments, if any.
23222
23223Returns a new instance of the contract, if the deployment was successful.
23224
23225For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
23226        #[inline]
23227        pub async fn deploy(
23228            provider: P,
23229            params: <IRegistryCoordinatorTypes::RegistryCoordinatorParams as alloy::sol_types::SolType>::RustType,
23230        ) -> alloy_contract::Result<RegistryCoordinatorInstance<T, P, N>> {
23231            let call_builder = Self::deploy_builder(provider, params);
23232            let contract_address = call_builder.deploy().await?;
23233            Ok(Self::new(contract_address, call_builder.provider))
23234        }
23235        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
23236and constructor arguments, if any.
23237
23238This is a simple wrapper around creating a `RawCallBuilder` with the data set to
23239the bytecode concatenated with the constructor's ABI-encoded arguments.*/
23240        #[inline]
23241        pub fn deploy_builder(
23242            provider: P,
23243            params: <IRegistryCoordinatorTypes::RegistryCoordinatorParams as alloy::sol_types::SolType>::RustType,
23244        ) -> alloy_contract::RawCallBuilder<T, P, N> {
23245            alloy_contract::RawCallBuilder::new_raw_deploy(
23246                provider,
23247                [
23248                    &BYTECODE[..],
23249                    &alloy_sol_types::SolConstructor::abi_encode(
23250                        &constructorCall { params },
23251                    )[..],
23252                ]
23253                    .concat()
23254                    .into(),
23255            )
23256        }
23257        /// Returns a reference to the address.
23258        #[inline]
23259        pub const fn address(&self) -> &alloy_sol_types::private::Address {
23260            &self.address
23261        }
23262        /// Sets the address.
23263        #[inline]
23264        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
23265            self.address = address;
23266        }
23267        /// Sets the address and returns `self`.
23268        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
23269            self.set_address(address);
23270            self
23271        }
23272        /// Returns a reference to the provider.
23273        #[inline]
23274        pub const fn provider(&self) -> &P {
23275            &self.provider
23276        }
23277    }
23278    impl<T, P: ::core::clone::Clone, N> RegistryCoordinatorInstance<T, &P, N> {
23279        /// Clones the provider and returns a new instance with the cloned provider.
23280        #[inline]
23281        pub fn with_cloned_provider(self) -> RegistryCoordinatorInstance<T, P, N> {
23282            RegistryCoordinatorInstance {
23283                address: self.address,
23284                provider: ::core::clone::Clone::clone(&self.provider),
23285                _network_transport: ::core::marker::PhantomData,
23286            }
23287        }
23288    }
23289    /// Function calls.
23290    #[automatically_derived]
23291    impl<
23292        T: alloy_contract::private::Transport + ::core::clone::Clone,
23293        P: alloy_contract::private::Provider<T, N>,
23294        N: alloy_contract::private::Network,
23295    > RegistryCoordinatorInstance<T, P, N> {
23296        /// Creates a new call builder using this contract instance's provider and address.
23297        ///
23298        /// Note that the call can be any function call, not just those defined in this
23299        /// contract. Prefer using the other methods for building type-safe contract calls.
23300        pub fn call_builder<C: alloy_sol_types::SolCall>(
23301            &self,
23302            call: &C,
23303        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
23304            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
23305        }
23306        ///Creates a new call builder for the [`OPERATOR_CHURN_APPROVAL_TYPEHASH`] function.
23307        pub fn OPERATOR_CHURN_APPROVAL_TYPEHASH(
23308            &self,
23309        ) -> alloy_contract::SolCallBuilder<
23310            T,
23311            &P,
23312            OPERATOR_CHURN_APPROVAL_TYPEHASHCall,
23313            N,
23314        > {
23315            self.call_builder(
23316                &OPERATOR_CHURN_APPROVAL_TYPEHASHCall {
23317                },
23318            )
23319        }
23320        ///Creates a new call builder for the [`PUBKEY_REGISTRATION_TYPEHASH`] function.
23321        pub fn PUBKEY_REGISTRATION_TYPEHASH(
23322            &self,
23323        ) -> alloy_contract::SolCallBuilder<T, &P, PUBKEY_REGISTRATION_TYPEHASHCall, N> {
23324            self.call_builder(
23325                &PUBKEY_REGISTRATION_TYPEHASHCall {
23326                },
23327            )
23328        }
23329        ///Creates a new call builder for the [`allocationManager`] function.
23330        pub fn allocationManager(
23331            &self,
23332        ) -> alloy_contract::SolCallBuilder<T, &P, allocationManagerCall, N> {
23333            self.call_builder(&allocationManagerCall {})
23334        }
23335        ///Creates a new call builder for the [`avs`] function.
23336        pub fn avs(&self) -> alloy_contract::SolCallBuilder<T, &P, avsCall, N> {
23337            self.call_builder(&avsCall {})
23338        }
23339        ///Creates a new call builder for the [`blsApkRegistry`] function.
23340        pub fn blsApkRegistry(
23341            &self,
23342        ) -> alloy_contract::SolCallBuilder<T, &P, blsApkRegistryCall, N> {
23343            self.call_builder(&blsApkRegistryCall {})
23344        }
23345        ///Creates a new call builder for the [`calculateOperatorChurnApprovalDigestHash`] function.
23346        pub fn calculateOperatorChurnApprovalDigestHash(
23347            &self,
23348            registeringOperator: alloy::sol_types::private::Address,
23349            registeringOperatorId: alloy::sol_types::private::FixedBytes<32>,
23350            operatorKickParams: alloy::sol_types::private::Vec<
23351                <ISlashingRegistryCoordinatorTypes::OperatorKickParam as alloy::sol_types::SolType>::RustType,
23352            >,
23353            salt: alloy::sol_types::private::FixedBytes<32>,
23354            expiry: alloy::sol_types::private::primitives::aliases::U256,
23355        ) -> alloy_contract::SolCallBuilder<
23356            T,
23357            &P,
23358            calculateOperatorChurnApprovalDigestHashCall,
23359            N,
23360        > {
23361            self.call_builder(
23362                &calculateOperatorChurnApprovalDigestHashCall {
23363                    registeringOperator,
23364                    registeringOperatorId,
23365                    operatorKickParams,
23366                    salt,
23367                    expiry,
23368                },
23369            )
23370        }
23371        ///Creates a new call builder for the [`calculatePubkeyRegistrationMessageHash`] function.
23372        pub fn calculatePubkeyRegistrationMessageHash(
23373            &self,
23374            operator: alloy::sol_types::private::Address,
23375        ) -> alloy_contract::SolCallBuilder<
23376            T,
23377            &P,
23378            calculatePubkeyRegistrationMessageHashCall,
23379            N,
23380        > {
23381            self.call_builder(
23382                &calculatePubkeyRegistrationMessageHashCall {
23383                    operator,
23384                },
23385            )
23386        }
23387        ///Creates a new call builder for the [`churnApprover`] function.
23388        pub fn churnApprover(
23389            &self,
23390        ) -> alloy_contract::SolCallBuilder<T, &P, churnApproverCall, N> {
23391            self.call_builder(&churnApproverCall {})
23392        }
23393        ///Creates a new call builder for the [`createSlashableStakeQuorum`] function.
23394        pub fn createSlashableStakeQuorum(
23395            &self,
23396            operatorSetParams: <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
23397            minimumStake: alloy::sol_types::private::primitives::aliases::U96,
23398            strategyParams: alloy::sol_types::private::Vec<
23399                <IStakeRegistryTypes::StrategyParams as alloy::sol_types::SolType>::RustType,
23400            >,
23401            lookAheadPeriod: u32,
23402        ) -> alloy_contract::SolCallBuilder<T, &P, createSlashableStakeQuorumCall, N> {
23403            self.call_builder(
23404                &createSlashableStakeQuorumCall {
23405                    operatorSetParams,
23406                    minimumStake,
23407                    strategyParams,
23408                    lookAheadPeriod,
23409                },
23410            )
23411        }
23412        ///Creates a new call builder for the [`createTotalDelegatedStakeQuorum`] function.
23413        pub fn createTotalDelegatedStakeQuorum(
23414            &self,
23415            operatorSetParams: <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
23416            minimumStake: alloy::sol_types::private::primitives::aliases::U96,
23417            strategyParams: alloy::sol_types::private::Vec<
23418                <IStakeRegistryTypes::StrategyParams as alloy::sol_types::SolType>::RustType,
23419            >,
23420        ) -> alloy_contract::SolCallBuilder<
23421            T,
23422            &P,
23423            createTotalDelegatedStakeQuorumCall,
23424            N,
23425        > {
23426            self.call_builder(
23427                &createTotalDelegatedStakeQuorumCall {
23428                    operatorSetParams,
23429                    minimumStake,
23430                    strategyParams,
23431                },
23432            )
23433        }
23434        ///Creates a new call builder for the [`deregisterOperator_0`] function.
23435        pub fn deregisterOperator_0(
23436            &self,
23437            operator: alloy::sol_types::private::Address,
23438            avs: alloy::sol_types::private::Address,
23439            operatorSetIds: alloy::sol_types::private::Vec<u32>,
23440        ) -> alloy_contract::SolCallBuilder<T, &P, deregisterOperator_0Call, N> {
23441            self.call_builder(
23442                &deregisterOperator_0Call {
23443                    operator,
23444                    avs,
23445                    operatorSetIds,
23446                },
23447            )
23448        }
23449        ///Creates a new call builder for the [`deregisterOperator_1`] function.
23450        pub fn deregisterOperator_1(
23451            &self,
23452            quorumNumbers: alloy::sol_types::private::Bytes,
23453        ) -> alloy_contract::SolCallBuilder<T, &P, deregisterOperator_1Call, N> {
23454            self.call_builder(
23455                &deregisterOperator_1Call {
23456                    quorumNumbers,
23457                },
23458            )
23459        }
23460        ///Creates a new call builder for the [`disableM2QuorumRegistration`] function.
23461        pub fn disableM2QuorumRegistration(
23462            &self,
23463        ) -> alloy_contract::SolCallBuilder<T, &P, disableM2QuorumRegistrationCall, N> {
23464            self.call_builder(&disableM2QuorumRegistrationCall {})
23465        }
23466        ///Creates a new call builder for the [`domainSeparator`] function.
23467        pub fn domainSeparator(
23468            &self,
23469        ) -> alloy_contract::SolCallBuilder<T, &P, domainSeparatorCall, N> {
23470            self.call_builder(&domainSeparatorCall {})
23471        }
23472        ///Creates a new call builder for the [`eip712Domain`] function.
23473        pub fn eip712Domain(
23474            &self,
23475        ) -> alloy_contract::SolCallBuilder<T, &P, eip712DomainCall, N> {
23476            self.call_builder(&eip712DomainCall {})
23477        }
23478        ///Creates a new call builder for the [`ejectOperator`] function.
23479        pub fn ejectOperator(
23480            &self,
23481            operator: alloy::sol_types::private::Address,
23482            quorumNumbers: alloy::sol_types::private::Bytes,
23483        ) -> alloy_contract::SolCallBuilder<T, &P, ejectOperatorCall, N> {
23484            self.call_builder(
23485                &ejectOperatorCall {
23486                    operator,
23487                    quorumNumbers,
23488                },
23489            )
23490        }
23491        ///Creates a new call builder for the [`ejectionCooldown`] function.
23492        pub fn ejectionCooldown(
23493            &self,
23494        ) -> alloy_contract::SolCallBuilder<T, &P, ejectionCooldownCall, N> {
23495            self.call_builder(&ejectionCooldownCall {})
23496        }
23497        ///Creates a new call builder for the [`ejector`] function.
23498        pub fn ejector(&self) -> alloy_contract::SolCallBuilder<T, &P, ejectorCall, N> {
23499            self.call_builder(&ejectorCall {})
23500        }
23501        ///Creates a new call builder for the [`getCurrentQuorumBitmap`] function.
23502        pub fn getCurrentQuorumBitmap(
23503            &self,
23504            operatorId: alloy::sol_types::private::FixedBytes<32>,
23505        ) -> alloy_contract::SolCallBuilder<T, &P, getCurrentQuorumBitmapCall, N> {
23506            self.call_builder(
23507                &getCurrentQuorumBitmapCall {
23508                    operatorId,
23509                },
23510            )
23511        }
23512        ///Creates a new call builder for the [`getOperator`] function.
23513        pub fn getOperator(
23514            &self,
23515            operator: alloy::sol_types::private::Address,
23516        ) -> alloy_contract::SolCallBuilder<T, &P, getOperatorCall, N> {
23517            self.call_builder(&getOperatorCall { operator })
23518        }
23519        ///Creates a new call builder for the [`getOperatorFromId`] function.
23520        pub fn getOperatorFromId(
23521            &self,
23522            operatorId: alloy::sol_types::private::FixedBytes<32>,
23523        ) -> alloy_contract::SolCallBuilder<T, &P, getOperatorFromIdCall, N> {
23524            self.call_builder(
23525                &getOperatorFromIdCall {
23526                    operatorId,
23527                },
23528            )
23529        }
23530        ///Creates a new call builder for the [`getOperatorId`] function.
23531        pub fn getOperatorId(
23532            &self,
23533            operator: alloy::sol_types::private::Address,
23534        ) -> alloy_contract::SolCallBuilder<T, &P, getOperatorIdCall, N> {
23535            self.call_builder(&getOperatorIdCall { operator })
23536        }
23537        ///Creates a new call builder for the [`getOperatorSetParams`] function.
23538        pub fn getOperatorSetParams(
23539            &self,
23540            quorumNumber: u8,
23541        ) -> alloy_contract::SolCallBuilder<T, &P, getOperatorSetParamsCall, N> {
23542            self.call_builder(
23543                &getOperatorSetParamsCall {
23544                    quorumNumber,
23545                },
23546            )
23547        }
23548        ///Creates a new call builder for the [`getOperatorStatus`] function.
23549        pub fn getOperatorStatus(
23550            &self,
23551            operator: alloy::sol_types::private::Address,
23552        ) -> alloy_contract::SolCallBuilder<T, &P, getOperatorStatusCall, N> {
23553            self.call_builder(&getOperatorStatusCall { operator })
23554        }
23555        ///Creates a new call builder for the [`getQuorumBitmapAtBlockNumberByIndex`] function.
23556        pub fn getQuorumBitmapAtBlockNumberByIndex(
23557            &self,
23558            operatorId: alloy::sol_types::private::FixedBytes<32>,
23559            blockNumber: u32,
23560            index: alloy::sol_types::private::primitives::aliases::U256,
23561        ) -> alloy_contract::SolCallBuilder<
23562            T,
23563            &P,
23564            getQuorumBitmapAtBlockNumberByIndexCall,
23565            N,
23566        > {
23567            self.call_builder(
23568                &getQuorumBitmapAtBlockNumberByIndexCall {
23569                    operatorId,
23570                    blockNumber,
23571                    index,
23572                },
23573            )
23574        }
23575        ///Creates a new call builder for the [`getQuorumBitmapHistoryLength`] function.
23576        pub fn getQuorumBitmapHistoryLength(
23577            &self,
23578            operatorId: alloy::sol_types::private::FixedBytes<32>,
23579        ) -> alloy_contract::SolCallBuilder<T, &P, getQuorumBitmapHistoryLengthCall, N> {
23580            self.call_builder(
23581                &getQuorumBitmapHistoryLengthCall {
23582                    operatorId,
23583                },
23584            )
23585        }
23586        ///Creates a new call builder for the [`getQuorumBitmapIndicesAtBlockNumber`] function.
23587        pub fn getQuorumBitmapIndicesAtBlockNumber(
23588            &self,
23589            blockNumber: u32,
23590            operatorIds: alloy::sol_types::private::Vec<
23591                alloy::sol_types::private::FixedBytes<32>,
23592            >,
23593        ) -> alloy_contract::SolCallBuilder<
23594            T,
23595            &P,
23596            getQuorumBitmapIndicesAtBlockNumberCall,
23597            N,
23598        > {
23599            self.call_builder(
23600                &getQuorumBitmapIndicesAtBlockNumberCall {
23601                    blockNumber,
23602                    operatorIds,
23603                },
23604            )
23605        }
23606        ///Creates a new call builder for the [`getQuorumBitmapUpdateByIndex`] function.
23607        pub fn getQuorumBitmapUpdateByIndex(
23608            &self,
23609            operatorId: alloy::sol_types::private::FixedBytes<32>,
23610            index: alloy::sol_types::private::primitives::aliases::U256,
23611        ) -> alloy_contract::SolCallBuilder<T, &P, getQuorumBitmapUpdateByIndexCall, N> {
23612            self.call_builder(
23613                &getQuorumBitmapUpdateByIndexCall {
23614                    operatorId,
23615                    index,
23616                },
23617            )
23618        }
23619        ///Creates a new call builder for the [`indexRegistry`] function.
23620        pub fn indexRegistry(
23621            &self,
23622        ) -> alloy_contract::SolCallBuilder<T, &P, indexRegistryCall, N> {
23623            self.call_builder(&indexRegistryCall {})
23624        }
23625        ///Creates a new call builder for the [`initialize`] function.
23626        pub fn initialize(
23627            &self,
23628            initialOwner: alloy::sol_types::private::Address,
23629            churnApprover: alloy::sol_types::private::Address,
23630            ejector: alloy::sol_types::private::Address,
23631            initialPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
23632            avs: alloy::sol_types::private::Address,
23633        ) -> alloy_contract::SolCallBuilder<T, &P, initializeCall, N> {
23634            self.call_builder(
23635                &initializeCall {
23636                    initialOwner,
23637                    churnApprover,
23638                    ejector,
23639                    initialPausedStatus,
23640                    avs,
23641                },
23642            )
23643        }
23644        ///Creates a new call builder for the [`isChurnApproverSaltUsed`] function.
23645        pub fn isChurnApproverSaltUsed(
23646            &self,
23647            _0: alloy::sol_types::private::FixedBytes<32>,
23648        ) -> alloy_contract::SolCallBuilder<T, &P, isChurnApproverSaltUsedCall, N> {
23649            self.call_builder(&isChurnApproverSaltUsedCall { _0 })
23650        }
23651        ///Creates a new call builder for the [`isM2Quorum`] function.
23652        pub fn isM2Quorum(
23653            &self,
23654            quorumNumber: u8,
23655        ) -> alloy_contract::SolCallBuilder<T, &P, isM2QuorumCall, N> {
23656            self.call_builder(&isM2QuorumCall { quorumNumber })
23657        }
23658        ///Creates a new call builder for the [`isM2QuorumRegistrationDisabled`] function.
23659        pub fn isM2QuorumRegistrationDisabled(
23660            &self,
23661        ) -> alloy_contract::SolCallBuilder<
23662            T,
23663            &P,
23664            isM2QuorumRegistrationDisabledCall,
23665            N,
23666        > {
23667            self.call_builder(
23668                &isM2QuorumRegistrationDisabledCall {
23669                },
23670            )
23671        }
23672        ///Creates a new call builder for the [`lastEjectionTimestamp`] function.
23673        pub fn lastEjectionTimestamp(
23674            &self,
23675            _0: alloy::sol_types::private::Address,
23676        ) -> alloy_contract::SolCallBuilder<T, &P, lastEjectionTimestampCall, N> {
23677            self.call_builder(&lastEjectionTimestampCall { _0 })
23678        }
23679        ///Creates a new call builder for the [`m2QuorumBitmap`] function.
23680        pub fn m2QuorumBitmap(
23681            &self,
23682        ) -> alloy_contract::SolCallBuilder<T, &P, m2QuorumBitmapCall, N> {
23683            self.call_builder(&m2QuorumBitmapCall {})
23684        }
23685        ///Creates a new call builder for the [`operatorSetsEnabled`] function.
23686        pub fn operatorSetsEnabled(
23687            &self,
23688        ) -> alloy_contract::SolCallBuilder<T, &P, operatorSetsEnabledCall, N> {
23689            self.call_builder(&operatorSetsEnabledCall {})
23690        }
23691        ///Creates a new call builder for the [`owner`] function.
23692        pub fn owner(&self) -> alloy_contract::SolCallBuilder<T, &P, ownerCall, N> {
23693            self.call_builder(&ownerCall {})
23694        }
23695        ///Creates a new call builder for the [`pause`] function.
23696        pub fn pause(
23697            &self,
23698            newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
23699        ) -> alloy_contract::SolCallBuilder<T, &P, pauseCall, N> {
23700            self.call_builder(&pauseCall { newPausedStatus })
23701        }
23702        ///Creates a new call builder for the [`pauseAll`] function.
23703        pub fn pauseAll(
23704            &self,
23705        ) -> alloy_contract::SolCallBuilder<T, &P, pauseAllCall, N> {
23706            self.call_builder(&pauseAllCall {})
23707        }
23708        ///Creates a new call builder for the [`paused_0`] function.
23709        pub fn paused_0(
23710            &self,
23711            index: u8,
23712        ) -> alloy_contract::SolCallBuilder<T, &P, paused_0Call, N> {
23713            self.call_builder(&paused_0Call { index })
23714        }
23715        ///Creates a new call builder for the [`paused_1`] function.
23716        pub fn paused_1(
23717            &self,
23718        ) -> alloy_contract::SolCallBuilder<T, &P, paused_1Call, N> {
23719            self.call_builder(&paused_1Call {})
23720        }
23721        ///Creates a new call builder for the [`pauserRegistry`] function.
23722        pub fn pauserRegistry(
23723            &self,
23724        ) -> alloy_contract::SolCallBuilder<T, &P, pauserRegistryCall, N> {
23725            self.call_builder(&pauserRegistryCall {})
23726        }
23727        ///Creates a new call builder for the [`pubkeyRegistrationMessageHash`] function.
23728        pub fn pubkeyRegistrationMessageHash(
23729            &self,
23730            operator: alloy::sol_types::private::Address,
23731        ) -> alloy_contract::SolCallBuilder<
23732            T,
23733            &P,
23734            pubkeyRegistrationMessageHashCall,
23735            N,
23736        > {
23737            self.call_builder(
23738                &pubkeyRegistrationMessageHashCall {
23739                    operator,
23740                },
23741            )
23742        }
23743        ///Creates a new call builder for the [`quorumCount`] function.
23744        pub fn quorumCount(
23745            &self,
23746        ) -> alloy_contract::SolCallBuilder<T, &P, quorumCountCall, N> {
23747            self.call_builder(&quorumCountCall {})
23748        }
23749        ///Creates a new call builder for the [`quorumUpdateBlockNumber`] function.
23750        pub fn quorumUpdateBlockNumber(
23751            &self,
23752            _0: u8,
23753        ) -> alloy_contract::SolCallBuilder<T, &P, quorumUpdateBlockNumberCall, N> {
23754            self.call_builder(&quorumUpdateBlockNumberCall { _0 })
23755        }
23756        ///Creates a new call builder for the [`registerOperator_0`] function.
23757        pub fn registerOperator_0(
23758            &self,
23759            quorumNumbers: alloy::sol_types::private::Bytes,
23760            socket: alloy::sol_types::private::String,
23761            params: <IBLSApkRegistryTypes::PubkeyRegistrationParams as alloy::sol_types::SolType>::RustType,
23762            operatorSignature: <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy::sol_types::SolType>::RustType,
23763        ) -> alloy_contract::SolCallBuilder<T, &P, registerOperator_0Call, N> {
23764            self.call_builder(
23765                &registerOperator_0Call {
23766                    quorumNumbers,
23767                    socket,
23768                    params,
23769                    operatorSignature,
23770                },
23771            )
23772        }
23773        ///Creates a new call builder for the [`registerOperator_1`] function.
23774        pub fn registerOperator_1(
23775            &self,
23776            operator: alloy::sol_types::private::Address,
23777            avs: alloy::sol_types::private::Address,
23778            operatorSetIds: alloy::sol_types::private::Vec<u32>,
23779            data: alloy::sol_types::private::Bytes,
23780        ) -> alloy_contract::SolCallBuilder<T, &P, registerOperator_1Call, N> {
23781            self.call_builder(
23782                &registerOperator_1Call {
23783                    operator,
23784                    avs,
23785                    operatorSetIds,
23786                    data,
23787                },
23788            )
23789        }
23790        ///Creates a new call builder for the [`registerOperatorWithChurn`] function.
23791        pub fn registerOperatorWithChurn(
23792            &self,
23793            quorumNumbers: alloy::sol_types::private::Bytes,
23794            socket: alloy::sol_types::private::String,
23795            params: <IBLSApkRegistryTypes::PubkeyRegistrationParams as alloy::sol_types::SolType>::RustType,
23796            operatorKickParams: alloy::sol_types::private::Vec<
23797                <ISlashingRegistryCoordinatorTypes::OperatorKickParam as alloy::sol_types::SolType>::RustType,
23798            >,
23799            churnApproverSignature: <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy::sol_types::SolType>::RustType,
23800            operatorSignature: <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy::sol_types::SolType>::RustType,
23801        ) -> alloy_contract::SolCallBuilder<T, &P, registerOperatorWithChurnCall, N> {
23802            self.call_builder(
23803                &registerOperatorWithChurnCall {
23804                    quorumNumbers,
23805                    socket,
23806                    params,
23807                    operatorKickParams,
23808                    churnApproverSignature,
23809                    operatorSignature,
23810                },
23811            )
23812        }
23813        ///Creates a new call builder for the [`renounceOwnership`] function.
23814        pub fn renounceOwnership(
23815            &self,
23816        ) -> alloy_contract::SolCallBuilder<T, &P, renounceOwnershipCall, N> {
23817            self.call_builder(&renounceOwnershipCall {})
23818        }
23819        ///Creates a new call builder for the [`serviceManager`] function.
23820        pub fn serviceManager(
23821            &self,
23822        ) -> alloy_contract::SolCallBuilder<T, &P, serviceManagerCall, N> {
23823            self.call_builder(&serviceManagerCall {})
23824        }
23825        ///Creates a new call builder for the [`setAVS`] function.
23826        pub fn setAVS(
23827            &self,
23828            _avs: alloy::sol_types::private::Address,
23829        ) -> alloy_contract::SolCallBuilder<T, &P, setAVSCall, N> {
23830            self.call_builder(&setAVSCall { _avs })
23831        }
23832        ///Creates a new call builder for the [`setChurnApprover`] function.
23833        pub fn setChurnApprover(
23834            &self,
23835            _churnApprover: alloy::sol_types::private::Address,
23836        ) -> alloy_contract::SolCallBuilder<T, &P, setChurnApproverCall, N> {
23837            self.call_builder(
23838                &setChurnApproverCall {
23839                    _churnApprover,
23840                },
23841            )
23842        }
23843        ///Creates a new call builder for the [`setEjectionCooldown`] function.
23844        pub fn setEjectionCooldown(
23845            &self,
23846            _ejectionCooldown: alloy::sol_types::private::primitives::aliases::U256,
23847        ) -> alloy_contract::SolCallBuilder<T, &P, setEjectionCooldownCall, N> {
23848            self.call_builder(
23849                &setEjectionCooldownCall {
23850                    _ejectionCooldown,
23851                },
23852            )
23853        }
23854        ///Creates a new call builder for the [`setEjector`] function.
23855        pub fn setEjector(
23856            &self,
23857            _ejector: alloy::sol_types::private::Address,
23858        ) -> alloy_contract::SolCallBuilder<T, &P, setEjectorCall, N> {
23859            self.call_builder(&setEjectorCall { _ejector })
23860        }
23861        ///Creates a new call builder for the [`setOperatorSetParams`] function.
23862        pub fn setOperatorSetParams(
23863            &self,
23864            quorumNumber: u8,
23865            operatorSetParams: <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
23866        ) -> alloy_contract::SolCallBuilder<T, &P, setOperatorSetParamsCall, N> {
23867            self.call_builder(
23868                &setOperatorSetParamsCall {
23869                    quorumNumber,
23870                    operatorSetParams,
23871                },
23872            )
23873        }
23874        ///Creates a new call builder for the [`socketRegistry`] function.
23875        pub fn socketRegistry(
23876            &self,
23877        ) -> alloy_contract::SolCallBuilder<T, &P, socketRegistryCall, N> {
23878            self.call_builder(&socketRegistryCall {})
23879        }
23880        ///Creates a new call builder for the [`stakeRegistry`] function.
23881        pub fn stakeRegistry(
23882            &self,
23883        ) -> alloy_contract::SolCallBuilder<T, &P, stakeRegistryCall, N> {
23884            self.call_builder(&stakeRegistryCall {})
23885        }
23886        ///Creates a new call builder for the [`supportsAVS`] function.
23887        pub fn supportsAVS(
23888            &self,
23889            _avs: alloy::sol_types::private::Address,
23890        ) -> alloy_contract::SolCallBuilder<T, &P, supportsAVSCall, N> {
23891            self.call_builder(&supportsAVSCall { _avs })
23892        }
23893        ///Creates a new call builder for the [`transferOwnership`] function.
23894        pub fn transferOwnership(
23895            &self,
23896            newOwner: alloy::sol_types::private::Address,
23897        ) -> alloy_contract::SolCallBuilder<T, &P, transferOwnershipCall, N> {
23898            self.call_builder(&transferOwnershipCall { newOwner })
23899        }
23900        ///Creates a new call builder for the [`unpause`] function.
23901        pub fn unpause(
23902            &self,
23903            newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
23904        ) -> alloy_contract::SolCallBuilder<T, &P, unpauseCall, N> {
23905            self.call_builder(&unpauseCall { newPausedStatus })
23906        }
23907        ///Creates a new call builder for the [`updateOperators`] function.
23908        pub fn updateOperators(
23909            &self,
23910            operators: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
23911        ) -> alloy_contract::SolCallBuilder<T, &P, updateOperatorsCall, N> {
23912            self.call_builder(&updateOperatorsCall { operators })
23913        }
23914        ///Creates a new call builder for the [`updateOperatorsForQuorum`] function.
23915        pub fn updateOperatorsForQuorum(
23916            &self,
23917            operatorsPerQuorum: alloy::sol_types::private::Vec<
23918                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
23919            >,
23920            quorumNumbers: alloy::sol_types::private::Bytes,
23921        ) -> alloy_contract::SolCallBuilder<T, &P, updateOperatorsForQuorumCall, N> {
23922            self.call_builder(
23923                &updateOperatorsForQuorumCall {
23924                    operatorsPerQuorum,
23925                    quorumNumbers,
23926                },
23927            )
23928        }
23929        ///Creates a new call builder for the [`updateSocket`] function.
23930        pub fn updateSocket(
23931            &self,
23932            socket: alloy::sol_types::private::String,
23933        ) -> alloy_contract::SolCallBuilder<T, &P, updateSocketCall, N> {
23934            self.call_builder(&updateSocketCall { socket })
23935        }
23936        ///Creates a new call builder for the [`version`] function.
23937        pub fn version(&self) -> alloy_contract::SolCallBuilder<T, &P, versionCall, N> {
23938            self.call_builder(&versionCall {})
23939        }
23940    }
23941    /// Event filters.
23942    #[automatically_derived]
23943    impl<
23944        T: alloy_contract::private::Transport + ::core::clone::Clone,
23945        P: alloy_contract::private::Provider<T, N>,
23946        N: alloy_contract::private::Network,
23947    > RegistryCoordinatorInstance<T, P, N> {
23948        /// Creates a new event filter using this contract instance's provider and address.
23949        ///
23950        /// Note that the type can be any event, not just those defined in this contract.
23951        /// Prefer using the other methods for building type-safe event filters.
23952        pub fn event_filter<E: alloy_sol_types::SolEvent>(
23953            &self,
23954        ) -> alloy_contract::Event<T, &P, E, N> {
23955            alloy_contract::Event::new_sol(&self.provider, &self.address)
23956        }
23957        ///Creates a new event filter for the [`AVSUpdated`] event.
23958        pub fn AVSUpdated_filter(&self) -> alloy_contract::Event<T, &P, AVSUpdated, N> {
23959            self.event_filter::<AVSUpdated>()
23960        }
23961        ///Creates a new event filter for the [`ChurnApproverUpdated`] event.
23962        pub fn ChurnApproverUpdated_filter(
23963            &self,
23964        ) -> alloy_contract::Event<T, &P, ChurnApproverUpdated, N> {
23965            self.event_filter::<ChurnApproverUpdated>()
23966        }
23967        ///Creates a new event filter for the [`EIP712DomainChanged`] event.
23968        pub fn EIP712DomainChanged_filter(
23969            &self,
23970        ) -> alloy_contract::Event<T, &P, EIP712DomainChanged, N> {
23971            self.event_filter::<EIP712DomainChanged>()
23972        }
23973        ///Creates a new event filter for the [`EjectionCooldownUpdated`] event.
23974        pub fn EjectionCooldownUpdated_filter(
23975            &self,
23976        ) -> alloy_contract::Event<T, &P, EjectionCooldownUpdated, N> {
23977            self.event_filter::<EjectionCooldownUpdated>()
23978        }
23979        ///Creates a new event filter for the [`EjectorUpdated`] event.
23980        pub fn EjectorUpdated_filter(
23981            &self,
23982        ) -> alloy_contract::Event<T, &P, EjectorUpdated, N> {
23983            self.event_filter::<EjectorUpdated>()
23984        }
23985        ///Creates a new event filter for the [`Initialized`] event.
23986        pub fn Initialized_filter(
23987            &self,
23988        ) -> alloy_contract::Event<T, &P, Initialized, N> {
23989            self.event_filter::<Initialized>()
23990        }
23991        ///Creates a new event filter for the [`M2QuorumRegistrationDisabled`] event.
23992        pub fn M2QuorumRegistrationDisabled_filter(
23993            &self,
23994        ) -> alloy_contract::Event<T, &P, M2QuorumRegistrationDisabled, N> {
23995            self.event_filter::<M2QuorumRegistrationDisabled>()
23996        }
23997        ///Creates a new event filter for the [`OperatorDeregistered`] event.
23998        pub fn OperatorDeregistered_filter(
23999            &self,
24000        ) -> alloy_contract::Event<T, &P, OperatorDeregistered, N> {
24001            self.event_filter::<OperatorDeregistered>()
24002        }
24003        ///Creates a new event filter for the [`OperatorRegistered`] event.
24004        pub fn OperatorRegistered_filter(
24005            &self,
24006        ) -> alloy_contract::Event<T, &P, OperatorRegistered, N> {
24007            self.event_filter::<OperatorRegistered>()
24008        }
24009        ///Creates a new event filter for the [`OperatorSetParamsUpdated`] event.
24010        pub fn OperatorSetParamsUpdated_filter(
24011            &self,
24012        ) -> alloy_contract::Event<T, &P, OperatorSetParamsUpdated, N> {
24013            self.event_filter::<OperatorSetParamsUpdated>()
24014        }
24015        ///Creates a new event filter for the [`OperatorSetsEnabled`] event.
24016        pub fn OperatorSetsEnabled_filter(
24017            &self,
24018        ) -> alloy_contract::Event<T, &P, OperatorSetsEnabled, N> {
24019            self.event_filter::<OperatorSetsEnabled>()
24020        }
24021        ///Creates a new event filter for the [`OperatorSocketUpdate`] event.
24022        pub fn OperatorSocketUpdate_filter(
24023            &self,
24024        ) -> alloy_contract::Event<T, &P, OperatorSocketUpdate, N> {
24025            self.event_filter::<OperatorSocketUpdate>()
24026        }
24027        ///Creates a new event filter for the [`OwnershipTransferred`] event.
24028        pub fn OwnershipTransferred_filter(
24029            &self,
24030        ) -> alloy_contract::Event<T, &P, OwnershipTransferred, N> {
24031            self.event_filter::<OwnershipTransferred>()
24032        }
24033        ///Creates a new event filter for the [`Paused`] event.
24034        pub fn Paused_filter(&self) -> alloy_contract::Event<T, &P, Paused, N> {
24035            self.event_filter::<Paused>()
24036        }
24037        ///Creates a new event filter for the [`QuorumBlockNumberUpdated`] event.
24038        pub fn QuorumBlockNumberUpdated_filter(
24039            &self,
24040        ) -> alloy_contract::Event<T, &P, QuorumBlockNumberUpdated, N> {
24041            self.event_filter::<QuorumBlockNumberUpdated>()
24042        }
24043        ///Creates a new event filter for the [`QuorumCreated`] event.
24044        pub fn QuorumCreated_filter(
24045            &self,
24046        ) -> alloy_contract::Event<T, &P, QuorumCreated, N> {
24047            self.event_filter::<QuorumCreated>()
24048        }
24049        ///Creates a new event filter for the [`Unpaused`] event.
24050        pub fn Unpaused_filter(&self) -> alloy_contract::Event<T, &P, Unpaused, N> {
24051            self.event_filter::<Unpaused>()
24052        }
24053    }
24054}
eigenlayer_contract_deployer/bindings/core/registrycoordinator.rs

eigenlayer_contract_deployer/bindings/core/
registrycoordinator.rs
