eigen_utils/slashing/core/
allocation_manager.rs

1///Module containing a contract's types and functions.
2/**
3
4```solidity
5library IAllocationManagerTypes {
6    struct AllocateParams { OperatorSet operatorSet; address[] strategies; uint64[] newMagnitudes; }
7    struct Allocation { uint64 currentMagnitude; int128 pendingDiff; uint32 effectBlock; }
8    struct CreateSetParams { uint32 operatorSetId; address[] strategies; }
9    struct DeregisterParams { address operator; address avs; uint32[] operatorSetIds; }
10    struct RegisterParams { address avs; uint32[] operatorSetIds; bytes data; }
11    struct SlashingParams { address operator; uint32 operatorSetId; address[] strategies; uint256[] wadsToSlash; string description; }
12}
13```*/
14#[allow(
15    non_camel_case_types,
16    non_snake_case,
17    clippy::pub_underscore_fields,
18    clippy::style,
19    clippy::empty_structs_with_brackets
20)]
21pub mod IAllocationManagerTypes {
22    use super::*;
23    use crate::slashing::core::allocation_manager::AllocationManager::OperatorSet;
24    use alloy::sol_types as alloy_sol_types;
25    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
26    /**```solidity
27    struct AllocateParams { OperatorSet operatorSet; address[] strategies; uint64[] newMagnitudes; }
28    ```*/
29    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
30    #[derive(Clone)]
31    pub struct AllocateParams {
32        #[allow(missing_docs)]
33        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
34        #[allow(missing_docs)]
35        pub strategies: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
36        #[allow(missing_docs)]
37        pub newMagnitudes: alloy::sol_types::private::Vec<u64>,
38    }
39    #[allow(
40        non_camel_case_types,
41        non_snake_case,
42        clippy::pub_underscore_fields,
43        clippy::style
44    )]
45    const _: () = {
46        use alloy::sol_types as alloy_sol_types;
47        #[doc(hidden)]
48        type UnderlyingSolTuple<'a> = (
49            OperatorSet,
50            alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
51            alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<64>>,
52        );
53        #[doc(hidden)]
54        type UnderlyingRustTuple<'a> = (
55            <OperatorSet as alloy::sol_types::SolType>::RustType,
56            alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
57            alloy::sol_types::private::Vec<u64>,
58        );
59        #[cfg(test)]
60        #[allow(dead_code, unreachable_patterns)]
61        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
62            match _t {
63                alloy_sol_types::private::AssertTypeEq::<
64                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
65                >(_) => {}
66            }
67        }
68        #[automatically_derived]
69        #[doc(hidden)]
70        impl ::core::convert::From<AllocateParams> for UnderlyingRustTuple<'_> {
71            fn from(value: AllocateParams) -> Self {
72                (value.operatorSet, value.strategies, value.newMagnitudes)
73            }
74        }
75        #[automatically_derived]
76        #[doc(hidden)]
77        impl ::core::convert::From<UnderlyingRustTuple<'_>> for AllocateParams {
78            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
79                Self {
80                    operatorSet: tuple.0,
81                    strategies: tuple.1,
82                    newMagnitudes: tuple.2,
83                }
84            }
85        }
86        #[automatically_derived]
87        impl alloy_sol_types::SolValue for AllocateParams {
88            type SolType = Self;
89        }
90        #[automatically_derived]
91        impl alloy_sol_types::private::SolTypeValue<Self> for AllocateParams {
92            #[inline]
93            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
94                (
95                    <OperatorSet as alloy_sol_types::SolType>::tokenize(
96                        &self.operatorSet,
97                    ),
98                    <alloy::sol_types::sol_data::Array<
99                        alloy::sol_types::sol_data::Address,
100                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
101                    <alloy::sol_types::sol_data::Array<
102                        alloy::sol_types::sol_data::Uint<64>,
103                    > as alloy_sol_types::SolType>::tokenize(&self.newMagnitudes),
104                )
105            }
106            #[inline]
107            fn stv_abi_encoded_size(&self) -> usize {
108                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
109                    return size;
110                }
111                let tuple =
112                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
113                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
114            }
115            #[inline]
116            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
117                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
118            }
119            #[inline]
120            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
121                let tuple =
122                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
123                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
124                    &tuple, out,
125                )
126            }
127            #[inline]
128            fn stv_abi_packed_encoded_size(&self) -> usize {
129                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
130                    return size;
131                }
132                let tuple =
133                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
134                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
135                    &tuple,
136                )
137            }
138        }
139        #[automatically_derived]
140        impl alloy_sol_types::SolType for AllocateParams {
141            type RustType = Self;
142            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
143            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
144            const ENCODED_SIZE: Option<usize> =
145                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
146            const PACKED_ENCODED_SIZE: Option<usize> =
147                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
148            #[inline]
149            fn valid_token(token: &Self::Token<'_>) -> bool {
150                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
151            }
152            #[inline]
153            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
154                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
155                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
156            }
157        }
158        #[automatically_derived]
159        impl alloy_sol_types::SolStruct for AllocateParams {
160            const NAME: &'static str = "AllocateParams";
161            #[inline]
162            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
163                alloy_sol_types::private::Cow::Borrowed(
164                    "AllocateParams(OperatorSet operatorSet,address[] strategies,uint64[] newMagnitudes)",
165                )
166            }
167            #[inline]
168            fn eip712_components(
169            ) -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
170            {
171                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
172                components.push(<OperatorSet as alloy_sol_types::SolStruct>::eip712_root_type());
173                components.extend(<OperatorSet as alloy_sol_types::SolStruct>::eip712_components());
174                components
175            }
176            #[inline]
177            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
178                [
179                    <OperatorSet as alloy_sol_types::SolType>::eip712_data_word(
180                            &self.operatorSet,
181                        )
182                        .0,
183                    <alloy::sol_types::sol_data::Array<
184                        alloy::sol_types::sol_data::Address,
185                    > as alloy_sol_types::SolType>::eip712_data_word(&self.strategies)
186                        .0,
187                    <alloy::sol_types::sol_data::Array<
188                        alloy::sol_types::sol_data::Uint<64>,
189                    > as alloy_sol_types::SolType>::eip712_data_word(&self.newMagnitudes)
190                        .0,
191                ]
192                    .concat()
193            }
194        }
195        #[automatically_derived]
196        impl alloy_sol_types::EventTopic for AllocateParams {
197            #[inline]
198            fn topic_preimage_length(rust: &Self::RustType) -> usize {
199                0usize
200                    + <OperatorSet as alloy_sol_types::EventTopic>::topic_preimage_length(
201                        &rust.operatorSet,
202                    )
203                    + <alloy::sol_types::sol_data::Array<
204                        alloy::sol_types::sol_data::Address,
205                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
206                        &rust.strategies,
207                    )
208                    + <alloy::sol_types::sol_data::Array<
209                        alloy::sol_types::sol_data::Uint<64>,
210                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
211                        &rust.newMagnitudes,
212                    )
213            }
214            #[inline]
215            fn encode_topic_preimage(
216                rust: &Self::RustType,
217                out: &mut alloy_sol_types::private::Vec<u8>,
218            ) {
219                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
220                <OperatorSet as alloy_sol_types::EventTopic>::encode_topic_preimage(
221                    &rust.operatorSet,
222                    out,
223                );
224                <alloy::sol_types::sol_data::Array<
225                    alloy::sol_types::sol_data::Address,
226                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
227                    &rust.strategies,
228                    out,
229                );
230                <alloy::sol_types::sol_data::Array<
231                    alloy::sol_types::sol_data::Uint<64>,
232                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
233                    &rust.newMagnitudes,
234                    out,
235                );
236            }
237            #[inline]
238            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
239                let mut out = alloy_sol_types::private::Vec::new();
240                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
241                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
242            }
243        }
244    };
245    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
246    /**```solidity
247    struct Allocation { uint64 currentMagnitude; int128 pendingDiff; uint32 effectBlock; }
248    ```*/
249    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
250    #[derive(Clone)]
251    pub struct Allocation {
252        #[allow(missing_docs)]
253        pub currentMagnitude: u64,
254        #[allow(missing_docs)]
255        pub pendingDiff: i128,
256        #[allow(missing_docs)]
257        pub effectBlock: u32,
258    }
259    #[allow(
260        non_camel_case_types,
261        non_snake_case,
262        clippy::pub_underscore_fields,
263        clippy::style
264    )]
265    const _: () = {
266        use alloy::sol_types as alloy_sol_types;
267        #[doc(hidden)]
268        type UnderlyingSolTuple<'a> = (
269            alloy::sol_types::sol_data::Uint<64>,
270            alloy::sol_types::sol_data::Int<128>,
271            alloy::sol_types::sol_data::Uint<32>,
272        );
273        #[doc(hidden)]
274        type UnderlyingRustTuple<'a> = (u64, i128, u32);
275        #[cfg(test)]
276        #[allow(dead_code, unreachable_patterns)]
277        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
278            match _t {
279                alloy_sol_types::private::AssertTypeEq::<
280                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
281                >(_) => {}
282            }
283        }
284        #[automatically_derived]
285        #[doc(hidden)]
286        impl ::core::convert::From<Allocation> for UnderlyingRustTuple<'_> {
287            fn from(value: Allocation) -> Self {
288                (value.currentMagnitude, value.pendingDiff, value.effectBlock)
289            }
290        }
291        #[automatically_derived]
292        #[doc(hidden)]
293        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Allocation {
294            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
295                Self {
296                    currentMagnitude: tuple.0,
297                    pendingDiff: tuple.1,
298                    effectBlock: tuple.2,
299                }
300            }
301        }
302        #[automatically_derived]
303        impl alloy_sol_types::SolValue for Allocation {
304            type SolType = Self;
305        }
306        #[automatically_derived]
307        impl alloy_sol_types::private::SolTypeValue<Self> for Allocation {
308            #[inline]
309            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
310                (
311                    <alloy::sol_types::sol_data::Uint<64> as alloy_sol_types::SolType>::tokenize(
312                        &self.currentMagnitude,
313                    ),
314                    <alloy::sol_types::sol_data::Int<128> as alloy_sol_types::SolType>::tokenize(
315                        &self.pendingDiff,
316                    ),
317                    <alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
318                        &self.effectBlock,
319                    ),
320                )
321            }
322            #[inline]
323            fn stv_abi_encoded_size(&self) -> usize {
324                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
325                    return size;
326                }
327                let tuple =
328                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
329                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
330            }
331            #[inline]
332            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
333                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
334            }
335            #[inline]
336            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
337                let tuple =
338                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
339                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
340                    &tuple, out,
341                )
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 =
349                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
350                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
351                    &tuple,
352                )
353            }
354        }
355        #[automatically_derived]
356        impl alloy_sol_types::SolType for Allocation {
357            type RustType = Self;
358            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
359            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
360            const ENCODED_SIZE: Option<usize> =
361                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
362            const PACKED_ENCODED_SIZE: Option<usize> =
363                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
364            #[inline]
365            fn valid_token(token: &Self::Token<'_>) -> bool {
366                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
367            }
368            #[inline]
369            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
370                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
371                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
372            }
373        }
374        #[automatically_derived]
375        impl alloy_sol_types::SolStruct for Allocation {
376            const NAME: &'static str = "Allocation";
377            #[inline]
378            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
379                alloy_sol_types::private::Cow::Borrowed(
380                    "Allocation(uint64 currentMagnitude,int128 pendingDiff,uint32 effectBlock)",
381                )
382            }
383            #[inline]
384            fn eip712_components(
385            ) -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
386            {
387                alloy_sol_types::private::Vec::new()
388            }
389            #[inline]
390            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
391                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
392            }
393            #[inline]
394            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
395                [
396                    <alloy::sol_types::sol_data::Uint<
397                        64,
398                    > as alloy_sol_types::SolType>::eip712_data_word(
399                            &self.currentMagnitude,
400                        )
401                        .0,
402                    <alloy::sol_types::sol_data::Int<
403                        128,
404                    > as alloy_sol_types::SolType>::eip712_data_word(&self.pendingDiff)
405                        .0,
406                    <alloy::sol_types::sol_data::Uint<
407                        32,
408                    > as alloy_sol_types::SolType>::eip712_data_word(&self.effectBlock)
409                        .0,
410                ]
411                    .concat()
412            }
413        }
414        #[automatically_derived]
415        impl alloy_sol_types::EventTopic for Allocation {
416            #[inline]
417            fn topic_preimage_length(rust: &Self::RustType) -> usize {
418                0usize
419                    + <alloy::sol_types::sol_data::Uint<
420                        64,
421                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
422                        &rust.currentMagnitude,
423                    )
424                    + <alloy::sol_types::sol_data::Int<
425                        128,
426                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
427                        &rust.pendingDiff,
428                    )
429                    + <alloy::sol_types::sol_data::Uint<
430                        32,
431                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
432                        &rust.effectBlock,
433                    )
434            }
435            #[inline]
436            fn encode_topic_preimage(
437                rust: &Self::RustType,
438                out: &mut alloy_sol_types::private::Vec<u8>,
439            ) {
440                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
441                <alloy::sol_types::sol_data::Uint<
442                    64,
443                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
444                    &rust.currentMagnitude,
445                    out,
446                );
447                <alloy::sol_types::sol_data::Int<
448                    128,
449                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
450                    &rust.pendingDiff,
451                    out,
452                );
453                <alloy::sol_types::sol_data::Uint<
454                    32,
455                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
456                    &rust.effectBlock,
457                    out,
458                );
459            }
460            #[inline]
461            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
462                let mut out = alloy_sol_types::private::Vec::new();
463                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
464                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
465            }
466        }
467    };
468    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
469    /**```solidity
470    struct CreateSetParams { uint32 operatorSetId; address[] strategies; }
471    ```*/
472    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
473    #[derive(Clone)]
474    pub struct CreateSetParams {
475        #[allow(missing_docs)]
476        pub operatorSetId: u32,
477        #[allow(missing_docs)]
478        pub strategies: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
479    }
480    #[allow(
481        non_camel_case_types,
482        non_snake_case,
483        clippy::pub_underscore_fields,
484        clippy::style
485    )]
486    const _: () = {
487        use alloy::sol_types as alloy_sol_types;
488        #[doc(hidden)]
489        type UnderlyingSolTuple<'a> = (
490            alloy::sol_types::sol_data::Uint<32>,
491            alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
492        );
493        #[doc(hidden)]
494        type UnderlyingRustTuple<'a> = (
495            u32,
496            alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
497        );
498        #[cfg(test)]
499        #[allow(dead_code, unreachable_patterns)]
500        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
501            match _t {
502                alloy_sol_types::private::AssertTypeEq::<
503                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
504                >(_) => {}
505            }
506        }
507        #[automatically_derived]
508        #[doc(hidden)]
509        impl ::core::convert::From<CreateSetParams> for UnderlyingRustTuple<'_> {
510            fn from(value: CreateSetParams) -> Self {
511                (value.operatorSetId, value.strategies)
512            }
513        }
514        #[automatically_derived]
515        #[doc(hidden)]
516        impl ::core::convert::From<UnderlyingRustTuple<'_>> for CreateSetParams {
517            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
518                Self {
519                    operatorSetId: tuple.0,
520                    strategies: tuple.1,
521                }
522            }
523        }
524        #[automatically_derived]
525        impl alloy_sol_types::SolValue for CreateSetParams {
526            type SolType = Self;
527        }
528        #[automatically_derived]
529        impl alloy_sol_types::private::SolTypeValue<Self> for CreateSetParams {
530            #[inline]
531            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
532                (
533                    <alloy::sol_types::sol_data::Uint<
534                        32,
535                    > as alloy_sol_types::SolType>::tokenize(&self.operatorSetId),
536                    <alloy::sol_types::sol_data::Array<
537                        alloy::sol_types::sol_data::Address,
538                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
539                )
540            }
541            #[inline]
542            fn stv_abi_encoded_size(&self) -> usize {
543                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
544                    return size;
545                }
546                let tuple =
547                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
548                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
549            }
550            #[inline]
551            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
552                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
553            }
554            #[inline]
555            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
556                let tuple =
557                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
558                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
559                    &tuple, out,
560                )
561            }
562            #[inline]
563            fn stv_abi_packed_encoded_size(&self) -> usize {
564                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
565                    return size;
566                }
567                let tuple =
568                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
569                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
570                    &tuple,
571                )
572            }
573        }
574        #[automatically_derived]
575        impl alloy_sol_types::SolType for CreateSetParams {
576            type RustType = Self;
577            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
578            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
579            const ENCODED_SIZE: Option<usize> =
580                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
581            const PACKED_ENCODED_SIZE: Option<usize> =
582                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
583            #[inline]
584            fn valid_token(token: &Self::Token<'_>) -> bool {
585                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
586            }
587            #[inline]
588            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
589                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
590                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
591            }
592        }
593        #[automatically_derived]
594        impl alloy_sol_types::SolStruct for CreateSetParams {
595            const NAME: &'static str = "CreateSetParams";
596            #[inline]
597            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
598                alloy_sol_types::private::Cow::Borrowed(
599                    "CreateSetParams(uint32 operatorSetId,address[] strategies)",
600                )
601            }
602            #[inline]
603            fn eip712_components(
604            ) -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
605            {
606                alloy_sol_types::private::Vec::new()
607            }
608            #[inline]
609            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
610                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
611            }
612            #[inline]
613            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
614                [
615                    <alloy::sol_types::sol_data::Uint<
616                        32,
617                    > as alloy_sol_types::SolType>::eip712_data_word(&self.operatorSetId)
618                        .0,
619                    <alloy::sol_types::sol_data::Array<
620                        alloy::sol_types::sol_data::Address,
621                    > as alloy_sol_types::SolType>::eip712_data_word(&self.strategies)
622                        .0,
623                ]
624                    .concat()
625            }
626        }
627        #[automatically_derived]
628        impl alloy_sol_types::EventTopic for CreateSetParams {
629            #[inline]
630            fn topic_preimage_length(rust: &Self::RustType) -> usize {
631                0usize
632                    + <alloy::sol_types::sol_data::Uint<
633                        32,
634                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
635                        &rust.operatorSetId,
636                    )
637                    + <alloy::sol_types::sol_data::Array<
638                        alloy::sol_types::sol_data::Address,
639                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
640                        &rust.strategies,
641                    )
642            }
643            #[inline]
644            fn encode_topic_preimage(
645                rust: &Self::RustType,
646                out: &mut alloy_sol_types::private::Vec<u8>,
647            ) {
648                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
649                <alloy::sol_types::sol_data::Uint<
650                    32,
651                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
652                    &rust.operatorSetId,
653                    out,
654                );
655                <alloy::sol_types::sol_data::Array<
656                    alloy::sol_types::sol_data::Address,
657                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
658                    &rust.strategies,
659                    out,
660                );
661            }
662            #[inline]
663            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
664                let mut out = alloy_sol_types::private::Vec::new();
665                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
666                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
667            }
668        }
669    };
670    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
671    /**```solidity
672    struct DeregisterParams { address operator; address avs; uint32[] operatorSetIds; }
673    ```*/
674    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
675    #[derive(Clone)]
676    pub struct DeregisterParams {
677        #[allow(missing_docs)]
678        pub operator: alloy::sol_types::private::Address,
679        #[allow(missing_docs)]
680        pub avs: alloy::sol_types::private::Address,
681        #[allow(missing_docs)]
682        pub operatorSetIds: alloy::sol_types::private::Vec<u32>,
683    }
684    #[allow(
685        non_camel_case_types,
686        non_snake_case,
687        clippy::pub_underscore_fields,
688        clippy::style
689    )]
690    const _: () = {
691        use alloy::sol_types as alloy_sol_types;
692        #[doc(hidden)]
693        type UnderlyingSolTuple<'a> = (
694            alloy::sol_types::sol_data::Address,
695            alloy::sol_types::sol_data::Address,
696            alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
697        );
698        #[doc(hidden)]
699        type UnderlyingRustTuple<'a> = (
700            alloy::sol_types::private::Address,
701            alloy::sol_types::private::Address,
702            alloy::sol_types::private::Vec<u32>,
703        );
704        #[cfg(test)]
705        #[allow(dead_code, unreachable_patterns)]
706        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
707            match _t {
708                alloy_sol_types::private::AssertTypeEq::<
709                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
710                >(_) => {}
711            }
712        }
713        #[automatically_derived]
714        #[doc(hidden)]
715        impl ::core::convert::From<DeregisterParams> for UnderlyingRustTuple<'_> {
716            fn from(value: DeregisterParams) -> Self {
717                (value.operator, value.avs, value.operatorSetIds)
718            }
719        }
720        #[automatically_derived]
721        #[doc(hidden)]
722        impl ::core::convert::From<UnderlyingRustTuple<'_>> for DeregisterParams {
723            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
724                Self {
725                    operator: tuple.0,
726                    avs: tuple.1,
727                    operatorSetIds: tuple.2,
728                }
729            }
730        }
731        #[automatically_derived]
732        impl alloy_sol_types::SolValue for DeregisterParams {
733            type SolType = Self;
734        }
735        #[automatically_derived]
736        impl alloy_sol_types::private::SolTypeValue<Self> for DeregisterParams {
737            #[inline]
738            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
739                (
740                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
741                        &self.operator,
742                    ),
743                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
744                        &self.avs,
745                    ),
746                    <alloy::sol_types::sol_data::Array<
747                        alloy::sol_types::sol_data::Uint<32>,
748                    > as alloy_sol_types::SolType>::tokenize(&self.operatorSetIds),
749                )
750            }
751            #[inline]
752            fn stv_abi_encoded_size(&self) -> usize {
753                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
754                    return size;
755                }
756                let tuple =
757                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
758                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
759            }
760            #[inline]
761            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
762                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
763            }
764            #[inline]
765            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
766                let tuple =
767                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
768                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
769                    &tuple, out,
770                )
771            }
772            #[inline]
773            fn stv_abi_packed_encoded_size(&self) -> usize {
774                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
775                    return size;
776                }
777                let tuple =
778                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
779                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
780                    &tuple,
781                )
782            }
783        }
784        #[automatically_derived]
785        impl alloy_sol_types::SolType for DeregisterParams {
786            type RustType = Self;
787            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
788            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
789            const ENCODED_SIZE: Option<usize> =
790                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
791            const PACKED_ENCODED_SIZE: Option<usize> =
792                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
793            #[inline]
794            fn valid_token(token: &Self::Token<'_>) -> bool {
795                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
796            }
797            #[inline]
798            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
799                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
800                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
801            }
802        }
803        #[automatically_derived]
804        impl alloy_sol_types::SolStruct for DeregisterParams {
805            const NAME: &'static str = "DeregisterParams";
806            #[inline]
807            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
808                alloy_sol_types::private::Cow::Borrowed(
809                    "DeregisterParams(address operator,address avs,uint32[] operatorSetIds)",
810                )
811            }
812            #[inline]
813            fn eip712_components(
814            ) -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
815            {
816                alloy_sol_types::private::Vec::new()
817            }
818            #[inline]
819            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
820                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
821            }
822            #[inline]
823            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
824                [
825                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
826                            &self.operator,
827                        )
828                        .0,
829                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
830                            &self.avs,
831                        )
832                        .0,
833                    <alloy::sol_types::sol_data::Array<
834                        alloy::sol_types::sol_data::Uint<32>,
835                    > as alloy_sol_types::SolType>::eip712_data_word(
836                            &self.operatorSetIds,
837                        )
838                        .0,
839                ]
840                    .concat()
841            }
842        }
843        #[automatically_derived]
844        impl alloy_sol_types::EventTopic for DeregisterParams {
845            #[inline]
846            fn topic_preimage_length(rust: &Self::RustType) -> usize {
847                0usize
848                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
849                        &rust.operator,
850                    )
851                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
852                        &rust.avs,
853                    )
854                    + <alloy::sol_types::sol_data::Array<
855                        alloy::sol_types::sol_data::Uint<32>,
856                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
857                        &rust.operatorSetIds,
858                    )
859            }
860            #[inline]
861            fn encode_topic_preimage(
862                rust: &Self::RustType,
863                out: &mut alloy_sol_types::private::Vec<u8>,
864            ) {
865                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
866                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
867                    &rust.operator,
868                    out,
869                );
870                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
871                    &rust.avs,
872                    out,
873                );
874                <alloy::sol_types::sol_data::Array<
875                    alloy::sol_types::sol_data::Uint<32>,
876                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
877                    &rust.operatorSetIds,
878                    out,
879                );
880            }
881            #[inline]
882            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
883                let mut out = alloy_sol_types::private::Vec::new();
884                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
885                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
886            }
887        }
888    };
889    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
890    /**```solidity
891    struct RegisterParams { address avs; uint32[] operatorSetIds; bytes data; }
892    ```*/
893    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
894    #[derive(Clone)]
895    pub struct RegisterParams {
896        #[allow(missing_docs)]
897        pub avs: alloy::sol_types::private::Address,
898        #[allow(missing_docs)]
899        pub operatorSetIds: alloy::sol_types::private::Vec<u32>,
900        #[allow(missing_docs)]
901        pub data: alloy::sol_types::private::Bytes,
902    }
903    #[allow(
904        non_camel_case_types,
905        non_snake_case,
906        clippy::pub_underscore_fields,
907        clippy::style
908    )]
909    const _: () = {
910        use alloy::sol_types as alloy_sol_types;
911        #[doc(hidden)]
912        type UnderlyingSolTuple<'a> = (
913            alloy::sol_types::sol_data::Address,
914            alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
915            alloy::sol_types::sol_data::Bytes,
916        );
917        #[doc(hidden)]
918        type UnderlyingRustTuple<'a> = (
919            alloy::sol_types::private::Address,
920            alloy::sol_types::private::Vec<u32>,
921            alloy::sol_types::private::Bytes,
922        );
923        #[cfg(test)]
924        #[allow(dead_code, unreachable_patterns)]
925        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
926            match _t {
927                alloy_sol_types::private::AssertTypeEq::<
928                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
929                >(_) => {}
930            }
931        }
932        #[automatically_derived]
933        #[doc(hidden)]
934        impl ::core::convert::From<RegisterParams> for UnderlyingRustTuple<'_> {
935            fn from(value: RegisterParams) -> Self {
936                (value.avs, value.operatorSetIds, value.data)
937            }
938        }
939        #[automatically_derived]
940        #[doc(hidden)]
941        impl ::core::convert::From<UnderlyingRustTuple<'_>> for RegisterParams {
942            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
943                Self {
944                    avs: tuple.0,
945                    operatorSetIds: tuple.1,
946                    data: tuple.2,
947                }
948            }
949        }
950        #[automatically_derived]
951        impl alloy_sol_types::SolValue for RegisterParams {
952            type SolType = Self;
953        }
954        #[automatically_derived]
955        impl alloy_sol_types::private::SolTypeValue<Self> for RegisterParams {
956            #[inline]
957            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
958                (
959                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
960                        &self.avs,
961                    ),
962                    <alloy::sol_types::sol_data::Array<
963                        alloy::sol_types::sol_data::Uint<32>,
964                    > as alloy_sol_types::SolType>::tokenize(&self.operatorSetIds),
965                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
966                        &self.data,
967                    ),
968                )
969            }
970            #[inline]
971            fn stv_abi_encoded_size(&self) -> usize {
972                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
973                    return size;
974                }
975                let tuple =
976                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
977                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
978            }
979            #[inline]
980            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
981                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
982            }
983            #[inline]
984            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
985                let tuple =
986                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
987                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
988                    &tuple, out,
989                )
990            }
991            #[inline]
992            fn stv_abi_packed_encoded_size(&self) -> usize {
993                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
994                    return size;
995                }
996                let tuple =
997                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
998                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
999                    &tuple,
1000                )
1001            }
1002        }
1003        #[automatically_derived]
1004        impl alloy_sol_types::SolType for RegisterParams {
1005            type RustType = Self;
1006            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
1007            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
1008            const ENCODED_SIZE: Option<usize> =
1009                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
1010            const PACKED_ENCODED_SIZE: Option<usize> =
1011                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
1012            #[inline]
1013            fn valid_token(token: &Self::Token<'_>) -> bool {
1014                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
1015            }
1016            #[inline]
1017            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
1018                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
1019                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
1020            }
1021        }
1022        #[automatically_derived]
1023        impl alloy_sol_types::SolStruct for RegisterParams {
1024            const NAME: &'static str = "RegisterParams";
1025            #[inline]
1026            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
1027                alloy_sol_types::private::Cow::Borrowed(
1028                    "RegisterParams(address avs,uint32[] operatorSetIds,bytes data)",
1029                )
1030            }
1031            #[inline]
1032            fn eip712_components(
1033            ) -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
1034            {
1035                alloy_sol_types::private::Vec::new()
1036            }
1037            #[inline]
1038            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
1039                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
1040            }
1041            #[inline]
1042            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
1043                [
1044                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
1045                            &self.avs,
1046                        )
1047                        .0,
1048                    <alloy::sol_types::sol_data::Array<
1049                        alloy::sol_types::sol_data::Uint<32>,
1050                    > as alloy_sol_types::SolType>::eip712_data_word(
1051                            &self.operatorSetIds,
1052                        )
1053                        .0,
1054                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
1055                            &self.data,
1056                        )
1057                        .0,
1058                ]
1059                    .concat()
1060            }
1061        }
1062        #[automatically_derived]
1063        impl alloy_sol_types::EventTopic for RegisterParams {
1064            #[inline]
1065            fn topic_preimage_length(rust: &Self::RustType) -> usize {
1066                0usize
1067                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
1068                        &rust.avs,
1069                    )
1070                    + <alloy::sol_types::sol_data::Array<
1071                        alloy::sol_types::sol_data::Uint<32>,
1072                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
1073                        &rust.operatorSetIds,
1074                    )
1075                    + <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
1076                        &rust.data,
1077                    )
1078            }
1079            #[inline]
1080            fn encode_topic_preimage(
1081                rust: &Self::RustType,
1082                out: &mut alloy_sol_types::private::Vec<u8>,
1083            ) {
1084                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
1085                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
1086                    &rust.avs,
1087                    out,
1088                );
1089                <alloy::sol_types::sol_data::Array<
1090                    alloy::sol_types::sol_data::Uint<32>,
1091                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1092                    &rust.operatorSetIds,
1093                    out,
1094                );
1095                <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
1096                    &rust.data,
1097                    out,
1098                );
1099            }
1100            #[inline]
1101            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
1102                let mut out = alloy_sol_types::private::Vec::new();
1103                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
1104                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
1105            }
1106        }
1107    };
1108    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
1109    /**```solidity
1110    struct SlashingParams { address operator; uint32 operatorSetId; address[] strategies; uint256[] wadsToSlash; string description; }
1111    ```*/
1112    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1113    #[derive(Clone)]
1114    pub struct SlashingParams {
1115        #[allow(missing_docs)]
1116        pub operator: alloy::sol_types::private::Address,
1117        #[allow(missing_docs)]
1118        pub operatorSetId: u32,
1119        #[allow(missing_docs)]
1120        pub strategies: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
1121        #[allow(missing_docs)]
1122        pub wadsToSlash:
1123            alloy::sol_types::private::Vec<alloy::sol_types::private::primitives::aliases::U256>,
1124        #[allow(missing_docs)]
1125        pub description: alloy::sol_types::private::String,
1126    }
1127    #[allow(
1128        non_camel_case_types,
1129        non_snake_case,
1130        clippy::pub_underscore_fields,
1131        clippy::style
1132    )]
1133    const _: () = {
1134        use alloy::sol_types as alloy_sol_types;
1135        #[doc(hidden)]
1136        type UnderlyingSolTuple<'a> = (
1137            alloy::sol_types::sol_data::Address,
1138            alloy::sol_types::sol_data::Uint<32>,
1139            alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
1140            alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
1141            alloy::sol_types::sol_data::String,
1142        );
1143        #[doc(hidden)]
1144        type UnderlyingRustTuple<'a> = (
1145            alloy::sol_types::private::Address,
1146            u32,
1147            alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
1148            alloy::sol_types::private::Vec<alloy::sol_types::private::primitives::aliases::U256>,
1149            alloy::sol_types::private::String,
1150        );
1151        #[cfg(test)]
1152        #[allow(dead_code, unreachable_patterns)]
1153        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1154            match _t {
1155                alloy_sol_types::private::AssertTypeEq::<
1156                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1157                >(_) => {}
1158            }
1159        }
1160        #[automatically_derived]
1161        #[doc(hidden)]
1162        impl ::core::convert::From<SlashingParams> for UnderlyingRustTuple<'_> {
1163            fn from(value: SlashingParams) -> Self {
1164                (
1165                    value.operator,
1166                    value.operatorSetId,
1167                    value.strategies,
1168                    value.wadsToSlash,
1169                    value.description,
1170                )
1171            }
1172        }
1173        #[automatically_derived]
1174        #[doc(hidden)]
1175        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SlashingParams {
1176            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1177                Self {
1178                    operator: tuple.0,
1179                    operatorSetId: tuple.1,
1180                    strategies: tuple.2,
1181                    wadsToSlash: tuple.3,
1182                    description: tuple.4,
1183                }
1184            }
1185        }
1186        #[automatically_derived]
1187        impl alloy_sol_types::SolValue for SlashingParams {
1188            type SolType = Self;
1189        }
1190        #[automatically_derived]
1191        impl alloy_sol_types::private::SolTypeValue<Self> for SlashingParams {
1192            #[inline]
1193            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
1194                (
1195                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1196                        &self.operator,
1197                    ),
1198                    <alloy::sol_types::sol_data::Uint<
1199                        32,
1200                    > as alloy_sol_types::SolType>::tokenize(&self.operatorSetId),
1201                    <alloy::sol_types::sol_data::Array<
1202                        alloy::sol_types::sol_data::Address,
1203                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
1204                    <alloy::sol_types::sol_data::Array<
1205                        alloy::sol_types::sol_data::Uint<256>,
1206                    > as alloy_sol_types::SolType>::tokenize(&self.wadsToSlash),
1207                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
1208                        &self.description,
1209                    ),
1210                )
1211            }
1212            #[inline]
1213            fn stv_abi_encoded_size(&self) -> usize {
1214                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
1215                    return size;
1216                }
1217                let tuple =
1218                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
1219                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
1220            }
1221            #[inline]
1222            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
1223                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
1224            }
1225            #[inline]
1226            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1227                let tuple =
1228                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
1229                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
1230                    &tuple, out,
1231                )
1232            }
1233            #[inline]
1234            fn stv_abi_packed_encoded_size(&self) -> usize {
1235                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
1236                    return size;
1237                }
1238                let tuple =
1239                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
1240                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
1241                    &tuple,
1242                )
1243            }
1244        }
1245        #[automatically_derived]
1246        impl alloy_sol_types::SolType for SlashingParams {
1247            type RustType = Self;
1248            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
1249            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
1250            const ENCODED_SIZE: Option<usize> =
1251                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
1252            const PACKED_ENCODED_SIZE: Option<usize> =
1253                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
1254            #[inline]
1255            fn valid_token(token: &Self::Token<'_>) -> bool {
1256                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
1257            }
1258            #[inline]
1259            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
1260                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
1261                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
1262            }
1263        }
1264        #[automatically_derived]
1265        impl alloy_sol_types::SolStruct for SlashingParams {
1266            const NAME: &'static str = "SlashingParams";
1267            #[inline]
1268            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
1269                alloy_sol_types::private::Cow::Borrowed(
1270                    "SlashingParams(address operator,uint32 operatorSetId,address[] strategies,uint256[] wadsToSlash,string description)",
1271                )
1272            }
1273            #[inline]
1274            fn eip712_components(
1275            ) -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
1276            {
1277                alloy_sol_types::private::Vec::new()
1278            }
1279            #[inline]
1280            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
1281                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
1282            }
1283            #[inline]
1284            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
1285                [
1286                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
1287                            &self.operator,
1288                        )
1289                        .0,
1290                    <alloy::sol_types::sol_data::Uint<
1291                        32,
1292                    > as alloy_sol_types::SolType>::eip712_data_word(&self.operatorSetId)
1293                        .0,
1294                    <alloy::sol_types::sol_data::Array<
1295                        alloy::sol_types::sol_data::Address,
1296                    > as alloy_sol_types::SolType>::eip712_data_word(&self.strategies)
1297                        .0,
1298                    <alloy::sol_types::sol_data::Array<
1299                        alloy::sol_types::sol_data::Uint<256>,
1300                    > as alloy_sol_types::SolType>::eip712_data_word(&self.wadsToSlash)
1301                        .0,
1302                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::eip712_data_word(
1303                            &self.description,
1304                        )
1305                        .0,
1306                ]
1307                    .concat()
1308            }
1309        }
1310        #[automatically_derived]
1311        impl alloy_sol_types::EventTopic for SlashingParams {
1312            #[inline]
1313            fn topic_preimage_length(rust: &Self::RustType) -> usize {
1314                0usize
1315                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
1316                        &rust.operator,
1317                    )
1318                    + <alloy::sol_types::sol_data::Uint<
1319                        32,
1320                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
1321                        &rust.operatorSetId,
1322                    )
1323                    + <alloy::sol_types::sol_data::Array<
1324                        alloy::sol_types::sol_data::Address,
1325                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
1326                        &rust.strategies,
1327                    )
1328                    + <alloy::sol_types::sol_data::Array<
1329                        alloy::sol_types::sol_data::Uint<256>,
1330                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
1331                        &rust.wadsToSlash,
1332                    )
1333                    + <alloy::sol_types::sol_data::String as alloy_sol_types::EventTopic>::topic_preimage_length(
1334                        &rust.description,
1335                    )
1336            }
1337            #[inline]
1338            fn encode_topic_preimage(
1339                rust: &Self::RustType,
1340                out: &mut alloy_sol_types::private::Vec<u8>,
1341            ) {
1342                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
1343                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
1344                    &rust.operator,
1345                    out,
1346                );
1347                <alloy::sol_types::sol_data::Uint<
1348                    32,
1349                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1350                    &rust.operatorSetId,
1351                    out,
1352                );
1353                <alloy::sol_types::sol_data::Array<
1354                    alloy::sol_types::sol_data::Address,
1355                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1356                    &rust.strategies,
1357                    out,
1358                );
1359                <alloy::sol_types::sol_data::Array<
1360                    alloy::sol_types::sol_data::Uint<256>,
1361                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1362                    &rust.wadsToSlash,
1363                    out,
1364                );
1365                <alloy::sol_types::sol_data::String as alloy_sol_types::EventTopic>::encode_topic_preimage(
1366                    &rust.description,
1367                    out,
1368                );
1369            }
1370            #[inline]
1371            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
1372                let mut out = alloy_sol_types::private::Vec::new();
1373                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
1374                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
1375            }
1376        }
1377    };
1378    use alloy::contract as alloy_contract;
1379    /**Creates a new wrapper around an on-chain [`IAllocationManagerTypes`](self) contract instance.
1380
1381    See the [wrapper's documentation](`IAllocationManagerTypesInstance`) for more details.*/
1382    #[inline]
1383    pub const fn new<
1384        P: alloy_contract::private::Provider<N>,
1385        N: alloy_contract::private::Network,
1386    >(
1387        address: alloy_sol_types::private::Address,
1388        provider: P,
1389    ) -> IAllocationManagerTypesInstance<P, N> {
1390        IAllocationManagerTypesInstance::<P, N>::new(address, provider)
1391    }
1392    /**A [`IAllocationManagerTypes`](self) instance.
1393
1394    Contains type-safe methods for interacting with an on-chain instance of the
1395    [`IAllocationManagerTypes`](self) contract located at a given `address`, using a given
1396    provider `P`.
1397
1398    If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
1399    documentation on how to provide it), the `deploy` and `deploy_builder` methods can
1400    be used to deploy a new instance of the contract.
1401
1402    See the [module-level documentation](self) for all the available methods.*/
1403    #[derive(Clone)]
1404    pub struct IAllocationManagerTypesInstance<P, N = alloy_contract::private::Ethereum> {
1405        address: alloy_sol_types::private::Address,
1406        provider: P,
1407        _network: ::core::marker::PhantomData<N>,
1408    }
1409    #[automatically_derived]
1410    impl<P, N> ::core::fmt::Debug for IAllocationManagerTypesInstance<P, N> {
1411        #[inline]
1412        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1413            f.debug_tuple("IAllocationManagerTypesInstance")
1414                .field(&self.address)
1415                .finish()
1416        }
1417    }
1418    /// Instantiation and getters/setters.
1419    #[automatically_derived]
1420    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
1421        IAllocationManagerTypesInstance<P, N>
1422    {
1423        /**Creates a new wrapper around an on-chain [`IAllocationManagerTypes`](self) contract instance.
1424
1425        See the [wrapper's documentation](`IAllocationManagerTypesInstance`) for more details.*/
1426        #[inline]
1427        pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self {
1428            Self {
1429                address,
1430                provider,
1431                _network: ::core::marker::PhantomData,
1432            }
1433        }
1434        /// Returns a reference to the address.
1435        #[inline]
1436        pub const fn address(&self) -> &alloy_sol_types::private::Address {
1437            &self.address
1438        }
1439        /// Sets the address.
1440        #[inline]
1441        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
1442            self.address = address;
1443        }
1444        /// Sets the address and returns `self`.
1445        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
1446            self.set_address(address);
1447            self
1448        }
1449        /// Returns a reference to the provider.
1450        #[inline]
1451        pub const fn provider(&self) -> &P {
1452            &self.provider
1453        }
1454    }
1455    impl<P: ::core::clone::Clone, N> IAllocationManagerTypesInstance<&P, N> {
1456        /// Clones the provider and returns a new instance with the cloned provider.
1457        #[inline]
1458        pub fn with_cloned_provider(self) -> IAllocationManagerTypesInstance<P, N> {
1459            IAllocationManagerTypesInstance {
1460                address: self.address,
1461                provider: ::core::clone::Clone::clone(&self.provider),
1462                _network: ::core::marker::PhantomData,
1463            }
1464        }
1465    }
1466    /// Function calls.
1467    #[automatically_derived]
1468    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
1469        IAllocationManagerTypesInstance<P, N>
1470    {
1471        /// Creates a new call builder using this contract instance's provider and address.
1472        ///
1473        /// Note that the call can be any function call, not just those defined in this
1474        /// contract. Prefer using the other methods for building type-safe contract calls.
1475        pub fn call_builder<C: alloy_sol_types::SolCall>(
1476            &self,
1477            call: &C,
1478        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
1479            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
1480        }
1481    }
1482    /// Event filters.
1483    #[automatically_derived]
1484    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
1485        IAllocationManagerTypesInstance<P, N>
1486    {
1487        /// Creates a new event filter using this contract instance's provider and address.
1488        ///
1489        /// Note that the type can be any event, not just those defined in this contract.
1490        /// Prefer using the other methods for building type-safe event filters.
1491        pub fn event_filter<E: alloy_sol_types::SolEvent>(
1492            &self,
1493        ) -> alloy_contract::Event<&P, E, N> {
1494            alloy_contract::Event::new_sol(&self.provider, &self.address)
1495        }
1496    }
1497}
1498/**
1499
1500Generated by the following Solidity interface...
1501```solidity
1502library IAllocationManagerTypes {
1503    struct AllocateParams {
1504        OperatorSet operatorSet;
1505        address[] strategies;
1506        uint64[] newMagnitudes;
1507    }
1508    struct Allocation {
1509        uint64 currentMagnitude;
1510        int128 pendingDiff;
1511        uint32 effectBlock;
1512    }
1513    struct CreateSetParams {
1514        uint32 operatorSetId;
1515        address[] strategies;
1516    }
1517    struct DeregisterParams {
1518        address operator;
1519        address avs;
1520        uint32[] operatorSetIds;
1521    }
1522    struct RegisterParams {
1523        address avs;
1524        uint32[] operatorSetIds;
1525        bytes data;
1526    }
1527    struct SlashingParams {
1528        address operator;
1529        uint32 operatorSetId;
1530        address[] strategies;
1531        uint256[] wadsToSlash;
1532        string description;
1533    }
1534}
1535
1536interface AllocationManager {
1537    struct OperatorSet {
1538        address avs;
1539        uint32 id;
1540    }
1541
1542    error AlreadyMemberOfSet();
1543    error CurrentlyPaused();
1544    error Empty();
1545    error InputAddressZero();
1546    error InputArrayLengthMismatch();
1547    error InsufficientMagnitude();
1548    error InvalidAVSRegistrar();
1549    error InvalidCaller();
1550    error InvalidNewPausedStatus();
1551    error InvalidOperator();
1552    error InvalidOperatorSet();
1553    error InvalidPermissions();
1554    error InvalidShortString();
1555    error InvalidSnapshotOrdering();
1556    error InvalidWadToSlash();
1557    error ModificationAlreadyPending();
1558    error NonexistentAVSMetadata();
1559    error NotMemberOfSet();
1560    error OnlyPauser();
1561    error OnlyUnpauser();
1562    error OperatorNotSlashable();
1563    error OutOfBounds();
1564    error SameMagnitude();
1565    error StrategiesMustBeInAscendingOrder();
1566    error StrategyAlreadyInOperatorSet();
1567    error StrategyNotInOperatorSet();
1568    error StringTooLong(string str);
1569    error UninitializedAllocationDelay();
1570
1571    event AVSMetadataURIUpdated(address indexed avs, string metadataURI);
1572    event AVSRegistrarSet(address avs, address registrar);
1573    event AllocationDelaySet(address operator, uint32 delay, uint32 effectBlock);
1574    event AllocationUpdated(address operator, OperatorSet operatorSet, address strategy, uint64 magnitude, uint32 effectBlock);
1575    event EncumberedMagnitudeUpdated(address operator, address strategy, uint64 encumberedMagnitude);
1576    event Initialized(uint8 version);
1577    event MaxMagnitudeUpdated(address operator, address strategy, uint64 maxMagnitude);
1578    event OperatorAddedToOperatorSet(address indexed operator, OperatorSet operatorSet);
1579    event OperatorRemovedFromOperatorSet(address indexed operator, OperatorSet operatorSet);
1580    event OperatorSetCreated(OperatorSet operatorSet);
1581    event OperatorSlashed(address operator, OperatorSet operatorSet, address[] strategies, uint256[] wadSlashed, string description);
1582    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
1583    event Paused(address indexed account, uint256 newPausedStatus);
1584    event StrategyAddedToOperatorSet(OperatorSet operatorSet, address strategy);
1585    event StrategyRemovedFromOperatorSet(OperatorSet operatorSet, address strategy);
1586    event Unpaused(address indexed account, uint256 newPausedStatus);
1587
1588    constructor(address _delegation, address _pauserRegistry, address _permissionController, uint32 _DEALLOCATION_DELAY, uint32 _ALLOCATION_CONFIGURATION_DELAY, string _version);
1589
1590    function ALLOCATION_CONFIGURATION_DELAY() external view returns (uint32);
1591    function DEALLOCATION_DELAY() external view returns (uint32);
1592    function addStrategiesToOperatorSet(address avs, uint32 operatorSetId, address[] memory strategies) external;
1593    function clearDeallocationQueue(address operator, address[] memory strategies, uint16[] memory numToClear) external;
1594    function createOperatorSets(address avs, IAllocationManagerTypes.CreateSetParams[] memory params) external;
1595    function delegation() external view returns (address);
1596    function deregisterFromOperatorSets(IAllocationManagerTypes.DeregisterParams memory params) external;
1597    function getAVSRegistrar(address avs) external view returns (address);
1598    function getAllocatableMagnitude(address operator, address strategy) external view returns (uint64);
1599    function getAllocatedSets(address operator) external view returns (OperatorSet[] memory);
1600    function getAllocatedStake(OperatorSet memory operatorSet, address[] memory operators, address[] memory strategies) external view returns (uint256[][] memory);
1601    function getAllocatedStrategies(address operator, OperatorSet memory operatorSet) external view returns (address[] memory);
1602    function getAllocation(address operator, OperatorSet memory operatorSet, address strategy) external view returns (IAllocationManagerTypes.Allocation memory);
1603    function getAllocationDelay(address operator) external view returns (bool, uint32);
1604    function getAllocations(address[] memory operators, OperatorSet memory operatorSet, address strategy) external view returns (IAllocationManagerTypes.Allocation[] memory);
1605    function getEncumberedMagnitude(address operator, address strategy) external view returns (uint64);
1606    function getMaxMagnitude(address operator, address strategy) external view returns (uint64);
1607    function getMaxMagnitudes(address[] memory operators, address strategy) external view returns (uint64[] memory);
1608    function getMaxMagnitudes(address operator, address[] memory strategies) external view returns (uint64[] memory);
1609    function getMaxMagnitudesAtBlock(address operator, address[] memory strategies, uint32 blockNumber) external view returns (uint64[] memory);
1610    function getMemberCount(OperatorSet memory operatorSet) external view returns (uint256);
1611    function getMembers(OperatorSet memory operatorSet) external view returns (address[] memory);
1612    function getMinimumSlashableStake(OperatorSet memory operatorSet, address[] memory operators, address[] memory strategies, uint32 futureBlock) external view returns (uint256[][] memory slashableStake);
1613    function getOperatorSetCount(address avs) external view returns (uint256);
1614    function getRegisteredSets(address operator) external view returns (OperatorSet[] memory);
1615    function getStrategiesInOperatorSet(OperatorSet memory operatorSet) external view returns (address[] memory);
1616    function getStrategyAllocations(address operator, address strategy) external view returns (OperatorSet[] memory, IAllocationManagerTypes.Allocation[] memory);
1617    function initialize(address initialOwner, uint256 initialPausedStatus) external;
1618    function isMemberOfOperatorSet(address operator, OperatorSet memory operatorSet) external view returns (bool);
1619    function isOperatorSet(OperatorSet memory operatorSet) external view returns (bool);
1620    function isOperatorSlashable(address operator, OperatorSet memory operatorSet) external view returns (bool);
1621    function modifyAllocations(address operator, IAllocationManagerTypes.AllocateParams[] memory params) external;
1622    function owner() external view returns (address);
1623    function pause(uint256 newPausedStatus) external;
1624    function pauseAll() external;
1625    function paused(uint8 index) external view returns (bool);
1626    function paused() external view returns (uint256);
1627    function pauserRegistry() external view returns (address);
1628    function permissionController() external view returns (address);
1629    function registerForOperatorSets(address operator, IAllocationManagerTypes.RegisterParams memory params) external;
1630    function removeStrategiesFromOperatorSet(address avs, uint32 operatorSetId, address[] memory strategies) external;
1631    function renounceOwnership() external;
1632    function setAVSRegistrar(address avs, address registrar) external;
1633    function setAllocationDelay(address operator, uint32 delay) external;
1634    function slashOperator(address avs, IAllocationManagerTypes.SlashingParams memory params) external;
1635    function transferOwnership(address newOwner) external;
1636    function unpause(uint256 newPausedStatus) external;
1637    function updateAVSMetadataURI(address avs, string memory metadataURI) external;
1638    function version() external view returns (string memory);
1639}
1640```
1641
1642...which was generated by the following JSON ABI:
1643```json
1644[
1645  {
1646    "type": "constructor",
1647    "inputs": [
1648      {
1649        "name": "_delegation",
1650        "type": "address",
1651        "internalType": "contract IDelegationManager"
1652      },
1653      {
1654        "name": "_pauserRegistry",
1655        "type": "address",
1656        "internalType": "contract IPauserRegistry"
1657      },
1658      {
1659        "name": "_permissionController",
1660        "type": "address",
1661        "internalType": "contract IPermissionController"
1662      },
1663      {
1664        "name": "_DEALLOCATION_DELAY",
1665        "type": "uint32",
1666        "internalType": "uint32"
1667      },
1668      {
1669        "name": "_ALLOCATION_CONFIGURATION_DELAY",
1670        "type": "uint32",
1671        "internalType": "uint32"
1672      },
1673      {
1674        "name": "_version",
1675        "type": "string",
1676        "internalType": "string"
1677      }
1678    ],
1679    "stateMutability": "nonpayable"
1680  },
1681  {
1682    "type": "function",
1683    "name": "ALLOCATION_CONFIGURATION_DELAY",
1684    "inputs": [],
1685    "outputs": [
1686      {
1687        "name": "",
1688        "type": "uint32",
1689        "internalType": "uint32"
1690      }
1691    ],
1692    "stateMutability": "view"
1693  },
1694  {
1695    "type": "function",
1696    "name": "DEALLOCATION_DELAY",
1697    "inputs": [],
1698    "outputs": [
1699      {
1700        "name": "",
1701        "type": "uint32",
1702        "internalType": "uint32"
1703      }
1704    ],
1705    "stateMutability": "view"
1706  },
1707  {
1708    "type": "function",
1709    "name": "addStrategiesToOperatorSet",
1710    "inputs": [
1711      {
1712        "name": "avs",
1713        "type": "address",
1714        "internalType": "address"
1715      },
1716      {
1717        "name": "operatorSetId",
1718        "type": "uint32",
1719        "internalType": "uint32"
1720      },
1721      {
1722        "name": "strategies",
1723        "type": "address[]",
1724        "internalType": "contract IStrategy[]"
1725      }
1726    ],
1727    "outputs": [],
1728    "stateMutability": "nonpayable"
1729  },
1730  {
1731    "type": "function",
1732    "name": "clearDeallocationQueue",
1733    "inputs": [
1734      {
1735        "name": "operator",
1736        "type": "address",
1737        "internalType": "address"
1738      },
1739      {
1740        "name": "strategies",
1741        "type": "address[]",
1742        "internalType": "contract IStrategy[]"
1743      },
1744      {
1745        "name": "numToClear",
1746        "type": "uint16[]",
1747        "internalType": "uint16[]"
1748      }
1749    ],
1750    "outputs": [],
1751    "stateMutability": "nonpayable"
1752  },
1753  {
1754    "type": "function",
1755    "name": "createOperatorSets",
1756    "inputs": [
1757      {
1758        "name": "avs",
1759        "type": "address",
1760        "internalType": "address"
1761      },
1762      {
1763        "name": "params",
1764        "type": "tuple[]",
1765        "internalType": "struct IAllocationManagerTypes.CreateSetParams[]",
1766        "components": [
1767          {
1768            "name": "operatorSetId",
1769            "type": "uint32",
1770            "internalType": "uint32"
1771          },
1772          {
1773            "name": "strategies",
1774            "type": "address[]",
1775            "internalType": "contract IStrategy[]"
1776          }
1777        ]
1778      }
1779    ],
1780    "outputs": [],
1781    "stateMutability": "nonpayable"
1782  },
1783  {
1784    "type": "function",
1785    "name": "delegation",
1786    "inputs": [],
1787    "outputs": [
1788      {
1789        "name": "",
1790        "type": "address",
1791        "internalType": "contract IDelegationManager"
1792      }
1793    ],
1794    "stateMutability": "view"
1795  },
1796  {
1797    "type": "function",
1798    "name": "deregisterFromOperatorSets",
1799    "inputs": [
1800      {
1801        "name": "params",
1802        "type": "tuple",
1803        "internalType": "struct IAllocationManagerTypes.DeregisterParams",
1804        "components": [
1805          {
1806            "name": "operator",
1807            "type": "address",
1808            "internalType": "address"
1809          },
1810          {
1811            "name": "avs",
1812            "type": "address",
1813            "internalType": "address"
1814          },
1815          {
1816            "name": "operatorSetIds",
1817            "type": "uint32[]",
1818            "internalType": "uint32[]"
1819          }
1820        ]
1821      }
1822    ],
1823    "outputs": [],
1824    "stateMutability": "nonpayable"
1825  },
1826  {
1827    "type": "function",
1828    "name": "getAVSRegistrar",
1829    "inputs": [
1830      {
1831        "name": "avs",
1832        "type": "address",
1833        "internalType": "address"
1834      }
1835    ],
1836    "outputs": [
1837      {
1838        "name": "",
1839        "type": "address",
1840        "internalType": "contract IAVSRegistrar"
1841      }
1842    ],
1843    "stateMutability": "view"
1844  },
1845  {
1846    "type": "function",
1847    "name": "getAllocatableMagnitude",
1848    "inputs": [
1849      {
1850        "name": "operator",
1851        "type": "address",
1852        "internalType": "address"
1853      },
1854      {
1855        "name": "strategy",
1856        "type": "address",
1857        "internalType": "contract IStrategy"
1858      }
1859    ],
1860    "outputs": [
1861      {
1862        "name": "",
1863        "type": "uint64",
1864        "internalType": "uint64"
1865      }
1866    ],
1867    "stateMutability": "view"
1868  },
1869  {
1870    "type": "function",
1871    "name": "getAllocatedSets",
1872    "inputs": [
1873      {
1874        "name": "operator",
1875        "type": "address",
1876        "internalType": "address"
1877      }
1878    ],
1879    "outputs": [
1880      {
1881        "name": "",
1882        "type": "tuple[]",
1883        "internalType": "struct OperatorSet[]",
1884        "components": [
1885          {
1886            "name": "avs",
1887            "type": "address",
1888            "internalType": "address"
1889          },
1890          {
1891            "name": "id",
1892            "type": "uint32",
1893            "internalType": "uint32"
1894          }
1895        ]
1896      }
1897    ],
1898    "stateMutability": "view"
1899  },
1900  {
1901    "type": "function",
1902    "name": "getAllocatedStake",
1903    "inputs": [
1904      {
1905        "name": "operatorSet",
1906        "type": "tuple",
1907        "internalType": "struct OperatorSet",
1908        "components": [
1909          {
1910            "name": "avs",
1911            "type": "address",
1912            "internalType": "address"
1913          },
1914          {
1915            "name": "id",
1916            "type": "uint32",
1917            "internalType": "uint32"
1918          }
1919        ]
1920      },
1921      {
1922        "name": "operators",
1923        "type": "address[]",
1924        "internalType": "address[]"
1925      },
1926      {
1927        "name": "strategies",
1928        "type": "address[]",
1929        "internalType": "contract IStrategy[]"
1930      }
1931    ],
1932    "outputs": [
1933      {
1934        "name": "",
1935        "type": "uint256[][]",
1936        "internalType": "uint256[][]"
1937      }
1938    ],
1939    "stateMutability": "view"
1940  },
1941  {
1942    "type": "function",
1943    "name": "getAllocatedStrategies",
1944    "inputs": [
1945      {
1946        "name": "operator",
1947        "type": "address",
1948        "internalType": "address"
1949      },
1950      {
1951        "name": "operatorSet",
1952        "type": "tuple",
1953        "internalType": "struct OperatorSet",
1954        "components": [
1955          {
1956            "name": "avs",
1957            "type": "address",
1958            "internalType": "address"
1959          },
1960          {
1961            "name": "id",
1962            "type": "uint32",
1963            "internalType": "uint32"
1964          }
1965        ]
1966      }
1967    ],
1968    "outputs": [
1969      {
1970        "name": "",
1971        "type": "address[]",
1972        "internalType": "contract IStrategy[]"
1973      }
1974    ],
1975    "stateMutability": "view"
1976  },
1977  {
1978    "type": "function",
1979    "name": "getAllocation",
1980    "inputs": [
1981      {
1982        "name": "operator",
1983        "type": "address",
1984        "internalType": "address"
1985      },
1986      {
1987        "name": "operatorSet",
1988        "type": "tuple",
1989        "internalType": "struct OperatorSet",
1990        "components": [
1991          {
1992            "name": "avs",
1993            "type": "address",
1994            "internalType": "address"
1995          },
1996          {
1997            "name": "id",
1998            "type": "uint32",
1999            "internalType": "uint32"
2000          }
2001        ]
2002      },
2003      {
2004        "name": "strategy",
2005        "type": "address",
2006        "internalType": "contract IStrategy"
2007      }
2008    ],
2009    "outputs": [
2010      {
2011        "name": "",
2012        "type": "tuple",
2013        "internalType": "struct IAllocationManagerTypes.Allocation",
2014        "components": [
2015          {
2016            "name": "currentMagnitude",
2017            "type": "uint64",
2018            "internalType": "uint64"
2019          },
2020          {
2021            "name": "pendingDiff",
2022            "type": "int128",
2023            "internalType": "int128"
2024          },
2025          {
2026            "name": "effectBlock",
2027            "type": "uint32",
2028            "internalType": "uint32"
2029          }
2030        ]
2031      }
2032    ],
2033    "stateMutability": "view"
2034  },
2035  {
2036    "type": "function",
2037    "name": "getAllocationDelay",
2038    "inputs": [
2039      {
2040        "name": "operator",
2041        "type": "address",
2042        "internalType": "address"
2043      }
2044    ],
2045    "outputs": [
2046      {
2047        "name": "",
2048        "type": "bool",
2049        "internalType": "bool"
2050      },
2051      {
2052        "name": "",
2053        "type": "uint32",
2054        "internalType": "uint32"
2055      }
2056    ],
2057    "stateMutability": "view"
2058  },
2059  {
2060    "type": "function",
2061    "name": "getAllocations",
2062    "inputs": [
2063      {
2064        "name": "operators",
2065        "type": "address[]",
2066        "internalType": "address[]"
2067      },
2068      {
2069        "name": "operatorSet",
2070        "type": "tuple",
2071        "internalType": "struct OperatorSet",
2072        "components": [
2073          {
2074            "name": "avs",
2075            "type": "address",
2076            "internalType": "address"
2077          },
2078          {
2079            "name": "id",
2080            "type": "uint32",
2081            "internalType": "uint32"
2082          }
2083        ]
2084      },
2085      {
2086        "name": "strategy",
2087        "type": "address",
2088        "internalType": "contract IStrategy"
2089      }
2090    ],
2091    "outputs": [
2092      {
2093        "name": "",
2094        "type": "tuple[]",
2095        "internalType": "struct IAllocationManagerTypes.Allocation[]",
2096        "components": [
2097          {
2098            "name": "currentMagnitude",
2099            "type": "uint64",
2100            "internalType": "uint64"
2101          },
2102          {
2103            "name": "pendingDiff",
2104            "type": "int128",
2105            "internalType": "int128"
2106          },
2107          {
2108            "name": "effectBlock",
2109            "type": "uint32",
2110            "internalType": "uint32"
2111          }
2112        ]
2113      }
2114    ],
2115    "stateMutability": "view"
2116  },
2117  {
2118    "type": "function",
2119    "name": "getEncumberedMagnitude",
2120    "inputs": [
2121      {
2122        "name": "operator",
2123        "type": "address",
2124        "internalType": "address"
2125      },
2126      {
2127        "name": "strategy",
2128        "type": "address",
2129        "internalType": "contract IStrategy"
2130      }
2131    ],
2132    "outputs": [
2133      {
2134        "name": "",
2135        "type": "uint64",
2136        "internalType": "uint64"
2137      }
2138    ],
2139    "stateMutability": "view"
2140  },
2141  {
2142    "type": "function",
2143    "name": "getMaxMagnitude",
2144    "inputs": [
2145      {
2146        "name": "operator",
2147        "type": "address",
2148        "internalType": "address"
2149      },
2150      {
2151        "name": "strategy",
2152        "type": "address",
2153        "internalType": "contract IStrategy"
2154      }
2155    ],
2156    "outputs": [
2157      {
2158        "name": "",
2159        "type": "uint64",
2160        "internalType": "uint64"
2161      }
2162    ],
2163    "stateMutability": "view"
2164  },
2165  {
2166    "type": "function",
2167    "name": "getMaxMagnitudes",
2168    "inputs": [
2169      {
2170        "name": "operators",
2171        "type": "address[]",
2172        "internalType": "address[]"
2173      },
2174      {
2175        "name": "strategy",
2176        "type": "address",
2177        "internalType": "contract IStrategy"
2178      }
2179    ],
2180    "outputs": [
2181      {
2182        "name": "",
2183        "type": "uint64[]",
2184        "internalType": "uint64[]"
2185      }
2186    ],
2187    "stateMutability": "view"
2188  },
2189  {
2190    "type": "function",
2191    "name": "getMaxMagnitudes",
2192    "inputs": [
2193      {
2194        "name": "operator",
2195        "type": "address",
2196        "internalType": "address"
2197      },
2198      {
2199        "name": "strategies",
2200        "type": "address[]",
2201        "internalType": "contract IStrategy[]"
2202      }
2203    ],
2204    "outputs": [
2205      {
2206        "name": "",
2207        "type": "uint64[]",
2208        "internalType": "uint64[]"
2209      }
2210    ],
2211    "stateMutability": "view"
2212  },
2213  {
2214    "type": "function",
2215    "name": "getMaxMagnitudesAtBlock",
2216    "inputs": [
2217      {
2218        "name": "operator",
2219        "type": "address",
2220        "internalType": "address"
2221      },
2222      {
2223        "name": "strategies",
2224        "type": "address[]",
2225        "internalType": "contract IStrategy[]"
2226      },
2227      {
2228        "name": "blockNumber",
2229        "type": "uint32",
2230        "internalType": "uint32"
2231      }
2232    ],
2233    "outputs": [
2234      {
2235        "name": "",
2236        "type": "uint64[]",
2237        "internalType": "uint64[]"
2238      }
2239    ],
2240    "stateMutability": "view"
2241  },
2242  {
2243    "type": "function",
2244    "name": "getMemberCount",
2245    "inputs": [
2246      {
2247        "name": "operatorSet",
2248        "type": "tuple",
2249        "internalType": "struct OperatorSet",
2250        "components": [
2251          {
2252            "name": "avs",
2253            "type": "address",
2254            "internalType": "address"
2255          },
2256          {
2257            "name": "id",
2258            "type": "uint32",
2259            "internalType": "uint32"
2260          }
2261        ]
2262      }
2263    ],
2264    "outputs": [
2265      {
2266        "name": "",
2267        "type": "uint256",
2268        "internalType": "uint256"
2269      }
2270    ],
2271    "stateMutability": "view"
2272  },
2273  {
2274    "type": "function",
2275    "name": "getMembers",
2276    "inputs": [
2277      {
2278        "name": "operatorSet",
2279        "type": "tuple",
2280        "internalType": "struct OperatorSet",
2281        "components": [
2282          {
2283            "name": "avs",
2284            "type": "address",
2285            "internalType": "address"
2286          },
2287          {
2288            "name": "id",
2289            "type": "uint32",
2290            "internalType": "uint32"
2291          }
2292        ]
2293      }
2294    ],
2295    "outputs": [
2296      {
2297        "name": "",
2298        "type": "address[]",
2299        "internalType": "address[]"
2300      }
2301    ],
2302    "stateMutability": "view"
2303  },
2304  {
2305    "type": "function",
2306    "name": "getMinimumSlashableStake",
2307    "inputs": [
2308      {
2309        "name": "operatorSet",
2310        "type": "tuple",
2311        "internalType": "struct OperatorSet",
2312        "components": [
2313          {
2314            "name": "avs",
2315            "type": "address",
2316            "internalType": "address"
2317          },
2318          {
2319            "name": "id",
2320            "type": "uint32",
2321            "internalType": "uint32"
2322          }
2323        ]
2324      },
2325      {
2326        "name": "operators",
2327        "type": "address[]",
2328        "internalType": "address[]"
2329      },
2330      {
2331        "name": "strategies",
2332        "type": "address[]",
2333        "internalType": "contract IStrategy[]"
2334      },
2335      {
2336        "name": "futureBlock",
2337        "type": "uint32",
2338        "internalType": "uint32"
2339      }
2340    ],
2341    "outputs": [
2342      {
2343        "name": "slashableStake",
2344        "type": "uint256[][]",
2345        "internalType": "uint256[][]"
2346      }
2347    ],
2348    "stateMutability": "view"
2349  },
2350  {
2351    "type": "function",
2352    "name": "getOperatorSetCount",
2353    "inputs": [
2354      {
2355        "name": "avs",
2356        "type": "address",
2357        "internalType": "address"
2358      }
2359    ],
2360    "outputs": [
2361      {
2362        "name": "",
2363        "type": "uint256",
2364        "internalType": "uint256"
2365      }
2366    ],
2367    "stateMutability": "view"
2368  },
2369  {
2370    "type": "function",
2371    "name": "getRegisteredSets",
2372    "inputs": [
2373      {
2374        "name": "operator",
2375        "type": "address",
2376        "internalType": "address"
2377      }
2378    ],
2379    "outputs": [
2380      {
2381        "name": "",
2382        "type": "tuple[]",
2383        "internalType": "struct OperatorSet[]",
2384        "components": [
2385          {
2386            "name": "avs",
2387            "type": "address",
2388            "internalType": "address"
2389          },
2390          {
2391            "name": "id",
2392            "type": "uint32",
2393            "internalType": "uint32"
2394          }
2395        ]
2396      }
2397    ],
2398    "stateMutability": "view"
2399  },
2400  {
2401    "type": "function",
2402    "name": "getStrategiesInOperatorSet",
2403    "inputs": [
2404      {
2405        "name": "operatorSet",
2406        "type": "tuple",
2407        "internalType": "struct OperatorSet",
2408        "components": [
2409          {
2410            "name": "avs",
2411            "type": "address",
2412            "internalType": "address"
2413          },
2414          {
2415            "name": "id",
2416            "type": "uint32",
2417            "internalType": "uint32"
2418          }
2419        ]
2420      }
2421    ],
2422    "outputs": [
2423      {
2424        "name": "",
2425        "type": "address[]",
2426        "internalType": "contract IStrategy[]"
2427      }
2428    ],
2429    "stateMutability": "view"
2430  },
2431  {
2432    "type": "function",
2433    "name": "getStrategyAllocations",
2434    "inputs": [
2435      {
2436        "name": "operator",
2437        "type": "address",
2438        "internalType": "address"
2439      },
2440      {
2441        "name": "strategy",
2442        "type": "address",
2443        "internalType": "contract IStrategy"
2444      }
2445    ],
2446    "outputs": [
2447      {
2448        "name": "",
2449        "type": "tuple[]",
2450        "internalType": "struct OperatorSet[]",
2451        "components": [
2452          {
2453            "name": "avs",
2454            "type": "address",
2455            "internalType": "address"
2456          },
2457          {
2458            "name": "id",
2459            "type": "uint32",
2460            "internalType": "uint32"
2461          }
2462        ]
2463      },
2464      {
2465        "name": "",
2466        "type": "tuple[]",
2467        "internalType": "struct IAllocationManagerTypes.Allocation[]",
2468        "components": [
2469          {
2470            "name": "currentMagnitude",
2471            "type": "uint64",
2472            "internalType": "uint64"
2473          },
2474          {
2475            "name": "pendingDiff",
2476            "type": "int128",
2477            "internalType": "int128"
2478          },
2479          {
2480            "name": "effectBlock",
2481            "type": "uint32",
2482            "internalType": "uint32"
2483          }
2484        ]
2485      }
2486    ],
2487    "stateMutability": "view"
2488  },
2489  {
2490    "type": "function",
2491    "name": "initialize",
2492    "inputs": [
2493      {
2494        "name": "initialOwner",
2495        "type": "address",
2496        "internalType": "address"
2497      },
2498      {
2499        "name": "initialPausedStatus",
2500        "type": "uint256",
2501        "internalType": "uint256"
2502      }
2503    ],
2504    "outputs": [],
2505    "stateMutability": "nonpayable"
2506  },
2507  {
2508    "type": "function",
2509    "name": "isMemberOfOperatorSet",
2510    "inputs": [
2511      {
2512        "name": "operator",
2513        "type": "address",
2514        "internalType": "address"
2515      },
2516      {
2517        "name": "operatorSet",
2518        "type": "tuple",
2519        "internalType": "struct OperatorSet",
2520        "components": [
2521          {
2522            "name": "avs",
2523            "type": "address",
2524            "internalType": "address"
2525          },
2526          {
2527            "name": "id",
2528            "type": "uint32",
2529            "internalType": "uint32"
2530          }
2531        ]
2532      }
2533    ],
2534    "outputs": [
2535      {
2536        "name": "",
2537        "type": "bool",
2538        "internalType": "bool"
2539      }
2540    ],
2541    "stateMutability": "view"
2542  },
2543  {
2544    "type": "function",
2545    "name": "isOperatorSet",
2546    "inputs": [
2547      {
2548        "name": "operatorSet",
2549        "type": "tuple",
2550        "internalType": "struct OperatorSet",
2551        "components": [
2552          {
2553            "name": "avs",
2554            "type": "address",
2555            "internalType": "address"
2556          },
2557          {
2558            "name": "id",
2559            "type": "uint32",
2560            "internalType": "uint32"
2561          }
2562        ]
2563      }
2564    ],
2565    "outputs": [
2566      {
2567        "name": "",
2568        "type": "bool",
2569        "internalType": "bool"
2570      }
2571    ],
2572    "stateMutability": "view"
2573  },
2574  {
2575    "type": "function",
2576    "name": "isOperatorSlashable",
2577    "inputs": [
2578      {
2579        "name": "operator",
2580        "type": "address",
2581        "internalType": "address"
2582      },
2583      {
2584        "name": "operatorSet",
2585        "type": "tuple",
2586        "internalType": "struct OperatorSet",
2587        "components": [
2588          {
2589            "name": "avs",
2590            "type": "address",
2591            "internalType": "address"
2592          },
2593          {
2594            "name": "id",
2595            "type": "uint32",
2596            "internalType": "uint32"
2597          }
2598        ]
2599      }
2600    ],
2601    "outputs": [
2602      {
2603        "name": "",
2604        "type": "bool",
2605        "internalType": "bool"
2606      }
2607    ],
2608    "stateMutability": "view"
2609  },
2610  {
2611    "type": "function",
2612    "name": "modifyAllocations",
2613    "inputs": [
2614      {
2615        "name": "operator",
2616        "type": "address",
2617        "internalType": "address"
2618      },
2619      {
2620        "name": "params",
2621        "type": "tuple[]",
2622        "internalType": "struct IAllocationManagerTypes.AllocateParams[]",
2623        "components": [
2624          {
2625            "name": "operatorSet",
2626            "type": "tuple",
2627            "internalType": "struct OperatorSet",
2628            "components": [
2629              {
2630                "name": "avs",
2631                "type": "address",
2632                "internalType": "address"
2633              },
2634              {
2635                "name": "id",
2636                "type": "uint32",
2637                "internalType": "uint32"
2638              }
2639            ]
2640          },
2641          {
2642            "name": "strategies",
2643            "type": "address[]",
2644            "internalType": "contract IStrategy[]"
2645          },
2646          {
2647            "name": "newMagnitudes",
2648            "type": "uint64[]",
2649            "internalType": "uint64[]"
2650          }
2651        ]
2652      }
2653    ],
2654    "outputs": [],
2655    "stateMutability": "nonpayable"
2656  },
2657  {
2658    "type": "function",
2659    "name": "owner",
2660    "inputs": [],
2661    "outputs": [
2662      {
2663        "name": "",
2664        "type": "address",
2665        "internalType": "address"
2666      }
2667    ],
2668    "stateMutability": "view"
2669  },
2670  {
2671    "type": "function",
2672    "name": "pause",
2673    "inputs": [
2674      {
2675        "name": "newPausedStatus",
2676        "type": "uint256",
2677        "internalType": "uint256"
2678      }
2679    ],
2680    "outputs": [],
2681    "stateMutability": "nonpayable"
2682  },
2683  {
2684    "type": "function",
2685    "name": "pauseAll",
2686    "inputs": [],
2687    "outputs": [],
2688    "stateMutability": "nonpayable"
2689  },
2690  {
2691    "type": "function",
2692    "name": "paused",
2693    "inputs": [
2694      {
2695        "name": "index",
2696        "type": "uint8",
2697        "internalType": "uint8"
2698      }
2699    ],
2700    "outputs": [
2701      {
2702        "name": "",
2703        "type": "bool",
2704        "internalType": "bool"
2705      }
2706    ],
2707    "stateMutability": "view"
2708  },
2709  {
2710    "type": "function",
2711    "name": "paused",
2712    "inputs": [],
2713    "outputs": [
2714      {
2715        "name": "",
2716        "type": "uint256",
2717        "internalType": "uint256"
2718      }
2719    ],
2720    "stateMutability": "view"
2721  },
2722  {
2723    "type": "function",
2724    "name": "pauserRegistry",
2725    "inputs": [],
2726    "outputs": [
2727      {
2728        "name": "",
2729        "type": "address",
2730        "internalType": "contract IPauserRegistry"
2731      }
2732    ],
2733    "stateMutability": "view"
2734  },
2735  {
2736    "type": "function",
2737    "name": "permissionController",
2738    "inputs": [],
2739    "outputs": [
2740      {
2741        "name": "",
2742        "type": "address",
2743        "internalType": "contract IPermissionController"
2744      }
2745    ],
2746    "stateMutability": "view"
2747  },
2748  {
2749    "type": "function",
2750    "name": "registerForOperatorSets",
2751    "inputs": [
2752      {
2753        "name": "operator",
2754        "type": "address",
2755        "internalType": "address"
2756      },
2757      {
2758        "name": "params",
2759        "type": "tuple",
2760        "internalType": "struct IAllocationManagerTypes.RegisterParams",
2761        "components": [
2762          {
2763            "name": "avs",
2764            "type": "address",
2765            "internalType": "address"
2766          },
2767          {
2768            "name": "operatorSetIds",
2769            "type": "uint32[]",
2770            "internalType": "uint32[]"
2771          },
2772          {
2773            "name": "data",
2774            "type": "bytes",
2775            "internalType": "bytes"
2776          }
2777        ]
2778      }
2779    ],
2780    "outputs": [],
2781    "stateMutability": "nonpayable"
2782  },
2783  {
2784    "type": "function",
2785    "name": "removeStrategiesFromOperatorSet",
2786    "inputs": [
2787      {
2788        "name": "avs",
2789        "type": "address",
2790        "internalType": "address"
2791      },
2792      {
2793        "name": "operatorSetId",
2794        "type": "uint32",
2795        "internalType": "uint32"
2796      },
2797      {
2798        "name": "strategies",
2799        "type": "address[]",
2800        "internalType": "contract IStrategy[]"
2801      }
2802    ],
2803    "outputs": [],
2804    "stateMutability": "nonpayable"
2805  },
2806  {
2807    "type": "function",
2808    "name": "renounceOwnership",
2809    "inputs": [],
2810    "outputs": [],
2811    "stateMutability": "nonpayable"
2812  },
2813  {
2814    "type": "function",
2815    "name": "setAVSRegistrar",
2816    "inputs": [
2817      {
2818        "name": "avs",
2819        "type": "address",
2820        "internalType": "address"
2821      },
2822      {
2823        "name": "registrar",
2824        "type": "address",
2825        "internalType": "contract IAVSRegistrar"
2826      }
2827    ],
2828    "outputs": [],
2829    "stateMutability": "nonpayable"
2830  },
2831  {
2832    "type": "function",
2833    "name": "setAllocationDelay",
2834    "inputs": [
2835      {
2836        "name": "operator",
2837        "type": "address",
2838        "internalType": "address"
2839      },
2840      {
2841        "name": "delay",
2842        "type": "uint32",
2843        "internalType": "uint32"
2844      }
2845    ],
2846    "outputs": [],
2847    "stateMutability": "nonpayable"
2848  },
2849  {
2850    "type": "function",
2851    "name": "slashOperator",
2852    "inputs": [
2853      {
2854        "name": "avs",
2855        "type": "address",
2856        "internalType": "address"
2857      },
2858      {
2859        "name": "params",
2860        "type": "tuple",
2861        "internalType": "struct IAllocationManagerTypes.SlashingParams",
2862        "components": [
2863          {
2864            "name": "operator",
2865            "type": "address",
2866            "internalType": "address"
2867          },
2868          {
2869            "name": "operatorSetId",
2870            "type": "uint32",
2871            "internalType": "uint32"
2872          },
2873          {
2874            "name": "strategies",
2875            "type": "address[]",
2876            "internalType": "contract IStrategy[]"
2877          },
2878          {
2879            "name": "wadsToSlash",
2880            "type": "uint256[]",
2881            "internalType": "uint256[]"
2882          },
2883          {
2884            "name": "description",
2885            "type": "string",
2886            "internalType": "string"
2887          }
2888        ]
2889      }
2890    ],
2891    "outputs": [],
2892    "stateMutability": "nonpayable"
2893  },
2894  {
2895    "type": "function",
2896    "name": "transferOwnership",
2897    "inputs": [
2898      {
2899        "name": "newOwner",
2900        "type": "address",
2901        "internalType": "address"
2902      }
2903    ],
2904    "outputs": [],
2905    "stateMutability": "nonpayable"
2906  },
2907  {
2908    "type": "function",
2909    "name": "unpause",
2910    "inputs": [
2911      {
2912        "name": "newPausedStatus",
2913        "type": "uint256",
2914        "internalType": "uint256"
2915      }
2916    ],
2917    "outputs": [],
2918    "stateMutability": "nonpayable"
2919  },
2920  {
2921    "type": "function",
2922    "name": "updateAVSMetadataURI",
2923    "inputs": [
2924      {
2925        "name": "avs",
2926        "type": "address",
2927        "internalType": "address"
2928      },
2929      {
2930        "name": "metadataURI",
2931        "type": "string",
2932        "internalType": "string"
2933      }
2934    ],
2935    "outputs": [],
2936    "stateMutability": "nonpayable"
2937  },
2938  {
2939    "type": "function",
2940    "name": "version",
2941    "inputs": [],
2942    "outputs": [
2943      {
2944        "name": "",
2945        "type": "string",
2946        "internalType": "string"
2947      }
2948    ],
2949    "stateMutability": "view"
2950  },
2951  {
2952    "type": "event",
2953    "name": "AVSMetadataURIUpdated",
2954    "inputs": [
2955      {
2956        "name": "avs",
2957        "type": "address",
2958        "indexed": true,
2959        "internalType": "address"
2960      },
2961      {
2962        "name": "metadataURI",
2963        "type": "string",
2964        "indexed": false,
2965        "internalType": "string"
2966      }
2967    ],
2968    "anonymous": false
2969  },
2970  {
2971    "type": "event",
2972    "name": "AVSRegistrarSet",
2973    "inputs": [
2974      {
2975        "name": "avs",
2976        "type": "address",
2977        "indexed": false,
2978        "internalType": "address"
2979      },
2980      {
2981        "name": "registrar",
2982        "type": "address",
2983        "indexed": false,
2984        "internalType": "contract IAVSRegistrar"
2985      }
2986    ],
2987    "anonymous": false
2988  },
2989  {
2990    "type": "event",
2991    "name": "AllocationDelaySet",
2992    "inputs": [
2993      {
2994        "name": "operator",
2995        "type": "address",
2996        "indexed": false,
2997        "internalType": "address"
2998      },
2999      {
3000        "name": "delay",
3001        "type": "uint32",
3002        "indexed": false,
3003        "internalType": "uint32"
3004      },
3005      {
3006        "name": "effectBlock",
3007        "type": "uint32",
3008        "indexed": false,
3009        "internalType": "uint32"
3010      }
3011    ],
3012    "anonymous": false
3013  },
3014  {
3015    "type": "event",
3016    "name": "AllocationUpdated",
3017    "inputs": [
3018      {
3019        "name": "operator",
3020        "type": "address",
3021        "indexed": false,
3022        "internalType": "address"
3023      },
3024      {
3025        "name": "operatorSet",
3026        "type": "tuple",
3027        "indexed": false,
3028        "internalType": "struct OperatorSet",
3029        "components": [
3030          {
3031            "name": "avs",
3032            "type": "address",
3033            "internalType": "address"
3034          },
3035          {
3036            "name": "id",
3037            "type": "uint32",
3038            "internalType": "uint32"
3039          }
3040        ]
3041      },
3042      {
3043        "name": "strategy",
3044        "type": "address",
3045        "indexed": false,
3046        "internalType": "contract IStrategy"
3047      },
3048      {
3049        "name": "magnitude",
3050        "type": "uint64",
3051        "indexed": false,
3052        "internalType": "uint64"
3053      },
3054      {
3055        "name": "effectBlock",
3056        "type": "uint32",
3057        "indexed": false,
3058        "internalType": "uint32"
3059      }
3060    ],
3061    "anonymous": false
3062  },
3063  {
3064    "type": "event",
3065    "name": "EncumberedMagnitudeUpdated",
3066    "inputs": [
3067      {
3068        "name": "operator",
3069        "type": "address",
3070        "indexed": false,
3071        "internalType": "address"
3072      },
3073      {
3074        "name": "strategy",
3075        "type": "address",
3076        "indexed": false,
3077        "internalType": "contract IStrategy"
3078      },
3079      {
3080        "name": "encumberedMagnitude",
3081        "type": "uint64",
3082        "indexed": false,
3083        "internalType": "uint64"
3084      }
3085    ],
3086    "anonymous": false
3087  },
3088  {
3089    "type": "event",
3090    "name": "Initialized",
3091    "inputs": [
3092      {
3093        "name": "version",
3094        "type": "uint8",
3095        "indexed": false,
3096        "internalType": "uint8"
3097      }
3098    ],
3099    "anonymous": false
3100  },
3101  {
3102    "type": "event",
3103    "name": "MaxMagnitudeUpdated",
3104    "inputs": [
3105      {
3106        "name": "operator",
3107        "type": "address",
3108        "indexed": false,
3109        "internalType": "address"
3110      },
3111      {
3112        "name": "strategy",
3113        "type": "address",
3114        "indexed": false,
3115        "internalType": "contract IStrategy"
3116      },
3117      {
3118        "name": "maxMagnitude",
3119        "type": "uint64",
3120        "indexed": false,
3121        "internalType": "uint64"
3122      }
3123    ],
3124    "anonymous": false
3125  },
3126  {
3127    "type": "event",
3128    "name": "OperatorAddedToOperatorSet",
3129    "inputs": [
3130      {
3131        "name": "operator",
3132        "type": "address",
3133        "indexed": true,
3134        "internalType": "address"
3135      },
3136      {
3137        "name": "operatorSet",
3138        "type": "tuple",
3139        "indexed": false,
3140        "internalType": "struct OperatorSet",
3141        "components": [
3142          {
3143            "name": "avs",
3144            "type": "address",
3145            "internalType": "address"
3146          },
3147          {
3148            "name": "id",
3149            "type": "uint32",
3150            "internalType": "uint32"
3151          }
3152        ]
3153      }
3154    ],
3155    "anonymous": false
3156  },
3157  {
3158    "type": "event",
3159    "name": "OperatorRemovedFromOperatorSet",
3160    "inputs": [
3161      {
3162        "name": "operator",
3163        "type": "address",
3164        "indexed": true,
3165        "internalType": "address"
3166      },
3167      {
3168        "name": "operatorSet",
3169        "type": "tuple",
3170        "indexed": false,
3171        "internalType": "struct OperatorSet",
3172        "components": [
3173          {
3174            "name": "avs",
3175            "type": "address",
3176            "internalType": "address"
3177          },
3178          {
3179            "name": "id",
3180            "type": "uint32",
3181            "internalType": "uint32"
3182          }
3183        ]
3184      }
3185    ],
3186    "anonymous": false
3187  },
3188  {
3189    "type": "event",
3190    "name": "OperatorSetCreated",
3191    "inputs": [
3192      {
3193        "name": "operatorSet",
3194        "type": "tuple",
3195        "indexed": false,
3196        "internalType": "struct OperatorSet",
3197        "components": [
3198          {
3199            "name": "avs",
3200            "type": "address",
3201            "internalType": "address"
3202          },
3203          {
3204            "name": "id",
3205            "type": "uint32",
3206            "internalType": "uint32"
3207          }
3208        ]
3209      }
3210    ],
3211    "anonymous": false
3212  },
3213  {
3214    "type": "event",
3215    "name": "OperatorSlashed",
3216    "inputs": [
3217      {
3218        "name": "operator",
3219        "type": "address",
3220        "indexed": false,
3221        "internalType": "address"
3222      },
3223      {
3224        "name": "operatorSet",
3225        "type": "tuple",
3226        "indexed": false,
3227        "internalType": "struct OperatorSet",
3228        "components": [
3229          {
3230            "name": "avs",
3231            "type": "address",
3232            "internalType": "address"
3233          },
3234          {
3235            "name": "id",
3236            "type": "uint32",
3237            "internalType": "uint32"
3238          }
3239        ]
3240      },
3241      {
3242        "name": "strategies",
3243        "type": "address[]",
3244        "indexed": false,
3245        "internalType": "contract IStrategy[]"
3246      },
3247      {
3248        "name": "wadSlashed",
3249        "type": "uint256[]",
3250        "indexed": false,
3251        "internalType": "uint256[]"
3252      },
3253      {
3254        "name": "description",
3255        "type": "string",
3256        "indexed": false,
3257        "internalType": "string"
3258      }
3259    ],
3260    "anonymous": false
3261  },
3262  {
3263    "type": "event",
3264    "name": "OwnershipTransferred",
3265    "inputs": [
3266      {
3267        "name": "previousOwner",
3268        "type": "address",
3269        "indexed": true,
3270        "internalType": "address"
3271      },
3272      {
3273        "name": "newOwner",
3274        "type": "address",
3275        "indexed": true,
3276        "internalType": "address"
3277      }
3278    ],
3279    "anonymous": false
3280  },
3281  {
3282    "type": "event",
3283    "name": "Paused",
3284    "inputs": [
3285      {
3286        "name": "account",
3287        "type": "address",
3288        "indexed": true,
3289        "internalType": "address"
3290      },
3291      {
3292        "name": "newPausedStatus",
3293        "type": "uint256",
3294        "indexed": false,
3295        "internalType": "uint256"
3296      }
3297    ],
3298    "anonymous": false
3299  },
3300  {
3301    "type": "event",
3302    "name": "StrategyAddedToOperatorSet",
3303    "inputs": [
3304      {
3305        "name": "operatorSet",
3306        "type": "tuple",
3307        "indexed": false,
3308        "internalType": "struct OperatorSet",
3309        "components": [
3310          {
3311            "name": "avs",
3312            "type": "address",
3313            "internalType": "address"
3314          },
3315          {
3316            "name": "id",
3317            "type": "uint32",
3318            "internalType": "uint32"
3319          }
3320        ]
3321      },
3322      {
3323        "name": "strategy",
3324        "type": "address",
3325        "indexed": false,
3326        "internalType": "contract IStrategy"
3327      }
3328    ],
3329    "anonymous": false
3330  },
3331  {
3332    "type": "event",
3333    "name": "StrategyRemovedFromOperatorSet",
3334    "inputs": [
3335      {
3336        "name": "operatorSet",
3337        "type": "tuple",
3338        "indexed": false,
3339        "internalType": "struct OperatorSet",
3340        "components": [
3341          {
3342            "name": "avs",
3343            "type": "address",
3344            "internalType": "address"
3345          },
3346          {
3347            "name": "id",
3348            "type": "uint32",
3349            "internalType": "uint32"
3350          }
3351        ]
3352      },
3353      {
3354        "name": "strategy",
3355        "type": "address",
3356        "indexed": false,
3357        "internalType": "contract IStrategy"
3358      }
3359    ],
3360    "anonymous": false
3361  },
3362  {
3363    "type": "event",
3364    "name": "Unpaused",
3365    "inputs": [
3366      {
3367        "name": "account",
3368        "type": "address",
3369        "indexed": true,
3370        "internalType": "address"
3371      },
3372      {
3373        "name": "newPausedStatus",
3374        "type": "uint256",
3375        "indexed": false,
3376        "internalType": "uint256"
3377      }
3378    ],
3379    "anonymous": false
3380  },
3381  {
3382    "type": "error",
3383    "name": "AlreadyMemberOfSet",
3384    "inputs": []
3385  },
3386  {
3387    "type": "error",
3388    "name": "CurrentlyPaused",
3389    "inputs": []
3390  },
3391  {
3392    "type": "error",
3393    "name": "Empty",
3394    "inputs": []
3395  },
3396  {
3397    "type": "error",
3398    "name": "InputAddressZero",
3399    "inputs": []
3400  },
3401  {
3402    "type": "error",
3403    "name": "InputArrayLengthMismatch",
3404    "inputs": []
3405  },
3406  {
3407    "type": "error",
3408    "name": "InsufficientMagnitude",
3409    "inputs": []
3410  },
3411  {
3412    "type": "error",
3413    "name": "InvalidAVSRegistrar",
3414    "inputs": []
3415  },
3416  {
3417    "type": "error",
3418    "name": "InvalidCaller",
3419    "inputs": []
3420  },
3421  {
3422    "type": "error",
3423    "name": "InvalidNewPausedStatus",
3424    "inputs": []
3425  },
3426  {
3427    "type": "error",
3428    "name": "InvalidOperator",
3429    "inputs": []
3430  },
3431  {
3432    "type": "error",
3433    "name": "InvalidOperatorSet",
3434    "inputs": []
3435  },
3436  {
3437    "type": "error",
3438    "name": "InvalidPermissions",
3439    "inputs": []
3440  },
3441  {
3442    "type": "error",
3443    "name": "InvalidShortString",
3444    "inputs": []
3445  },
3446  {
3447    "type": "error",
3448    "name": "InvalidSnapshotOrdering",
3449    "inputs": []
3450  },
3451  {
3452    "type": "error",
3453    "name": "InvalidWadToSlash",
3454    "inputs": []
3455  },
3456  {
3457    "type": "error",
3458    "name": "ModificationAlreadyPending",
3459    "inputs": []
3460  },
3461  {
3462    "type": "error",
3463    "name": "NonexistentAVSMetadata",
3464    "inputs": []
3465  },
3466  {
3467    "type": "error",
3468    "name": "NotMemberOfSet",
3469    "inputs": []
3470  },
3471  {
3472    "type": "error",
3473    "name": "OnlyPauser",
3474    "inputs": []
3475  },
3476  {
3477    "type": "error",
3478    "name": "OnlyUnpauser",
3479    "inputs": []
3480  },
3481  {
3482    "type": "error",
3483    "name": "OperatorNotSlashable",
3484    "inputs": []
3485  },
3486  {
3487    "type": "error",
3488    "name": "OutOfBounds",
3489    "inputs": []
3490  },
3491  {
3492    "type": "error",
3493    "name": "SameMagnitude",
3494    "inputs": []
3495  },
3496  {
3497    "type": "error",
3498    "name": "StrategiesMustBeInAscendingOrder",
3499    "inputs": []
3500  },
3501  {
3502    "type": "error",
3503    "name": "StrategyAlreadyInOperatorSet",
3504    "inputs": []
3505  },
3506  {
3507    "type": "error",
3508    "name": "StrategyNotInOperatorSet",
3509    "inputs": []
3510  },
3511  {
3512    "type": "error",
3513    "name": "StringTooLong",
3514    "inputs": [
3515      {
3516        "name": "str",
3517        "type": "string",
3518        "internalType": "string"
3519      }
3520    ]
3521  },
3522  {
3523    "type": "error",
3524    "name": "UninitializedAllocationDelay",
3525    "inputs": []
3526  }
3527]
3528```*/
3529#[allow(
3530    non_camel_case_types,
3531    non_snake_case,
3532    clippy::pub_underscore_fields,
3533    clippy::style,
3534    clippy::empty_structs_with_brackets
3535)]
3536pub mod AllocationManager {
3537    use super::*;
3538    use alloy::sol_types as alloy_sol_types;
3539    /// The creation / init bytecode of the contract.
3540    ///
3541    /// ```text
3542    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
3543    /// ```
3544    #[rustfmt::skip]
3545    #[allow(clippy::all)]
3546    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
3547        b"a\x01@`@R4\x80\x15a\0\x10W__\xFD[P`@Qa_\xB78\x03\x80a_\xB7\x839\x81\x01`@\x81\x90Ra\0/\x91a\x01\xE6V[\x80\x84\x87\x85\x85\x89`\x01`\x01`\xA0\x1B\x03\x81\x16a\0\\W`@Qc9\xB1\x90\xBB`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x80R\x92\x83\x16`\xA0Rc\xFF\xFF\xFF\xFF\x91\x82\x16`\xC0R\x16`\xE0R\x16a\x01\0Ra\0\x8D\x81a\0\xA5V[a\x01 RPa\0\x9Aa\0\xEBV[PPPPPPa\x03JV[__\x82\x90P`\x1F\x81Q\x11\x15a\0\xD8W\x82`@Qc0Z'\xA9`\xE0\x1B\x81R`\x04\x01a\0\xCF\x91\x90a\x02\xEFV[`@Q\x80\x91\x03\x90\xFD[\x80Qa\0\xE3\x82a\x03$V[\x17\x93\x92PPPV[_Ta\x01\0\x90\x04`\xFF\x16\x15a\x01RW`@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\0\xCFV[_T`\xFF\x90\x81\x16\x14a\x01\xA1W_\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[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x01\xB7W__\xFD[PV[\x80Qc\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x01\xCDW__\xFD[\x91\x90PV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[______`\xC0\x87\x89\x03\x12\x15a\x01\xFBW__\xFD[\x86Qa\x02\x06\x81a\x01\xA3V[` \x88\x01Q\x90\x96Pa\x02\x17\x81a\x01\xA3V[`@\x88\x01Q\x90\x95Pa\x02(\x81a\x01\xA3V[\x93Pa\x026``\x88\x01a\x01\xBAV[\x92Pa\x02D`\x80\x88\x01a\x01\xBAV[`\xA0\x88\x01Q\x90\x92P`\x01`\x01`@\x1B\x03\x81\x11\x15a\x02_W__\xFD[\x87\x01`\x1F\x81\x01\x89\x13a\x02oW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x02\x88Wa\x02\x88a\x01\xD2V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x02\xB6Wa\x02\xB6a\x01\xD2V[`@R\x81\x81R\x82\x82\x01` \x01\x8B\x10\x15a\x02\xCDW__\xFD[\x81` \x84\x01` \x83\x01^_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95P\x92\x95P\x92\x95V[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\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\x03DW_\x19\x81` \x03`\x03\x1B\x1B\x82\x16\x91P[P\x91\x90PV[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa[\xD2a\x03\xE5_9_a\x1B7\x01R_\x81\x81a\x04O\x01Ra5l\x01R_\x81\x81a\x05\xB3\x01Ra=\xFC\x01R_\x81\x81a\x03a\x01R\x81\x81a\x1F\xCE\x01Ra&\xD0\x01R_\x81\x81a\x072\x01R\x81\x81a\x14\xD5\x01R\x81\x81a\x1Bk\x01R\x81\x81a\x1B\xD5\x01R\x81\x81a)\xCE\x01Ra6K\x01R_\x81\x81a\x05\xDA\x01R\x81\x81a\x08X\x01R\x81\x81a\x1Cz\x01Ra1\xE3\x01Ra[\xD2_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x02\xB1W_5`\xE0\x1C\x80cl\xFBD\x81\x11a\x01{W\x80c\xA9\x82\x18!\x11a\0\xE4W\x80c\xC2!\xD8\xAE\x11a\0\x9EW\x80c\xDF\\\xF7#\x11a\0yW\x80c\xDF\\\xF7#\x14a\x07-W\x80c\xF2\xFD\xE3\x8B\x14a\x07TW\x80c\xF6\x05\xCE\x08\x14a\x07gW\x80c\xFA\xBC\x1C\xBC\x14a\x07zW__\xFD[\x80c\xC2!\xD8\xAE\x14a\x06\xF4W\x80c\xCDm\xC6\x87\x14a\x07\x07W\x80c\xD3\xD9o\xF4\x14a\x07\x1AW__\xFD[\x80c\xA9\x82\x18!\x14a\x06fW\x80c\xAD\xC2\xE3\xD9\x14a\x06yW\x80c\xB2Dz\xF7\x14a\x06\x8CW\x80c\xB6k\xD9\x89\x14a\x06\x9FW\x80c\xB9\xFB\xAE\xD1\x14a\x06\xB2W\x80c\xBA\x1A\x84\xE5\x14a\x06\xE1W__\xFD[\x80c\x88o\x11\x95\x11a\x015W\x80c\x88o\x11\x95\x14a\x05\xD5W\x80c\x8C\xE6HT\x14a\x05\xFCW\x80c\x8D\xA5\xCB[\x14a\x06\x1CW\x80c\x94\xD7\xD0\x0C\x14a\x06-W\x80c\x95(\x99\xEE\x14a\x06@W\x80c\xA93>\xC8\x14a\x06SW__\xFD[\x80cl\xFBD\x81\x14a\x05BW\x80cn4\x92\xB5\x14a\x05mW\x80cn\x87]\xBA\x14a\x05\x80W\x80cqP\x18\xA6\x14a\x05\x93W\x80cy\xAEP\xCD\x14a\x05\x9BW\x80c{\xC1\xEFa\x14a\x05\xAEW__\xFD[\x80cAw\xA8|\x11a\x02\x1DW\x80cT\xFDMP\x11a\x01\xD7W\x80cT\xFDMP\x14a\x04\xCAW\x80cV\xC4\x83\xE6\x14a\x04\xDFW\x80cY\\jg\x14a\x04\xF2W\x80cZ\xC8j\xB7\x14a\x04\xFAW\x80c\\\x97Z\xBB\x14a\x05\x1DW\x80cg\r;\xA2\x14a\x05/W__\xFD[\x80cAw\xA8|\x14a\x04*W\x80cFW\xE2j\x14a\x04JW\x80cJ\x10\xFF\xE5\x14a\x04qW\x80cKPF\xEF\x14a\x04\x91W\x80cP\xFE\xEA \x14a\x04\xA4W\x80cTz\xFB\x87\x14a\x04\xB7W__\xFD[\x80c)\x81\xEBw\x11a\x02nW\x80c)\x81\xEBw\x14a\x03\\W\x80c+E:\x9A\x14a\x03\x98W\x80c+\xAB,J\x14a\x03\xB8W\x80c0L\x10\xCD\x14a\x03\xCBW\x80c65 W\x14a\x03\xF6W\x80c@\x12\r\xAB\x14a\x04\tW__\xFD[\x80c\x10\xE1\xB9\xB8\x14a\x02\xB5W\x80c\x13R\xC3\xE6\x14a\x02\xDEW\x80c\x13d9\xDD\x14a\x03\x01W\x80c\x15\xFEP(\x14a\x03\x16W\x80c&\r\xC7X\x14a\x036W\x80c&\x1F\x84\xE0\x14a\x03IW[__\xFD[a\x02\xC8a\x02\xC36`\x04aJPV[a\x07\x8DV[`@Qa\x02\xD5\x91\x90aJ\x97V[`@Q\x80\x91\x03\x90\xF3[a\x02\xF1a\x02\xEC6`\x04aJ\xCAV[a\x07\xC8V[`@Q\x90\x15\x15\x81R` \x01a\x02\xD5V[a\x03\x14a\x03\x0F6`\x04aJ\xFEV[a\x08CV[\0[a\x03)a\x03$6`\x04aK\x15V[a\t\x18V[`@Qa\x02\xD5\x91\x90aK\x93V[a\x02\xF1a\x03D6`\x04aK\xA5V[a\n/V[a\x03\x14a\x03W6`\x04aK\xFFV[a\n`V[a\x03\x83\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[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x02\xD5V[a\x03\xABa\x03\xA66`\x04aL\xE4V[a\r;V[`@Qa\x02\xD5\x91\x90aM\x87V[a\x03\xABa\x03\xC66`\x04aM\xEAV[a\rQV[a\x03\xDEa\x03\xD96`\x04aK\x15V[a\r\xF0V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x02\xD5V[a\x03\x14a\x04\x046`\x04aNnV[a\x0E\x1FV[a\x04\x1Ca\x04\x176`\x04aN\xC0V[a\x16)V[`@Qa\x02\xD5\x92\x91\x90aOMV[a\x04=a\x0486`\x04aK\xA5V[a\x17\xA4V[`@Qa\x02\xD5\x91\x90aO\xAAV[a\x03\xDE\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\x04\x84a\x04\x7F6`\x04aO\xBCV[a\x17\xC8V[`@Qa\x02\xD5\x91\x90aO\xFFV[a\x03\x14a\x04\x9F6`\x04aPJV[a\x18pV[a\x03\x14a\x04\xB26`\x04aP\xCAV[a\x19*V[a\x04\x84a\x04\xC56`\x04aQ(V[a\x1A\x88V[a\x04\xD2a\x1B0V[`@Qa\x02\xD5\x91\x90aQjV[a\x03\x14a\x04\xED6`\x04aQ\x9FV[a\x1B`V[a\x03\x14a\x1CeV[a\x02\xF1a\x05\x086`\x04aQ\xC9V[`fT`\x01`\xFF\x90\x92\x16\x91\x90\x91\x1B\x90\x81\x16\x14\x90V[`fT[`@Q\x90\x81R` \x01a\x02\xD5V[a\x02\xF1a\x05=6`\x04aJ\xCAV[a\x1D\x14V[a\x05Ua\x05P6`\x04aN\xC0V[a\x1D%V[`@Q`\x01`\x01`@\x1B\x03\x90\x91\x16\x81R` \x01a\x02\xD5V[a\x03\x14a\x05{6`\x04aQ\xFFV[a\x1D:V[a\x04=a\x05\x8E6`\x04aK\xA5V[a!\x1BV[a\x03\x14a!,V[a\x03)a\x05\xA96`\x04aK\x15V[a!=V[a\x03\x83\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\xDE\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\x06\x0Fa\x06\n6`\x04aR0V[a\"\x17V[`@Qa\x02\xD5\x91\x90aRsV[`3T`\x01`\x01`\xA0\x1B\x03\x16a\x03\xDEV[a\x04\x84a\x06;6`\x04aR\x85V[a\"\xD3V[a\x03\x14a\x06N6`\x04aR\xE0V[a#\xBFV[a\x05Ua\x06a6`\x04aN\xC0V[a(~V[a\x03\x14a\x06t6`\x04aT\x89V[a(\xADV[a\x03\x14a\x06\x876`\x04aU\x07V[a)_V[a\x05!a\x06\x9A6`\x04aK\xA5V[a,\xBCV[a\x03\x14a\x06\xAD6`\x04aP\xCAV[a,\xDEV[a\x06\xC5a\x06\xC06`\x04aK\x15V[a.8V[`@\x80Q\x92\x15\x15\x83Rc\xFF\xFF\xFF\xFF\x90\x91\x16` \x83\x01R\x01a\x02\xD5V[a\x05!a\x06\xEF6`\x04aK\x15V[a.\xD2V[a\x04=a\x07\x026`\x04aJ\xCAV[a.\xF2V[a\x03\x14a\x07\x156`\x04aUIV[a/\x1BV[a\x03\x14a\x07(6`\x04aN\xC0V[a08V[a\x03\xDE\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\x14a\x07b6`\x04aK\x15V[a1\\V[a\x05Ua\x07u6`\x04aN\xC0V[a1\xD5V[a\x03\x14a\x07\x886`\x04aJ\xFEV[a1\xE1V[`@\x80Q``\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R\x90a\x07\xBC\x85a\x07\xB6\x86a2\xF7V[\x85a3ZV[\x92PPP[\x93\x92PPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x9E` R`@\x81 \x81\x90\x81a\x07\xEB\x85a2\xF7V[\x81R` \x80\x82\x01\x92\x90\x92R`@\x90\x81\x01_ \x81Q\x80\x83\x01\x90\x92RT`\xFF\x81\x16\x15\x15\x80\x83Ra\x01\0\x90\x91\x04c\xFF\xFF\xFF\xFF\x16\x92\x82\x01\x92\x90\x92R\x91P\x80a\x089WP\x80` \x01Qc\xFF\xFF\xFF\xFF\x16C\x11\x15[\x91PP[\x92\x91PPV[`@Qc#}\xFBG`\xE1\x1B\x81R3`\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\x90cF\xFB\xF6\x8E\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\xA5W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xC9\x91\x90aUsV[a\x08\xE6W`@Qc\x1Dw\xD4w`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`fT\x81\x81\x16\x81\x14a\t\x0BW`@Qc\xC6\x1D\xCA]`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\t\x14\x82a4\xC6V[PPV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x9D` R`@\x81 ``\x91\x90a\t<\x90a5\x03V[\x90P_\x81`\x01`\x01`@\x1B\x03\x81\x11\x15a\tWWa\tWaItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\t\x9BW\x81` \x01[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R\x81R` \x01\x90`\x01\x90\x03\x90\x81a\tuW\x90P[P\x90P_[\x82\x81\x10\x15a\n'W`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x9D` R`@\x90 a\n\x02\x90a\t\xCD\x90\x83a5\x0CV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01RP`@\x80Q\x80\x82\x01\x90\x91R``\x82\x90\x1C\x81Rc\xFF\xFF\xFF\xFF\x90\x91\x16` \x82\x01R\x90V[\x82\x82\x81Q\x81\x10a\n\x14Wa\n\x14aU\x92V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\t\xA0V[P\x93\x92PPPV[` \x80\x82\x01Q\x82Q`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R`\x98\x90\x92R`@\x82 a\x08=\x91c\xFF\xFF\xFF\xFF\x90\x81\x16\x90a5\x17\x16V[\x82a\nj\x81a5.V[a\n\x87W`@Qc\x93-\x94\xF7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x84\x16_\x90\x81R`\xA4` R`@\x90 T`\xFF\x16a\n\xBFW`@QcH\xF7\xDB\xB9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_[\x82\x81\x10\x15a\r4W_`@Q\x80`@\x01`@R\x80\x87`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x86\x86\x85\x81\x81\x10a\n\xF6Wa\n\xF6aU\x92V[\x90P` \x02\x81\x01\x90a\x0B\x08\x91\x90aU\xA6V[a\x0B\x16\x90` \x81\x01\x90aU\xC4V[c\xFF\xFF\xFF\xFF\x16\x81RP\x90Pa\x0B`\x81` \x01Qc\xFF\xFF\xFF\xFF\x16`\x98_\x89`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x90\x81R` \x01_ a5\xD8\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[a\x0B}W`@Qc\x1F\xB1pU`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F1b\x92\x85\xEA\xD23Z\xE0\x93?\x86\xED*\xE63!\xF7\xAFw\xB4\xE6\xEA\xAB\xC4,\x05x\x80\x97~l`@Q\x80`@\x01`@R\x80\x88`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x83` \x01Qc\xFF\xFF\xFF\xFF\x16\x81RP`@Qa\x0B\xD3\x91\x90aU\xDDV[`@Q\x80\x91\x03\x90\xA1_a\x0B\xE5\x82a2\xF7V[\x90P_[\x86\x86\x85\x81\x81\x10a\x0B\xFBWa\x0B\xFBaU\x92V[\x90P` \x02\x81\x01\x90a\x0C\r\x91\x90aU\xA6V[a\x0C\x1B\x90` \x81\x01\x90aU\xEBV[\x90P\x81\x10\x15a\r)Wa\x0C\x91\x87\x87\x86\x81\x81\x10a\x0C9Wa\x0C9aU\x92V[\x90P` \x02\x81\x01\x90a\x0CK\x91\x90aU\xA6V[a\x0CY\x90` \x81\x01\x90aU\xEBV[\x83\x81\x81\x10a\x0CiWa\x0CiaU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x0C~\x91\x90aK\x15V[_\x84\x81R`\x99` R`@\x90 \x90a5\xE3V[P\x7Fz\xB2`\xFE\n\xF1\x93\xDB_I\x86w\r\x83\x1B\xDAN\xA4`\x99\xDC\x81~\x8Bg\x16\xDC\xAE\x8A\xF8\xE8\x8B\x83\x88\x88\x87\x81\x81\x10a\x0C\xC6Wa\x0C\xC6aU\x92V[\x90P` \x02\x81\x01\x90a\x0C\xD8\x91\x90aU\xA6V[a\x0C\xE6\x90` \x81\x01\x90aU\xEBV[\x84\x81\x81\x10a\x0C\xF6Wa\x0C\xF6aU\x92V[\x90P` \x02\x01` \x81\x01\x90a\r\x0B\x91\x90aK\x15V[`@Qa\r\x19\x92\x91\x90aV0V[`@Q\x80\x91\x03\x90\xA1`\x01\x01a\x0B\xE9V[PPP`\x01\x01a\n\xC1V[PPPPPV[``a\rI\x84\x84\x84Ca5\xF7V[\x94\x93PPPPV[``a\r_\x85\x85\x85\x85a5\xF7V[\x90P_[\x84Q\x81\x10\x15a\r\xE7Wa\r\x8F\x85\x82\x81Q\x81\x10a\r\x81Wa\r\x81aU\x92V[` \x02` \x01\x01Q\x87a\x07\xC8V[a\r\xDFW_[\x84Q\x81\x10\x15a\r\xDDW_\x83\x83\x81Q\x81\x10a\r\xB1Wa\r\xB1aU\x92V[` \x02` \x01\x01Q\x82\x81Q\x81\x10a\r\xCAWa\r\xCAaU\x92V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\r\x95V[P[`\x01\x01a\rcV[P\x94\x93PPPPV[`\x01`\x01`\xA0\x1B\x03\x80\x82\x16_\x90\x81R`\x97` R`@\x81 T\x90\x91\x16\x80\x15a\x0E\x18W\x80a\x07\xC1V[P\x90\x91\x90PV[`fT`\x01\x90`\x02\x90\x81\x16\x03a\x0EHW`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x82a\x0ER\x81a5.V[a\x0EoW`@Qc\x93-\x94\xF7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_`@Q\x80`@\x01`@R\x80\x86`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x85` \x01` \x81\x01\x90a\x0E\x9D\x91\x90aU\xC4V[c\xFF\xFF\xFF\xFF\x16\x90R\x90Pa\x0E\xB4``\x85\x01\x85aU\xEBV[\x90Pa\x0E\xC3`@\x86\x01\x86aU\xEBV[\x90P\x14a\x0E\xE3W`@QcCqJ\xFD`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[` \x80\x82\x01Q\x82Q`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R`\x98\x90\x92R`@\x90\x91 a\x0F\x15\x91c\xFF\xFF\xFF\xFF\x90\x81\x16\x90a5\x17\x16V[a\x0F2W`@Qc\x1F\xB1pU`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x0FHa\x0FB` \x86\x01\x86aK\x15V[\x82a\x07\xC8V[a\x0FeW`@Qc\xEB\xBF\xF4\x97`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x0Fs`@\x86\x01\x86aU\xEBV[\x90P`\x01`\x01`@\x1B\x03\x81\x11\x15a\x0F\x8CWa\x0F\x8CaItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0F\xB5W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[a\x0F\xC7`@\x87\x01\x87aU\xEBV[\x90P\x81\x10\x15a\x15\xBBW\x80\x15\x80a\x10ZWPa\x0F\xE5`@\x87\x01\x87aU\xEBV[a\x0F\xF0`\x01\x84aVjV[\x81\x81\x10a\x0F\xFFWa\x0F\xFFaU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x10\x14\x91\x90aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16a\x10*`@\x88\x01\x88aU\xEBV[\x83\x81\x81\x10a\x10:Wa\x10:aU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x10O\x91\x90aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16\x11[a\x10wW`@Qc\x9F\x1C\x80S`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x10\x84``\x87\x01\x87aU\xEBV[\x82\x81\x81\x10a\x10\x94Wa\x10\x94aU\x92V[\x90P` \x02\x015_\x10\x80\x15a\x10\xD4WPg\r\xE0\xB6\xB3\xA7d\0\0a\x10\xBA``\x88\x01\x88aU\xEBV[\x83\x81\x81\x10a\x10\xCAWa\x10\xCAaU\x92V[\x90P` \x02\x015\x11\x15[a\x10\xF1W`@Qc\x13S`1`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x11Ma\x11\x01`@\x88\x01\x88aU\xEBV[\x83\x81\x81\x10a\x11\x11Wa\x11\x11aU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x11&\x91\x90aK\x15V[`\x99_a\x112\x87a2\xF7V[\x81R` \x01\x90\x81R` \x01_ a8\xE4\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[a\x11jW`@Qc1\xBC4'`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80a\x11\xBCa\x11|` \x8A\x01\x8AaK\x15V[a\x11\x85\x87a2\xF7V[a\x11\x92`@\x8C\x01\x8CaU\xEBV[\x87\x81\x81\x10a\x11\xA2Wa\x11\xA2aU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x11\xB7\x91\x90aK\x15V[a3ZV[\x80Q\x91\x93P\x91P`\x01`\x01`@\x1B\x03\x16_\x03a\x11\xD9WPPa\x15\xB3V[_a\x12\x14a\x11\xEA``\x8B\x01\x8BaU\xEBV[\x86\x81\x81\x10a\x11\xFAWa\x11\xFAaU\x92V[\x85Q`\x01`\x01`@\x1B\x03\x16\x92` \x90\x91\x02\x015\x90Pa9\x05V[\x83Q\x90\x91Pa\x12/`\x01`\x01`@\x1B\x03\x80\x84\x16\x90\x83\x16a9\x1BV[\x86\x86\x81Q\x81\x10a\x12AWa\x12AaU\x92V[` \x02` \x01\x01\x81\x81RPP\x81\x83_\x01\x81\x81Qa\x12^\x91\x90aV}V[`\x01`\x01`@\x1B\x03\x16\x90RP\x83Q\x82\x90\x85\x90a\x12{\x90\x83\x90aV}V[`\x01`\x01`@\x1B\x03\x16\x90RP` \x84\x01\x80Q\x83\x91\x90a\x12\x9B\x90\x83\x90aV}V[`\x01`\x01`@\x1B\x03\x16\x90RP` \x83\x01Q_`\x0F\x91\x90\x91\x0B\x12\x15a\x13\xB3W_a\x12\xFEa\x12\xCA``\x8D\x01\x8DaU\xEBV[\x88\x81\x81\x10a\x12\xDAWa\x12\xDAaU\x92V[\x90P` \x02\x015\x85` \x01Qa\x12\xEF\x90aV\x9CV[`\x01`\x01`\x80\x1B\x03\x16\x90a9\x05V[\x90P\x80`\x01`\x01`@\x1B\x03\x16\x84` \x01\x81\x81Qa\x13\x1B\x91\x90aV\xC0V[`\x0F\x0B\x90RP\x7F\x14\x87\xAFT\x18\xC4~\xE5\xEAE\xEFJ\x939\x86h\x12\x08\x90wJ\x9E\x13H~a\xE9\xDC;\xAFv\xDDa\x13O` \x8D\x01\x8DaK\x15V[\x89a\x13]`@\x8F\x01\x8FaU\xEBV[\x8A\x81\x81\x10a\x13mWa\x13maU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x13\x82\x91\x90aK\x15V[a\x13\x93\x88_\x01Q\x89` \x01Qa9/V[\x88`@\x01Q`@Qa\x13\xA9\x95\x94\x93\x92\x91\x90aV\xEDV[`@Q\x80\x91\x03\x90\xA1P[a\x14\x05a\x13\xC3` \x8C\x01\x8CaK\x15V[a\x13\xCC\x89a2\xF7V[a\x13\xD9`@\x8E\x01\x8EaU\xEBV[\x89\x81\x81\x10a\x13\xE9Wa\x13\xE9aU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x13\xFE\x91\x90aK\x15V[\x87\x87a9NV[\x7F\x14\x87\xAFT\x18\xC4~\xE5\xEAE\xEFJ\x939\x86h\x12\x08\x90wJ\x9E\x13H~a\xE9\xDC;\xAFv\xDDa\x143` \x8C\x01\x8CaK\x15V[\x88a\x14A`@\x8E\x01\x8EaU\xEBV[\x89\x81\x81\x10a\x14QWa\x14QaU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x14f\x91\x90aK\x15V[\x86Q`@Qa\x14z\x94\x93\x92\x91\x90C\x90aV\xEDV[`@Q\x80\x91\x03\x90\xA1a\x14\xCBa\x14\x92` \x8C\x01\x8CaK\x15V[a\x14\x9F`@\x8D\x01\x8DaU\xEBV[\x88\x81\x81\x10a\x14\xAFWa\x14\xAFaU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x14\xC4\x91\x90aK\x15V[\x86Qa;\x86V[`\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\x16c`\x1B\xB3oa\x15\x07` \x8D\x01\x8DaK\x15V[a\x15\x14`@\x8E\x01\x8EaU\xEBV[\x89\x81\x81\x10a\x15$Wa\x15$aU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x159\x91\x90aK\x15V[\x87Q`@Q`\xE0\x85\x90\x1B`\x01`\x01`\xE0\x1B\x03\x19\x16\x81R`\x01`\x01`\xA0\x1B\x03\x93\x84\x16`\x04\x82\x01R\x92\x90\x91\x16`$\x83\x01R`\x01`\x01`@\x1B\x03\x80\x86\x16`D\x84\x01R\x16`d\x82\x01R`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x15\x98W__\xFD[PZ\xF1\x15\x80\x15a\x15\xAAW=__>=_\xFD[PPPPPPPP[`\x01\x01a\x0F\xBAV[P\x7F\x80\x96\x9A\xD2\x94(\xD6y~\xE7\xAA\xD0\x84\xF9\xE4\xA4*\x82\xFCPm\xCD,\xA3\xB6\xFBC\x1F\x85\xCC\xEB\xE5a\x15\xEA` \x87\x01\x87aK\x15V[\x83a\x15\xF8`@\x89\x01\x89aU\xEBV[\x85a\x16\x06`\x80\x8C\x01\x8CaW>V[`@Qa\x16\x19\x97\x96\x95\x94\x93\x92\x91\x90aW\xA8V[`@Q\x80\x91\x03\x90\xA1PPPPPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x9D` R`@\x81 ``\x91\x82\x91a\x16N\x90a5\x03V[\x90P_\x81`\x01`\x01`@\x1B\x03\x81\x11\x15a\x16iWa\x16iaItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x16\xADW\x81` \x01[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x16\x87W\x90P[P\x90P_\x82`\x01`\x01`@\x1B\x03\x81\x11\x15a\x16\xC9Wa\x16\xC9aItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x17\x12W\x81` \x01[`@\x80Q``\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x92\x82\x01R\x82R_\x19\x90\x92\x01\x91\x01\x81a\x16\xE7W\x90P[P\x90P_[\x83\x81\x10\x15a\x17\x95W`\x01`\x01`\xA0\x1B\x03\x88\x16_\x90\x81R`\x9D` R`@\x81 a\x17D\x90a\t\xCD\x90\x84a5\x0CV[\x90P\x80\x84\x83\x81Q\x81\x10a\x17YWa\x17YaU\x92V[` \x02` \x01\x01\x81\x90RPa\x17o\x89\x82\x8Aa\x07\x8DV[\x83\x83\x81Q\x81\x10a\x17\x81Wa\x17\x81aU\x92V[` \x90\x81\x02\x91\x90\x91\x01\x01RP`\x01\x01a\x17\x17V[P\x90\x93P\x91PP[\x92P\x92\x90PV[``_a\x07\xC1`\x99_a\x17\xB6\x86a2\xF7V[\x81R` \x01\x90\x81R` \x01_ a<\x08V[``_\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x17\xE4Wa\x17\xE4aItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x18\rW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x84Q\x81\x10\x15a\n'Wa\x18>\x85\x82\x81Q\x81\x10a\x180Wa\x180aU\x92V[` \x02` \x01\x01Q\x85a(~V[\x82\x82\x81Q\x81\x10a\x18PWa\x18PaU\x92V[`\x01`\x01`@\x1B\x03\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`\x01\x01a\x18\x12V[`fT_\x90`\x01\x90\x81\x16\x03a\x18\x98W`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x83\x82\x14a\x18\xB8W`@QcCqJ\xFD`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_[\x84\x81\x10\x15a\x19!Wa\x19\x19\x87\x87\x87\x84\x81\x81\x10a\x18\xD8Wa\x18\xD8aU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x18\xED\x91\x90aK\x15V[\x86\x86\x85\x81\x81\x10a\x18\xFFWa\x18\xFFaU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x19\x14\x91\x90aX>V[a<\x14V[`\x01\x01a\x18\xBAV[PPPPPPPV[\x83a\x194\x81a5.V[a\x19QW`@Qc\x93-\x94\xF7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x80Q\x80\x82\x01\x90\x91R`\x01`\x01`\xA0\x1B\x03\x86\x16\x81Rc\xFF\xFF\xFF\xFF\x85\x16` \x82\x01R_a\x19}\x82a2\xF7V[\x90Pa\x19\xBE\x82` \x01Qc\xFF\xFF\xFF\xFF\x16`\x98_\x8A`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x90\x81R` \x01_ a5\x17\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[a\x19\xDBW`@Qc\x1F\xB1pU`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_[\x84\x81\x10\x15a\x1A~Wa\x19\xFA\x86\x86\x83\x81\x81\x10a\x0CiWa\x0CiaU\x92V[a\x1A\x17W`@QcX\\\xFB/`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7Fz\xB2`\xFE\n\xF1\x93\xDB_I\x86w\r\x83\x1B\xDAN\xA4`\x99\xDC\x81~\x8Bg\x16\xDC\xAE\x8A\xF8\xE8\x8B\x83\x87\x87\x84\x81\x81\x10a\x1AKWa\x1AKaU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x1A`\x91\x90aK\x15V[`@Qa\x1An\x92\x91\x90aV0V[`@Q\x80\x91\x03\x90\xA1`\x01\x01a\x19\xDDV[PPPPPPPPV[``_\x82Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x1A\xA4Wa\x1A\xA4aItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x1A\xCDW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x83Q\x81\x10\x15a\n'Wa\x1A\xFE\x85\x85\x83\x81Q\x81\x10a\x1A\xF1Wa\x1A\xF1aU\x92V[` \x02` \x01\x01Qa(~V[\x82\x82\x81Q\x81\x10a\x1B\x10Wa\x1B\x10aU\x92V[`\x01`\x01`@\x1B\x03\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`\x01\x01a\x1A\xD2V[``a\x1B[\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\0a=\x18V[\x90P\x90V[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\x1C[Wa\x1B\x99\x82a5.V[a\x1B\xB6W`@QcH\xF5\xC3\xED`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Qc6\xB8{\xD7`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x04\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\x90cmp\xF7\xAE\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1C\x1AW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1C>\x91\x90aUsV[a\x1C[W`@Qc\xCC\xEA\x9Eo`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\t\x14\x82\x82a=UV[`@Qc#}\xFBG`\xE1\x1B\x81R3`\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\x90cF\xFB\xF6\x8E\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1C\xC7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1C\xEB\x91\x90aUsV[a\x1D\x08W`@Qc\x1Dw\xD4w`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1D\x12_\x19a4\xC6V[V[_a\x07\xC1\x83`\x9A_a\x112\x86a2\xF7V[__a\x1D1\x84\x84a?\x01V[\x95\x94PPPPPV[`fT`\x02\x90`\x04\x90\x81\x16\x03a\x1DcW`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1Dxa\x1Ds` \x84\x01\x84aK\x15V[a5.V[\x80a\x1D\x91WPa\x1D\x91a\x1Ds`@\x84\x01` \x85\x01aK\x15V[a\x1D\xAEW`@QcH\xF5\xC3\xED`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_[a\x1D\xBD`@\x84\x01\x84aU\xEBV[\x90P\x81\x10\x15a \x7FW_`@Q\x80`@\x01`@R\x80\x85` \x01` \x81\x01\x90a\x1D\xE5\x91\x90aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a\x1E\0`@\x87\x01\x87aU\xEBV[\x85\x81\x81\x10a\x1E\x10Wa\x1E\x10aU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x1E%\x91\x90aU\xC4V[c\xFF\xFF\xFF\xFF\x16\x81RP\x90Pa\x1Er\x81` \x01Qc\xFF\xFF\xFF\xFF\x16`\x98_\x87` \x01` \x81\x01\x90a\x1ET\x91\x90aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x81\x01\x91\x90\x91R`@\x01_ \x90a5\x17V[a\x1E\x8FW`@Qc\x1F\xB1pU`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x9E_a\x1E\x9F` \x87\x01\x87aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x90\x81R` \x01_ _a\x1E\xC8\x83a2\xF7V[\x81R` \x81\x01\x91\x90\x91R`@\x01_ T`\xFF\x16a\x1E\xF8W`@Qc%\x13\x1DO`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1F2a\x1F\x04\x82a2\xF7V[`\x9C_a\x1F\x14` \x89\x01\x89aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x81\x01\x91\x90\x91R`@\x01_ \x90a@pV[Pa\x1Fja\x1FC` \x86\x01\x86aK\x15V[`\x9A_a\x1FO\x85a2\xF7V[\x81R` \x01\x90\x81R` \x01_ a@{\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[Pa\x1Fx` \x85\x01\x85aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16\x7F\xAD4\xC3\x07\x0B\xE1\xDF\xFB\xCA\xA4\x99\xD0\0\xBA+\x8D\x98H\xAE\xFC\xAC0Y\xDF$]\xD9\\N\xCE\x14\xFE\x82`@Qa\x1F\xB0\x91\x90aU\xDDV[`@Q\x80\x91\x03\x90\xA2`@\x80Q\x80\x82\x01\x90\x91R_\x81R` \x81\x01a\x1F\xF3\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\0CaX_V[c\xFF\xFF\xFF\xFF\x16\x90R`\x9E_a \x0B` \x88\x01\x88aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x90\x81R` \x01_ _a 4\x84a2\xF7V[\x81R` \x80\x82\x01\x92\x90\x92R`@\x01_ \x82Q\x81T\x93\x90\x92\x01Qc\xFF\xFF\xFF\xFF\x16a\x01\0\x02d\xFF\xFF\xFF\xFF\0\x19\x92\x15\x15\x92\x90\x92\x16d\xFF\xFF\xFF\xFF\xFF\x19\x90\x93\x16\x92\x90\x92\x17\x17\x90UP`\x01\x01a\x1D\xB0V[Pa \x93a\x03\xD9`@\x84\x01` \x85\x01aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16c0<\xA9Va \xAE` \x85\x01\x85aK\x15V[a \xBE`@\x86\x01` \x87\x01aK\x15V[a \xCB`@\x87\x01\x87aU\xEBV[`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a \xEA\x94\x93\x92\x91\x90aX\xB4V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a!\x01W__\xFD[PZ\xF1\x15\x80\x15a!\x13W=__>=_\xFD[PPPPPPV[``a\x08=`\x9A_a\x17\xB6\x85a2\xF7V[a!4a@\x8FV[a\x1D\x12_a@\xE9V[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x9C` R`@\x81 ``\x91\x90a!a\x90a5\x03V[\x90P_\x81`\x01`\x01`@\x1B\x03\x81\x11\x15a!|Wa!|aItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a!\xC0W\x81` \x01[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R\x81R` \x01\x90`\x01\x90\x03\x90\x81a!\x9AW\x90P[P\x90P_[\x82\x81\x10\x15a\n'W`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x9C` R`@\x90 a!\xF2\x90a\t\xCD\x90\x83a5\x0CV[\x82\x82\x81Q\x81\x10a\"\x04Wa\"\x04aU\x92V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a!\xC5V[``_\x84Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\"3Wa\"3aItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\"|W\x81` \x01[`@\x80Q``\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x92\x82\x01R\x82R_\x19\x90\x92\x01\x91\x01\x81a\"QW\x90P[P\x90P_[\x85Q\x81\x10\x15a\r\xE7Wa\"\xAE\x86\x82\x81Q\x81\x10a\"\x9FWa\"\x9FaU\x92V[` \x02` \x01\x01Q\x86\x86a\x07\x8DV[\x82\x82\x81Q\x81\x10a\"\xC0Wa\"\xC0aU\x92V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\"\x81V[``_\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\"\xEFWa\"\xEFaItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a#\x18W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x84Q\x81\x10\x15a\r\xE7W`\x01`\x01`\xA0\x1B\x03\x86\x16_\x90\x81R`\xA1` R`@\x81 \x86Qa#\x8D\x92\x87\x92\x91\x89\x90\x86\x90\x81\x10a#XWa#XaU\x92V[` \x02` \x01\x01Q`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x90\x81R` \x01_ aA:\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82\x82\x81Q\x81\x10a#\x9FWa#\x9FaU\x92V[`\x01`\x01`@\x1B\x03\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`\x01\x01a#\x1DV[`fT_\x90`\x01\x90\x81\x16\x03a#\xE7W`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a#\xF0\x83a5.V[a$\rW`@QcH\xF5\xC3\xED`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[___a$\x19\x86a.8V[\x91P\x91P\x81a$;W`@Qc\xFAU\xFC\x81`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x91P_\x90P[\x83Q\x81\x10\x15a\r4W\x83\x81\x81Q\x81\x10a$\\Wa$\\aU\x92V[` \x02` \x01\x01Q`@\x01QQ\x84\x82\x81Q\x81\x10a${Wa${aU\x92V[` \x02` \x01\x01Q` \x01QQ\x14a$\xA6W`@QcCqJ\xFD`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x84\x82\x81Q\x81\x10a$\xB9Wa$\xB9aU\x92V[` \x90\x81\x02\x91\x90\x91\x01\x81\x01QQ\x80\x82\x01Q\x81Q`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R`\x98\x90\x93R`@\x90\x92 \x90\x92Pa$\xF9\x91c\xFF\xFF\xFF\xFF\x90\x81\x16\x90a5\x17\x16V[a%\x16W`@Qc\x1F\xB1pU`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a%!\x87\x83a\x07\xC8V[\x90P_[\x86\x84\x81Q\x81\x10a%7Wa%7aU\x92V[` \x02` \x01\x01Q` \x01QQ\x81\x10\x15a(sW_\x87\x85\x81Q\x81\x10a%^Wa%^aU\x92V[` \x02` \x01\x01Q` \x01Q\x82\x81Q\x81\x10a%{Wa%{aU\x92V[` \x02` \x01\x01Q\x90Pa%\x92\x89\x82a\xFF\xFFa<\x14V[__a%\xA1\x8Ba\x07\xB6\x88a2\xF7V[\x91P\x91P\x80`@\x01Qc\xFF\xFF\xFF\xFF\x16_\x14a%\xCFW`@Qc\r\x8F\xCB\xE3`\xE4\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a%\xDC\x87\x85\x84\x89aANV[\x90Pa&!\x82_\x01Q\x8C\x8A\x81Q\x81\x10a%\xF7Wa%\xF7aU\x92V[` \x02` \x01\x01Q`@\x01Q\x87\x81Q\x81\x10a&\x14Wa&\x14aU\x92V[` \x02` \x01\x01QaA\x84V[`\x0F\x0B` \x83\x01\x81\x90R_\x03a&JW`@QcF\x06\x17\x93`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x82` \x01Q`\x0F\x0B\x12\x15a'\x8EW\x80\x15a'\x10Wa&\xCBa&k\x88a2\xF7V[`\x01`\x01`\xA0\x1B\x03\x80\x8F\x16_\x90\x81R`\xA3` \x90\x81R`@\x80\x83 \x93\x8A\x16\x83R\x92\x90R \x90\x81T`\x01`\x80\x1B\x90\x81\x90\x04`\x0F\x0B_\x81\x81R`\x01\x80\x86\x01` R`@\x90\x91 \x93\x90\x93U\x83T`\x01`\x01`\x80\x1B\x03\x90\x81\x16\x93\x90\x91\x01\x16\x02\x17\x90UV[a&\xF5\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\0CaX_V[a'\0\x90`\x01aX_V[c\xFF\xFF\xFF\xFF\x16`@\x83\x01Ra'\xFBV[a'\"\x83` \x01Q\x83` \x01Qa9/V[`\x01`\x01`@\x1B\x03\x16` \x84\x01R\x8AQ\x8B\x90\x89\x90\x81\x10a'DWa'DaU\x92V[` \x02` \x01\x01Q`@\x01Q\x85\x81Q\x81\x10a'aWa'aaU\x92V[` \x90\x81\x02\x91\x90\x91\x01\x81\x01Q`\x01`\x01`@\x1B\x03\x16\x83R_\x90\x83\x01Rc\xFF\xFF\xFF\xFFC\x16`@\x83\x01Ra'\xFBV[_\x82` \x01Q`\x0F\x0B\x13\x15a'\xFBWa'\xAF\x83` \x01Q\x83` \x01Qa9/V[`\x01`\x01`@\x1B\x03\x90\x81\x16` \x85\x01\x81\x90R\x84Q\x90\x91\x16\x10\x15a'\xE5W`@Qcl\x9B\xE0\xBF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a'\xEF\x89CaX_V[c\xFF\xFF\xFF\xFF\x16`@\x83\x01R[a(\x10\x8Ca(\x08\x89a2\xF7V[\x86\x86\x86a9NV[\x7F\x14\x87\xAFT\x18\xC4~\xE5\xEAE\xEFJ\x939\x86h\x12\x08\x90wJ\x9E\x13H~a\xE9\xDC;\xAFv\xDD\x8C\x88\x86a(E\x86_\x01Q\x87` \x01Qa9/V[\x86`@\x01Q`@Qa([\x95\x94\x93\x92\x91\x90aV\xEDV[`@Q\x80\x91\x03\x90\xA1PP`\x01\x90\x92\x01\x91Pa%%\x90PV[PPP`\x01\x01a$AV[`\x01`\x01`\xA0\x1B\x03\x80\x83\x16_\x90\x81R`\xA1` \x90\x81R`@\x80\x83 \x93\x85\x16\x83R\x92\x90R\x90\x81 a\x07\xC1\x90aA\x9BV[\x82a(\xB7\x81a5.V[a(\xD4W`@Qc\x93-\x94\xF7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x84\x16_\x90\x81R`\xA4` R`@\x90 T`\xFF\x16a)\x16W`\x01`\x01`\xA0\x1B\x03\x84\x16_\x90\x81R`\xA4` R`@\x90 \x80T`\xFF\x19\x16`\x01\x17\x90U[\x83`\x01`\x01`\xA0\x1B\x03\x16\x7F\xA8\x9C\x1D\xC2C\xD8\x90\x8A\x96\xDD\x84\x94K\xCC\x97\xD6\xBCj\xC0\r\xD7\x8E b\x15v\xBEj<\x947\x13\x84\x84`@Qa)Q\x92\x91\x90aX\xE0V[`@Q\x80\x91\x03\x90\xA2PPPPV[`fT`\x02\x90`\x04\x90\x81\x16\x03a)\x88W`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x82a)\x92\x81a5.V[a)\xAFW`@Qc\x93-\x94\xF7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Qc6\xB8{\xD7`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\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\x90cmp\xF7\xAE\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a*\x13W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a*7\x91\x90aUsV[a*TW`@Qc\xCC\xEA\x9Eo`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_[a*c` \x85\x01\x85aU\xEBV[\x90P\x81\x10\x15a,+W`@\x80Q\x80\x82\x01\x90\x91R_\x90\x80a*\x86` \x88\x01\x88aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x86\x80` \x01\x90a*\xA4\x91\x90aU\xEBV[\x85\x81\x81\x10a*\xB4Wa*\xB4aU\x92V[\x90P` \x02\x01` \x81\x01\x90a*\xC9\x91\x90aU\xC4V[c\xFF\xFF\xFF\xFF\x90\x81\x16\x90\x91R` \x80\x83\x01Q\x83Q`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R`\x98\x90\x92R`@\x90\x91 \x92\x93Pa+\x05\x92\x91\x90\x81\x16\x90a5\x17\x16V[a+\"W`@Qc\x1F\xB1pU`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a+,\x86\x82a\x07\xC8V[\x15a+JW`@Qclln'`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a+sa+V\x82a2\xF7V[`\x01`\x01`\xA0\x1B\x03\x88\x16_\x90\x81R`\x9C` R`@\x90 \x90a5\xD8V[Pa+\x9F\x86`\x9A_a+\x84\x85a2\xF7V[\x81R` \x01\x90\x81R` \x01_ a5\xE3\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[P\x85`\x01`\x01`\xA0\x1B\x03\x16\x7FC#.\xDF\x90qu=#!\xE5\xFA~\x01\x83c\xEE$\x8E_!B\xE6\xC0\x8E\xDD2e\xBF\xB4\x89^\x82`@Qa+\xD9\x91\x90aU\xDDV[`@Q\x80\x91\x03\x90\xA2`\x01`\x01`\xA0\x1B\x03\x86\x16_\x90\x81R`\x9E` R`@\x81 `\x01\x91a,\x04\x84a2\xF7V[\x81R` \x81\x01\x91\x90\x91R`@\x01_ \x80T`\xFF\x19\x16\x91\x15\x15\x91\x90\x91\x17\x90UP`\x01\x01a*VV[Pa,<a\x03\xD9` \x85\x01\x85aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16c\xC6?\xD5\x02\x85a,X` \x87\x01\x87aK\x15V[a,e` \x88\x01\x88aU\xEBV[a,r`@\x8A\x01\x8AaW>V[`@Q\x87c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a,\x93\x96\x95\x94\x93\x92\x91\x90aX\xF3V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a,\xAAW__\xFD[PZ\xF1\x15\x80\x15a\x1A~W=__>=_\xFD[_a\x08=`\x9A_a,\xCC\x85a2\xF7V[\x81R` \x01\x90\x81R` \x01_ a5\x03V[\x83a,\xE8\x81a5.V[a-\x05W`@Qc\x93-\x94\xF7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x80Q\x80\x82\x01\x82R`\x01`\x01`\xA0\x1B\x03\x87\x16\x80\x82Rc\xFF\xFF\xFF\xFF\x80\x88\x16` \x80\x85\x01\x82\x90R_\x93\x84R`\x98\x90R\x93\x90\x91 \x91\x92a-D\x92\x91a5\x17\x16V[a-aW`@Qc\x1F\xB1pU`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a-k\x82a2\xF7V[\x90P_[\x84\x81\x10\x15a\x1A~Wa-\xB4\x86\x86\x83\x81\x81\x10a-\x8CWa-\x8CaU\x92V[\x90P` \x02\x01` \x81\x01\x90a-\xA1\x91\x90aK\x15V[_\x84\x81R`\x99` R`@\x90 \x90a@{V[a-\xD1W`@Qc1\xBC4'`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F{K\x07=\x80\xDC\xACU\xA1\x11w\xD8E\x9A\xD9\xF6d\xCE\xEB\x91\xF7\x1F'\x16{\xB1O\x81R\xA7\xEE\xEE\x83\x87\x87\x84\x81\x81\x10a.\x05Wa.\x05aU\x92V[\x90P` \x02\x01` \x81\x01\x90a.\x1A\x91\x90aK\x15V[`@Qa.(\x92\x91\x90aV0V[`@Q\x80\x91\x03\x90\xA1`\x01\x01a-oV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x9B` \x90\x81R`@\x80\x83 \x81Q`\x80\x81\x01\x83R\x90Tc\xFF\xFF\xFF\xFF\x80\x82\x16\x80\x84R`\xFF`\x01` \x1B\x84\x04\x16\x15\x15\x95\x84\x01\x86\x90Re\x01\0\0\0\0\0\x83\x04\x82\x16\x94\x84\x01\x94\x90\x94R`\x01`H\x1B\x90\x91\x04\x16``\x82\x01\x81\x90R\x84\x93\x91\x92\x91\x90\x15\x80\x15\x90a.\xB9WP\x82``\x01Qc\xFF\xFF\xFF\xFF\x16C\x10\x15[\x15a.\xC8WPP`@\x81\x01Q`\x01[\x95\x90\x94P\x92PPPV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x98` R`@\x81 a\x08=\x90a5\x03V[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x9F` R`@\x81 ``\x91\x90a\x089\x90\x82a\x17\xB6\x86a2\xF7V[_Ta\x01\0\x90\x04`\xFF\x16\x15\x80\x80\x15a/9WP_T`\x01`\xFF\x90\x91\x16\x10[\x80a/RWP0;\x15\x80\x15a/RWP_T`\xFF\x16`\x01\x14[a/\xBAW`@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[_\x80T`\xFF\x19\x16`\x01\x17\x90U\x80\x15a/\xDBW_\x80Ta\xFF\0\x19\x16a\x01\0\x17\x90U[a/\xE4\x82a4\xC6V[a/\xED\x83a@\xE9V[\x80\x15a03W_\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[PPPV[\x81a0B\x81a5.V[a0_W`@Qc\x93-\x94\xF7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Qc\xB5&W\x87`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x84\x81\x16`\x04\x83\x01R\x83\x16\x90c\xB5&W\x87\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a0\xA3W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a0\xC7\x91\x90aUsV[a0\xE4W`@Qc\x1D\x0B\x13\xC1`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\x97` R`@\x90 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x91\x84\x16\x91\x90\x91\x17\x90U\x7F*\xE9E\xC4\x0CD\xDC\x0E\xC2c\xF9V\t\xC3\xFD\xC6\x95.\n\xEF\xA2-ct\xE4O,\x99z\xCE\xDF\x85\x83a1<\x81a\r\xF0V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x81R\x92\x90\x91\x16` \x83\x01R\x01a0*V[a1da@\x8FV[`\x01`\x01`\xA0\x1B\x03\x81\x16a1\xC9W`@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/\xB1V[a1\xD2\x81a@\xE9V[PV[__a\r\xE7\x84\x84a?\x01V[\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\x15a2=W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a2a\x91\x90aY?V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a2\x92W`@QcyH!\xFF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`fT\x80\x19\x82\x19\x81\x16\x14a2\xB9W`@Qc\xC6\x1D\xCA]`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`f\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[_\x81_\x01Q\x82` \x01Qc\xFF\xFF\xFF\xFF\x16`@Q` \x01a3B\x92\x91\x90``\x92\x90\x92\x1Bk\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x82R`\xA0\x1B`\x01`\x01`\xA0\x1B\x03\x19\x16`\x14\x82\x01R` \x01\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@Ra\x08=\x90aYZV[`@\x80Q\x80\x82\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x83Q``\x81\x01\x85R\x82\x81R\x80\x82\x01\x83\x90R\x80\x85\x01\x83\x90R\x84Q\x80\x86\x01\x86R`\x01`\x01`\xA0\x1B\x03\x89\x81\x16\x85R`\xA1\x84R\x86\x85 \x90\x88\x16\x85R\x90\x92R\x93\x82 \x92\x93\x92\x81\x90a3\xBA\x90aA\x9BV[`\x01`\x01`@\x1B\x03\x90\x81\x16\x82R`\x01`\x01`\xA0\x1B\x03\x89\x81\x16_\x81\x81R`\xA2` \x90\x81R`@\x80\x83 \x94\x8C\x16\x80\x84R\x94\x82R\x80\x83 T\x86\x16\x96\x82\x01\x96\x90\x96R\x91\x81R`\xA0\x82R\x84\x81 \x8B\x82R\x82R\x84\x81 \x92\x81R\x91\x81R\x90\x83\x90 \x83Q``\x81\x01\x85R\x90T\x92\x83\x16\x81R`\x01`@\x1B\x83\x04`\x0F\x0B\x91\x81\x01\x91\x90\x91R`\x01`\xC0\x1B\x90\x91\x04c\xFF\xFF\xFF\xFF\x16\x91\x81\x01\x82\x90R\x91\x92PC\x10\x15a4\\W\x90\x92P\x90Pa4\xBEV[a4m\x81_\x01Q\x82` \x01Qa9/V[`\x01`\x01`@\x1B\x03\x16\x81R` \x81\x01Q_`\x0F\x91\x90\x91\x0B\x12\x15a4\xABWa4\x9C\x82` \x01Q\x82` \x01Qa9/V[`\x01`\x01`@\x1B\x03\x16` \x83\x01R[_`@\x82\x01\x81\x90R` \x82\x01R\x90\x92P\x90P[\x93P\x93\x91PPV[`f\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[_a\x08=\x82T\x90V[_a\x07\xC1\x83\x83aA\xAEV[_\x81\x81R`\x01\x83\x01` R`@\x81 T\x15\x15a\x07\xC1V[`@Qc\x1B\xEB+\x97`\xE3\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x81\x16`\x04\x83\x01R3`$\x83\x01R0`D\x83\x01R_\x805`\x01`\x01`\xE0\x1B\x03\x19\x16`d\x84\x01R\x91\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\x90\x91\x16\x90c\xDFY\\\xB8\x90`\x84\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a5\xB4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08=\x91\x90aUsV[_a\x07\xC1\x83\x83aA\xD4V[_a\x07\xC1\x83`\x01`\x01`\xA0\x1B\x03\x84\x16aA\xD4V[``\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a6\x12Wa6\x12aItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a6EW\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a60W\x90P[P\x90P_\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\xF0\xE0\xE6v\x86\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a6\x97\x92\x91\x90aY}V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a6\xB1W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra6\xD8\x91\x90\x81\x01\x90aY\xA1V[\x90P_[\x85Q\x81\x10\x15a8\xDAW_\x86\x82\x81Q\x81\x10a6\xF8Wa6\xF8aU\x92V[` \x02` \x01\x01Q\x90P\x85Q`\x01`\x01`@\x1B\x03\x81\x11\x15a7\x1BWa7\x1BaItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a7DW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x84\x83\x81Q\x81\x10a7WWa7WaU\x92V[` \x90\x81\x02\x91\x90\x91\x01\x01R_[\x86Q\x81\x10\x15a8\xD0W_\x87\x82\x81Q\x81\x10a7\x80Wa7\x80aU\x92V[` \x90\x81\x02\x91\x90\x91\x01\x81\x01Q`\x01`\x01`\xA0\x1B\x03\x80\x86\x16_\x90\x81R`\xA1\x84R`@\x80\x82 \x92\x84\x16\x82R\x91\x90\x93R\x82 \x90\x92Pa7\xBB\x90aA\x9BV[\x90P\x80`\x01`\x01`@\x1B\x03\x16_\x03a7\xD4WPPa8\xC8V[_a7\xE0\x85\x8D\x85a\x07\x8DV[\x90P\x88c\xFF\xFF\xFF\xFF\x16\x81`@\x01Qc\xFF\xFF\xFF\xFF\x16\x11\x15\x80\x15a8\x08WP_\x81` \x01Q`\x0F\x0B\x12[\x15a8*Wa8\x1E\x81_\x01Q\x82` \x01Qa9/V[`\x01`\x01`@\x1B\x03\x16\x81R[\x80Q_\x90a8E\x90`\x01`\x01`@\x1B\x03\x90\x81\x16\x90\x85\x16a9\x1BV[\x90Pa8\x8C\x81\x89\x89\x81Q\x81\x10a8]Wa8]aU\x92V[` \x02` \x01\x01Q\x87\x81Q\x81\x10a8vWa8vaU\x92V[` \x02` \x01\x01QaB \x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x89\x88\x81Q\x81\x10a8\x9EWa8\x9EaU\x92V[` \x02` \x01\x01Q\x86\x81Q\x81\x10a8\xB7Wa8\xB7aU\x92V[` \x02` \x01\x01\x81\x81RPPPPPP[`\x01\x01a7dV[PP`\x01\x01a6\xDCV[PP\x94\x93PPPPV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x01\x83\x01` R`@\x81 T\x15\x15a\x07\xC1V[_a\x07\xC1\x83\x83g\r\xE0\xB6\xB3\xA7d\0\0`\x01aB4V[_a\x07\xC1\x83g\r\xE0\xB6\xB3\xA7d\0\0\x84aB\x8DV[_a\x07\xC1a9F\x83`\x01`\x01`@\x1B\x03\x86\x16aV\xC0V[`\x0F\x0BaCrV[` \x80\x83\x01Q`\x01`\x01`\xA0\x1B\x03\x80\x88\x16_\x90\x81R`\xA2\x84R`@\x80\x82 \x92\x88\x16\x82R\x91\x90\x93R\x90\x91 T`\x01`\x01`@\x1B\x03\x90\x81\x16\x91\x16\x14a:\x14W` \x82\x81\x01\x80Q`\x01`\x01`\xA0\x1B\x03\x88\x81\x16_\x81\x81R`\xA2\x86R`@\x80\x82 \x93\x8A\x16\x80\x83R\x93\x87R\x90\x81\x90 \x80Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\x01`\x01`@\x1B\x03\x95\x86\x16\x17\x90U\x93Q\x84Q\x91\x82R\x94\x81\x01\x91\x90\x91R\x92\x16\x90\x82\x01R\x7F\xAC\xF9\t_\xEB:7\x0C\x9C\xF6\x92B\x1Ci\xEF2\rM\xB5\xC6nj})\xC7iN\xB0#d\xFCU\x90``\x01`@Q\x80\x91\x03\x90\xA1[`\x01`\x01`\xA0\x1B\x03\x80\x86\x16_\x90\x81R`\xA0` \x90\x81R`@\x80\x83 \x88\x84R\x82R\x80\x83 \x93\x87\x16\x83R\x92\x81R\x90\x82\x90 \x83Q\x81T\x92\x85\x01Q\x93\x85\x01Qc\xFF\xFF\xFF\xFF\x16`\x01`\xC0\x1B\x02c\xFF\xFF\xFF\xFF`\xC0\x1B\x19`\x01`\x01`\x80\x1B\x03\x86\x16`\x01`@\x1B\x02`\x01`\x01`\xC0\x1B\x03\x19\x90\x95\x16`\x01`\x01`@\x1B\x03\x90\x93\x16\x92\x90\x92\x17\x93\x90\x93\x17\x16\x91\x90\x91\x17\x90U`\x0F\x0B\x15a:\xF6W`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x9F` \x90\x81R`@\x80\x83 \x87\x84R\x90\x91R\x90 a:\xCE\x90\x84a5\xE3V[P`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x9D` R`@\x90 a:\xF0\x90\x85a5\xD8V[Pa\r4V[\x80Q`\x01`\x01`@\x1B\x03\x16_\x03a\r4W`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x9F` \x90\x81R`@\x80\x83 \x87\x84R\x90\x91R\x90 a;3\x90\x84a@{V[P`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x9F` \x90\x81R`@\x80\x83 \x87\x84R\x90\x91R\x90 a;_\x90a5\x03V[_\x03a\r4W`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x9D` R`@\x90 a!\x13\x90\x85a@pV[`\x01`\x01`\xA0\x1B\x03\x80\x84\x16_\x90\x81R`\xA1` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R a;\xB5\x90C\x83aC\xDDV[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x80\x86\x16\x82R\x84\x16` \x82\x01R`\x01`\x01`@\x1B\x03\x83\x16\x91\x81\x01\x91\x90\x91R\x7F\x1CdX\x07\x9AA\x07}\0<\x11\xFA\xF9\xBF\t~i;\xD6yy\xE4\xE6P\x0B\xAC{)\xDBw\x9B\\\x90``\x01a0*V[``_a\x07\xC1\x83aC\xF1V[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\xA3` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R\x90\x81 T`\x0F\x81\x81\x0B`\x01`\x80\x1B\x90\x92\x04\x90\x0B\x03[_\x81\x11\x80\x15a<^WP\x82a\xFF\xFF\x16\x82\x10[\x15a\r4W`\x01`\x01`\xA0\x1B\x03\x80\x86\x16_\x90\x81R`\xA3` \x90\x81R`@\x80\x83 \x93\x88\x16\x83R\x92\x90R\x90\x81 a<\x92\x90aDJV[\x90P__a<\xA1\x88\x84\x89a3ZV[\x91P\x91P\x80`@\x01Qc\xFF\xFF\xFF\xFF\x16C\x10\x15a<\xBFWPPPa\r4V[a<\xCC\x88\x84\x89\x85\x85a9NV[`\x01`\x01`\xA0\x1B\x03\x80\x89\x16_\x90\x81R`\xA3` \x90\x81R`@\x80\x83 \x93\x8B\x16\x83R\x92\x90R a<\xF9\x90aD\x9CV[Pa=\x03\x85aZ\xADV[\x94Pa=\x0E\x84aZ\xC5V[\x93PPPPa<LV[``_a=$\x83aE\x19V[`@\x80Q` \x80\x82R\x81\x83\x01\x90\x92R\x91\x92P_\x91\x90` \x82\x01\x81\x806\x837PPP\x91\x82RP` \x81\x01\x92\x90\x92RP\x90V[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x9B` \x90\x81R`@\x91\x82\x90 \x82Q`\x80\x81\x01\x84R\x90Tc\xFF\xFF\xFF\xFF\x80\x82\x16\x83R`\xFF`\x01` \x1B\x83\x04\x16\x15\x15\x93\x83\x01\x93\x90\x93Re\x01\0\0\0\0\0\x81\x04\x83\x16\x93\x82\x01\x93\x90\x93R`\x01`H\x1B\x90\x92\x04\x16``\x82\x01\x81\x90R\x15\x80\x15\x90a=\xD1WP\x80``\x01Qc\xFF\xFF\xFF\xFF\x16C\x10\x15[\x15a=\xEBW`@\x81\x01Qc\xFF\xFF\xFF\xFF\x16\x81R`\x01` \x82\x01R[c\xFF\xFF\xFF\xFF\x82\x16`@\x82\x01Ra>!\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\0CaX_V[a>,\x90`\x01aX_V[c\xFF\xFF\xFF\xFF\x90\x81\x16``\x83\x81\x01\x91\x82R`\x01`\x01`\xA0\x1B\x03\x86\x16_\x81\x81R`\x9B` \x90\x81R`@\x91\x82\x90 \x87Q\x81T\x83\x8A\x01Q\x85\x8B\x01Q\x98Q\x92\x8A\x16d\xFF\xFF\xFF\xFF\xFF\x19\x90\x92\x16\x91\x90\x91\x17`\x01` \x1B\x91\x15\x15\x91\x90\x91\x02\x17l\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\x19\x16e\x01\0\0\0\0\0\x97\x89\x16\x97\x90\x97\x02l\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\x19\x16\x96\x90\x96\x17`\x01`H\x1B\x96\x88\x16\x96\x87\x02\x17\x90U\x81Q\x92\x83R\x94\x87\x16\x94\x82\x01\x94\x90\x94R\x92\x83\x01\x91\x90\x91R\x7FN\x85u\x1Dc1Pllb3_ ~\xB3\x1F\x12\xA6\x1EW\x0F4\xF5\xC1v@0\x87\x85\xC6\xD4\xDB\x91\x01a0*V[`\x01`\x01`\xA0\x1B\x03\x82\x81\x16_\x81\x81R`\xA2` \x90\x81R`@\x80\x83 \x94\x86\x16\x80\x84R\x94\x82R\x80\x83 T\x93\x83R`\xA3\x82R\x80\x83 \x94\x83R\x93\x90R\x91\x82 T`\x01`\x01`@\x1B\x03\x90\x91\x16\x91\x90`\x0F\x81\x81\x0B`\x01`\x80\x1B\x90\x92\x04\x90\x0B\x03\x81[\x81\x81\x10\x15a@,W`\x01`\x01`\xA0\x1B\x03\x80\x87\x16_\x90\x81R`\xA3` \x90\x81R`@\x80\x83 \x93\x89\x16\x83R\x92\x90R\x90\x81 a?\x94\x90\x83aE@V[`\x01`\x01`\xA0\x1B\x03\x88\x81\x16_\x90\x81R`\xA0` \x90\x81R`@\x80\x83 \x85\x84R\x82R\x80\x83 \x93\x8B\x16\x83R\x92\x81R\x90\x82\x90 \x82Q``\x81\x01\x84R\x90T`\x01`\x01`@\x1B\x03\x81\x16\x82R`\x01`@\x1B\x81\x04`\x0F\x0B\x92\x82\x01\x92\x90\x92R`\x01`\xC0\x1B\x90\x91\x04c\xFF\xFF\xFF\xFF\x16\x91\x81\x01\x82\x90R\x91\x92PC\x10\x15a@\x0FWPPa@,V[a@\x1D\x86\x82` \x01Qa9/V[\x95PPP\x80`\x01\x01\x90Pa?\\V[P`\x01`\x01`\xA0\x1B\x03\x80\x86\x16_\x90\x81R`\xA1` \x90\x81R`@\x80\x83 \x93\x88\x16\x83R\x92\x90R \x83\x90a@\\\x90aA\x9BV[a@f\x91\x90aV}V[\x91PP\x92P\x92\x90PV[_a\x07\xC1\x83\x83aE\xAFV[_a\x07\xC1\x83`\x01`\x01`\xA0\x1B\x03\x84\x16aE\xAFV[`3T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x1D\x12W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a/\xB1V[`3\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[_a\x07\xC1\x83\x83g\r\xE0\xB6\xB3\xA7d\0\0aF\x92V[_aA_\x84`\x99_a\x112\x89a2\xF7V[\x80\x15aAhWP\x81[\x80\x15a\x1D1WPP\x90Q`\x01`\x01`@\x1B\x03\x16\x15\x15\x93\x92PPPV[_a\x07\xC1`\x01`\x01`@\x1B\x03\x80\x85\x16\x90\x84\x16aZ\xDAV[_a\x08=\x82g\r\xE0\xB6\xB3\xA7d\0\0aF\xE7V[_\x82_\x01\x82\x81T\x81\x10aA\xC3WaA\xC3aU\x92V[\x90_R` _ \x01T\x90P\x92\x91PPV[_\x81\x81R`\x01\x83\x01` R`@\x81 TaB\x19WP\x81T`\x01\x81\x81\x01\x84U_\x84\x81R` \x80\x82 \x90\x93\x01\x84\x90U\x84T\x84\x82R\x82\x86\x01\x90\x93R`@\x90 \x91\x90\x91Ua\x08=V[P_a\x08=V[_a\x07\xC1\x83\x83g\r\xE0\xB6\xB3\xA7d\0\0aB\x8DV[__aBA\x86\x86\x86aB\x8DV[\x90P`\x01\x83`\x02\x81\x11\x15aBWWaBWa[\x07V[\x14\x80\x15aBsWP_\x84\x80aBnWaBna[\x1BV[\x86\x88\t\x11[\x15a\x1D1WaB\x83`\x01\x82a[/V[\x96\x95PPPPPPV[_\x80\x80_\x19\x85\x87\t\x85\x87\x02\x92P\x82\x81\x10\x83\x82\x03\x03\x91PP\x80_\x03aB\xC4W\x83\x82\x81aB\xBAWaB\xBAa[\x1BV[\x04\x92PPPa\x07\xC1V[\x80\x84\x11aC\x0BW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x15`$\x82\x01RtMath: mulDiv overflow`X\x1B`D\x82\x01R`d\x01a/\xB1V[_\x84\x86\x88\t`\x02`\x01\x87\x19\x81\x01\x88\x16\x97\x88\x90\x04`\x03\x81\x02\x83\x18\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x90\x81\x02\x90\x92\x03\x90\x91\x02_\x88\x90\x03\x88\x90\x04\x90\x91\x01\x85\x83\x11\x90\x94\x03\x93\x90\x93\x02\x93\x03\x94\x90\x94\x04\x91\x90\x91\x17\x02\x94\x93PPPPV[_`\x01`\x01`@\x1B\x03\x82\x11\x15aC\xD9W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FSafeCast: value doesn't fit in 6`D\x82\x01Re4 bits`\xD0\x1B`d\x82\x01R`\x84\x01a/\xB1V[P\x90V[a03\x83\x83`\x01`\x01`@\x1B\x03\x84\x16aG\x1EV[``\x81_\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15aD>W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T\x81R` \x01\x90`\x01\x01\x90\x80\x83\x11aD*W[PPPPP\x90P\x91\x90PV[_aDd\x82T`\x0F\x81\x81\x0B`\x01`\x80\x1B\x90\x92\x04\x90\x0B\x13\x15\x90V[\x15aD\x82W`@Qc\x1E\xD9P\x95`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P\x80T`\x0F\x0B_\x90\x81R`\x01\x90\x91\x01` R`@\x90 T\x90V[_aD\xB6\x82T`\x0F\x81\x81\x0B`\x01`\x80\x1B\x90\x92\x04\x90\x0B\x13\x15\x90V[\x15aD\xD4W`@Qc\x1E\xD9P\x95`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P\x80T`\x0F\x0B_\x81\x81R`\x01\x80\x84\x01` R`@\x82 \x80T\x92\x90U\x83To\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x92\x01`\x01`\x01`\x80\x1B\x03\x16\x91\x90\x91\x17\x90\x91U\x90V[_`\xFF\x82\x16`\x1F\x81\x11\x15a\x08=W`@Qc,\xD4J\xC3`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[__aEbaEN\x84aH!V[\x85TaE]\x91\x90`\x0F\x0Ba[BV[aH\x8AV[\x84T\x90\x91P`\x01`\x80\x1B\x90\x04`\x0F\x90\x81\x0B\x90\x82\x90\x0B\x12aE\x95W`@Qc-\x04\x83\xC5`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x0F\x0B_\x90\x81R`\x01\x93\x90\x93\x01` RPP`@\x90 T\x90V[_\x81\x81R`\x01\x83\x01` R`@\x81 T\x80\x15aF\x89W_aE\xD1`\x01\x83aVjV[\x85T\x90\x91P_\x90aE\xE4\x90`\x01\x90aVjV[\x90P\x81\x81\x14aFCW_\x86_\x01\x82\x81T\x81\x10aF\x02WaF\x02aU\x92V[\x90_R` _ \x01T\x90P\x80\x87_\x01\x84\x81T\x81\x10aF\"WaF\"aU\x92V[_\x91\x82R` \x80\x83 \x90\x91\x01\x92\x90\x92U\x91\x82R`\x01\x88\x01\x90R`@\x90 \x83\x90U[\x85T\x86\x90\x80aFTWaFTa[iV[`\x01\x90\x03\x81\x81\x90_R` _ \x01_\x90U\x90U\x85`\x01\x01_\x86\x81R` \x01\x90\x81R` \x01_ _\x90U`\x01\x93PPPPa\x08=V[_\x91PPa\x08=V[\x82T_\x90\x81aF\xA3\x86\x86\x83\x85aH\xF3V[\x90P\x80\x15aF\xDDWaF\xC7\x86aF\xBA`\x01\x84aVjV[_\x91\x82R` \x90\x91 \x01\x90V[T`\x01` \x1B\x90\x04`\x01`\x01`\xE0\x1B\x03\x16a\x07\xBCV[P\x91\x94\x93PPPPV[\x81T_\x90\x80\x15aG\x16WaG\0\x84aF\xBA`\x01\x84aVjV[T`\x01` \x1B\x90\x04`\x01`\x01`\xE0\x1B\x03\x16a\x089V[P\x90\x92\x91PPV[\x82T\x80\x15aG\xD4W_aG6\x85aF\xBA`\x01\x85aVjV[`@\x80Q\x80\x82\x01\x90\x91R\x90Tc\xFF\xFF\xFF\xFF\x80\x82\x16\x80\x84R`\x01` \x1B\x90\x92\x04`\x01`\x01`\xE0\x1B\x03\x16` \x84\x01R\x91\x92P\x90\x85\x16\x10\x15aG\x88W`@Qc\x15\x1B\x8E?`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80Qc\xFF\xFF\xFF\xFF\x80\x86\x16\x91\x16\x03aG\xD2W\x82aG\xA9\x86aF\xBA`\x01\x86aVjV[\x80T`\x01`\x01`\xE0\x1B\x03\x92\x90\x92\x16`\x01` \x1B\x02c\xFF\xFF\xFF\xFF\x90\x92\x16\x91\x90\x91\x17\x90UPPPPPV[P[P`@\x80Q\x80\x82\x01\x90\x91Rc\xFF\xFF\xFF\xFF\x92\x83\x16\x81R`\x01`\x01`\xE0\x1B\x03\x91\x82\x16` \x80\x83\x01\x91\x82R\x85T`\x01\x81\x01\x87U_\x96\x87R\x95 \x91Q\x90Q\x90\x92\x16`\x01` \x1B\x02\x91\x90\x92\x16\x17\x91\x01UV[_`\x01`\x01`\xFF\x1B\x03\x82\x11\x15aC\xD9W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FSafeCast: value doesn't fit in a`D\x82\x01Rg7\x104\xB7:\x19\x1A\x9B`\xC1\x1B`d\x82\x01R`\x84\x01a/\xB1V[\x80`\x0F\x81\x90\x0B\x81\x14aH\xEEW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FSafeCast: value doesn't fit in 1`D\x82\x01Rf28 bits`\xC8\x1B`d\x82\x01R`\x84\x01a/\xB1V[\x91\x90PV[_[\x81\x83\x10\x15a\n'W_aI\x08\x84\x84aIFV[_\x87\x81R` \x90 \x90\x91Pc\xFF\xFF\xFF\xFF\x86\x16\x90\x82\x01Tc\xFF\xFF\xFF\xFF\x16\x11\x15aI2W\x80\x92PaI@V[aI=\x81`\x01a[/V[\x93P[PaH\xF5V[_aIT`\x02\x84\x84\x18a[}V[a\x07\xC1\x90\x84\x84\x16a[/V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a1\xD2W__\xFD[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@Q``\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15aI\xAAWaI\xAAaItV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15aI\xD8WaI\xD8aItV[`@R\x91\x90PV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14aH\xEEW__\xFD[_`@\x82\x84\x03\x12\x15aJ\x03W__\xFD[`@\x80Q\x90\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15aJ%WaJ%aItV[`@R\x90P\x80\x825aJ6\x81aI`V[\x81RaJD` \x84\x01aI\xE0V[` \x82\x01RP\x92\x91PPV[___`\x80\x84\x86\x03\x12\x15aJbW__\xFD[\x835aJm\x81aI`V[\x92PaJ|\x85` \x86\x01aI\xF3V[\x91P``\x84\x015aJ\x8C\x81aI`V[\x80\x91PP\x92P\x92P\x92V[\x81Q`\x01`\x01`@\x1B\x03\x16\x81R` \x80\x83\x01Q`\x0F\x0B\x90\x82\x01R`@\x80\x83\x01Qc\xFF\xFF\xFF\xFF\x16\x90\x82\x01R``\x81\x01a\x08=V[__``\x83\x85\x03\x12\x15aJ\xDBW__\xFD[\x825aJ\xE6\x81aI`V[\x91PaJ\xF5\x84` \x85\x01aI\xF3V[\x90P\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15aK\x0EW__\xFD[P5\x91\x90PV[_` \x82\x84\x03\x12\x15aK%W__\xFD[\x815a\x07\xC1\x81aI`V[\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x82R` \x90\x81\x01Qc\xFF\xFF\xFF\xFF\x16\x91\x01RV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15aK\x89WaKs\x86\x83QaK0V[`@\x95\x90\x95\x01\x94` \x91\x90\x91\x01\x90`\x01\x01aK`V[P\x93\x94\x93PPPPV[` \x81R_a\x07\xC1` \x83\x01\x84aKNV[_`@\x82\x84\x03\x12\x15aK\xB5W__\xFD[a\x07\xC1\x83\x83aI\xF3V[__\x83`\x1F\x84\x01\x12aK\xCFW__\xFD[P\x815`\x01`\x01`@\x1B\x03\x81\x11\x15aK\xE5W__\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a\x17\x9DW__\xFD[___`@\x84\x86\x03\x12\x15aL\x11W__\xFD[\x835aL\x1C\x81aI`V[\x92P` \x84\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aL6W__\xFD[aLB\x86\x82\x87\x01aK\xBFV[\x94\x97\x90\x96P\x93\x94PPPPV[_`\x01`\x01`@\x1B\x03\x82\x11\x15aLgWaLgaItV[P`\x05\x1B` \x01\x90V[_\x82`\x1F\x83\x01\x12aL\x80W__\xFD[\x815aL\x93aL\x8E\x82aLOV[aI\xB0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x86\x01\x01\x92P\x85\x83\x11\x15aL\xB4W__\xFD[` \x85\x01[\x83\x81\x10\x15aL\xDAW\x805aL\xCC\x81aI`V[\x83R` \x92\x83\x01\x92\x01aL\xB9V[P\x95\x94PPPPPV[___`\x80\x84\x86\x03\x12\x15aL\xF6W__\xFD[aM\0\x85\x85aI\xF3V[\x92P`@\x84\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aM\x1AW__\xFD[aM&\x86\x82\x87\x01aLqV[\x92PP``\x84\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aMAW__\xFD[aMM\x86\x82\x87\x01aLqV[\x91PP\x92P\x92P\x92V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15aK\x89W\x81Q\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01aMiV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15aM\xDEW`?\x19\x87\x86\x03\x01\x84RaM\xC9\x85\x83QaMWV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01aM\xADV[P\x92\x96\x95PPPPPPV[____`\xA0\x85\x87\x03\x12\x15aM\xFDW__\xFD[aN\x07\x86\x86aI\xF3V[\x93P`@\x85\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aN!W__\xFD[aN-\x87\x82\x88\x01aLqV[\x93PP``\x85\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aNHW__\xFD[aNT\x87\x82\x88\x01aLqV[\x92PPaNc`\x80\x86\x01aI\xE0V[\x90P\x92\x95\x91\x94P\x92PV[__`@\x83\x85\x03\x12\x15aN\x7FW__\xFD[\x825aN\x8A\x81aI`V[\x91P` \x83\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aN\xA4W__\xFD[\x83\x01`\xA0\x81\x86\x03\x12\x15aN\xB5W__\xFD[\x80\x91PP\x92P\x92\x90PV[__`@\x83\x85\x03\x12\x15aN\xD1W__\xFD[\x825aN\xDC\x81aI`V[\x91P` \x83\x015aN\xB5\x81aI`V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15aK\x89WaO7\x86\x83Q\x80Q`\x01`\x01`@\x1B\x03\x16\x82R` \x80\x82\x01Q`\x0F\x0B\x90\x83\x01R`@\x90\x81\x01Qc\xFF\xFF\xFF\xFF\x16\x91\x01RV[``\x95\x90\x95\x01\x94` \x91\x90\x91\x01\x90`\x01\x01aN\xFEV[`@\x81R_aO_`@\x83\x01\x85aKNV[\x82\x81\x03` \x84\x01Ra\x1D1\x81\x85aN\xECV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15aK\x89W\x81Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01aO\x83V[` \x81R_a\x07\xC1` \x83\x01\x84aOqV[__`@\x83\x85\x03\x12\x15aO\xCDW__\xFD[\x825`\x01`\x01`@\x1B\x03\x81\x11\x15aO\xE2W__\xFD[aO\xEE\x85\x82\x86\x01aLqV[\x92PP` \x83\x015aN\xB5\x81aI`V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15aP?W\x83Q`\x01`\x01`@\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01aP\x18V[P\x90\x95\x94PPPPPV[_____``\x86\x88\x03\x12\x15aP^W__\xFD[\x855aPi\x81aI`V[\x94P` \x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aP\x83W__\xFD[aP\x8F\x88\x82\x89\x01aK\xBFV[\x90\x95P\x93PP`@\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aP\xADW__\xFD[aP\xB9\x88\x82\x89\x01aK\xBFV[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[____``\x85\x87\x03\x12\x15aP\xDDW__\xFD[\x845aP\xE8\x81aI`V[\x93PaP\xF6` \x86\x01aI\xE0V[\x92P`@\x85\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aQ\x10W__\xFD[aQ\x1C\x87\x82\x88\x01aK\xBFV[\x95\x98\x94\x97P\x95PPPPV[__`@\x83\x85\x03\x12\x15aQ9W__\xFD[\x825aQD\x81aI`V[\x91P` \x83\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aQ^W__\xFD[a@f\x85\x82\x86\x01aLqV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[__`@\x83\x85\x03\x12\x15aQ\xB0W__\xFD[\x825aQ\xBB\x81aI`V[\x91PaJ\xF5` \x84\x01aI\xE0V[_` \x82\x84\x03\x12\x15aQ\xD9W__\xFD[\x815`\xFF\x81\x16\x81\x14a\x07\xC1W__\xFD[_``\x82\x84\x03\x12\x15aQ\xF9W__\xFD[P\x91\x90PV[_` \x82\x84\x03\x12\x15aR\x0FW__\xFD[\x815`\x01`\x01`@\x1B\x03\x81\x11\x15aR$W__\xFD[a\x089\x84\x82\x85\x01aQ\xE9V[___`\x80\x84\x86\x03\x12\x15aRBW__\xFD[\x835`\x01`\x01`@\x1B\x03\x81\x11\x15aRWW__\xFD[aRc\x86\x82\x87\x01aLqV[\x93PPaJ|\x85` \x86\x01aI\xF3V[` \x81R_a\x07\xC1` \x83\x01\x84aN\xECV[___``\x84\x86\x03\x12\x15aR\x97W__\xFD[\x835aR\xA2\x81aI`V[\x92P` \x84\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aR\xBCW__\xFD[aR\xC8\x86\x82\x87\x01aLqV[\x92PPaR\xD7`@\x85\x01aI\xE0V[\x90P\x92P\x92P\x92V[__`@\x83\x85\x03\x12\x15aR\xF1W__\xFD[\x825aR\xFC\x81aI`V[\x91P` \x83\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aS\x16W__\xFD[\x83\x01`\x1F\x81\x01\x85\x13aS&W__\xFD[\x805aS4aL\x8E\x82aLOV[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x85\x01\x01\x92P\x87\x83\x11\x15aSUW__\xFD[` \x84\x01[\x83\x81\x10\x15aTzW\x805`\x01`\x01`@\x1B\x03\x81\x11\x15aSwW__\xFD[\x85\x01`\x80\x81\x8B\x03`\x1F\x19\x01\x12\x15aS\x8CW__\xFD[aS\x94aI\x88V[aS\xA1\x8B` \x84\x01aI\xF3V[\x81R``\x82\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aS\xBBW__\xFD[aS\xCA\x8C` \x83\x86\x01\x01aLqV[` \x83\x01RP`\x80\x82\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aS\xE8W__\xFD[` \x81\x84\x01\x01\x92PP\x8A`\x1F\x83\x01\x12aS\xFFW__\xFD[\x815aT\raL\x8E\x82aLOV[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x86\x01\x01\x92P\x8D\x83\x11\x15aT.W__\xFD[` \x85\x01\x94P[\x82\x85\x10\x15aTdW\x845`\x01`\x01`@\x1B\x03\x81\x16\x81\x14aTSW__\xFD[\x82R` \x94\x85\x01\x94\x90\x91\x01\x90aT5V[`@\x84\x01RPP\x84RP` \x92\x83\x01\x92\x01aSZV[P\x80\x94PPPPP\x92P\x92\x90PV[___`@\x84\x86\x03\x12\x15aT\x9BW__\xFD[\x835aT\xA6\x81aI`V[\x92P` \x84\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aT\xC0W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13aT\xD0W__\xFD[\x805`\x01`\x01`@\x1B\x03\x81\x11\x15aT\xE5W__\xFD[\x86` \x82\x84\x01\x01\x11\x15aT\xF6W__\xFD[\x93\x96` \x91\x90\x91\x01\x95P\x92\x93PPPV[__`@\x83\x85\x03\x12\x15aU\x18W__\xFD[\x825aU#\x81aI`V[\x91P` \x83\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aU=W__\xFD[a@f\x85\x82\x86\x01aQ\xE9V[__`@\x83\x85\x03\x12\x15aUZW__\xFD[\x825aUe\x81aI`V[\x94` \x93\x90\x93\x015\x93PPPV[_` \x82\x84\x03\x12\x15aU\x83W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\xC1W__\xFD[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[_\x825`>\x19\x836\x03\x01\x81\x12aU\xBAW__\xFD[\x91\x90\x91\x01\x92\x91PPV[_` \x82\x84\x03\x12\x15aU\xD4W__\xFD[a\x07\xC1\x82aI\xE0V[`@\x81\x01a\x08=\x82\x84aK0V[__\x835`\x1E\x19\x846\x03\x01\x81\x12aV\0W__\xFD[\x83\x01\x805\x91P`\x01`\x01`@\x1B\x03\x82\x11\x15aV\x19W__\xFD[` \x01\x91P`\x05\x81\x90\x1B6\x03\x82\x13\x15a\x17\x9DW__\xFD[``\x81\x01aV>\x82\x85aK0V[`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16`@\x91\x90\x91\x01R\x91\x90PV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x08=Wa\x08=aVVV[`\x01`\x01`@\x1B\x03\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x08=Wa\x08=aVVV[_\x81`\x0F\x0B`\x01`\x01`\x7F\x1B\x03\x19\x81\x03aV\xB8WaV\xB8aVVV[_\x03\x92\x91PPV[`\x0F\x81\x81\x0B\x90\x83\x90\x0B\x01`\x01`\x01`\x7F\x1B\x03\x81\x13`\x01`\x01`\x7F\x1B\x03\x19\x82\x12\x17\x15a\x08=Wa\x08=aVVV[`\x01`\x01`\xA0\x1B\x03\x86\x16\x81R`\xC0\x81\x01aW\n` \x83\x01\x87aK0V[`\x01`\x01`\xA0\x1B\x03\x94\x90\x94\x16``\x82\x01R`\x01`\x01`@\x1B\x03\x92\x90\x92\x16`\x80\x83\x01Rc\xFF\xFF\xFF\xFF\x16`\xA0\x90\x91\x01R\x92\x91PPV[__\x835`\x1E\x19\x846\x03\x01\x81\x12aWSW__\xFD[\x83\x01\x805\x91P`\x01`\x01`@\x1B\x03\x82\x11\x15aWlW__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\x17\x9DW__\xFD[\x81\x83R\x81\x81` \x85\x017P_\x82\x82\x01` \x90\x81\x01\x91\x90\x91R`\x1F\x90\x91\x01`\x1F\x19\x16\x90\x91\x01\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x88\x16\x81R_`\xC0\x82\x01aW\xC6` \x84\x01\x8AaK0V[`\xC0``\x84\x01R\x86\x90R\x86`\xE0\x83\x01_[\x88\x81\x10\x15aX\x07W\x825aW\xEA\x81aI`V[`\x01`\x01`\xA0\x1B\x03\x16\x82R` \x92\x83\x01\x92\x90\x91\x01\x90`\x01\x01aW\xD7V[P\x83\x81\x03`\x80\x85\x01RaX\x1A\x81\x88aMWV[\x91PP\x82\x81\x03`\xA0\x84\x01RaX0\x81\x85\x87aW\x80V[\x9A\x99PPPPPPPPPPV[_` \x82\x84\x03\x12\x15aXNW__\xFD[\x815a\xFF\xFF\x81\x16\x81\x14a\x07\xC1W__\xFD[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x08=Wa\x08=aVVV[\x81\x83R` \x83\x01\x92P_\x81_[\x84\x81\x10\x15aK\x89Wc\xFF\xFF\xFF\xFFaX\x9E\x83aI\xE0V[\x16\x86R` \x95\x86\x01\x95\x91\x90\x91\x01\x90`\x01\x01aX\x88V[`\x01`\x01`\xA0\x1B\x03\x85\x81\x16\x82R\x84\x16` \x82\x01R```@\x82\x01\x81\x90R_\x90aB\x83\x90\x83\x01\x84\x86aX{V[` \x81R_a\rI` \x83\x01\x84\x86aW\x80V[`\x01`\x01`\xA0\x1B\x03\x87\x81\x16\x82R\x86\x16` \x82\x01R`\x80`@\x82\x01\x81\x90R_\x90aY\x1F\x90\x83\x01\x86\x88aX{V[\x82\x81\x03``\x84\x01RaY2\x81\x85\x87aW\x80V[\x99\x98PPPPPPPPPV[_` \x82\x84\x03\x12\x15aYOW__\xFD[\x81Qa\x07\xC1\x81aI`V[\x80Q` \x80\x83\x01Q\x91\x90\x81\x10\x15aQ\xF9W_\x19` \x91\x90\x91\x03`\x03\x1B\x1B\x16\x91\x90PV[`@\x81R_aY\x8F`@\x83\x01\x85aOqV[\x82\x81\x03` \x84\x01Ra\x1D1\x81\x85aOqV[_` \x82\x84\x03\x12\x15aY\xB1W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15aY\xC6W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13aY\xD6W__\xFD[\x80QaY\xE4aL\x8E\x82aLOV[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x85\x01\x01\x92P\x86\x83\x11\x15aZ\x05W__\xFD[` \x84\x01[\x83\x81\x10\x15aZ\xA2W\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15aZ'W__\xFD[\x85\x01`?\x81\x01\x89\x13aZ7W__\xFD[` \x81\x01QaZHaL\x8E\x82aLOV[\x80\x82\x82R` \x82\x01\x91P` \x80\x84`\x05\x1B\x86\x01\x01\x01\x92P\x8B\x83\x11\x15aZkW__\xFD[`@\x84\x01\x93P[\x82\x84\x10\x15aZ\x8DW\x83Q\x82R` \x93\x84\x01\x93\x90\x91\x01\x90aZrV[\x86RPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90PaZ\nV[P\x96\x95PPPPPPV[_`\x01\x82\x01aZ\xBEWaZ\xBEaVVV[P`\x01\x01\x90V[_\x81aZ\xD3WaZ\xD3aVVV[P_\x19\x01\x90V[`\x0F\x82\x81\x0B\x90\x82\x90\x0B\x03`\x01`\x01`\x7F\x1B\x03\x19\x81\x12`\x01`\x01`\x7F\x1B\x03\x82\x13\x17\x15a\x08=Wa\x08=aVVV[cNH{q`\xE0\x1B_R`!`\x04R`$_\xFD[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[\x80\x82\x01\x80\x82\x11\x15a\x08=Wa\x08=aVVV[\x80\x82\x01\x82\x81\x12_\x83\x12\x80\x15\x82\x16\x82\x15\x82\x16\x17\x15a[aWa[aaVVV[PP\x92\x91PPV[cNH{q`\xE0\x1B_R`1`\x04R`$_\xFD[_\x82a[\x97WcNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[P\x04\x90V\xFE\xA2dipfsX\"\x12 \x87^r\x97\xF92\x8Aoc/ QRu\xF1\x81\xF0i\xC1\xF3\x97\xBE\xFB\x91\xD9\x80\xA2\xBF\x16\x9FJ\x9FdsolcC\0\x08\x1B\x003",
3548    );
3549    /// The runtime bytecode of the contract, as deployed on the network.
3550    ///
3551    /// ```text
3552    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
3553    /// ```
3554    #[rustfmt::skip]
3555    #[allow(clippy::all)]
3556    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
3557        b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x02\xB1W_5`\xE0\x1C\x80cl\xFBD\x81\x11a\x01{W\x80c\xA9\x82\x18!\x11a\0\xE4W\x80c\xC2!\xD8\xAE\x11a\0\x9EW\x80c\xDF\\\xF7#\x11a\0yW\x80c\xDF\\\xF7#\x14a\x07-W\x80c\xF2\xFD\xE3\x8B\x14a\x07TW\x80c\xF6\x05\xCE\x08\x14a\x07gW\x80c\xFA\xBC\x1C\xBC\x14a\x07zW__\xFD[\x80c\xC2!\xD8\xAE\x14a\x06\xF4W\x80c\xCDm\xC6\x87\x14a\x07\x07W\x80c\xD3\xD9o\xF4\x14a\x07\x1AW__\xFD[\x80c\xA9\x82\x18!\x14a\x06fW\x80c\xAD\xC2\xE3\xD9\x14a\x06yW\x80c\xB2Dz\xF7\x14a\x06\x8CW\x80c\xB6k\xD9\x89\x14a\x06\x9FW\x80c\xB9\xFB\xAE\xD1\x14a\x06\xB2W\x80c\xBA\x1A\x84\xE5\x14a\x06\xE1W__\xFD[\x80c\x88o\x11\x95\x11a\x015W\x80c\x88o\x11\x95\x14a\x05\xD5W\x80c\x8C\xE6HT\x14a\x05\xFCW\x80c\x8D\xA5\xCB[\x14a\x06\x1CW\x80c\x94\xD7\xD0\x0C\x14a\x06-W\x80c\x95(\x99\xEE\x14a\x06@W\x80c\xA93>\xC8\x14a\x06SW__\xFD[\x80cl\xFBD\x81\x14a\x05BW\x80cn4\x92\xB5\x14a\x05mW\x80cn\x87]\xBA\x14a\x05\x80W\x80cqP\x18\xA6\x14a\x05\x93W\x80cy\xAEP\xCD\x14a\x05\x9BW\x80c{\xC1\xEFa\x14a\x05\xAEW__\xFD[\x80cAw\xA8|\x11a\x02\x1DW\x80cT\xFDMP\x11a\x01\xD7W\x80cT\xFDMP\x14a\x04\xCAW\x80cV\xC4\x83\xE6\x14a\x04\xDFW\x80cY\\jg\x14a\x04\xF2W\x80cZ\xC8j\xB7\x14a\x04\xFAW\x80c\\\x97Z\xBB\x14a\x05\x1DW\x80cg\r;\xA2\x14a\x05/W__\xFD[\x80cAw\xA8|\x14a\x04*W\x80cFW\xE2j\x14a\x04JW\x80cJ\x10\xFF\xE5\x14a\x04qW\x80cKPF\xEF\x14a\x04\x91W\x80cP\xFE\xEA \x14a\x04\xA4W\x80cTz\xFB\x87\x14a\x04\xB7W__\xFD[\x80c)\x81\xEBw\x11a\x02nW\x80c)\x81\xEBw\x14a\x03\\W\x80c+E:\x9A\x14a\x03\x98W\x80c+\xAB,J\x14a\x03\xB8W\x80c0L\x10\xCD\x14a\x03\xCBW\x80c65 W\x14a\x03\xF6W\x80c@\x12\r\xAB\x14a\x04\tW__\xFD[\x80c\x10\xE1\xB9\xB8\x14a\x02\xB5W\x80c\x13R\xC3\xE6\x14a\x02\xDEW\x80c\x13d9\xDD\x14a\x03\x01W\x80c\x15\xFEP(\x14a\x03\x16W\x80c&\r\xC7X\x14a\x036W\x80c&\x1F\x84\xE0\x14a\x03IW[__\xFD[a\x02\xC8a\x02\xC36`\x04aJPV[a\x07\x8DV[`@Qa\x02\xD5\x91\x90aJ\x97V[`@Q\x80\x91\x03\x90\xF3[a\x02\xF1a\x02\xEC6`\x04aJ\xCAV[a\x07\xC8V[`@Q\x90\x15\x15\x81R` \x01a\x02\xD5V[a\x03\x14a\x03\x0F6`\x04aJ\xFEV[a\x08CV[\0[a\x03)a\x03$6`\x04aK\x15V[a\t\x18V[`@Qa\x02\xD5\x91\x90aK\x93V[a\x02\xF1a\x03D6`\x04aK\xA5V[a\n/V[a\x03\x14a\x03W6`\x04aK\xFFV[a\n`V[a\x03\x83\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[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x02\xD5V[a\x03\xABa\x03\xA66`\x04aL\xE4V[a\r;V[`@Qa\x02\xD5\x91\x90aM\x87V[a\x03\xABa\x03\xC66`\x04aM\xEAV[a\rQV[a\x03\xDEa\x03\xD96`\x04aK\x15V[a\r\xF0V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x02\xD5V[a\x03\x14a\x04\x046`\x04aNnV[a\x0E\x1FV[a\x04\x1Ca\x04\x176`\x04aN\xC0V[a\x16)V[`@Qa\x02\xD5\x92\x91\x90aOMV[a\x04=a\x0486`\x04aK\xA5V[a\x17\xA4V[`@Qa\x02\xD5\x91\x90aO\xAAV[a\x03\xDE\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\x04\x84a\x04\x7F6`\x04aO\xBCV[a\x17\xC8V[`@Qa\x02\xD5\x91\x90aO\xFFV[a\x03\x14a\x04\x9F6`\x04aPJV[a\x18pV[a\x03\x14a\x04\xB26`\x04aP\xCAV[a\x19*V[a\x04\x84a\x04\xC56`\x04aQ(V[a\x1A\x88V[a\x04\xD2a\x1B0V[`@Qa\x02\xD5\x91\x90aQjV[a\x03\x14a\x04\xED6`\x04aQ\x9FV[a\x1B`V[a\x03\x14a\x1CeV[a\x02\xF1a\x05\x086`\x04aQ\xC9V[`fT`\x01`\xFF\x90\x92\x16\x91\x90\x91\x1B\x90\x81\x16\x14\x90V[`fT[`@Q\x90\x81R` \x01a\x02\xD5V[a\x02\xF1a\x05=6`\x04aJ\xCAV[a\x1D\x14V[a\x05Ua\x05P6`\x04aN\xC0V[a\x1D%V[`@Q`\x01`\x01`@\x1B\x03\x90\x91\x16\x81R` \x01a\x02\xD5V[a\x03\x14a\x05{6`\x04aQ\xFFV[a\x1D:V[a\x04=a\x05\x8E6`\x04aK\xA5V[a!\x1BV[a\x03\x14a!,V[a\x03)a\x05\xA96`\x04aK\x15V[a!=V[a\x03\x83\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\xDE\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\x06\x0Fa\x06\n6`\x04aR0V[a\"\x17V[`@Qa\x02\xD5\x91\x90aRsV[`3T`\x01`\x01`\xA0\x1B\x03\x16a\x03\xDEV[a\x04\x84a\x06;6`\x04aR\x85V[a\"\xD3V[a\x03\x14a\x06N6`\x04aR\xE0V[a#\xBFV[a\x05Ua\x06a6`\x04aN\xC0V[a(~V[a\x03\x14a\x06t6`\x04aT\x89V[a(\xADV[a\x03\x14a\x06\x876`\x04aU\x07V[a)_V[a\x05!a\x06\x9A6`\x04aK\xA5V[a,\xBCV[a\x03\x14a\x06\xAD6`\x04aP\xCAV[a,\xDEV[a\x06\xC5a\x06\xC06`\x04aK\x15V[a.8V[`@\x80Q\x92\x15\x15\x83Rc\xFF\xFF\xFF\xFF\x90\x91\x16` \x83\x01R\x01a\x02\xD5V[a\x05!a\x06\xEF6`\x04aK\x15V[a.\xD2V[a\x04=a\x07\x026`\x04aJ\xCAV[a.\xF2V[a\x03\x14a\x07\x156`\x04aUIV[a/\x1BV[a\x03\x14a\x07(6`\x04aN\xC0V[a08V[a\x03\xDE\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\x14a\x07b6`\x04aK\x15V[a1\\V[a\x05Ua\x07u6`\x04aN\xC0V[a1\xD5V[a\x03\x14a\x07\x886`\x04aJ\xFEV[a1\xE1V[`@\x80Q``\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R\x90a\x07\xBC\x85a\x07\xB6\x86a2\xF7V[\x85a3ZV[\x92PPP[\x93\x92PPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x9E` R`@\x81 \x81\x90\x81a\x07\xEB\x85a2\xF7V[\x81R` \x80\x82\x01\x92\x90\x92R`@\x90\x81\x01_ \x81Q\x80\x83\x01\x90\x92RT`\xFF\x81\x16\x15\x15\x80\x83Ra\x01\0\x90\x91\x04c\xFF\xFF\xFF\xFF\x16\x92\x82\x01\x92\x90\x92R\x91P\x80a\x089WP\x80` \x01Qc\xFF\xFF\xFF\xFF\x16C\x11\x15[\x91PP[\x92\x91PPV[`@Qc#}\xFBG`\xE1\x1B\x81R3`\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\x90cF\xFB\xF6\x8E\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\xA5W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xC9\x91\x90aUsV[a\x08\xE6W`@Qc\x1Dw\xD4w`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`fT\x81\x81\x16\x81\x14a\t\x0BW`@Qc\xC6\x1D\xCA]`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\t\x14\x82a4\xC6V[PPV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x9D` R`@\x81 ``\x91\x90a\t<\x90a5\x03V[\x90P_\x81`\x01`\x01`@\x1B\x03\x81\x11\x15a\tWWa\tWaItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\t\x9BW\x81` \x01[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R\x81R` \x01\x90`\x01\x90\x03\x90\x81a\tuW\x90P[P\x90P_[\x82\x81\x10\x15a\n'W`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x9D` R`@\x90 a\n\x02\x90a\t\xCD\x90\x83a5\x0CV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01RP`@\x80Q\x80\x82\x01\x90\x91R``\x82\x90\x1C\x81Rc\xFF\xFF\xFF\xFF\x90\x91\x16` \x82\x01R\x90V[\x82\x82\x81Q\x81\x10a\n\x14Wa\n\x14aU\x92V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\t\xA0V[P\x93\x92PPPV[` \x80\x82\x01Q\x82Q`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R`\x98\x90\x92R`@\x82 a\x08=\x91c\xFF\xFF\xFF\xFF\x90\x81\x16\x90a5\x17\x16V[\x82a\nj\x81a5.V[a\n\x87W`@Qc\x93-\x94\xF7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x84\x16_\x90\x81R`\xA4` R`@\x90 T`\xFF\x16a\n\xBFW`@QcH\xF7\xDB\xB9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_[\x82\x81\x10\x15a\r4W_`@Q\x80`@\x01`@R\x80\x87`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x86\x86\x85\x81\x81\x10a\n\xF6Wa\n\xF6aU\x92V[\x90P` \x02\x81\x01\x90a\x0B\x08\x91\x90aU\xA6V[a\x0B\x16\x90` \x81\x01\x90aU\xC4V[c\xFF\xFF\xFF\xFF\x16\x81RP\x90Pa\x0B`\x81` \x01Qc\xFF\xFF\xFF\xFF\x16`\x98_\x89`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x90\x81R` \x01_ a5\xD8\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[a\x0B}W`@Qc\x1F\xB1pU`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F1b\x92\x85\xEA\xD23Z\xE0\x93?\x86\xED*\xE63!\xF7\xAFw\xB4\xE6\xEA\xAB\xC4,\x05x\x80\x97~l`@Q\x80`@\x01`@R\x80\x88`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x83` \x01Qc\xFF\xFF\xFF\xFF\x16\x81RP`@Qa\x0B\xD3\x91\x90aU\xDDV[`@Q\x80\x91\x03\x90\xA1_a\x0B\xE5\x82a2\xF7V[\x90P_[\x86\x86\x85\x81\x81\x10a\x0B\xFBWa\x0B\xFBaU\x92V[\x90P` \x02\x81\x01\x90a\x0C\r\x91\x90aU\xA6V[a\x0C\x1B\x90` \x81\x01\x90aU\xEBV[\x90P\x81\x10\x15a\r)Wa\x0C\x91\x87\x87\x86\x81\x81\x10a\x0C9Wa\x0C9aU\x92V[\x90P` \x02\x81\x01\x90a\x0CK\x91\x90aU\xA6V[a\x0CY\x90` \x81\x01\x90aU\xEBV[\x83\x81\x81\x10a\x0CiWa\x0CiaU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x0C~\x91\x90aK\x15V[_\x84\x81R`\x99` R`@\x90 \x90a5\xE3V[P\x7Fz\xB2`\xFE\n\xF1\x93\xDB_I\x86w\r\x83\x1B\xDAN\xA4`\x99\xDC\x81~\x8Bg\x16\xDC\xAE\x8A\xF8\xE8\x8B\x83\x88\x88\x87\x81\x81\x10a\x0C\xC6Wa\x0C\xC6aU\x92V[\x90P` \x02\x81\x01\x90a\x0C\xD8\x91\x90aU\xA6V[a\x0C\xE6\x90` \x81\x01\x90aU\xEBV[\x84\x81\x81\x10a\x0C\xF6Wa\x0C\xF6aU\x92V[\x90P` \x02\x01` \x81\x01\x90a\r\x0B\x91\x90aK\x15V[`@Qa\r\x19\x92\x91\x90aV0V[`@Q\x80\x91\x03\x90\xA1`\x01\x01a\x0B\xE9V[PPP`\x01\x01a\n\xC1V[PPPPPV[``a\rI\x84\x84\x84Ca5\xF7V[\x94\x93PPPPV[``a\r_\x85\x85\x85\x85a5\xF7V[\x90P_[\x84Q\x81\x10\x15a\r\xE7Wa\r\x8F\x85\x82\x81Q\x81\x10a\r\x81Wa\r\x81aU\x92V[` \x02` \x01\x01Q\x87a\x07\xC8V[a\r\xDFW_[\x84Q\x81\x10\x15a\r\xDDW_\x83\x83\x81Q\x81\x10a\r\xB1Wa\r\xB1aU\x92V[` \x02` \x01\x01Q\x82\x81Q\x81\x10a\r\xCAWa\r\xCAaU\x92V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\r\x95V[P[`\x01\x01a\rcV[P\x94\x93PPPPV[`\x01`\x01`\xA0\x1B\x03\x80\x82\x16_\x90\x81R`\x97` R`@\x81 T\x90\x91\x16\x80\x15a\x0E\x18W\x80a\x07\xC1V[P\x90\x91\x90PV[`fT`\x01\x90`\x02\x90\x81\x16\x03a\x0EHW`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x82a\x0ER\x81a5.V[a\x0EoW`@Qc\x93-\x94\xF7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_`@Q\x80`@\x01`@R\x80\x86`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x85` \x01` \x81\x01\x90a\x0E\x9D\x91\x90aU\xC4V[c\xFF\xFF\xFF\xFF\x16\x90R\x90Pa\x0E\xB4``\x85\x01\x85aU\xEBV[\x90Pa\x0E\xC3`@\x86\x01\x86aU\xEBV[\x90P\x14a\x0E\xE3W`@QcCqJ\xFD`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[` \x80\x82\x01Q\x82Q`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R`\x98\x90\x92R`@\x90\x91 a\x0F\x15\x91c\xFF\xFF\xFF\xFF\x90\x81\x16\x90a5\x17\x16V[a\x0F2W`@Qc\x1F\xB1pU`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x0FHa\x0FB` \x86\x01\x86aK\x15V[\x82a\x07\xC8V[a\x0FeW`@Qc\xEB\xBF\xF4\x97`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x0Fs`@\x86\x01\x86aU\xEBV[\x90P`\x01`\x01`@\x1B\x03\x81\x11\x15a\x0F\x8CWa\x0F\x8CaItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0F\xB5W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[a\x0F\xC7`@\x87\x01\x87aU\xEBV[\x90P\x81\x10\x15a\x15\xBBW\x80\x15\x80a\x10ZWPa\x0F\xE5`@\x87\x01\x87aU\xEBV[a\x0F\xF0`\x01\x84aVjV[\x81\x81\x10a\x0F\xFFWa\x0F\xFFaU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x10\x14\x91\x90aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16a\x10*`@\x88\x01\x88aU\xEBV[\x83\x81\x81\x10a\x10:Wa\x10:aU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x10O\x91\x90aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16\x11[a\x10wW`@Qc\x9F\x1C\x80S`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x10\x84``\x87\x01\x87aU\xEBV[\x82\x81\x81\x10a\x10\x94Wa\x10\x94aU\x92V[\x90P` \x02\x015_\x10\x80\x15a\x10\xD4WPg\r\xE0\xB6\xB3\xA7d\0\0a\x10\xBA``\x88\x01\x88aU\xEBV[\x83\x81\x81\x10a\x10\xCAWa\x10\xCAaU\x92V[\x90P` \x02\x015\x11\x15[a\x10\xF1W`@Qc\x13S`1`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x11Ma\x11\x01`@\x88\x01\x88aU\xEBV[\x83\x81\x81\x10a\x11\x11Wa\x11\x11aU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x11&\x91\x90aK\x15V[`\x99_a\x112\x87a2\xF7V[\x81R` \x01\x90\x81R` \x01_ a8\xE4\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[a\x11jW`@Qc1\xBC4'`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80a\x11\xBCa\x11|` \x8A\x01\x8AaK\x15V[a\x11\x85\x87a2\xF7V[a\x11\x92`@\x8C\x01\x8CaU\xEBV[\x87\x81\x81\x10a\x11\xA2Wa\x11\xA2aU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x11\xB7\x91\x90aK\x15V[a3ZV[\x80Q\x91\x93P\x91P`\x01`\x01`@\x1B\x03\x16_\x03a\x11\xD9WPPa\x15\xB3V[_a\x12\x14a\x11\xEA``\x8B\x01\x8BaU\xEBV[\x86\x81\x81\x10a\x11\xFAWa\x11\xFAaU\x92V[\x85Q`\x01`\x01`@\x1B\x03\x16\x92` \x90\x91\x02\x015\x90Pa9\x05V[\x83Q\x90\x91Pa\x12/`\x01`\x01`@\x1B\x03\x80\x84\x16\x90\x83\x16a9\x1BV[\x86\x86\x81Q\x81\x10a\x12AWa\x12AaU\x92V[` \x02` \x01\x01\x81\x81RPP\x81\x83_\x01\x81\x81Qa\x12^\x91\x90aV}V[`\x01`\x01`@\x1B\x03\x16\x90RP\x83Q\x82\x90\x85\x90a\x12{\x90\x83\x90aV}V[`\x01`\x01`@\x1B\x03\x16\x90RP` \x84\x01\x80Q\x83\x91\x90a\x12\x9B\x90\x83\x90aV}V[`\x01`\x01`@\x1B\x03\x16\x90RP` \x83\x01Q_`\x0F\x91\x90\x91\x0B\x12\x15a\x13\xB3W_a\x12\xFEa\x12\xCA``\x8D\x01\x8DaU\xEBV[\x88\x81\x81\x10a\x12\xDAWa\x12\xDAaU\x92V[\x90P` \x02\x015\x85` \x01Qa\x12\xEF\x90aV\x9CV[`\x01`\x01`\x80\x1B\x03\x16\x90a9\x05V[\x90P\x80`\x01`\x01`@\x1B\x03\x16\x84` \x01\x81\x81Qa\x13\x1B\x91\x90aV\xC0V[`\x0F\x0B\x90RP\x7F\x14\x87\xAFT\x18\xC4~\xE5\xEAE\xEFJ\x939\x86h\x12\x08\x90wJ\x9E\x13H~a\xE9\xDC;\xAFv\xDDa\x13O` \x8D\x01\x8DaK\x15V[\x89a\x13]`@\x8F\x01\x8FaU\xEBV[\x8A\x81\x81\x10a\x13mWa\x13maU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x13\x82\x91\x90aK\x15V[a\x13\x93\x88_\x01Q\x89` \x01Qa9/V[\x88`@\x01Q`@Qa\x13\xA9\x95\x94\x93\x92\x91\x90aV\xEDV[`@Q\x80\x91\x03\x90\xA1P[a\x14\x05a\x13\xC3` \x8C\x01\x8CaK\x15V[a\x13\xCC\x89a2\xF7V[a\x13\xD9`@\x8E\x01\x8EaU\xEBV[\x89\x81\x81\x10a\x13\xE9Wa\x13\xE9aU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x13\xFE\x91\x90aK\x15V[\x87\x87a9NV[\x7F\x14\x87\xAFT\x18\xC4~\xE5\xEAE\xEFJ\x939\x86h\x12\x08\x90wJ\x9E\x13H~a\xE9\xDC;\xAFv\xDDa\x143` \x8C\x01\x8CaK\x15V[\x88a\x14A`@\x8E\x01\x8EaU\xEBV[\x89\x81\x81\x10a\x14QWa\x14QaU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x14f\x91\x90aK\x15V[\x86Q`@Qa\x14z\x94\x93\x92\x91\x90C\x90aV\xEDV[`@Q\x80\x91\x03\x90\xA1a\x14\xCBa\x14\x92` \x8C\x01\x8CaK\x15V[a\x14\x9F`@\x8D\x01\x8DaU\xEBV[\x88\x81\x81\x10a\x14\xAFWa\x14\xAFaU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x14\xC4\x91\x90aK\x15V[\x86Qa;\x86V[`\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\x16c`\x1B\xB3oa\x15\x07` \x8D\x01\x8DaK\x15V[a\x15\x14`@\x8E\x01\x8EaU\xEBV[\x89\x81\x81\x10a\x15$Wa\x15$aU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x159\x91\x90aK\x15V[\x87Q`@Q`\xE0\x85\x90\x1B`\x01`\x01`\xE0\x1B\x03\x19\x16\x81R`\x01`\x01`\xA0\x1B\x03\x93\x84\x16`\x04\x82\x01R\x92\x90\x91\x16`$\x83\x01R`\x01`\x01`@\x1B\x03\x80\x86\x16`D\x84\x01R\x16`d\x82\x01R`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x15\x98W__\xFD[PZ\xF1\x15\x80\x15a\x15\xAAW=__>=_\xFD[PPPPPPPP[`\x01\x01a\x0F\xBAV[P\x7F\x80\x96\x9A\xD2\x94(\xD6y~\xE7\xAA\xD0\x84\xF9\xE4\xA4*\x82\xFCPm\xCD,\xA3\xB6\xFBC\x1F\x85\xCC\xEB\xE5a\x15\xEA` \x87\x01\x87aK\x15V[\x83a\x15\xF8`@\x89\x01\x89aU\xEBV[\x85a\x16\x06`\x80\x8C\x01\x8CaW>V[`@Qa\x16\x19\x97\x96\x95\x94\x93\x92\x91\x90aW\xA8V[`@Q\x80\x91\x03\x90\xA1PPPPPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x9D` R`@\x81 ``\x91\x82\x91a\x16N\x90a5\x03V[\x90P_\x81`\x01`\x01`@\x1B\x03\x81\x11\x15a\x16iWa\x16iaItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x16\xADW\x81` \x01[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x16\x87W\x90P[P\x90P_\x82`\x01`\x01`@\x1B\x03\x81\x11\x15a\x16\xC9Wa\x16\xC9aItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x17\x12W\x81` \x01[`@\x80Q``\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x92\x82\x01R\x82R_\x19\x90\x92\x01\x91\x01\x81a\x16\xE7W\x90P[P\x90P_[\x83\x81\x10\x15a\x17\x95W`\x01`\x01`\xA0\x1B\x03\x88\x16_\x90\x81R`\x9D` R`@\x81 a\x17D\x90a\t\xCD\x90\x84a5\x0CV[\x90P\x80\x84\x83\x81Q\x81\x10a\x17YWa\x17YaU\x92V[` \x02` \x01\x01\x81\x90RPa\x17o\x89\x82\x8Aa\x07\x8DV[\x83\x83\x81Q\x81\x10a\x17\x81Wa\x17\x81aU\x92V[` \x90\x81\x02\x91\x90\x91\x01\x01RP`\x01\x01a\x17\x17V[P\x90\x93P\x91PP[\x92P\x92\x90PV[``_a\x07\xC1`\x99_a\x17\xB6\x86a2\xF7V[\x81R` \x01\x90\x81R` \x01_ a<\x08V[``_\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x17\xE4Wa\x17\xE4aItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x18\rW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x84Q\x81\x10\x15a\n'Wa\x18>\x85\x82\x81Q\x81\x10a\x180Wa\x180aU\x92V[` \x02` \x01\x01Q\x85a(~V[\x82\x82\x81Q\x81\x10a\x18PWa\x18PaU\x92V[`\x01`\x01`@\x1B\x03\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`\x01\x01a\x18\x12V[`fT_\x90`\x01\x90\x81\x16\x03a\x18\x98W`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x83\x82\x14a\x18\xB8W`@QcCqJ\xFD`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_[\x84\x81\x10\x15a\x19!Wa\x19\x19\x87\x87\x87\x84\x81\x81\x10a\x18\xD8Wa\x18\xD8aU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x18\xED\x91\x90aK\x15V[\x86\x86\x85\x81\x81\x10a\x18\xFFWa\x18\xFFaU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x19\x14\x91\x90aX>V[a<\x14V[`\x01\x01a\x18\xBAV[PPPPPPPV[\x83a\x194\x81a5.V[a\x19QW`@Qc\x93-\x94\xF7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x80Q\x80\x82\x01\x90\x91R`\x01`\x01`\xA0\x1B\x03\x86\x16\x81Rc\xFF\xFF\xFF\xFF\x85\x16` \x82\x01R_a\x19}\x82a2\xF7V[\x90Pa\x19\xBE\x82` \x01Qc\xFF\xFF\xFF\xFF\x16`\x98_\x8A`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x90\x81R` \x01_ a5\x17\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[a\x19\xDBW`@Qc\x1F\xB1pU`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_[\x84\x81\x10\x15a\x1A~Wa\x19\xFA\x86\x86\x83\x81\x81\x10a\x0CiWa\x0CiaU\x92V[a\x1A\x17W`@QcX\\\xFB/`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7Fz\xB2`\xFE\n\xF1\x93\xDB_I\x86w\r\x83\x1B\xDAN\xA4`\x99\xDC\x81~\x8Bg\x16\xDC\xAE\x8A\xF8\xE8\x8B\x83\x87\x87\x84\x81\x81\x10a\x1AKWa\x1AKaU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x1A`\x91\x90aK\x15V[`@Qa\x1An\x92\x91\x90aV0V[`@Q\x80\x91\x03\x90\xA1`\x01\x01a\x19\xDDV[PPPPPPPPV[``_\x82Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x1A\xA4Wa\x1A\xA4aItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x1A\xCDW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x83Q\x81\x10\x15a\n'Wa\x1A\xFE\x85\x85\x83\x81Q\x81\x10a\x1A\xF1Wa\x1A\xF1aU\x92V[` \x02` \x01\x01Qa(~V[\x82\x82\x81Q\x81\x10a\x1B\x10Wa\x1B\x10aU\x92V[`\x01`\x01`@\x1B\x03\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`\x01\x01a\x1A\xD2V[``a\x1B[\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\0a=\x18V[\x90P\x90V[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\x1C[Wa\x1B\x99\x82a5.V[a\x1B\xB6W`@QcH\xF5\xC3\xED`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Qc6\xB8{\xD7`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x04\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\x90cmp\xF7\xAE\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1C\x1AW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1C>\x91\x90aUsV[a\x1C[W`@Qc\xCC\xEA\x9Eo`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\t\x14\x82\x82a=UV[`@Qc#}\xFBG`\xE1\x1B\x81R3`\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\x90cF\xFB\xF6\x8E\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1C\xC7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1C\xEB\x91\x90aUsV[a\x1D\x08W`@Qc\x1Dw\xD4w`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1D\x12_\x19a4\xC6V[V[_a\x07\xC1\x83`\x9A_a\x112\x86a2\xF7V[__a\x1D1\x84\x84a?\x01V[\x95\x94PPPPPV[`fT`\x02\x90`\x04\x90\x81\x16\x03a\x1DcW`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1Dxa\x1Ds` \x84\x01\x84aK\x15V[a5.V[\x80a\x1D\x91WPa\x1D\x91a\x1Ds`@\x84\x01` \x85\x01aK\x15V[a\x1D\xAEW`@QcH\xF5\xC3\xED`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_[a\x1D\xBD`@\x84\x01\x84aU\xEBV[\x90P\x81\x10\x15a \x7FW_`@Q\x80`@\x01`@R\x80\x85` \x01` \x81\x01\x90a\x1D\xE5\x91\x90aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a\x1E\0`@\x87\x01\x87aU\xEBV[\x85\x81\x81\x10a\x1E\x10Wa\x1E\x10aU\x92V[\x90P` \x02\x01` \x81\x01\x90a\x1E%\x91\x90aU\xC4V[c\xFF\xFF\xFF\xFF\x16\x81RP\x90Pa\x1Er\x81` \x01Qc\xFF\xFF\xFF\xFF\x16`\x98_\x87` \x01` \x81\x01\x90a\x1ET\x91\x90aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x81\x01\x91\x90\x91R`@\x01_ \x90a5\x17V[a\x1E\x8FW`@Qc\x1F\xB1pU`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x9E_a\x1E\x9F` \x87\x01\x87aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x90\x81R` \x01_ _a\x1E\xC8\x83a2\xF7V[\x81R` \x81\x01\x91\x90\x91R`@\x01_ T`\xFF\x16a\x1E\xF8W`@Qc%\x13\x1DO`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1F2a\x1F\x04\x82a2\xF7V[`\x9C_a\x1F\x14` \x89\x01\x89aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x81\x01\x91\x90\x91R`@\x01_ \x90a@pV[Pa\x1Fja\x1FC` \x86\x01\x86aK\x15V[`\x9A_a\x1FO\x85a2\xF7V[\x81R` \x01\x90\x81R` \x01_ a@{\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[Pa\x1Fx` \x85\x01\x85aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16\x7F\xAD4\xC3\x07\x0B\xE1\xDF\xFB\xCA\xA4\x99\xD0\0\xBA+\x8D\x98H\xAE\xFC\xAC0Y\xDF$]\xD9\\N\xCE\x14\xFE\x82`@Qa\x1F\xB0\x91\x90aU\xDDV[`@Q\x80\x91\x03\x90\xA2`@\x80Q\x80\x82\x01\x90\x91R_\x81R` \x81\x01a\x1F\xF3\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\0CaX_V[c\xFF\xFF\xFF\xFF\x16\x90R`\x9E_a \x0B` \x88\x01\x88aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x90\x81R` \x01_ _a 4\x84a2\xF7V[\x81R` \x80\x82\x01\x92\x90\x92R`@\x01_ \x82Q\x81T\x93\x90\x92\x01Qc\xFF\xFF\xFF\xFF\x16a\x01\0\x02d\xFF\xFF\xFF\xFF\0\x19\x92\x15\x15\x92\x90\x92\x16d\xFF\xFF\xFF\xFF\xFF\x19\x90\x93\x16\x92\x90\x92\x17\x17\x90UP`\x01\x01a\x1D\xB0V[Pa \x93a\x03\xD9`@\x84\x01` \x85\x01aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16c0<\xA9Va \xAE` \x85\x01\x85aK\x15V[a \xBE`@\x86\x01` \x87\x01aK\x15V[a \xCB`@\x87\x01\x87aU\xEBV[`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a \xEA\x94\x93\x92\x91\x90aX\xB4V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a!\x01W__\xFD[PZ\xF1\x15\x80\x15a!\x13W=__>=_\xFD[PPPPPPV[``a\x08=`\x9A_a\x17\xB6\x85a2\xF7V[a!4a@\x8FV[a\x1D\x12_a@\xE9V[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x9C` R`@\x81 ``\x91\x90a!a\x90a5\x03V[\x90P_\x81`\x01`\x01`@\x1B\x03\x81\x11\x15a!|Wa!|aItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a!\xC0W\x81` \x01[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R\x81R` \x01\x90`\x01\x90\x03\x90\x81a!\x9AW\x90P[P\x90P_[\x82\x81\x10\x15a\n'W`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x9C` R`@\x90 a!\xF2\x90a\t\xCD\x90\x83a5\x0CV[\x82\x82\x81Q\x81\x10a\"\x04Wa\"\x04aU\x92V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a!\xC5V[``_\x84Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\"3Wa\"3aItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\"|W\x81` \x01[`@\x80Q``\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x92\x82\x01R\x82R_\x19\x90\x92\x01\x91\x01\x81a\"QW\x90P[P\x90P_[\x85Q\x81\x10\x15a\r\xE7Wa\"\xAE\x86\x82\x81Q\x81\x10a\"\x9FWa\"\x9FaU\x92V[` \x02` \x01\x01Q\x86\x86a\x07\x8DV[\x82\x82\x81Q\x81\x10a\"\xC0Wa\"\xC0aU\x92V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\"\x81V[``_\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\"\xEFWa\"\xEFaItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a#\x18W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x84Q\x81\x10\x15a\r\xE7W`\x01`\x01`\xA0\x1B\x03\x86\x16_\x90\x81R`\xA1` R`@\x81 \x86Qa#\x8D\x92\x87\x92\x91\x89\x90\x86\x90\x81\x10a#XWa#XaU\x92V[` \x02` \x01\x01Q`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x90\x81R` \x01_ aA:\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82\x82\x81Q\x81\x10a#\x9FWa#\x9FaU\x92V[`\x01`\x01`@\x1B\x03\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`\x01\x01a#\x1DV[`fT_\x90`\x01\x90\x81\x16\x03a#\xE7W`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a#\xF0\x83a5.V[a$\rW`@QcH\xF5\xC3\xED`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[___a$\x19\x86a.8V[\x91P\x91P\x81a$;W`@Qc\xFAU\xFC\x81`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x91P_\x90P[\x83Q\x81\x10\x15a\r4W\x83\x81\x81Q\x81\x10a$\\Wa$\\aU\x92V[` \x02` \x01\x01Q`@\x01QQ\x84\x82\x81Q\x81\x10a${Wa${aU\x92V[` \x02` \x01\x01Q` \x01QQ\x14a$\xA6W`@QcCqJ\xFD`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x84\x82\x81Q\x81\x10a$\xB9Wa$\xB9aU\x92V[` \x90\x81\x02\x91\x90\x91\x01\x81\x01QQ\x80\x82\x01Q\x81Q`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R`\x98\x90\x93R`@\x90\x92 \x90\x92Pa$\xF9\x91c\xFF\xFF\xFF\xFF\x90\x81\x16\x90a5\x17\x16V[a%\x16W`@Qc\x1F\xB1pU`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a%!\x87\x83a\x07\xC8V[\x90P_[\x86\x84\x81Q\x81\x10a%7Wa%7aU\x92V[` \x02` \x01\x01Q` \x01QQ\x81\x10\x15a(sW_\x87\x85\x81Q\x81\x10a%^Wa%^aU\x92V[` \x02` \x01\x01Q` \x01Q\x82\x81Q\x81\x10a%{Wa%{aU\x92V[` \x02` \x01\x01Q\x90Pa%\x92\x89\x82a\xFF\xFFa<\x14V[__a%\xA1\x8Ba\x07\xB6\x88a2\xF7V[\x91P\x91P\x80`@\x01Qc\xFF\xFF\xFF\xFF\x16_\x14a%\xCFW`@Qc\r\x8F\xCB\xE3`\xE4\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a%\xDC\x87\x85\x84\x89aANV[\x90Pa&!\x82_\x01Q\x8C\x8A\x81Q\x81\x10a%\xF7Wa%\xF7aU\x92V[` \x02` \x01\x01Q`@\x01Q\x87\x81Q\x81\x10a&\x14Wa&\x14aU\x92V[` \x02` \x01\x01QaA\x84V[`\x0F\x0B` \x83\x01\x81\x90R_\x03a&JW`@QcF\x06\x17\x93`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x82` \x01Q`\x0F\x0B\x12\x15a'\x8EW\x80\x15a'\x10Wa&\xCBa&k\x88a2\xF7V[`\x01`\x01`\xA0\x1B\x03\x80\x8F\x16_\x90\x81R`\xA3` \x90\x81R`@\x80\x83 \x93\x8A\x16\x83R\x92\x90R \x90\x81T`\x01`\x80\x1B\x90\x81\x90\x04`\x0F\x0B_\x81\x81R`\x01\x80\x86\x01` R`@\x90\x91 \x93\x90\x93U\x83T`\x01`\x01`\x80\x1B\x03\x90\x81\x16\x93\x90\x91\x01\x16\x02\x17\x90UV[a&\xF5\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\0CaX_V[a'\0\x90`\x01aX_V[c\xFF\xFF\xFF\xFF\x16`@\x83\x01Ra'\xFBV[a'\"\x83` \x01Q\x83` \x01Qa9/V[`\x01`\x01`@\x1B\x03\x16` \x84\x01R\x8AQ\x8B\x90\x89\x90\x81\x10a'DWa'DaU\x92V[` \x02` \x01\x01Q`@\x01Q\x85\x81Q\x81\x10a'aWa'aaU\x92V[` \x90\x81\x02\x91\x90\x91\x01\x81\x01Q`\x01`\x01`@\x1B\x03\x16\x83R_\x90\x83\x01Rc\xFF\xFF\xFF\xFFC\x16`@\x83\x01Ra'\xFBV[_\x82` \x01Q`\x0F\x0B\x13\x15a'\xFBWa'\xAF\x83` \x01Q\x83` \x01Qa9/V[`\x01`\x01`@\x1B\x03\x90\x81\x16` \x85\x01\x81\x90R\x84Q\x90\x91\x16\x10\x15a'\xE5W`@Qcl\x9B\xE0\xBF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a'\xEF\x89CaX_V[c\xFF\xFF\xFF\xFF\x16`@\x83\x01R[a(\x10\x8Ca(\x08\x89a2\xF7V[\x86\x86\x86a9NV[\x7F\x14\x87\xAFT\x18\xC4~\xE5\xEAE\xEFJ\x939\x86h\x12\x08\x90wJ\x9E\x13H~a\xE9\xDC;\xAFv\xDD\x8C\x88\x86a(E\x86_\x01Q\x87` \x01Qa9/V[\x86`@\x01Q`@Qa([\x95\x94\x93\x92\x91\x90aV\xEDV[`@Q\x80\x91\x03\x90\xA1PP`\x01\x90\x92\x01\x91Pa%%\x90PV[PPP`\x01\x01a$AV[`\x01`\x01`\xA0\x1B\x03\x80\x83\x16_\x90\x81R`\xA1` \x90\x81R`@\x80\x83 \x93\x85\x16\x83R\x92\x90R\x90\x81 a\x07\xC1\x90aA\x9BV[\x82a(\xB7\x81a5.V[a(\xD4W`@Qc\x93-\x94\xF7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x84\x16_\x90\x81R`\xA4` R`@\x90 T`\xFF\x16a)\x16W`\x01`\x01`\xA0\x1B\x03\x84\x16_\x90\x81R`\xA4` R`@\x90 \x80T`\xFF\x19\x16`\x01\x17\x90U[\x83`\x01`\x01`\xA0\x1B\x03\x16\x7F\xA8\x9C\x1D\xC2C\xD8\x90\x8A\x96\xDD\x84\x94K\xCC\x97\xD6\xBCj\xC0\r\xD7\x8E b\x15v\xBEj<\x947\x13\x84\x84`@Qa)Q\x92\x91\x90aX\xE0V[`@Q\x80\x91\x03\x90\xA2PPPPV[`fT`\x02\x90`\x04\x90\x81\x16\x03a)\x88W`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x82a)\x92\x81a5.V[a)\xAFW`@Qc\x93-\x94\xF7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Qc6\xB8{\xD7`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\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\x90cmp\xF7\xAE\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a*\x13W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a*7\x91\x90aUsV[a*TW`@Qc\xCC\xEA\x9Eo`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_[a*c` \x85\x01\x85aU\xEBV[\x90P\x81\x10\x15a,+W`@\x80Q\x80\x82\x01\x90\x91R_\x90\x80a*\x86` \x88\x01\x88aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x86\x80` \x01\x90a*\xA4\x91\x90aU\xEBV[\x85\x81\x81\x10a*\xB4Wa*\xB4aU\x92V[\x90P` \x02\x01` \x81\x01\x90a*\xC9\x91\x90aU\xC4V[c\xFF\xFF\xFF\xFF\x90\x81\x16\x90\x91R` \x80\x83\x01Q\x83Q`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R`\x98\x90\x92R`@\x90\x91 \x92\x93Pa+\x05\x92\x91\x90\x81\x16\x90a5\x17\x16V[a+\"W`@Qc\x1F\xB1pU`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a+,\x86\x82a\x07\xC8V[\x15a+JW`@Qclln'`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a+sa+V\x82a2\xF7V[`\x01`\x01`\xA0\x1B\x03\x88\x16_\x90\x81R`\x9C` R`@\x90 \x90a5\xD8V[Pa+\x9F\x86`\x9A_a+\x84\x85a2\xF7V[\x81R` \x01\x90\x81R` \x01_ a5\xE3\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[P\x85`\x01`\x01`\xA0\x1B\x03\x16\x7FC#.\xDF\x90qu=#!\xE5\xFA~\x01\x83c\xEE$\x8E_!B\xE6\xC0\x8E\xDD2e\xBF\xB4\x89^\x82`@Qa+\xD9\x91\x90aU\xDDV[`@Q\x80\x91\x03\x90\xA2`\x01`\x01`\xA0\x1B\x03\x86\x16_\x90\x81R`\x9E` R`@\x81 `\x01\x91a,\x04\x84a2\xF7V[\x81R` \x81\x01\x91\x90\x91R`@\x01_ \x80T`\xFF\x19\x16\x91\x15\x15\x91\x90\x91\x17\x90UP`\x01\x01a*VV[Pa,<a\x03\xD9` \x85\x01\x85aK\x15V[`\x01`\x01`\xA0\x1B\x03\x16c\xC6?\xD5\x02\x85a,X` \x87\x01\x87aK\x15V[a,e` \x88\x01\x88aU\xEBV[a,r`@\x8A\x01\x8AaW>V[`@Q\x87c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a,\x93\x96\x95\x94\x93\x92\x91\x90aX\xF3V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a,\xAAW__\xFD[PZ\xF1\x15\x80\x15a\x1A~W=__>=_\xFD[_a\x08=`\x9A_a,\xCC\x85a2\xF7V[\x81R` \x01\x90\x81R` \x01_ a5\x03V[\x83a,\xE8\x81a5.V[a-\x05W`@Qc\x93-\x94\xF7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x80Q\x80\x82\x01\x82R`\x01`\x01`\xA0\x1B\x03\x87\x16\x80\x82Rc\xFF\xFF\xFF\xFF\x80\x88\x16` \x80\x85\x01\x82\x90R_\x93\x84R`\x98\x90R\x93\x90\x91 \x91\x92a-D\x92\x91a5\x17\x16V[a-aW`@Qc\x1F\xB1pU`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a-k\x82a2\xF7V[\x90P_[\x84\x81\x10\x15a\x1A~Wa-\xB4\x86\x86\x83\x81\x81\x10a-\x8CWa-\x8CaU\x92V[\x90P` \x02\x01` \x81\x01\x90a-\xA1\x91\x90aK\x15V[_\x84\x81R`\x99` R`@\x90 \x90a@{V[a-\xD1W`@Qc1\xBC4'`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F{K\x07=\x80\xDC\xACU\xA1\x11w\xD8E\x9A\xD9\xF6d\xCE\xEB\x91\xF7\x1F'\x16{\xB1O\x81R\xA7\xEE\xEE\x83\x87\x87\x84\x81\x81\x10a.\x05Wa.\x05aU\x92V[\x90P` \x02\x01` \x81\x01\x90a.\x1A\x91\x90aK\x15V[`@Qa.(\x92\x91\x90aV0V[`@Q\x80\x91\x03\x90\xA1`\x01\x01a-oV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x9B` \x90\x81R`@\x80\x83 \x81Q`\x80\x81\x01\x83R\x90Tc\xFF\xFF\xFF\xFF\x80\x82\x16\x80\x84R`\xFF`\x01` \x1B\x84\x04\x16\x15\x15\x95\x84\x01\x86\x90Re\x01\0\0\0\0\0\x83\x04\x82\x16\x94\x84\x01\x94\x90\x94R`\x01`H\x1B\x90\x91\x04\x16``\x82\x01\x81\x90R\x84\x93\x91\x92\x91\x90\x15\x80\x15\x90a.\xB9WP\x82``\x01Qc\xFF\xFF\xFF\xFF\x16C\x10\x15[\x15a.\xC8WPP`@\x81\x01Q`\x01[\x95\x90\x94P\x92PPPV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x98` R`@\x81 a\x08=\x90a5\x03V[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x9F` R`@\x81 ``\x91\x90a\x089\x90\x82a\x17\xB6\x86a2\xF7V[_Ta\x01\0\x90\x04`\xFF\x16\x15\x80\x80\x15a/9WP_T`\x01`\xFF\x90\x91\x16\x10[\x80a/RWP0;\x15\x80\x15a/RWP_T`\xFF\x16`\x01\x14[a/\xBAW`@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[_\x80T`\xFF\x19\x16`\x01\x17\x90U\x80\x15a/\xDBW_\x80Ta\xFF\0\x19\x16a\x01\0\x17\x90U[a/\xE4\x82a4\xC6V[a/\xED\x83a@\xE9V[\x80\x15a03W_\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[PPPV[\x81a0B\x81a5.V[a0_W`@Qc\x93-\x94\xF7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Qc\xB5&W\x87`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x84\x81\x16`\x04\x83\x01R\x83\x16\x90c\xB5&W\x87\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a0\xA3W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a0\xC7\x91\x90aUsV[a0\xE4W`@Qc\x1D\x0B\x13\xC1`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\x97` R`@\x90 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x91\x84\x16\x91\x90\x91\x17\x90U\x7F*\xE9E\xC4\x0CD\xDC\x0E\xC2c\xF9V\t\xC3\xFD\xC6\x95.\n\xEF\xA2-ct\xE4O,\x99z\xCE\xDF\x85\x83a1<\x81a\r\xF0V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x81R\x92\x90\x91\x16` \x83\x01R\x01a0*V[a1da@\x8FV[`\x01`\x01`\xA0\x1B\x03\x81\x16a1\xC9W`@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/\xB1V[a1\xD2\x81a@\xE9V[PV[__a\r\xE7\x84\x84a?\x01V[\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\x15a2=W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a2a\x91\x90aY?V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a2\x92W`@QcyH!\xFF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`fT\x80\x19\x82\x19\x81\x16\x14a2\xB9W`@Qc\xC6\x1D\xCA]`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`f\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[_\x81_\x01Q\x82` \x01Qc\xFF\xFF\xFF\xFF\x16`@Q` \x01a3B\x92\x91\x90``\x92\x90\x92\x1Bk\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x82R`\xA0\x1B`\x01`\x01`\xA0\x1B\x03\x19\x16`\x14\x82\x01R` \x01\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@Ra\x08=\x90aYZV[`@\x80Q\x80\x82\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x83Q``\x81\x01\x85R\x82\x81R\x80\x82\x01\x83\x90R\x80\x85\x01\x83\x90R\x84Q\x80\x86\x01\x86R`\x01`\x01`\xA0\x1B\x03\x89\x81\x16\x85R`\xA1\x84R\x86\x85 \x90\x88\x16\x85R\x90\x92R\x93\x82 \x92\x93\x92\x81\x90a3\xBA\x90aA\x9BV[`\x01`\x01`@\x1B\x03\x90\x81\x16\x82R`\x01`\x01`\xA0\x1B\x03\x89\x81\x16_\x81\x81R`\xA2` \x90\x81R`@\x80\x83 \x94\x8C\x16\x80\x84R\x94\x82R\x80\x83 T\x86\x16\x96\x82\x01\x96\x90\x96R\x91\x81R`\xA0\x82R\x84\x81 \x8B\x82R\x82R\x84\x81 \x92\x81R\x91\x81R\x90\x83\x90 \x83Q``\x81\x01\x85R\x90T\x92\x83\x16\x81R`\x01`@\x1B\x83\x04`\x0F\x0B\x91\x81\x01\x91\x90\x91R`\x01`\xC0\x1B\x90\x91\x04c\xFF\xFF\xFF\xFF\x16\x91\x81\x01\x82\x90R\x91\x92PC\x10\x15a4\\W\x90\x92P\x90Pa4\xBEV[a4m\x81_\x01Q\x82` \x01Qa9/V[`\x01`\x01`@\x1B\x03\x16\x81R` \x81\x01Q_`\x0F\x91\x90\x91\x0B\x12\x15a4\xABWa4\x9C\x82` \x01Q\x82` \x01Qa9/V[`\x01`\x01`@\x1B\x03\x16` \x83\x01R[_`@\x82\x01\x81\x90R` \x82\x01R\x90\x92P\x90P[\x93P\x93\x91PPV[`f\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[_a\x08=\x82T\x90V[_a\x07\xC1\x83\x83aA\xAEV[_\x81\x81R`\x01\x83\x01` R`@\x81 T\x15\x15a\x07\xC1V[`@Qc\x1B\xEB+\x97`\xE3\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x81\x16`\x04\x83\x01R3`$\x83\x01R0`D\x83\x01R_\x805`\x01`\x01`\xE0\x1B\x03\x19\x16`d\x84\x01R\x91\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\x90\x91\x16\x90c\xDFY\\\xB8\x90`\x84\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a5\xB4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08=\x91\x90aUsV[_a\x07\xC1\x83\x83aA\xD4V[_a\x07\xC1\x83`\x01`\x01`\xA0\x1B\x03\x84\x16aA\xD4V[``\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a6\x12Wa6\x12aItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a6EW\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a60W\x90P[P\x90P_\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\xF0\xE0\xE6v\x86\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a6\x97\x92\x91\x90aY}V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a6\xB1W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra6\xD8\x91\x90\x81\x01\x90aY\xA1V[\x90P_[\x85Q\x81\x10\x15a8\xDAW_\x86\x82\x81Q\x81\x10a6\xF8Wa6\xF8aU\x92V[` \x02` \x01\x01Q\x90P\x85Q`\x01`\x01`@\x1B\x03\x81\x11\x15a7\x1BWa7\x1BaItV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a7DW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x84\x83\x81Q\x81\x10a7WWa7WaU\x92V[` \x90\x81\x02\x91\x90\x91\x01\x01R_[\x86Q\x81\x10\x15a8\xD0W_\x87\x82\x81Q\x81\x10a7\x80Wa7\x80aU\x92V[` \x90\x81\x02\x91\x90\x91\x01\x81\x01Q`\x01`\x01`\xA0\x1B\x03\x80\x86\x16_\x90\x81R`\xA1\x84R`@\x80\x82 \x92\x84\x16\x82R\x91\x90\x93R\x82 \x90\x92Pa7\xBB\x90aA\x9BV[\x90P\x80`\x01`\x01`@\x1B\x03\x16_\x03a7\xD4WPPa8\xC8V[_a7\xE0\x85\x8D\x85a\x07\x8DV[\x90P\x88c\xFF\xFF\xFF\xFF\x16\x81`@\x01Qc\xFF\xFF\xFF\xFF\x16\x11\x15\x80\x15a8\x08WP_\x81` \x01Q`\x0F\x0B\x12[\x15a8*Wa8\x1E\x81_\x01Q\x82` \x01Qa9/V[`\x01`\x01`@\x1B\x03\x16\x81R[\x80Q_\x90a8E\x90`\x01`\x01`@\x1B\x03\x90\x81\x16\x90\x85\x16a9\x1BV[\x90Pa8\x8C\x81\x89\x89\x81Q\x81\x10a8]Wa8]aU\x92V[` \x02` \x01\x01Q\x87\x81Q\x81\x10a8vWa8vaU\x92V[` \x02` \x01\x01QaB \x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x89\x88\x81Q\x81\x10a8\x9EWa8\x9EaU\x92V[` \x02` \x01\x01Q\x86\x81Q\x81\x10a8\xB7Wa8\xB7aU\x92V[` \x02` \x01\x01\x81\x81RPPPPPP[`\x01\x01a7dV[PP`\x01\x01a6\xDCV[PP\x94\x93PPPPV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x01\x83\x01` R`@\x81 T\x15\x15a\x07\xC1V[_a\x07\xC1\x83\x83g\r\xE0\xB6\xB3\xA7d\0\0`\x01aB4V[_a\x07\xC1\x83g\r\xE0\xB6\xB3\xA7d\0\0\x84aB\x8DV[_a\x07\xC1a9F\x83`\x01`\x01`@\x1B\x03\x86\x16aV\xC0V[`\x0F\x0BaCrV[` \x80\x83\x01Q`\x01`\x01`\xA0\x1B\x03\x80\x88\x16_\x90\x81R`\xA2\x84R`@\x80\x82 \x92\x88\x16\x82R\x91\x90\x93R\x90\x91 T`\x01`\x01`@\x1B\x03\x90\x81\x16\x91\x16\x14a:\x14W` \x82\x81\x01\x80Q`\x01`\x01`\xA0\x1B\x03\x88\x81\x16_\x81\x81R`\xA2\x86R`@\x80\x82 \x93\x8A\x16\x80\x83R\x93\x87R\x90\x81\x90 \x80Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\x01`\x01`@\x1B\x03\x95\x86\x16\x17\x90U\x93Q\x84Q\x91\x82R\x94\x81\x01\x91\x90\x91R\x92\x16\x90\x82\x01R\x7F\xAC\xF9\t_\xEB:7\x0C\x9C\xF6\x92B\x1Ci\xEF2\rM\xB5\xC6nj})\xC7iN\xB0#d\xFCU\x90``\x01`@Q\x80\x91\x03\x90\xA1[`\x01`\x01`\xA0\x1B\x03\x80\x86\x16_\x90\x81R`\xA0` \x90\x81R`@\x80\x83 \x88\x84R\x82R\x80\x83 \x93\x87\x16\x83R\x92\x81R\x90\x82\x90 \x83Q\x81T\x92\x85\x01Q\x93\x85\x01Qc\xFF\xFF\xFF\xFF\x16`\x01`\xC0\x1B\x02c\xFF\xFF\xFF\xFF`\xC0\x1B\x19`\x01`\x01`\x80\x1B\x03\x86\x16`\x01`@\x1B\x02`\x01`\x01`\xC0\x1B\x03\x19\x90\x95\x16`\x01`\x01`@\x1B\x03\x90\x93\x16\x92\x90\x92\x17\x93\x90\x93\x17\x16\x91\x90\x91\x17\x90U`\x0F\x0B\x15a:\xF6W`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x9F` \x90\x81R`@\x80\x83 \x87\x84R\x90\x91R\x90 a:\xCE\x90\x84a5\xE3V[P`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x9D` R`@\x90 a:\xF0\x90\x85a5\xD8V[Pa\r4V[\x80Q`\x01`\x01`@\x1B\x03\x16_\x03a\r4W`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x9F` \x90\x81R`@\x80\x83 \x87\x84R\x90\x91R\x90 a;3\x90\x84a@{V[P`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x9F` \x90\x81R`@\x80\x83 \x87\x84R\x90\x91R\x90 a;_\x90a5\x03V[_\x03a\r4W`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x9D` R`@\x90 a!\x13\x90\x85a@pV[`\x01`\x01`\xA0\x1B\x03\x80\x84\x16_\x90\x81R`\xA1` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R a;\xB5\x90C\x83aC\xDDV[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x80\x86\x16\x82R\x84\x16` \x82\x01R`\x01`\x01`@\x1B\x03\x83\x16\x91\x81\x01\x91\x90\x91R\x7F\x1CdX\x07\x9AA\x07}\0<\x11\xFA\xF9\xBF\t~i;\xD6yy\xE4\xE6P\x0B\xAC{)\xDBw\x9B\\\x90``\x01a0*V[``_a\x07\xC1\x83aC\xF1V[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\xA3` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R\x90\x81 T`\x0F\x81\x81\x0B`\x01`\x80\x1B\x90\x92\x04\x90\x0B\x03[_\x81\x11\x80\x15a<^WP\x82a\xFF\xFF\x16\x82\x10[\x15a\r4W`\x01`\x01`\xA0\x1B\x03\x80\x86\x16_\x90\x81R`\xA3` \x90\x81R`@\x80\x83 \x93\x88\x16\x83R\x92\x90R\x90\x81 a<\x92\x90aDJV[\x90P__a<\xA1\x88\x84\x89a3ZV[\x91P\x91P\x80`@\x01Qc\xFF\xFF\xFF\xFF\x16C\x10\x15a<\xBFWPPPa\r4V[a<\xCC\x88\x84\x89\x85\x85a9NV[`\x01`\x01`\xA0\x1B\x03\x80\x89\x16_\x90\x81R`\xA3` \x90\x81R`@\x80\x83 \x93\x8B\x16\x83R\x92\x90R a<\xF9\x90aD\x9CV[Pa=\x03\x85aZ\xADV[\x94Pa=\x0E\x84aZ\xC5V[\x93PPPPa<LV[``_a=$\x83aE\x19V[`@\x80Q` \x80\x82R\x81\x83\x01\x90\x92R\x91\x92P_\x91\x90` \x82\x01\x81\x806\x837PPP\x91\x82RP` \x81\x01\x92\x90\x92RP\x90V[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x9B` \x90\x81R`@\x91\x82\x90 \x82Q`\x80\x81\x01\x84R\x90Tc\xFF\xFF\xFF\xFF\x80\x82\x16\x83R`\xFF`\x01` \x1B\x83\x04\x16\x15\x15\x93\x83\x01\x93\x90\x93Re\x01\0\0\0\0\0\x81\x04\x83\x16\x93\x82\x01\x93\x90\x93R`\x01`H\x1B\x90\x92\x04\x16``\x82\x01\x81\x90R\x15\x80\x15\x90a=\xD1WP\x80``\x01Qc\xFF\xFF\xFF\xFF\x16C\x10\x15[\x15a=\xEBW`@\x81\x01Qc\xFF\xFF\xFF\xFF\x16\x81R`\x01` \x82\x01R[c\xFF\xFF\xFF\xFF\x82\x16`@\x82\x01Ra>!\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\0CaX_V[a>,\x90`\x01aX_V[c\xFF\xFF\xFF\xFF\x90\x81\x16``\x83\x81\x01\x91\x82R`\x01`\x01`\xA0\x1B\x03\x86\x16_\x81\x81R`\x9B` \x90\x81R`@\x91\x82\x90 \x87Q\x81T\x83\x8A\x01Q\x85\x8B\x01Q\x98Q\x92\x8A\x16d\xFF\xFF\xFF\xFF\xFF\x19\x90\x92\x16\x91\x90\x91\x17`\x01` \x1B\x91\x15\x15\x91\x90\x91\x02\x17l\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\x19\x16e\x01\0\0\0\0\0\x97\x89\x16\x97\x90\x97\x02l\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\x19\x16\x96\x90\x96\x17`\x01`H\x1B\x96\x88\x16\x96\x87\x02\x17\x90U\x81Q\x92\x83R\x94\x87\x16\x94\x82\x01\x94\x90\x94R\x92\x83\x01\x91\x90\x91R\x7FN\x85u\x1Dc1Pllb3_ ~\xB3\x1F\x12\xA6\x1EW\x0F4\xF5\xC1v@0\x87\x85\xC6\xD4\xDB\x91\x01a0*V[`\x01`\x01`\xA0\x1B\x03\x82\x81\x16_\x81\x81R`\xA2` \x90\x81R`@\x80\x83 \x94\x86\x16\x80\x84R\x94\x82R\x80\x83 T\x93\x83R`\xA3\x82R\x80\x83 \x94\x83R\x93\x90R\x91\x82 T`\x01`\x01`@\x1B\x03\x90\x91\x16\x91\x90`\x0F\x81\x81\x0B`\x01`\x80\x1B\x90\x92\x04\x90\x0B\x03\x81[\x81\x81\x10\x15a@,W`\x01`\x01`\xA0\x1B\x03\x80\x87\x16_\x90\x81R`\xA3` \x90\x81R`@\x80\x83 \x93\x89\x16\x83R\x92\x90R\x90\x81 a?\x94\x90\x83aE@V[`\x01`\x01`\xA0\x1B\x03\x88\x81\x16_\x90\x81R`\xA0` \x90\x81R`@\x80\x83 \x85\x84R\x82R\x80\x83 \x93\x8B\x16\x83R\x92\x81R\x90\x82\x90 \x82Q``\x81\x01\x84R\x90T`\x01`\x01`@\x1B\x03\x81\x16\x82R`\x01`@\x1B\x81\x04`\x0F\x0B\x92\x82\x01\x92\x90\x92R`\x01`\xC0\x1B\x90\x91\x04c\xFF\xFF\xFF\xFF\x16\x91\x81\x01\x82\x90R\x91\x92PC\x10\x15a@\x0FWPPa@,V[a@\x1D\x86\x82` \x01Qa9/V[\x95PPP\x80`\x01\x01\x90Pa?\\V[P`\x01`\x01`\xA0\x1B\x03\x80\x86\x16_\x90\x81R`\xA1` \x90\x81R`@\x80\x83 \x93\x88\x16\x83R\x92\x90R \x83\x90a@\\\x90aA\x9BV[a@f\x91\x90aV}V[\x91PP\x92P\x92\x90PV[_a\x07\xC1\x83\x83aE\xAFV[_a\x07\xC1\x83`\x01`\x01`\xA0\x1B\x03\x84\x16aE\xAFV[`3T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x1D\x12W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a/\xB1V[`3\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[_a\x07\xC1\x83\x83g\r\xE0\xB6\xB3\xA7d\0\0aF\x92V[_aA_\x84`\x99_a\x112\x89a2\xF7V[\x80\x15aAhWP\x81[\x80\x15a\x1D1WPP\x90Q`\x01`\x01`@\x1B\x03\x16\x15\x15\x93\x92PPPV[_a\x07\xC1`\x01`\x01`@\x1B\x03\x80\x85\x16\x90\x84\x16aZ\xDAV[_a\x08=\x82g\r\xE0\xB6\xB3\xA7d\0\0aF\xE7V[_\x82_\x01\x82\x81T\x81\x10aA\xC3WaA\xC3aU\x92V[\x90_R` _ \x01T\x90P\x92\x91PPV[_\x81\x81R`\x01\x83\x01` R`@\x81 TaB\x19WP\x81T`\x01\x81\x81\x01\x84U_\x84\x81R` \x80\x82 \x90\x93\x01\x84\x90U\x84T\x84\x82R\x82\x86\x01\x90\x93R`@\x90 \x91\x90\x91Ua\x08=V[P_a\x08=V[_a\x07\xC1\x83\x83g\r\xE0\xB6\xB3\xA7d\0\0aB\x8DV[__aBA\x86\x86\x86aB\x8DV[\x90P`\x01\x83`\x02\x81\x11\x15aBWWaBWa[\x07V[\x14\x80\x15aBsWP_\x84\x80aBnWaBna[\x1BV[\x86\x88\t\x11[\x15a\x1D1WaB\x83`\x01\x82a[/V[\x96\x95PPPPPPV[_\x80\x80_\x19\x85\x87\t\x85\x87\x02\x92P\x82\x81\x10\x83\x82\x03\x03\x91PP\x80_\x03aB\xC4W\x83\x82\x81aB\xBAWaB\xBAa[\x1BV[\x04\x92PPPa\x07\xC1V[\x80\x84\x11aC\x0BW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x15`$\x82\x01RtMath: mulDiv overflow`X\x1B`D\x82\x01R`d\x01a/\xB1V[_\x84\x86\x88\t`\x02`\x01\x87\x19\x81\x01\x88\x16\x97\x88\x90\x04`\x03\x81\x02\x83\x18\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x90\x81\x02\x90\x92\x03\x90\x91\x02_\x88\x90\x03\x88\x90\x04\x90\x91\x01\x85\x83\x11\x90\x94\x03\x93\x90\x93\x02\x93\x03\x94\x90\x94\x04\x91\x90\x91\x17\x02\x94\x93PPPPV[_`\x01`\x01`@\x1B\x03\x82\x11\x15aC\xD9W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FSafeCast: value doesn't fit in 6`D\x82\x01Re4 bits`\xD0\x1B`d\x82\x01R`\x84\x01a/\xB1V[P\x90V[a03\x83\x83`\x01`\x01`@\x1B\x03\x84\x16aG\x1EV[``\x81_\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15aD>W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T\x81R` \x01\x90`\x01\x01\x90\x80\x83\x11aD*W[PPPPP\x90P\x91\x90PV[_aDd\x82T`\x0F\x81\x81\x0B`\x01`\x80\x1B\x90\x92\x04\x90\x0B\x13\x15\x90V[\x15aD\x82W`@Qc\x1E\xD9P\x95`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P\x80T`\x0F\x0B_\x90\x81R`\x01\x90\x91\x01` R`@\x90 T\x90V[_aD\xB6\x82T`\x0F\x81\x81\x0B`\x01`\x80\x1B\x90\x92\x04\x90\x0B\x13\x15\x90V[\x15aD\xD4W`@Qc\x1E\xD9P\x95`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P\x80T`\x0F\x0B_\x81\x81R`\x01\x80\x84\x01` R`@\x82 \x80T\x92\x90U\x83To\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x92\x01`\x01`\x01`\x80\x1B\x03\x16\x91\x90\x91\x17\x90\x91U\x90V[_`\xFF\x82\x16`\x1F\x81\x11\x15a\x08=W`@Qc,\xD4J\xC3`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[__aEbaEN\x84aH!V[\x85TaE]\x91\x90`\x0F\x0Ba[BV[aH\x8AV[\x84T\x90\x91P`\x01`\x80\x1B\x90\x04`\x0F\x90\x81\x0B\x90\x82\x90\x0B\x12aE\x95W`@Qc-\x04\x83\xC5`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x0F\x0B_\x90\x81R`\x01\x93\x90\x93\x01` RPP`@\x90 T\x90V[_\x81\x81R`\x01\x83\x01` R`@\x81 T\x80\x15aF\x89W_aE\xD1`\x01\x83aVjV[\x85T\x90\x91P_\x90aE\xE4\x90`\x01\x90aVjV[\x90P\x81\x81\x14aFCW_\x86_\x01\x82\x81T\x81\x10aF\x02WaF\x02aU\x92V[\x90_R` _ \x01T\x90P\x80\x87_\x01\x84\x81T\x81\x10aF\"WaF\"aU\x92V[_\x91\x82R` \x80\x83 \x90\x91\x01\x92\x90\x92U\x91\x82R`\x01\x88\x01\x90R`@\x90 \x83\x90U[\x85T\x86\x90\x80aFTWaFTa[iV[`\x01\x90\x03\x81\x81\x90_R` _ \x01_\x90U\x90U\x85`\x01\x01_\x86\x81R` \x01\x90\x81R` \x01_ _\x90U`\x01\x93PPPPa\x08=V[_\x91PPa\x08=V[\x82T_\x90\x81aF\xA3\x86\x86\x83\x85aH\xF3V[\x90P\x80\x15aF\xDDWaF\xC7\x86aF\xBA`\x01\x84aVjV[_\x91\x82R` \x90\x91 \x01\x90V[T`\x01` \x1B\x90\x04`\x01`\x01`\xE0\x1B\x03\x16a\x07\xBCV[P\x91\x94\x93PPPPV[\x81T_\x90\x80\x15aG\x16WaG\0\x84aF\xBA`\x01\x84aVjV[T`\x01` \x1B\x90\x04`\x01`\x01`\xE0\x1B\x03\x16a\x089V[P\x90\x92\x91PPV[\x82T\x80\x15aG\xD4W_aG6\x85aF\xBA`\x01\x85aVjV[`@\x80Q\x80\x82\x01\x90\x91R\x90Tc\xFF\xFF\xFF\xFF\x80\x82\x16\x80\x84R`\x01` \x1B\x90\x92\x04`\x01`\x01`\xE0\x1B\x03\x16` \x84\x01R\x91\x92P\x90\x85\x16\x10\x15aG\x88W`@Qc\x15\x1B\x8E?`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80Qc\xFF\xFF\xFF\xFF\x80\x86\x16\x91\x16\x03aG\xD2W\x82aG\xA9\x86aF\xBA`\x01\x86aVjV[\x80T`\x01`\x01`\xE0\x1B\x03\x92\x90\x92\x16`\x01` \x1B\x02c\xFF\xFF\xFF\xFF\x90\x92\x16\x91\x90\x91\x17\x90UPPPPPV[P[P`@\x80Q\x80\x82\x01\x90\x91Rc\xFF\xFF\xFF\xFF\x92\x83\x16\x81R`\x01`\x01`\xE0\x1B\x03\x91\x82\x16` \x80\x83\x01\x91\x82R\x85T`\x01\x81\x01\x87U_\x96\x87R\x95 \x91Q\x90Q\x90\x92\x16`\x01` \x1B\x02\x91\x90\x92\x16\x17\x91\x01UV[_`\x01`\x01`\xFF\x1B\x03\x82\x11\x15aC\xD9W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FSafeCast: value doesn't fit in a`D\x82\x01Rg7\x104\xB7:\x19\x1A\x9B`\xC1\x1B`d\x82\x01R`\x84\x01a/\xB1V[\x80`\x0F\x81\x90\x0B\x81\x14aH\xEEW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FSafeCast: value doesn't fit in 1`D\x82\x01Rf28 bits`\xC8\x1B`d\x82\x01R`\x84\x01a/\xB1V[\x91\x90PV[_[\x81\x83\x10\x15a\n'W_aI\x08\x84\x84aIFV[_\x87\x81R` \x90 \x90\x91Pc\xFF\xFF\xFF\xFF\x86\x16\x90\x82\x01Tc\xFF\xFF\xFF\xFF\x16\x11\x15aI2W\x80\x92PaI@V[aI=\x81`\x01a[/V[\x93P[PaH\xF5V[_aIT`\x02\x84\x84\x18a[}V[a\x07\xC1\x90\x84\x84\x16a[/V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a1\xD2W__\xFD[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@Q``\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15aI\xAAWaI\xAAaItV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15aI\xD8WaI\xD8aItV[`@R\x91\x90PV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14aH\xEEW__\xFD[_`@\x82\x84\x03\x12\x15aJ\x03W__\xFD[`@\x80Q\x90\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15aJ%WaJ%aItV[`@R\x90P\x80\x825aJ6\x81aI`V[\x81RaJD` \x84\x01aI\xE0V[` \x82\x01RP\x92\x91PPV[___`\x80\x84\x86\x03\x12\x15aJbW__\xFD[\x835aJm\x81aI`V[\x92PaJ|\x85` \x86\x01aI\xF3V[\x91P``\x84\x015aJ\x8C\x81aI`V[\x80\x91PP\x92P\x92P\x92V[\x81Q`\x01`\x01`@\x1B\x03\x16\x81R` \x80\x83\x01Q`\x0F\x0B\x90\x82\x01R`@\x80\x83\x01Qc\xFF\xFF\xFF\xFF\x16\x90\x82\x01R``\x81\x01a\x08=V[__``\x83\x85\x03\x12\x15aJ\xDBW__\xFD[\x825aJ\xE6\x81aI`V[\x91PaJ\xF5\x84` \x85\x01aI\xF3V[\x90P\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15aK\x0EW__\xFD[P5\x91\x90PV[_` \x82\x84\x03\x12\x15aK%W__\xFD[\x815a\x07\xC1\x81aI`V[\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x82R` \x90\x81\x01Qc\xFF\xFF\xFF\xFF\x16\x91\x01RV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15aK\x89WaKs\x86\x83QaK0V[`@\x95\x90\x95\x01\x94` \x91\x90\x91\x01\x90`\x01\x01aK`V[P\x93\x94\x93PPPPV[` \x81R_a\x07\xC1` \x83\x01\x84aKNV[_`@\x82\x84\x03\x12\x15aK\xB5W__\xFD[a\x07\xC1\x83\x83aI\xF3V[__\x83`\x1F\x84\x01\x12aK\xCFW__\xFD[P\x815`\x01`\x01`@\x1B\x03\x81\x11\x15aK\xE5W__\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a\x17\x9DW__\xFD[___`@\x84\x86\x03\x12\x15aL\x11W__\xFD[\x835aL\x1C\x81aI`V[\x92P` \x84\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aL6W__\xFD[aLB\x86\x82\x87\x01aK\xBFV[\x94\x97\x90\x96P\x93\x94PPPPV[_`\x01`\x01`@\x1B\x03\x82\x11\x15aLgWaLgaItV[P`\x05\x1B` \x01\x90V[_\x82`\x1F\x83\x01\x12aL\x80W__\xFD[\x815aL\x93aL\x8E\x82aLOV[aI\xB0V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x86\x01\x01\x92P\x85\x83\x11\x15aL\xB4W__\xFD[` \x85\x01[\x83\x81\x10\x15aL\xDAW\x805aL\xCC\x81aI`V[\x83R` \x92\x83\x01\x92\x01aL\xB9V[P\x95\x94PPPPPV[___`\x80\x84\x86\x03\x12\x15aL\xF6W__\xFD[aM\0\x85\x85aI\xF3V[\x92P`@\x84\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aM\x1AW__\xFD[aM&\x86\x82\x87\x01aLqV[\x92PP``\x84\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aMAW__\xFD[aMM\x86\x82\x87\x01aLqV[\x91PP\x92P\x92P\x92V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15aK\x89W\x81Q\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01aMiV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15aM\xDEW`?\x19\x87\x86\x03\x01\x84RaM\xC9\x85\x83QaMWV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01aM\xADV[P\x92\x96\x95PPPPPPV[____`\xA0\x85\x87\x03\x12\x15aM\xFDW__\xFD[aN\x07\x86\x86aI\xF3V[\x93P`@\x85\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aN!W__\xFD[aN-\x87\x82\x88\x01aLqV[\x93PP``\x85\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aNHW__\xFD[aNT\x87\x82\x88\x01aLqV[\x92PPaNc`\x80\x86\x01aI\xE0V[\x90P\x92\x95\x91\x94P\x92PV[__`@\x83\x85\x03\x12\x15aN\x7FW__\xFD[\x825aN\x8A\x81aI`V[\x91P` \x83\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aN\xA4W__\xFD[\x83\x01`\xA0\x81\x86\x03\x12\x15aN\xB5W__\xFD[\x80\x91PP\x92P\x92\x90PV[__`@\x83\x85\x03\x12\x15aN\xD1W__\xFD[\x825aN\xDC\x81aI`V[\x91P` \x83\x015aN\xB5\x81aI`V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15aK\x89WaO7\x86\x83Q\x80Q`\x01`\x01`@\x1B\x03\x16\x82R` \x80\x82\x01Q`\x0F\x0B\x90\x83\x01R`@\x90\x81\x01Qc\xFF\xFF\xFF\xFF\x16\x91\x01RV[``\x95\x90\x95\x01\x94` \x91\x90\x91\x01\x90`\x01\x01aN\xFEV[`@\x81R_aO_`@\x83\x01\x85aKNV[\x82\x81\x03` \x84\x01Ra\x1D1\x81\x85aN\xECV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15aK\x89W\x81Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01aO\x83V[` \x81R_a\x07\xC1` \x83\x01\x84aOqV[__`@\x83\x85\x03\x12\x15aO\xCDW__\xFD[\x825`\x01`\x01`@\x1B\x03\x81\x11\x15aO\xE2W__\xFD[aO\xEE\x85\x82\x86\x01aLqV[\x92PP` \x83\x015aN\xB5\x81aI`V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15aP?W\x83Q`\x01`\x01`@\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01aP\x18V[P\x90\x95\x94PPPPPV[_____``\x86\x88\x03\x12\x15aP^W__\xFD[\x855aPi\x81aI`V[\x94P` \x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aP\x83W__\xFD[aP\x8F\x88\x82\x89\x01aK\xBFV[\x90\x95P\x93PP`@\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aP\xADW__\xFD[aP\xB9\x88\x82\x89\x01aK\xBFV[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[____``\x85\x87\x03\x12\x15aP\xDDW__\xFD[\x845aP\xE8\x81aI`V[\x93PaP\xF6` \x86\x01aI\xE0V[\x92P`@\x85\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aQ\x10W__\xFD[aQ\x1C\x87\x82\x88\x01aK\xBFV[\x95\x98\x94\x97P\x95PPPPV[__`@\x83\x85\x03\x12\x15aQ9W__\xFD[\x825aQD\x81aI`V[\x91P` \x83\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aQ^W__\xFD[a@f\x85\x82\x86\x01aLqV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[__`@\x83\x85\x03\x12\x15aQ\xB0W__\xFD[\x825aQ\xBB\x81aI`V[\x91PaJ\xF5` \x84\x01aI\xE0V[_` \x82\x84\x03\x12\x15aQ\xD9W__\xFD[\x815`\xFF\x81\x16\x81\x14a\x07\xC1W__\xFD[_``\x82\x84\x03\x12\x15aQ\xF9W__\xFD[P\x91\x90PV[_` \x82\x84\x03\x12\x15aR\x0FW__\xFD[\x815`\x01`\x01`@\x1B\x03\x81\x11\x15aR$W__\xFD[a\x089\x84\x82\x85\x01aQ\xE9V[___`\x80\x84\x86\x03\x12\x15aRBW__\xFD[\x835`\x01`\x01`@\x1B\x03\x81\x11\x15aRWW__\xFD[aRc\x86\x82\x87\x01aLqV[\x93PPaJ|\x85` \x86\x01aI\xF3V[` \x81R_a\x07\xC1` \x83\x01\x84aN\xECV[___``\x84\x86\x03\x12\x15aR\x97W__\xFD[\x835aR\xA2\x81aI`V[\x92P` \x84\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aR\xBCW__\xFD[aR\xC8\x86\x82\x87\x01aLqV[\x92PPaR\xD7`@\x85\x01aI\xE0V[\x90P\x92P\x92P\x92V[__`@\x83\x85\x03\x12\x15aR\xF1W__\xFD[\x825aR\xFC\x81aI`V[\x91P` \x83\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aS\x16W__\xFD[\x83\x01`\x1F\x81\x01\x85\x13aS&W__\xFD[\x805aS4aL\x8E\x82aLOV[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x85\x01\x01\x92P\x87\x83\x11\x15aSUW__\xFD[` \x84\x01[\x83\x81\x10\x15aTzW\x805`\x01`\x01`@\x1B\x03\x81\x11\x15aSwW__\xFD[\x85\x01`\x80\x81\x8B\x03`\x1F\x19\x01\x12\x15aS\x8CW__\xFD[aS\x94aI\x88V[aS\xA1\x8B` \x84\x01aI\xF3V[\x81R``\x82\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aS\xBBW__\xFD[aS\xCA\x8C` \x83\x86\x01\x01aLqV[` \x83\x01RP`\x80\x82\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aS\xE8W__\xFD[` \x81\x84\x01\x01\x92PP\x8A`\x1F\x83\x01\x12aS\xFFW__\xFD[\x815aT\raL\x8E\x82aLOV[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x86\x01\x01\x92P\x8D\x83\x11\x15aT.W__\xFD[` \x85\x01\x94P[\x82\x85\x10\x15aTdW\x845`\x01`\x01`@\x1B\x03\x81\x16\x81\x14aTSW__\xFD[\x82R` \x94\x85\x01\x94\x90\x91\x01\x90aT5V[`@\x84\x01RPP\x84RP` \x92\x83\x01\x92\x01aSZV[P\x80\x94PPPPP\x92P\x92\x90PV[___`@\x84\x86\x03\x12\x15aT\x9BW__\xFD[\x835aT\xA6\x81aI`V[\x92P` \x84\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aT\xC0W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13aT\xD0W__\xFD[\x805`\x01`\x01`@\x1B\x03\x81\x11\x15aT\xE5W__\xFD[\x86` \x82\x84\x01\x01\x11\x15aT\xF6W__\xFD[\x93\x96` \x91\x90\x91\x01\x95P\x92\x93PPPV[__`@\x83\x85\x03\x12\x15aU\x18W__\xFD[\x825aU#\x81aI`V[\x91P` \x83\x015`\x01`\x01`@\x1B\x03\x81\x11\x15aU=W__\xFD[a@f\x85\x82\x86\x01aQ\xE9V[__`@\x83\x85\x03\x12\x15aUZW__\xFD[\x825aUe\x81aI`V[\x94` \x93\x90\x93\x015\x93PPPV[_` \x82\x84\x03\x12\x15aU\x83W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\xC1W__\xFD[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[_\x825`>\x19\x836\x03\x01\x81\x12aU\xBAW__\xFD[\x91\x90\x91\x01\x92\x91PPV[_` \x82\x84\x03\x12\x15aU\xD4W__\xFD[a\x07\xC1\x82aI\xE0V[`@\x81\x01a\x08=\x82\x84aK0V[__\x835`\x1E\x19\x846\x03\x01\x81\x12aV\0W__\xFD[\x83\x01\x805\x91P`\x01`\x01`@\x1B\x03\x82\x11\x15aV\x19W__\xFD[` \x01\x91P`\x05\x81\x90\x1B6\x03\x82\x13\x15a\x17\x9DW__\xFD[``\x81\x01aV>\x82\x85aK0V[`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16`@\x91\x90\x91\x01R\x91\x90PV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x08=Wa\x08=aVVV[`\x01`\x01`@\x1B\x03\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x08=Wa\x08=aVVV[_\x81`\x0F\x0B`\x01`\x01`\x7F\x1B\x03\x19\x81\x03aV\xB8WaV\xB8aVVV[_\x03\x92\x91PPV[`\x0F\x81\x81\x0B\x90\x83\x90\x0B\x01`\x01`\x01`\x7F\x1B\x03\x81\x13`\x01`\x01`\x7F\x1B\x03\x19\x82\x12\x17\x15a\x08=Wa\x08=aVVV[`\x01`\x01`\xA0\x1B\x03\x86\x16\x81R`\xC0\x81\x01aW\n` \x83\x01\x87aK0V[`\x01`\x01`\xA0\x1B\x03\x94\x90\x94\x16``\x82\x01R`\x01`\x01`@\x1B\x03\x92\x90\x92\x16`\x80\x83\x01Rc\xFF\xFF\xFF\xFF\x16`\xA0\x90\x91\x01R\x92\x91PPV[__\x835`\x1E\x19\x846\x03\x01\x81\x12aWSW__\xFD[\x83\x01\x805\x91P`\x01`\x01`@\x1B\x03\x82\x11\x15aWlW__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\x17\x9DW__\xFD[\x81\x83R\x81\x81` \x85\x017P_\x82\x82\x01` \x90\x81\x01\x91\x90\x91R`\x1F\x90\x91\x01`\x1F\x19\x16\x90\x91\x01\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x88\x16\x81R_`\xC0\x82\x01aW\xC6` \x84\x01\x8AaK0V[`\xC0``\x84\x01R\x86\x90R\x86`\xE0\x83\x01_[\x88\x81\x10\x15aX\x07W\x825aW\xEA\x81aI`V[`\x01`\x01`\xA0\x1B\x03\x16\x82R` \x92\x83\x01\x92\x90\x91\x01\x90`\x01\x01aW\xD7V[P\x83\x81\x03`\x80\x85\x01RaX\x1A\x81\x88aMWV[\x91PP\x82\x81\x03`\xA0\x84\x01RaX0\x81\x85\x87aW\x80V[\x9A\x99PPPPPPPPPPV[_` \x82\x84\x03\x12\x15aXNW__\xFD[\x815a\xFF\xFF\x81\x16\x81\x14a\x07\xC1W__\xFD[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x08=Wa\x08=aVVV[\x81\x83R` \x83\x01\x92P_\x81_[\x84\x81\x10\x15aK\x89Wc\xFF\xFF\xFF\xFFaX\x9E\x83aI\xE0V[\x16\x86R` \x95\x86\x01\x95\x91\x90\x91\x01\x90`\x01\x01aX\x88V[`\x01`\x01`\xA0\x1B\x03\x85\x81\x16\x82R\x84\x16` \x82\x01R```@\x82\x01\x81\x90R_\x90aB\x83\x90\x83\x01\x84\x86aX{V[` \x81R_a\rI` \x83\x01\x84\x86aW\x80V[`\x01`\x01`\xA0\x1B\x03\x87\x81\x16\x82R\x86\x16` \x82\x01R`\x80`@\x82\x01\x81\x90R_\x90aY\x1F\x90\x83\x01\x86\x88aX{V[\x82\x81\x03``\x84\x01RaY2\x81\x85\x87aW\x80V[\x99\x98PPPPPPPPPV[_` \x82\x84\x03\x12\x15aYOW__\xFD[\x81Qa\x07\xC1\x81aI`V[\x80Q` \x80\x83\x01Q\x91\x90\x81\x10\x15aQ\xF9W_\x19` \x91\x90\x91\x03`\x03\x1B\x1B\x16\x91\x90PV[`@\x81R_aY\x8F`@\x83\x01\x85aOqV[\x82\x81\x03` \x84\x01Ra\x1D1\x81\x85aOqV[_` \x82\x84\x03\x12\x15aY\xB1W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15aY\xC6W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13aY\xD6W__\xFD[\x80QaY\xE4aL\x8E\x82aLOV[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x85\x01\x01\x92P\x86\x83\x11\x15aZ\x05W__\xFD[` \x84\x01[\x83\x81\x10\x15aZ\xA2W\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15aZ'W__\xFD[\x85\x01`?\x81\x01\x89\x13aZ7W__\xFD[` \x81\x01QaZHaL\x8E\x82aLOV[\x80\x82\x82R` \x82\x01\x91P` \x80\x84`\x05\x1B\x86\x01\x01\x01\x92P\x8B\x83\x11\x15aZkW__\xFD[`@\x84\x01\x93P[\x82\x84\x10\x15aZ\x8DW\x83Q\x82R` \x93\x84\x01\x93\x90\x91\x01\x90aZrV[\x86RPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90PaZ\nV[P\x96\x95PPPPPPV[_`\x01\x82\x01aZ\xBEWaZ\xBEaVVV[P`\x01\x01\x90V[_\x81aZ\xD3WaZ\xD3aVVV[P_\x19\x01\x90V[`\x0F\x82\x81\x0B\x90\x82\x90\x0B\x03`\x01`\x01`\x7F\x1B\x03\x19\x81\x12`\x01`\x01`\x7F\x1B\x03\x82\x13\x17\x15a\x08=Wa\x08=aVVV[cNH{q`\xE0\x1B_R`!`\x04R`$_\xFD[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[\x80\x82\x01\x80\x82\x11\x15a\x08=Wa\x08=aVVV[\x80\x82\x01\x82\x81\x12_\x83\x12\x80\x15\x82\x16\x82\x15\x82\x16\x17\x15a[aWa[aaVVV[PP\x92\x91PPV[cNH{q`\xE0\x1B_R`1`\x04R`$_\xFD[_\x82a[\x97WcNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[P\x04\x90V\xFE\xA2dipfsX\"\x12 \x87^r\x97\xF92\x8Aoc/ QRu\xF1\x81\xF0i\xC1\xF3\x97\xBE\xFB\x91\xD9\x80\xA2\xBF\x16\x9FJ\x9FdsolcC\0\x08\x1B\x003",
3558    );
3559    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
3560    /**```solidity
3561    struct OperatorSet { address avs; uint32 id; }
3562    ```*/
3563    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3564    #[derive(Clone)]
3565    pub struct OperatorSet {
3566        #[allow(missing_docs)]
3567        pub avs: alloy::sol_types::private::Address,
3568        #[allow(missing_docs)]
3569        pub id: u32,
3570    }
3571    #[allow(
3572        non_camel_case_types,
3573        non_snake_case,
3574        clippy::pub_underscore_fields,
3575        clippy::style
3576    )]
3577    const _: () = {
3578        use alloy::sol_types as alloy_sol_types;
3579        #[doc(hidden)]
3580        type UnderlyingSolTuple<'a> = (
3581            alloy::sol_types::sol_data::Address,
3582            alloy::sol_types::sol_data::Uint<32>,
3583        );
3584        #[doc(hidden)]
3585        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address, u32);
3586        #[cfg(test)]
3587        #[allow(dead_code, unreachable_patterns)]
3588        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3589            match _t {
3590                alloy_sol_types::private::AssertTypeEq::<
3591                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3592                >(_) => {}
3593            }
3594        }
3595        #[automatically_derived]
3596        #[doc(hidden)]
3597        impl ::core::convert::From<OperatorSet> for UnderlyingRustTuple<'_> {
3598            fn from(value: OperatorSet) -> Self {
3599                (value.avs, value.id)
3600            }
3601        }
3602        #[automatically_derived]
3603        #[doc(hidden)]
3604        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorSet {
3605            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3606                Self {
3607                    avs: tuple.0,
3608                    id: tuple.1,
3609                }
3610            }
3611        }
3612        #[automatically_derived]
3613        impl alloy_sol_types::SolValue for OperatorSet {
3614            type SolType = Self;
3615        }
3616        #[automatically_derived]
3617        impl alloy_sol_types::private::SolTypeValue<Self> for OperatorSet {
3618            #[inline]
3619            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
3620                (
3621                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3622                        &self.avs,
3623                    ),
3624                    <alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
3625                        &self.id,
3626                    ),
3627                )
3628            }
3629            #[inline]
3630            fn stv_abi_encoded_size(&self) -> usize {
3631                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
3632                    return size;
3633                }
3634                let tuple =
3635                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
3636                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
3637            }
3638            #[inline]
3639            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
3640                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
3641            }
3642            #[inline]
3643            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
3644                let tuple =
3645                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
3646                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
3647                    &tuple, out,
3648                )
3649            }
3650            #[inline]
3651            fn stv_abi_packed_encoded_size(&self) -> usize {
3652                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
3653                    return size;
3654                }
3655                let tuple =
3656                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
3657                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
3658                    &tuple,
3659                )
3660            }
3661        }
3662        #[automatically_derived]
3663        impl alloy_sol_types::SolType for OperatorSet {
3664            type RustType = Self;
3665            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3666            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
3667            const ENCODED_SIZE: Option<usize> =
3668                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
3669            const PACKED_ENCODED_SIZE: Option<usize> =
3670                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
3671            #[inline]
3672            fn valid_token(token: &Self::Token<'_>) -> bool {
3673                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
3674            }
3675            #[inline]
3676            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
3677                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
3678                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
3679            }
3680        }
3681        #[automatically_derived]
3682        impl alloy_sol_types::SolStruct for OperatorSet {
3683            const NAME: &'static str = "OperatorSet";
3684            #[inline]
3685            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
3686                alloy_sol_types::private::Cow::Borrowed("OperatorSet(address avs,uint32 id)")
3687            }
3688            #[inline]
3689            fn eip712_components(
3690            ) -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
3691            {
3692                alloy_sol_types::private::Vec::new()
3693            }
3694            #[inline]
3695            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
3696                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
3697            }
3698            #[inline]
3699            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
3700                [
3701                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
3702                            &self.avs,
3703                        )
3704                        .0,
3705                    <alloy::sol_types::sol_data::Uint<
3706                        32,
3707                    > as alloy_sol_types::SolType>::eip712_data_word(&self.id)
3708                        .0,
3709                ]
3710                    .concat()
3711            }
3712        }
3713        #[automatically_derived]
3714        impl alloy_sol_types::EventTopic for OperatorSet {
3715            #[inline]
3716            fn topic_preimage_length(rust: &Self::RustType) -> usize {
3717                0usize
3718                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
3719                        &rust.avs,
3720                    )
3721                    + <alloy::sol_types::sol_data::Uint<
3722                        32,
3723                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.id)
3724            }
3725            #[inline]
3726            fn encode_topic_preimage(
3727                rust: &Self::RustType,
3728                out: &mut alloy_sol_types::private::Vec<u8>,
3729            ) {
3730                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
3731                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
3732                    &rust.avs,
3733                    out,
3734                );
3735                <alloy::sol_types::sol_data::Uint<
3736                    32,
3737                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.id, out);
3738            }
3739            #[inline]
3740            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
3741                let mut out = alloy_sol_types::private::Vec::new();
3742                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
3743                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
3744            }
3745        }
3746    };
3747    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
3748    /**Custom error with signature `AlreadyMemberOfSet()` and selector `0xd8d8dc4e`.
3749    ```solidity
3750    error AlreadyMemberOfSet();
3751    ```*/
3752    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3753    #[derive(Clone)]
3754    pub struct AlreadyMemberOfSet;
3755    #[allow(
3756        non_camel_case_types,
3757        non_snake_case,
3758        clippy::pub_underscore_fields,
3759        clippy::style
3760    )]
3761    const _: () = {
3762        use alloy::sol_types as alloy_sol_types;
3763        #[doc(hidden)]
3764        type UnderlyingSolTuple<'a> = ();
3765        #[doc(hidden)]
3766        type UnderlyingRustTuple<'a> = ();
3767        #[cfg(test)]
3768        #[allow(dead_code, unreachable_patterns)]
3769        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3770            match _t {
3771                alloy_sol_types::private::AssertTypeEq::<
3772                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3773                >(_) => {}
3774            }
3775        }
3776        #[automatically_derived]
3777        #[doc(hidden)]
3778        impl ::core::convert::From<AlreadyMemberOfSet> for UnderlyingRustTuple<'_> {
3779            fn from(value: AlreadyMemberOfSet) -> Self {
3780                ()
3781            }
3782        }
3783        #[automatically_derived]
3784        #[doc(hidden)]
3785        impl ::core::convert::From<UnderlyingRustTuple<'_>> for AlreadyMemberOfSet {
3786            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3787                Self
3788            }
3789        }
3790        #[automatically_derived]
3791        impl alloy_sol_types::SolError for AlreadyMemberOfSet {
3792            type Parameters<'a> = UnderlyingSolTuple<'a>;
3793            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3794            const SIGNATURE: &'static str = "AlreadyMemberOfSet()";
3795            const SELECTOR: [u8; 4] = [216u8, 216u8, 220u8, 78u8];
3796            #[inline]
3797            fn new<'a>(
3798                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3799            ) -> Self {
3800                tuple.into()
3801            }
3802            #[inline]
3803            fn tokenize(&self) -> Self::Token<'_> {
3804                ()
3805            }
3806            #[inline]
3807            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3808                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
3809                    data,
3810                )
3811                .map(Self::new)
3812            }
3813        }
3814    };
3815    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
3816    /**Custom error with signature `CurrentlyPaused()` and selector `0x840a48d5`.
3817    ```solidity
3818    error CurrentlyPaused();
3819    ```*/
3820    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3821    #[derive(Clone)]
3822    pub struct CurrentlyPaused;
3823    #[allow(
3824        non_camel_case_types,
3825        non_snake_case,
3826        clippy::pub_underscore_fields,
3827        clippy::style
3828    )]
3829    const _: () = {
3830        use alloy::sol_types as alloy_sol_types;
3831        #[doc(hidden)]
3832        type UnderlyingSolTuple<'a> = ();
3833        #[doc(hidden)]
3834        type UnderlyingRustTuple<'a> = ();
3835        #[cfg(test)]
3836        #[allow(dead_code, unreachable_patterns)]
3837        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3838            match _t {
3839                alloy_sol_types::private::AssertTypeEq::<
3840                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3841                >(_) => {}
3842            }
3843        }
3844        #[automatically_derived]
3845        #[doc(hidden)]
3846        impl ::core::convert::From<CurrentlyPaused> for UnderlyingRustTuple<'_> {
3847            fn from(value: CurrentlyPaused) -> Self {
3848                ()
3849            }
3850        }
3851        #[automatically_derived]
3852        #[doc(hidden)]
3853        impl ::core::convert::From<UnderlyingRustTuple<'_>> for CurrentlyPaused {
3854            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3855                Self
3856            }
3857        }
3858        #[automatically_derived]
3859        impl alloy_sol_types::SolError for CurrentlyPaused {
3860            type Parameters<'a> = UnderlyingSolTuple<'a>;
3861            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3862            const SIGNATURE: &'static str = "CurrentlyPaused()";
3863            const SELECTOR: [u8; 4] = [132u8, 10u8, 72u8, 213u8];
3864            #[inline]
3865            fn new<'a>(
3866                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3867            ) -> Self {
3868                tuple.into()
3869            }
3870            #[inline]
3871            fn tokenize(&self) -> Self::Token<'_> {
3872                ()
3873            }
3874            #[inline]
3875            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3876                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
3877                    data,
3878                )
3879                .map(Self::new)
3880            }
3881        }
3882    };
3883    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
3884    /**Custom error with signature `Empty()` and selector `0x3db2a12a`.
3885    ```solidity
3886    error Empty();
3887    ```*/
3888    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3889    #[derive(Clone)]
3890    pub struct Empty;
3891    #[allow(
3892        non_camel_case_types,
3893        non_snake_case,
3894        clippy::pub_underscore_fields,
3895        clippy::style
3896    )]
3897    const _: () = {
3898        use alloy::sol_types as alloy_sol_types;
3899        #[doc(hidden)]
3900        type UnderlyingSolTuple<'a> = ();
3901        #[doc(hidden)]
3902        type UnderlyingRustTuple<'a> = ();
3903        #[cfg(test)]
3904        #[allow(dead_code, unreachable_patterns)]
3905        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3906            match _t {
3907                alloy_sol_types::private::AssertTypeEq::<
3908                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3909                >(_) => {}
3910            }
3911        }
3912        #[automatically_derived]
3913        #[doc(hidden)]
3914        impl ::core::convert::From<Empty> for UnderlyingRustTuple<'_> {
3915            fn from(value: Empty) -> Self {
3916                ()
3917            }
3918        }
3919        #[automatically_derived]
3920        #[doc(hidden)]
3921        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Empty {
3922            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3923                Self
3924            }
3925        }
3926        #[automatically_derived]
3927        impl alloy_sol_types::SolError for Empty {
3928            type Parameters<'a> = UnderlyingSolTuple<'a>;
3929            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3930            const SIGNATURE: &'static str = "Empty()";
3931            const SELECTOR: [u8; 4] = [61u8, 178u8, 161u8, 42u8];
3932            #[inline]
3933            fn new<'a>(
3934                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3935            ) -> Self {
3936                tuple.into()
3937            }
3938            #[inline]
3939            fn tokenize(&self) -> Self::Token<'_> {
3940                ()
3941            }
3942            #[inline]
3943            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3944                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
3945                    data,
3946                )
3947                .map(Self::new)
3948            }
3949        }
3950    };
3951    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
3952    /**Custom error with signature `InputAddressZero()` and selector `0x73632176`.
3953    ```solidity
3954    error InputAddressZero();
3955    ```*/
3956    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3957    #[derive(Clone)]
3958    pub struct InputAddressZero;
3959    #[allow(
3960        non_camel_case_types,
3961        non_snake_case,
3962        clippy::pub_underscore_fields,
3963        clippy::style
3964    )]
3965    const _: () = {
3966        use alloy::sol_types as alloy_sol_types;
3967        #[doc(hidden)]
3968        type UnderlyingSolTuple<'a> = ();
3969        #[doc(hidden)]
3970        type UnderlyingRustTuple<'a> = ();
3971        #[cfg(test)]
3972        #[allow(dead_code, unreachable_patterns)]
3973        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3974            match _t {
3975                alloy_sol_types::private::AssertTypeEq::<
3976                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3977                >(_) => {}
3978            }
3979        }
3980        #[automatically_derived]
3981        #[doc(hidden)]
3982        impl ::core::convert::From<InputAddressZero> for UnderlyingRustTuple<'_> {
3983            fn from(value: InputAddressZero) -> Self {
3984                ()
3985            }
3986        }
3987        #[automatically_derived]
3988        #[doc(hidden)]
3989        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InputAddressZero {
3990            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3991                Self
3992            }
3993        }
3994        #[automatically_derived]
3995        impl alloy_sol_types::SolError for InputAddressZero {
3996            type Parameters<'a> = UnderlyingSolTuple<'a>;
3997            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3998            const SIGNATURE: &'static str = "InputAddressZero()";
3999            const SELECTOR: [u8; 4] = [115u8, 99u8, 33u8, 118u8];
4000            #[inline]
4001            fn new<'a>(
4002                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4003            ) -> Self {
4004                tuple.into()
4005            }
4006            #[inline]
4007            fn tokenize(&self) -> Self::Token<'_> {
4008                ()
4009            }
4010            #[inline]
4011            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4012                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4013                    data,
4014                )
4015                .map(Self::new)
4016            }
4017        }
4018    };
4019    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4020    /**Custom error with signature `InputArrayLengthMismatch()` and selector `0x43714afd`.
4021    ```solidity
4022    error InputArrayLengthMismatch();
4023    ```*/
4024    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4025    #[derive(Clone)]
4026    pub struct InputArrayLengthMismatch;
4027    #[allow(
4028        non_camel_case_types,
4029        non_snake_case,
4030        clippy::pub_underscore_fields,
4031        clippy::style
4032    )]
4033    const _: () = {
4034        use alloy::sol_types as alloy_sol_types;
4035        #[doc(hidden)]
4036        type UnderlyingSolTuple<'a> = ();
4037        #[doc(hidden)]
4038        type UnderlyingRustTuple<'a> = ();
4039        #[cfg(test)]
4040        #[allow(dead_code, unreachable_patterns)]
4041        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4042            match _t {
4043                alloy_sol_types::private::AssertTypeEq::<
4044                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4045                >(_) => {}
4046            }
4047        }
4048        #[automatically_derived]
4049        #[doc(hidden)]
4050        impl ::core::convert::From<InputArrayLengthMismatch> for UnderlyingRustTuple<'_> {
4051            fn from(value: InputArrayLengthMismatch) -> Self {
4052                ()
4053            }
4054        }
4055        #[automatically_derived]
4056        #[doc(hidden)]
4057        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InputArrayLengthMismatch {
4058            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4059                Self
4060            }
4061        }
4062        #[automatically_derived]
4063        impl alloy_sol_types::SolError for InputArrayLengthMismatch {
4064            type Parameters<'a> = UnderlyingSolTuple<'a>;
4065            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4066            const SIGNATURE: &'static str = "InputArrayLengthMismatch()";
4067            const SELECTOR: [u8; 4] = [67u8, 113u8, 74u8, 253u8];
4068            #[inline]
4069            fn new<'a>(
4070                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4071            ) -> Self {
4072                tuple.into()
4073            }
4074            #[inline]
4075            fn tokenize(&self) -> Self::Token<'_> {
4076                ()
4077            }
4078            #[inline]
4079            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4080                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4081                    data,
4082                )
4083                .map(Self::new)
4084            }
4085        }
4086    };
4087    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4088    /**Custom error with signature `InsufficientMagnitude()` and selector `0x6c9be0bf`.
4089    ```solidity
4090    error InsufficientMagnitude();
4091    ```*/
4092    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4093    #[derive(Clone)]
4094    pub struct InsufficientMagnitude;
4095    #[allow(
4096        non_camel_case_types,
4097        non_snake_case,
4098        clippy::pub_underscore_fields,
4099        clippy::style
4100    )]
4101    const _: () = {
4102        use alloy::sol_types as alloy_sol_types;
4103        #[doc(hidden)]
4104        type UnderlyingSolTuple<'a> = ();
4105        #[doc(hidden)]
4106        type UnderlyingRustTuple<'a> = ();
4107        #[cfg(test)]
4108        #[allow(dead_code, unreachable_patterns)]
4109        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4110            match _t {
4111                alloy_sol_types::private::AssertTypeEq::<
4112                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4113                >(_) => {}
4114            }
4115        }
4116        #[automatically_derived]
4117        #[doc(hidden)]
4118        impl ::core::convert::From<InsufficientMagnitude> for UnderlyingRustTuple<'_> {
4119            fn from(value: InsufficientMagnitude) -> Self {
4120                ()
4121            }
4122        }
4123        #[automatically_derived]
4124        #[doc(hidden)]
4125        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InsufficientMagnitude {
4126            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4127                Self
4128            }
4129        }
4130        #[automatically_derived]
4131        impl alloy_sol_types::SolError for InsufficientMagnitude {
4132            type Parameters<'a> = UnderlyingSolTuple<'a>;
4133            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4134            const SIGNATURE: &'static str = "InsufficientMagnitude()";
4135            const SELECTOR: [u8; 4] = [108u8, 155u8, 224u8, 191u8];
4136            #[inline]
4137            fn new<'a>(
4138                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4139            ) -> Self {
4140                tuple.into()
4141            }
4142            #[inline]
4143            fn tokenize(&self) -> Self::Token<'_> {
4144                ()
4145            }
4146            #[inline]
4147            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4148                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4149                    data,
4150                )
4151                .map(Self::new)
4152            }
4153        }
4154    };
4155    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4156    /**Custom error with signature `InvalidAVSRegistrar()` and selector `0xe8589e08`.
4157    ```solidity
4158    error InvalidAVSRegistrar();
4159    ```*/
4160    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4161    #[derive(Clone)]
4162    pub struct InvalidAVSRegistrar;
4163    #[allow(
4164        non_camel_case_types,
4165        non_snake_case,
4166        clippy::pub_underscore_fields,
4167        clippy::style
4168    )]
4169    const _: () = {
4170        use alloy::sol_types as alloy_sol_types;
4171        #[doc(hidden)]
4172        type UnderlyingSolTuple<'a> = ();
4173        #[doc(hidden)]
4174        type UnderlyingRustTuple<'a> = ();
4175        #[cfg(test)]
4176        #[allow(dead_code, unreachable_patterns)]
4177        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4178            match _t {
4179                alloy_sol_types::private::AssertTypeEq::<
4180                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4181                >(_) => {}
4182            }
4183        }
4184        #[automatically_derived]
4185        #[doc(hidden)]
4186        impl ::core::convert::From<InvalidAVSRegistrar> for UnderlyingRustTuple<'_> {
4187            fn from(value: InvalidAVSRegistrar) -> Self {
4188                ()
4189            }
4190        }
4191        #[automatically_derived]
4192        #[doc(hidden)]
4193        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidAVSRegistrar {
4194            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4195                Self
4196            }
4197        }
4198        #[automatically_derived]
4199        impl alloy_sol_types::SolError for InvalidAVSRegistrar {
4200            type Parameters<'a> = UnderlyingSolTuple<'a>;
4201            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4202            const SIGNATURE: &'static str = "InvalidAVSRegistrar()";
4203            const SELECTOR: [u8; 4] = [232u8, 88u8, 158u8, 8u8];
4204            #[inline]
4205            fn new<'a>(
4206                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4207            ) -> Self {
4208                tuple.into()
4209            }
4210            #[inline]
4211            fn tokenize(&self) -> Self::Token<'_> {
4212                ()
4213            }
4214            #[inline]
4215            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4216                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4217                    data,
4218                )
4219                .map(Self::new)
4220            }
4221        }
4222    };
4223    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4224    /**Custom error with signature `InvalidCaller()` and selector `0x48f5c3ed`.
4225    ```solidity
4226    error InvalidCaller();
4227    ```*/
4228    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4229    #[derive(Clone)]
4230    pub struct InvalidCaller;
4231    #[allow(
4232        non_camel_case_types,
4233        non_snake_case,
4234        clippy::pub_underscore_fields,
4235        clippy::style
4236    )]
4237    const _: () = {
4238        use alloy::sol_types as alloy_sol_types;
4239        #[doc(hidden)]
4240        type UnderlyingSolTuple<'a> = ();
4241        #[doc(hidden)]
4242        type UnderlyingRustTuple<'a> = ();
4243        #[cfg(test)]
4244        #[allow(dead_code, unreachable_patterns)]
4245        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4246            match _t {
4247                alloy_sol_types::private::AssertTypeEq::<
4248                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4249                >(_) => {}
4250            }
4251        }
4252        #[automatically_derived]
4253        #[doc(hidden)]
4254        impl ::core::convert::From<InvalidCaller> for UnderlyingRustTuple<'_> {
4255            fn from(value: InvalidCaller) -> Self {
4256                ()
4257            }
4258        }
4259        #[automatically_derived]
4260        #[doc(hidden)]
4261        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidCaller {
4262            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4263                Self
4264            }
4265        }
4266        #[automatically_derived]
4267        impl alloy_sol_types::SolError for InvalidCaller {
4268            type Parameters<'a> = UnderlyingSolTuple<'a>;
4269            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4270            const SIGNATURE: &'static str = "InvalidCaller()";
4271            const SELECTOR: [u8; 4] = [72u8, 245u8, 195u8, 237u8];
4272            #[inline]
4273            fn new<'a>(
4274                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4275            ) -> Self {
4276                tuple.into()
4277            }
4278            #[inline]
4279            fn tokenize(&self) -> Self::Token<'_> {
4280                ()
4281            }
4282            #[inline]
4283            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4284                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4285                    data,
4286                )
4287                .map(Self::new)
4288            }
4289        }
4290    };
4291    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4292    /**Custom error with signature `InvalidNewPausedStatus()` and selector `0xc61dca5d`.
4293    ```solidity
4294    error InvalidNewPausedStatus();
4295    ```*/
4296    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4297    #[derive(Clone)]
4298    pub struct InvalidNewPausedStatus;
4299    #[allow(
4300        non_camel_case_types,
4301        non_snake_case,
4302        clippy::pub_underscore_fields,
4303        clippy::style
4304    )]
4305    const _: () = {
4306        use alloy::sol_types as alloy_sol_types;
4307        #[doc(hidden)]
4308        type UnderlyingSolTuple<'a> = ();
4309        #[doc(hidden)]
4310        type UnderlyingRustTuple<'a> = ();
4311        #[cfg(test)]
4312        #[allow(dead_code, unreachable_patterns)]
4313        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4314            match _t {
4315                alloy_sol_types::private::AssertTypeEq::<
4316                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4317                >(_) => {}
4318            }
4319        }
4320        #[automatically_derived]
4321        #[doc(hidden)]
4322        impl ::core::convert::From<InvalidNewPausedStatus> for UnderlyingRustTuple<'_> {
4323            fn from(value: InvalidNewPausedStatus) -> Self {
4324                ()
4325            }
4326        }
4327        #[automatically_derived]
4328        #[doc(hidden)]
4329        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidNewPausedStatus {
4330            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4331                Self
4332            }
4333        }
4334        #[automatically_derived]
4335        impl alloy_sol_types::SolError for InvalidNewPausedStatus {
4336            type Parameters<'a> = UnderlyingSolTuple<'a>;
4337            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4338            const SIGNATURE: &'static str = "InvalidNewPausedStatus()";
4339            const SELECTOR: [u8; 4] = [198u8, 29u8, 202u8, 93u8];
4340            #[inline]
4341            fn new<'a>(
4342                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4343            ) -> Self {
4344                tuple.into()
4345            }
4346            #[inline]
4347            fn tokenize(&self) -> Self::Token<'_> {
4348                ()
4349            }
4350            #[inline]
4351            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4352                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4353                    data,
4354                )
4355                .map(Self::new)
4356            }
4357        }
4358    };
4359    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4360    /**Custom error with signature `InvalidOperator()` and selector `0xccea9e6f`.
4361    ```solidity
4362    error InvalidOperator();
4363    ```*/
4364    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4365    #[derive(Clone)]
4366    pub struct InvalidOperator;
4367    #[allow(
4368        non_camel_case_types,
4369        non_snake_case,
4370        clippy::pub_underscore_fields,
4371        clippy::style
4372    )]
4373    const _: () = {
4374        use alloy::sol_types as alloy_sol_types;
4375        #[doc(hidden)]
4376        type UnderlyingSolTuple<'a> = ();
4377        #[doc(hidden)]
4378        type UnderlyingRustTuple<'a> = ();
4379        #[cfg(test)]
4380        #[allow(dead_code, unreachable_patterns)]
4381        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4382            match _t {
4383                alloy_sol_types::private::AssertTypeEq::<
4384                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4385                >(_) => {}
4386            }
4387        }
4388        #[automatically_derived]
4389        #[doc(hidden)]
4390        impl ::core::convert::From<InvalidOperator> for UnderlyingRustTuple<'_> {
4391            fn from(value: InvalidOperator) -> Self {
4392                ()
4393            }
4394        }
4395        #[automatically_derived]
4396        #[doc(hidden)]
4397        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidOperator {
4398            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4399                Self
4400            }
4401        }
4402        #[automatically_derived]
4403        impl alloy_sol_types::SolError for InvalidOperator {
4404            type Parameters<'a> = UnderlyingSolTuple<'a>;
4405            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4406            const SIGNATURE: &'static str = "InvalidOperator()";
4407            const SELECTOR: [u8; 4] = [204u8, 234u8, 158u8, 111u8];
4408            #[inline]
4409            fn new<'a>(
4410                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4411            ) -> Self {
4412                tuple.into()
4413            }
4414            #[inline]
4415            fn tokenize(&self) -> Self::Token<'_> {
4416                ()
4417            }
4418            #[inline]
4419            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4420                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4421                    data,
4422                )
4423                .map(Self::new)
4424            }
4425        }
4426    };
4427    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4428    /**Custom error with signature `InvalidOperatorSet()` and selector `0x7ec5c154`.
4429    ```solidity
4430    error InvalidOperatorSet();
4431    ```*/
4432    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4433    #[derive(Clone)]
4434    pub struct InvalidOperatorSet;
4435    #[allow(
4436        non_camel_case_types,
4437        non_snake_case,
4438        clippy::pub_underscore_fields,
4439        clippy::style
4440    )]
4441    const _: () = {
4442        use alloy::sol_types as alloy_sol_types;
4443        #[doc(hidden)]
4444        type UnderlyingSolTuple<'a> = ();
4445        #[doc(hidden)]
4446        type UnderlyingRustTuple<'a> = ();
4447        #[cfg(test)]
4448        #[allow(dead_code, unreachable_patterns)]
4449        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4450            match _t {
4451                alloy_sol_types::private::AssertTypeEq::<
4452                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4453                >(_) => {}
4454            }
4455        }
4456        #[automatically_derived]
4457        #[doc(hidden)]
4458        impl ::core::convert::From<InvalidOperatorSet> for UnderlyingRustTuple<'_> {
4459            fn from(value: InvalidOperatorSet) -> Self {
4460                ()
4461            }
4462        }
4463        #[automatically_derived]
4464        #[doc(hidden)]
4465        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidOperatorSet {
4466            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4467                Self
4468            }
4469        }
4470        #[automatically_derived]
4471        impl alloy_sol_types::SolError for InvalidOperatorSet {
4472            type Parameters<'a> = UnderlyingSolTuple<'a>;
4473            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4474            const SIGNATURE: &'static str = "InvalidOperatorSet()";
4475            const SELECTOR: [u8; 4] = [126u8, 197u8, 193u8, 84u8];
4476            #[inline]
4477            fn new<'a>(
4478                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4479            ) -> Self {
4480                tuple.into()
4481            }
4482            #[inline]
4483            fn tokenize(&self) -> Self::Token<'_> {
4484                ()
4485            }
4486            #[inline]
4487            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4488                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4489                    data,
4490                )
4491                .map(Self::new)
4492            }
4493        }
4494    };
4495    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4496    /**Custom error with signature `InvalidPermissions()` and selector `0x932d94f7`.
4497    ```solidity
4498    error InvalidPermissions();
4499    ```*/
4500    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4501    #[derive(Clone)]
4502    pub struct InvalidPermissions;
4503    #[allow(
4504        non_camel_case_types,
4505        non_snake_case,
4506        clippy::pub_underscore_fields,
4507        clippy::style
4508    )]
4509    const _: () = {
4510        use alloy::sol_types as alloy_sol_types;
4511        #[doc(hidden)]
4512        type UnderlyingSolTuple<'a> = ();
4513        #[doc(hidden)]
4514        type UnderlyingRustTuple<'a> = ();
4515        #[cfg(test)]
4516        #[allow(dead_code, unreachable_patterns)]
4517        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4518            match _t {
4519                alloy_sol_types::private::AssertTypeEq::<
4520                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4521                >(_) => {}
4522            }
4523        }
4524        #[automatically_derived]
4525        #[doc(hidden)]
4526        impl ::core::convert::From<InvalidPermissions> for UnderlyingRustTuple<'_> {
4527            fn from(value: InvalidPermissions) -> Self {
4528                ()
4529            }
4530        }
4531        #[automatically_derived]
4532        #[doc(hidden)]
4533        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidPermissions {
4534            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4535                Self
4536            }
4537        }
4538        #[automatically_derived]
4539        impl alloy_sol_types::SolError for InvalidPermissions {
4540            type Parameters<'a> = UnderlyingSolTuple<'a>;
4541            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4542            const SIGNATURE: &'static str = "InvalidPermissions()";
4543            const SELECTOR: [u8; 4] = [147u8, 45u8, 148u8, 247u8];
4544            #[inline]
4545            fn new<'a>(
4546                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4547            ) -> Self {
4548                tuple.into()
4549            }
4550            #[inline]
4551            fn tokenize(&self) -> Self::Token<'_> {
4552                ()
4553            }
4554            #[inline]
4555            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4556                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4557                    data,
4558                )
4559                .map(Self::new)
4560            }
4561        }
4562    };
4563    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4564    /**Custom error with signature `InvalidShortString()` and selector `0xb3512b0c`.
4565    ```solidity
4566    error InvalidShortString();
4567    ```*/
4568    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4569    #[derive(Clone)]
4570    pub struct InvalidShortString;
4571    #[allow(
4572        non_camel_case_types,
4573        non_snake_case,
4574        clippy::pub_underscore_fields,
4575        clippy::style
4576    )]
4577    const _: () = {
4578        use alloy::sol_types as alloy_sol_types;
4579        #[doc(hidden)]
4580        type UnderlyingSolTuple<'a> = ();
4581        #[doc(hidden)]
4582        type UnderlyingRustTuple<'a> = ();
4583        #[cfg(test)]
4584        #[allow(dead_code, unreachable_patterns)]
4585        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4586            match _t {
4587                alloy_sol_types::private::AssertTypeEq::<
4588                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4589                >(_) => {}
4590            }
4591        }
4592        #[automatically_derived]
4593        #[doc(hidden)]
4594        impl ::core::convert::From<InvalidShortString> for UnderlyingRustTuple<'_> {
4595            fn from(value: InvalidShortString) -> Self {
4596                ()
4597            }
4598        }
4599        #[automatically_derived]
4600        #[doc(hidden)]
4601        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidShortString {
4602            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4603                Self
4604            }
4605        }
4606        #[automatically_derived]
4607        impl alloy_sol_types::SolError for InvalidShortString {
4608            type Parameters<'a> = UnderlyingSolTuple<'a>;
4609            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4610            const SIGNATURE: &'static str = "InvalidShortString()";
4611            const SELECTOR: [u8; 4] = [179u8, 81u8, 43u8, 12u8];
4612            #[inline]
4613            fn new<'a>(
4614                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4615            ) -> Self {
4616                tuple.into()
4617            }
4618            #[inline]
4619            fn tokenize(&self) -> Self::Token<'_> {
4620                ()
4621            }
4622            #[inline]
4623            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4624                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4625                    data,
4626                )
4627                .map(Self::new)
4628            }
4629        }
4630    };
4631    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4632    /**Custom error with signature `InvalidSnapshotOrdering()` and selector `0x2a371c7e`.
4633    ```solidity
4634    error InvalidSnapshotOrdering();
4635    ```*/
4636    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4637    #[derive(Clone)]
4638    pub struct InvalidSnapshotOrdering;
4639    #[allow(
4640        non_camel_case_types,
4641        non_snake_case,
4642        clippy::pub_underscore_fields,
4643        clippy::style
4644    )]
4645    const _: () = {
4646        use alloy::sol_types as alloy_sol_types;
4647        #[doc(hidden)]
4648        type UnderlyingSolTuple<'a> = ();
4649        #[doc(hidden)]
4650        type UnderlyingRustTuple<'a> = ();
4651        #[cfg(test)]
4652        #[allow(dead_code, unreachable_patterns)]
4653        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4654            match _t {
4655                alloy_sol_types::private::AssertTypeEq::<
4656                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4657                >(_) => {}
4658            }
4659        }
4660        #[automatically_derived]
4661        #[doc(hidden)]
4662        impl ::core::convert::From<InvalidSnapshotOrdering> for UnderlyingRustTuple<'_> {
4663            fn from(value: InvalidSnapshotOrdering) -> Self {
4664                ()
4665            }
4666        }
4667        #[automatically_derived]
4668        #[doc(hidden)]
4669        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSnapshotOrdering {
4670            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4671                Self
4672            }
4673        }
4674        #[automatically_derived]
4675        impl alloy_sol_types::SolError for InvalidSnapshotOrdering {
4676            type Parameters<'a> = UnderlyingSolTuple<'a>;
4677            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4678            const SIGNATURE: &'static str = "InvalidSnapshotOrdering()";
4679            const SELECTOR: [u8; 4] = [42u8, 55u8, 28u8, 126u8];
4680            #[inline]
4681            fn new<'a>(
4682                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4683            ) -> Self {
4684                tuple.into()
4685            }
4686            #[inline]
4687            fn tokenize(&self) -> Self::Token<'_> {
4688                ()
4689            }
4690            #[inline]
4691            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4692                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4693                    data,
4694                )
4695                .map(Self::new)
4696            }
4697        }
4698    };
4699    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4700    /**Custom error with signature `InvalidWadToSlash()` and selector `0x13536031`.
4701    ```solidity
4702    error InvalidWadToSlash();
4703    ```*/
4704    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4705    #[derive(Clone)]
4706    pub struct InvalidWadToSlash;
4707    #[allow(
4708        non_camel_case_types,
4709        non_snake_case,
4710        clippy::pub_underscore_fields,
4711        clippy::style
4712    )]
4713    const _: () = {
4714        use alloy::sol_types as alloy_sol_types;
4715        #[doc(hidden)]
4716        type UnderlyingSolTuple<'a> = ();
4717        #[doc(hidden)]
4718        type UnderlyingRustTuple<'a> = ();
4719        #[cfg(test)]
4720        #[allow(dead_code, unreachable_patterns)]
4721        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4722            match _t {
4723                alloy_sol_types::private::AssertTypeEq::<
4724                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4725                >(_) => {}
4726            }
4727        }
4728        #[automatically_derived]
4729        #[doc(hidden)]
4730        impl ::core::convert::From<InvalidWadToSlash> for UnderlyingRustTuple<'_> {
4731            fn from(value: InvalidWadToSlash) -> Self {
4732                ()
4733            }
4734        }
4735        #[automatically_derived]
4736        #[doc(hidden)]
4737        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidWadToSlash {
4738            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4739                Self
4740            }
4741        }
4742        #[automatically_derived]
4743        impl alloy_sol_types::SolError for InvalidWadToSlash {
4744            type Parameters<'a> = UnderlyingSolTuple<'a>;
4745            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4746            const SIGNATURE: &'static str = "InvalidWadToSlash()";
4747            const SELECTOR: [u8; 4] = [19u8, 83u8, 96u8, 49u8];
4748            #[inline]
4749            fn new<'a>(
4750                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4751            ) -> Self {
4752                tuple.into()
4753            }
4754            #[inline]
4755            fn tokenize(&self) -> Self::Token<'_> {
4756                ()
4757            }
4758            #[inline]
4759            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4760                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4761                    data,
4762                )
4763                .map(Self::new)
4764            }
4765        }
4766    };
4767    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4768    /**Custom error with signature `ModificationAlreadyPending()` and selector `0xd8fcbe30`.
4769    ```solidity
4770    error ModificationAlreadyPending();
4771    ```*/
4772    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4773    #[derive(Clone)]
4774    pub struct ModificationAlreadyPending;
4775    #[allow(
4776        non_camel_case_types,
4777        non_snake_case,
4778        clippy::pub_underscore_fields,
4779        clippy::style
4780    )]
4781    const _: () = {
4782        use alloy::sol_types as alloy_sol_types;
4783        #[doc(hidden)]
4784        type UnderlyingSolTuple<'a> = ();
4785        #[doc(hidden)]
4786        type UnderlyingRustTuple<'a> = ();
4787        #[cfg(test)]
4788        #[allow(dead_code, unreachable_patterns)]
4789        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4790            match _t {
4791                alloy_sol_types::private::AssertTypeEq::<
4792                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4793                >(_) => {}
4794            }
4795        }
4796        #[automatically_derived]
4797        #[doc(hidden)]
4798        impl ::core::convert::From<ModificationAlreadyPending> for UnderlyingRustTuple<'_> {
4799            fn from(value: ModificationAlreadyPending) -> Self {
4800                ()
4801            }
4802        }
4803        #[automatically_derived]
4804        #[doc(hidden)]
4805        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ModificationAlreadyPending {
4806            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4807                Self
4808            }
4809        }
4810        #[automatically_derived]
4811        impl alloy_sol_types::SolError for ModificationAlreadyPending {
4812            type Parameters<'a> = UnderlyingSolTuple<'a>;
4813            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4814            const SIGNATURE: &'static str = "ModificationAlreadyPending()";
4815            const SELECTOR: [u8; 4] = [216u8, 252u8, 190u8, 48u8];
4816            #[inline]
4817            fn new<'a>(
4818                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4819            ) -> Self {
4820                tuple.into()
4821            }
4822            #[inline]
4823            fn tokenize(&self) -> Self::Token<'_> {
4824                ()
4825            }
4826            #[inline]
4827            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4828                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4829                    data,
4830                )
4831                .map(Self::new)
4832            }
4833        }
4834    };
4835    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4836    /**Custom error with signature `NonexistentAVSMetadata()` and selector `0x48f7dbb9`.
4837    ```solidity
4838    error NonexistentAVSMetadata();
4839    ```*/
4840    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4841    #[derive(Clone)]
4842    pub struct NonexistentAVSMetadata;
4843    #[allow(
4844        non_camel_case_types,
4845        non_snake_case,
4846        clippy::pub_underscore_fields,
4847        clippy::style
4848    )]
4849    const _: () = {
4850        use alloy::sol_types as alloy_sol_types;
4851        #[doc(hidden)]
4852        type UnderlyingSolTuple<'a> = ();
4853        #[doc(hidden)]
4854        type UnderlyingRustTuple<'a> = ();
4855        #[cfg(test)]
4856        #[allow(dead_code, unreachable_patterns)]
4857        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4858            match _t {
4859                alloy_sol_types::private::AssertTypeEq::<
4860                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4861                >(_) => {}
4862            }
4863        }
4864        #[automatically_derived]
4865        #[doc(hidden)]
4866        impl ::core::convert::From<NonexistentAVSMetadata> for UnderlyingRustTuple<'_> {
4867            fn from(value: NonexistentAVSMetadata) -> Self {
4868                ()
4869            }
4870        }
4871        #[automatically_derived]
4872        #[doc(hidden)]
4873        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NonexistentAVSMetadata {
4874            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4875                Self
4876            }
4877        }
4878        #[automatically_derived]
4879        impl alloy_sol_types::SolError for NonexistentAVSMetadata {
4880            type Parameters<'a> = UnderlyingSolTuple<'a>;
4881            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4882            const SIGNATURE: &'static str = "NonexistentAVSMetadata()";
4883            const SELECTOR: [u8; 4] = [72u8, 247u8, 219u8, 185u8];
4884            #[inline]
4885            fn new<'a>(
4886                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4887            ) -> Self {
4888                tuple.into()
4889            }
4890            #[inline]
4891            fn tokenize(&self) -> Self::Token<'_> {
4892                ()
4893            }
4894            #[inline]
4895            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4896                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4897                    data,
4898                )
4899                .map(Self::new)
4900            }
4901        }
4902    };
4903    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4904    /**Custom error with signature `NotMemberOfSet()` and selector `0x25131d4f`.
4905    ```solidity
4906    error NotMemberOfSet();
4907    ```*/
4908    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4909    #[derive(Clone)]
4910    pub struct NotMemberOfSet;
4911    #[allow(
4912        non_camel_case_types,
4913        non_snake_case,
4914        clippy::pub_underscore_fields,
4915        clippy::style
4916    )]
4917    const _: () = {
4918        use alloy::sol_types as alloy_sol_types;
4919        #[doc(hidden)]
4920        type UnderlyingSolTuple<'a> = ();
4921        #[doc(hidden)]
4922        type UnderlyingRustTuple<'a> = ();
4923        #[cfg(test)]
4924        #[allow(dead_code, unreachable_patterns)]
4925        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4926            match _t {
4927                alloy_sol_types::private::AssertTypeEq::<
4928                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4929                >(_) => {}
4930            }
4931        }
4932        #[automatically_derived]
4933        #[doc(hidden)]
4934        impl ::core::convert::From<NotMemberOfSet> for UnderlyingRustTuple<'_> {
4935            fn from(value: NotMemberOfSet) -> Self {
4936                ()
4937            }
4938        }
4939        #[automatically_derived]
4940        #[doc(hidden)]
4941        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotMemberOfSet {
4942            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4943                Self
4944            }
4945        }
4946        #[automatically_derived]
4947        impl alloy_sol_types::SolError for NotMemberOfSet {
4948            type Parameters<'a> = UnderlyingSolTuple<'a>;
4949            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4950            const SIGNATURE: &'static str = "NotMemberOfSet()";
4951            const SELECTOR: [u8; 4] = [37u8, 19u8, 29u8, 79u8];
4952            #[inline]
4953            fn new<'a>(
4954                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4955            ) -> Self {
4956                tuple.into()
4957            }
4958            #[inline]
4959            fn tokenize(&self) -> Self::Token<'_> {
4960                ()
4961            }
4962            #[inline]
4963            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4964                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4965                    data,
4966                )
4967                .map(Self::new)
4968            }
4969        }
4970    };
4971    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4972    /**Custom error with signature `OnlyPauser()` and selector `0x75df51dc`.
4973    ```solidity
4974    error OnlyPauser();
4975    ```*/
4976    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4977    #[derive(Clone)]
4978    pub struct OnlyPauser;
4979    #[allow(
4980        non_camel_case_types,
4981        non_snake_case,
4982        clippy::pub_underscore_fields,
4983        clippy::style
4984    )]
4985    const _: () = {
4986        use alloy::sol_types as alloy_sol_types;
4987        #[doc(hidden)]
4988        type UnderlyingSolTuple<'a> = ();
4989        #[doc(hidden)]
4990        type UnderlyingRustTuple<'a> = ();
4991        #[cfg(test)]
4992        #[allow(dead_code, unreachable_patterns)]
4993        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4994            match _t {
4995                alloy_sol_types::private::AssertTypeEq::<
4996                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4997                >(_) => {}
4998            }
4999        }
5000        #[automatically_derived]
5001        #[doc(hidden)]
5002        impl ::core::convert::From<OnlyPauser> for UnderlyingRustTuple<'_> {
5003            fn from(value: OnlyPauser) -> Self {
5004                ()
5005            }
5006        }
5007        #[automatically_derived]
5008        #[doc(hidden)]
5009        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyPauser {
5010            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5011                Self
5012            }
5013        }
5014        #[automatically_derived]
5015        impl alloy_sol_types::SolError for OnlyPauser {
5016            type Parameters<'a> = UnderlyingSolTuple<'a>;
5017            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5018            const SIGNATURE: &'static str = "OnlyPauser()";
5019            const SELECTOR: [u8; 4] = [117u8, 223u8, 81u8, 220u8];
5020            #[inline]
5021            fn new<'a>(
5022                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5023            ) -> Self {
5024                tuple.into()
5025            }
5026            #[inline]
5027            fn tokenize(&self) -> Self::Token<'_> {
5028                ()
5029            }
5030            #[inline]
5031            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
5032                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
5033                    data,
5034                )
5035                .map(Self::new)
5036            }
5037        }
5038    };
5039    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
5040    /**Custom error with signature `OnlyUnpauser()` and selector `0x794821ff`.
5041    ```solidity
5042    error OnlyUnpauser();
5043    ```*/
5044    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5045    #[derive(Clone)]
5046    pub struct OnlyUnpauser;
5047    #[allow(
5048        non_camel_case_types,
5049        non_snake_case,
5050        clippy::pub_underscore_fields,
5051        clippy::style
5052    )]
5053    const _: () = {
5054        use alloy::sol_types as alloy_sol_types;
5055        #[doc(hidden)]
5056        type UnderlyingSolTuple<'a> = ();
5057        #[doc(hidden)]
5058        type UnderlyingRustTuple<'a> = ();
5059        #[cfg(test)]
5060        #[allow(dead_code, unreachable_patterns)]
5061        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5062            match _t {
5063                alloy_sol_types::private::AssertTypeEq::<
5064                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5065                >(_) => {}
5066            }
5067        }
5068        #[automatically_derived]
5069        #[doc(hidden)]
5070        impl ::core::convert::From<OnlyUnpauser> for UnderlyingRustTuple<'_> {
5071            fn from(value: OnlyUnpauser) -> Self {
5072                ()
5073            }
5074        }
5075        #[automatically_derived]
5076        #[doc(hidden)]
5077        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyUnpauser {
5078            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5079                Self
5080            }
5081        }
5082        #[automatically_derived]
5083        impl alloy_sol_types::SolError for OnlyUnpauser {
5084            type Parameters<'a> = UnderlyingSolTuple<'a>;
5085            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5086            const SIGNATURE: &'static str = "OnlyUnpauser()";
5087            const SELECTOR: [u8; 4] = [121u8, 72u8, 33u8, 255u8];
5088            #[inline]
5089            fn new<'a>(
5090                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5091            ) -> Self {
5092                tuple.into()
5093            }
5094            #[inline]
5095            fn tokenize(&self) -> Self::Token<'_> {
5096                ()
5097            }
5098            #[inline]
5099            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
5100                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
5101                    data,
5102                )
5103                .map(Self::new)
5104            }
5105        }
5106    };
5107    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
5108    /**Custom error with signature `OperatorNotSlashable()` and selector `0xebbff497`.
5109    ```solidity
5110    error OperatorNotSlashable();
5111    ```*/
5112    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5113    #[derive(Clone)]
5114    pub struct OperatorNotSlashable;
5115    #[allow(
5116        non_camel_case_types,
5117        non_snake_case,
5118        clippy::pub_underscore_fields,
5119        clippy::style
5120    )]
5121    const _: () = {
5122        use alloy::sol_types as alloy_sol_types;
5123        #[doc(hidden)]
5124        type UnderlyingSolTuple<'a> = ();
5125        #[doc(hidden)]
5126        type UnderlyingRustTuple<'a> = ();
5127        #[cfg(test)]
5128        #[allow(dead_code, unreachable_patterns)]
5129        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5130            match _t {
5131                alloy_sol_types::private::AssertTypeEq::<
5132                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5133                >(_) => {}
5134            }
5135        }
5136        #[automatically_derived]
5137        #[doc(hidden)]
5138        impl ::core::convert::From<OperatorNotSlashable> for UnderlyingRustTuple<'_> {
5139            fn from(value: OperatorNotSlashable) -> Self {
5140                ()
5141            }
5142        }
5143        #[automatically_derived]
5144        #[doc(hidden)]
5145        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorNotSlashable {
5146            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5147                Self
5148            }
5149        }
5150        #[automatically_derived]
5151        impl alloy_sol_types::SolError for OperatorNotSlashable {
5152            type Parameters<'a> = UnderlyingSolTuple<'a>;
5153            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5154            const SIGNATURE: &'static str = "OperatorNotSlashable()";
5155            const SELECTOR: [u8; 4] = [235u8, 191u8, 244u8, 151u8];
5156            #[inline]
5157            fn new<'a>(
5158                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5159            ) -> Self {
5160                tuple.into()
5161            }
5162            #[inline]
5163            fn tokenize(&self) -> Self::Token<'_> {
5164                ()
5165            }
5166            #[inline]
5167            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
5168                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
5169                    data,
5170                )
5171                .map(Self::new)
5172            }
5173        }
5174    };
5175    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
5176    /**Custom error with signature `OutOfBounds()` and selector `0xb4120f14`.
5177    ```solidity
5178    error OutOfBounds();
5179    ```*/
5180    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5181    #[derive(Clone)]
5182    pub struct OutOfBounds;
5183    #[allow(
5184        non_camel_case_types,
5185        non_snake_case,
5186        clippy::pub_underscore_fields,
5187        clippy::style
5188    )]
5189    const _: () = {
5190        use alloy::sol_types as alloy_sol_types;
5191        #[doc(hidden)]
5192        type UnderlyingSolTuple<'a> = ();
5193        #[doc(hidden)]
5194        type UnderlyingRustTuple<'a> = ();
5195        #[cfg(test)]
5196        #[allow(dead_code, unreachable_patterns)]
5197        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5198            match _t {
5199                alloy_sol_types::private::AssertTypeEq::<
5200                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5201                >(_) => {}
5202            }
5203        }
5204        #[automatically_derived]
5205        #[doc(hidden)]
5206        impl ::core::convert::From<OutOfBounds> for UnderlyingRustTuple<'_> {
5207            fn from(value: OutOfBounds) -> Self {
5208                ()
5209            }
5210        }
5211        #[automatically_derived]
5212        #[doc(hidden)]
5213        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OutOfBounds {
5214            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5215                Self
5216            }
5217        }
5218        #[automatically_derived]
5219        impl alloy_sol_types::SolError for OutOfBounds {
5220            type Parameters<'a> = UnderlyingSolTuple<'a>;
5221            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5222            const SIGNATURE: &'static str = "OutOfBounds()";
5223            const SELECTOR: [u8; 4] = [180u8, 18u8, 15u8, 20u8];
5224            #[inline]
5225            fn new<'a>(
5226                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5227            ) -> Self {
5228                tuple.into()
5229            }
5230            #[inline]
5231            fn tokenize(&self) -> Self::Token<'_> {
5232                ()
5233            }
5234            #[inline]
5235            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
5236                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
5237                    data,
5238                )
5239                .map(Self::new)
5240            }
5241        }
5242    };
5243    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
5244    /**Custom error with signature `SameMagnitude()` and selector `0x8c0c2f26`.
5245    ```solidity
5246    error SameMagnitude();
5247    ```*/
5248    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5249    #[derive(Clone)]
5250    pub struct SameMagnitude;
5251    #[allow(
5252        non_camel_case_types,
5253        non_snake_case,
5254        clippy::pub_underscore_fields,
5255        clippy::style
5256    )]
5257    const _: () = {
5258        use alloy::sol_types as alloy_sol_types;
5259        #[doc(hidden)]
5260        type UnderlyingSolTuple<'a> = ();
5261        #[doc(hidden)]
5262        type UnderlyingRustTuple<'a> = ();
5263        #[cfg(test)]
5264        #[allow(dead_code, unreachable_patterns)]
5265        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5266            match _t {
5267                alloy_sol_types::private::AssertTypeEq::<
5268                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5269                >(_) => {}
5270            }
5271        }
5272        #[automatically_derived]
5273        #[doc(hidden)]
5274        impl ::core::convert::From<SameMagnitude> for UnderlyingRustTuple<'_> {
5275            fn from(value: SameMagnitude) -> Self {
5276                ()
5277            }
5278        }
5279        #[automatically_derived]
5280        #[doc(hidden)]
5281        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SameMagnitude {
5282            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5283                Self
5284            }
5285        }
5286        #[automatically_derived]
5287        impl alloy_sol_types::SolError for SameMagnitude {
5288            type Parameters<'a> = UnderlyingSolTuple<'a>;
5289            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5290            const SIGNATURE: &'static str = "SameMagnitude()";
5291            const SELECTOR: [u8; 4] = [140u8, 12u8, 47u8, 38u8];
5292            #[inline]
5293            fn new<'a>(
5294                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5295            ) -> Self {
5296                tuple.into()
5297            }
5298            #[inline]
5299            fn tokenize(&self) -> Self::Token<'_> {
5300                ()
5301            }
5302            #[inline]
5303            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
5304                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
5305                    data,
5306                )
5307                .map(Self::new)
5308            }
5309        }
5310    };
5311    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
5312    /**Custom error with signature `StrategiesMustBeInAscendingOrder()` and selector `0x9f1c8053`.
5313    ```solidity
5314    error StrategiesMustBeInAscendingOrder();
5315    ```*/
5316    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5317    #[derive(Clone)]
5318    pub struct StrategiesMustBeInAscendingOrder;
5319    #[allow(
5320        non_camel_case_types,
5321        non_snake_case,
5322        clippy::pub_underscore_fields,
5323        clippy::style
5324    )]
5325    const _: () = {
5326        use alloy::sol_types as alloy_sol_types;
5327        #[doc(hidden)]
5328        type UnderlyingSolTuple<'a> = ();
5329        #[doc(hidden)]
5330        type UnderlyingRustTuple<'a> = ();
5331        #[cfg(test)]
5332        #[allow(dead_code, unreachable_patterns)]
5333        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5334            match _t {
5335                alloy_sol_types::private::AssertTypeEq::<
5336                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5337                >(_) => {}
5338            }
5339        }
5340        #[automatically_derived]
5341        #[doc(hidden)]
5342        impl ::core::convert::From<StrategiesMustBeInAscendingOrder> for UnderlyingRustTuple<'_> {
5343            fn from(value: StrategiesMustBeInAscendingOrder) -> Self {
5344                ()
5345            }
5346        }
5347        #[automatically_derived]
5348        #[doc(hidden)]
5349        impl ::core::convert::From<UnderlyingRustTuple<'_>> for StrategiesMustBeInAscendingOrder {
5350            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5351                Self
5352            }
5353        }
5354        #[automatically_derived]
5355        impl alloy_sol_types::SolError for StrategiesMustBeInAscendingOrder {
5356            type Parameters<'a> = UnderlyingSolTuple<'a>;
5357            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5358            const SIGNATURE: &'static str = "StrategiesMustBeInAscendingOrder()";
5359            const SELECTOR: [u8; 4] = [159u8, 28u8, 128u8, 83u8];
5360            #[inline]
5361            fn new<'a>(
5362                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5363            ) -> Self {
5364                tuple.into()
5365            }
5366            #[inline]
5367            fn tokenize(&self) -> Self::Token<'_> {
5368                ()
5369            }
5370            #[inline]
5371            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
5372                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
5373                    data,
5374                )
5375                .map(Self::new)
5376            }
5377        }
5378    };
5379    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
5380    /**Custom error with signature `StrategyAlreadyInOperatorSet()` and selector `0x585cfb2f`.
5381    ```solidity
5382    error StrategyAlreadyInOperatorSet();
5383    ```*/
5384    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5385    #[derive(Clone)]
5386    pub struct StrategyAlreadyInOperatorSet;
5387    #[allow(
5388        non_camel_case_types,
5389        non_snake_case,
5390        clippy::pub_underscore_fields,
5391        clippy::style
5392    )]
5393    const _: () = {
5394        use alloy::sol_types as alloy_sol_types;
5395        #[doc(hidden)]
5396        type UnderlyingSolTuple<'a> = ();
5397        #[doc(hidden)]
5398        type UnderlyingRustTuple<'a> = ();
5399        #[cfg(test)]
5400        #[allow(dead_code, unreachable_patterns)]
5401        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5402            match _t {
5403                alloy_sol_types::private::AssertTypeEq::<
5404                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5405                >(_) => {}
5406            }
5407        }
5408        #[automatically_derived]
5409        #[doc(hidden)]
5410        impl ::core::convert::From<StrategyAlreadyInOperatorSet> for UnderlyingRustTuple<'_> {
5411            fn from(value: StrategyAlreadyInOperatorSet) -> Self {
5412                ()
5413            }
5414        }
5415        #[automatically_derived]
5416        #[doc(hidden)]
5417        impl ::core::convert::From<UnderlyingRustTuple<'_>> for StrategyAlreadyInOperatorSet {
5418            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5419                Self
5420            }
5421        }
5422        #[automatically_derived]
5423        impl alloy_sol_types::SolError for StrategyAlreadyInOperatorSet {
5424            type Parameters<'a> = UnderlyingSolTuple<'a>;
5425            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5426            const SIGNATURE: &'static str = "StrategyAlreadyInOperatorSet()";
5427            const SELECTOR: [u8; 4] = [88u8, 92u8, 251u8, 47u8];
5428            #[inline]
5429            fn new<'a>(
5430                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5431            ) -> Self {
5432                tuple.into()
5433            }
5434            #[inline]
5435            fn tokenize(&self) -> Self::Token<'_> {
5436                ()
5437            }
5438            #[inline]
5439            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
5440                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
5441                    data,
5442                )
5443                .map(Self::new)
5444            }
5445        }
5446    };
5447    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
5448    /**Custom error with signature `StrategyNotInOperatorSet()` and selector `0x6378684e`.
5449    ```solidity
5450    error StrategyNotInOperatorSet();
5451    ```*/
5452    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5453    #[derive(Clone)]
5454    pub struct StrategyNotInOperatorSet;
5455    #[allow(
5456        non_camel_case_types,
5457        non_snake_case,
5458        clippy::pub_underscore_fields,
5459        clippy::style
5460    )]
5461    const _: () = {
5462        use alloy::sol_types as alloy_sol_types;
5463        #[doc(hidden)]
5464        type UnderlyingSolTuple<'a> = ();
5465        #[doc(hidden)]
5466        type UnderlyingRustTuple<'a> = ();
5467        #[cfg(test)]
5468        #[allow(dead_code, unreachable_patterns)]
5469        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5470            match _t {
5471                alloy_sol_types::private::AssertTypeEq::<
5472                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5473                >(_) => {}
5474            }
5475        }
5476        #[automatically_derived]
5477        #[doc(hidden)]
5478        impl ::core::convert::From<StrategyNotInOperatorSet> for UnderlyingRustTuple<'_> {
5479            fn from(value: StrategyNotInOperatorSet) -> Self {
5480                ()
5481            }
5482        }
5483        #[automatically_derived]
5484        #[doc(hidden)]
5485        impl ::core::convert::From<UnderlyingRustTuple<'_>> for StrategyNotInOperatorSet {
5486            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5487                Self
5488            }
5489        }
5490        #[automatically_derived]
5491        impl alloy_sol_types::SolError for StrategyNotInOperatorSet {
5492            type Parameters<'a> = UnderlyingSolTuple<'a>;
5493            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5494            const SIGNATURE: &'static str = "StrategyNotInOperatorSet()";
5495            const SELECTOR: [u8; 4] = [99u8, 120u8, 104u8, 78u8];
5496            #[inline]
5497            fn new<'a>(
5498                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5499            ) -> Self {
5500                tuple.into()
5501            }
5502            #[inline]
5503            fn tokenize(&self) -> Self::Token<'_> {
5504                ()
5505            }
5506            #[inline]
5507            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
5508                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
5509                    data,
5510                )
5511                .map(Self::new)
5512            }
5513        }
5514    };
5515    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
5516    /**Custom error with signature `StringTooLong(string)` and selector `0x305a27a9`.
5517    ```solidity
5518    error StringTooLong(string str);
5519    ```*/
5520    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5521    #[derive(Clone)]
5522    pub struct StringTooLong {
5523        #[allow(missing_docs)]
5524        pub str: alloy::sol_types::private::String,
5525    }
5526    #[allow(
5527        non_camel_case_types,
5528        non_snake_case,
5529        clippy::pub_underscore_fields,
5530        clippy::style
5531    )]
5532    const _: () = {
5533        use alloy::sol_types as alloy_sol_types;
5534        #[doc(hidden)]
5535        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
5536        #[doc(hidden)]
5537        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
5538        #[cfg(test)]
5539        #[allow(dead_code, unreachable_patterns)]
5540        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5541            match _t {
5542                alloy_sol_types::private::AssertTypeEq::<
5543                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5544                >(_) => {}
5545            }
5546        }
5547        #[automatically_derived]
5548        #[doc(hidden)]
5549        impl ::core::convert::From<StringTooLong> for UnderlyingRustTuple<'_> {
5550            fn from(value: StringTooLong) -> Self {
5551                (value.str,)
5552            }
5553        }
5554        #[automatically_derived]
5555        #[doc(hidden)]
5556        impl ::core::convert::From<UnderlyingRustTuple<'_>> for StringTooLong {
5557            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5558                Self { str: tuple.0 }
5559            }
5560        }
5561        #[automatically_derived]
5562        impl alloy_sol_types::SolError for StringTooLong {
5563            type Parameters<'a> = UnderlyingSolTuple<'a>;
5564            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5565            const SIGNATURE: &'static str = "StringTooLong(string)";
5566            const SELECTOR: [u8; 4] = [48u8, 90u8, 39u8, 169u8];
5567            #[inline]
5568            fn new<'a>(
5569                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5570            ) -> Self {
5571                tuple.into()
5572            }
5573            #[inline]
5574            fn tokenize(&self) -> Self::Token<'_> {
5575                (
5576                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
5577                        &self.str,
5578                    ),
5579                )
5580            }
5581            #[inline]
5582            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
5583                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
5584                    data,
5585                )
5586                .map(Self::new)
5587            }
5588        }
5589    };
5590    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
5591    /**Custom error with signature `UninitializedAllocationDelay()` and selector `0xfa55fc81`.
5592    ```solidity
5593    error UninitializedAllocationDelay();
5594    ```*/
5595    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5596    #[derive(Clone)]
5597    pub struct UninitializedAllocationDelay;
5598    #[allow(
5599        non_camel_case_types,
5600        non_snake_case,
5601        clippy::pub_underscore_fields,
5602        clippy::style
5603    )]
5604    const _: () = {
5605        use alloy::sol_types as alloy_sol_types;
5606        #[doc(hidden)]
5607        type UnderlyingSolTuple<'a> = ();
5608        #[doc(hidden)]
5609        type UnderlyingRustTuple<'a> = ();
5610        #[cfg(test)]
5611        #[allow(dead_code, unreachable_patterns)]
5612        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5613            match _t {
5614                alloy_sol_types::private::AssertTypeEq::<
5615                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5616                >(_) => {}
5617            }
5618        }
5619        #[automatically_derived]
5620        #[doc(hidden)]
5621        impl ::core::convert::From<UninitializedAllocationDelay> for UnderlyingRustTuple<'_> {
5622            fn from(value: UninitializedAllocationDelay) -> Self {
5623                ()
5624            }
5625        }
5626        #[automatically_derived]
5627        #[doc(hidden)]
5628        impl ::core::convert::From<UnderlyingRustTuple<'_>> for UninitializedAllocationDelay {
5629            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5630                Self
5631            }
5632        }
5633        #[automatically_derived]
5634        impl alloy_sol_types::SolError for UninitializedAllocationDelay {
5635            type Parameters<'a> = UnderlyingSolTuple<'a>;
5636            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5637            const SIGNATURE: &'static str = "UninitializedAllocationDelay()";
5638            const SELECTOR: [u8; 4] = [250u8, 85u8, 252u8, 129u8];
5639            #[inline]
5640            fn new<'a>(
5641                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5642            ) -> Self {
5643                tuple.into()
5644            }
5645            #[inline]
5646            fn tokenize(&self) -> Self::Token<'_> {
5647                ()
5648            }
5649            #[inline]
5650            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
5651                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
5652                    data,
5653                )
5654                .map(Self::new)
5655            }
5656        }
5657    };
5658    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
5659    /**Event with signature `AVSMetadataURIUpdated(address,string)` and selector `0xa89c1dc243d8908a96dd84944bcc97d6bc6ac00dd78e20621576be6a3c943713`.
5660    ```solidity
5661    event AVSMetadataURIUpdated(address indexed avs, string metadataURI);
5662    ```*/
5663    #[allow(
5664        non_camel_case_types,
5665        non_snake_case,
5666        clippy::pub_underscore_fields,
5667        clippy::style
5668    )]
5669    #[derive(Clone)]
5670    pub struct AVSMetadataURIUpdated {
5671        #[allow(missing_docs)]
5672        pub avs: alloy::sol_types::private::Address,
5673        #[allow(missing_docs)]
5674        pub metadataURI: alloy::sol_types::private::String,
5675    }
5676    #[allow(
5677        non_camel_case_types,
5678        non_snake_case,
5679        clippy::pub_underscore_fields,
5680        clippy::style
5681    )]
5682    const _: () = {
5683        use alloy::sol_types as alloy_sol_types;
5684        #[automatically_derived]
5685        impl alloy_sol_types::SolEvent for AVSMetadataURIUpdated {
5686            type DataTuple<'a> = (alloy::sol_types::sol_data::String,);
5687            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
5688            type TopicList = (
5689                alloy_sol_types::sol_data::FixedBytes<32>,
5690                alloy::sol_types::sol_data::Address,
5691            );
5692            const SIGNATURE: &'static str = "AVSMetadataURIUpdated(address,string)";
5693            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
5694                alloy_sol_types::private::B256::new([
5695                    168u8, 156u8, 29u8, 194u8, 67u8, 216u8, 144u8, 138u8, 150u8, 221u8, 132u8,
5696                    148u8, 75u8, 204u8, 151u8, 214u8, 188u8, 106u8, 192u8, 13u8, 215u8, 142u8,
5697                    32u8, 98u8, 21u8, 118u8, 190u8, 106u8, 60u8, 148u8, 55u8, 19u8,
5698                ]);
5699            const ANONYMOUS: bool = false;
5700            #[allow(unused_variables)]
5701            #[inline]
5702            fn new(
5703                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5704                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5705            ) -> Self {
5706                Self {
5707                    avs: topics.1,
5708                    metadataURI: data.0,
5709                }
5710            }
5711            #[inline]
5712            fn check_signature(
5713                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5714            ) -> alloy_sol_types::Result<()> {
5715                if topics.0 != Self::SIGNATURE_HASH {
5716                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
5717                        Self::SIGNATURE,
5718                        topics.0,
5719                        Self::SIGNATURE_HASH,
5720                    ));
5721                }
5722                Ok(())
5723            }
5724            #[inline]
5725            fn tokenize_body(&self) -> Self::DataToken<'_> {
5726                (
5727                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
5728                        &self.metadataURI,
5729                    ),
5730                )
5731            }
5732            #[inline]
5733            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5734                (Self::SIGNATURE_HASH.into(), self.avs.clone())
5735            }
5736            #[inline]
5737            fn encode_topics_raw(
5738                &self,
5739                out: &mut [alloy_sol_types::abi::token::WordToken],
5740            ) -> alloy_sol_types::Result<()> {
5741                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5742                    return Err(alloy_sol_types::Error::Overrun);
5743                }
5744                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
5745                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
5746                    &self.avs,
5747                );
5748                Ok(())
5749            }
5750        }
5751        #[automatically_derived]
5752        impl alloy_sol_types::private::IntoLogData for AVSMetadataURIUpdated {
5753            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5754                From::from(self)
5755            }
5756            fn into_log_data(self) -> alloy_sol_types::private::LogData {
5757                From::from(&self)
5758            }
5759        }
5760        #[automatically_derived]
5761        impl From<&AVSMetadataURIUpdated> for alloy_sol_types::private::LogData {
5762            #[inline]
5763            fn from(this: &AVSMetadataURIUpdated) -> alloy_sol_types::private::LogData {
5764                alloy_sol_types::SolEvent::encode_log_data(this)
5765            }
5766        }
5767    };
5768    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
5769    /**Event with signature `AVSRegistrarSet(address,address)` and selector `0x2ae945c40c44dc0ec263f95609c3fdc6952e0aefa22d6374e44f2c997acedf85`.
5770    ```solidity
5771    event AVSRegistrarSet(address avs, address registrar);
5772    ```*/
5773    #[allow(
5774        non_camel_case_types,
5775        non_snake_case,
5776        clippy::pub_underscore_fields,
5777        clippy::style
5778    )]
5779    #[derive(Clone)]
5780    pub struct AVSRegistrarSet {
5781        #[allow(missing_docs)]
5782        pub avs: alloy::sol_types::private::Address,
5783        #[allow(missing_docs)]
5784        pub registrar: alloy::sol_types::private::Address,
5785    }
5786    #[allow(
5787        non_camel_case_types,
5788        non_snake_case,
5789        clippy::pub_underscore_fields,
5790        clippy::style
5791    )]
5792    const _: () = {
5793        use alloy::sol_types as alloy_sol_types;
5794        #[automatically_derived]
5795        impl alloy_sol_types::SolEvent for AVSRegistrarSet {
5796            type DataTuple<'a> = (
5797                alloy::sol_types::sol_data::Address,
5798                alloy::sol_types::sol_data::Address,
5799            );
5800            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
5801            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
5802            const SIGNATURE: &'static str = "AVSRegistrarSet(address,address)";
5803            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
5804                alloy_sol_types::private::B256::new([
5805                    42u8, 233u8, 69u8, 196u8, 12u8, 68u8, 220u8, 14u8, 194u8, 99u8, 249u8, 86u8,
5806                    9u8, 195u8, 253u8, 198u8, 149u8, 46u8, 10u8, 239u8, 162u8, 45u8, 99u8, 116u8,
5807                    228u8, 79u8, 44u8, 153u8, 122u8, 206u8, 223u8, 133u8,
5808                ]);
5809            const ANONYMOUS: bool = false;
5810            #[allow(unused_variables)]
5811            #[inline]
5812            fn new(
5813                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5814                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5815            ) -> Self {
5816                Self {
5817                    avs: data.0,
5818                    registrar: data.1,
5819                }
5820            }
5821            #[inline]
5822            fn check_signature(
5823                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5824            ) -> alloy_sol_types::Result<()> {
5825                if topics.0 != Self::SIGNATURE_HASH {
5826                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
5827                        Self::SIGNATURE,
5828                        topics.0,
5829                        Self::SIGNATURE_HASH,
5830                    ));
5831                }
5832                Ok(())
5833            }
5834            #[inline]
5835            fn tokenize_body(&self) -> Self::DataToken<'_> {
5836                (
5837                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5838                        &self.avs,
5839                    ),
5840                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5841                        &self.registrar,
5842                    ),
5843                )
5844            }
5845            #[inline]
5846            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5847                (Self::SIGNATURE_HASH.into(),)
5848            }
5849            #[inline]
5850            fn encode_topics_raw(
5851                &self,
5852                out: &mut [alloy_sol_types::abi::token::WordToken],
5853            ) -> alloy_sol_types::Result<()> {
5854                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5855                    return Err(alloy_sol_types::Error::Overrun);
5856                }
5857                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
5858                Ok(())
5859            }
5860        }
5861        #[automatically_derived]
5862        impl alloy_sol_types::private::IntoLogData for AVSRegistrarSet {
5863            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5864                From::from(self)
5865            }
5866            fn into_log_data(self) -> alloy_sol_types::private::LogData {
5867                From::from(&self)
5868            }
5869        }
5870        #[automatically_derived]
5871        impl From<&AVSRegistrarSet> for alloy_sol_types::private::LogData {
5872            #[inline]
5873            fn from(this: &AVSRegistrarSet) -> alloy_sol_types::private::LogData {
5874                alloy_sol_types::SolEvent::encode_log_data(this)
5875            }
5876        }
5877    };
5878    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
5879    /**Event with signature `AllocationDelaySet(address,uint32,uint32)` and selector `0x4e85751d6331506c6c62335f207eb31f12a61e570f34f5c17640308785c6d4db`.
5880    ```solidity
5881    event AllocationDelaySet(address operator, uint32 delay, uint32 effectBlock);
5882    ```*/
5883    #[allow(
5884        non_camel_case_types,
5885        non_snake_case,
5886        clippy::pub_underscore_fields,
5887        clippy::style
5888    )]
5889    #[derive(Clone)]
5890    pub struct AllocationDelaySet {
5891        #[allow(missing_docs)]
5892        pub operator: alloy::sol_types::private::Address,
5893        #[allow(missing_docs)]
5894        pub delay: u32,
5895        #[allow(missing_docs)]
5896        pub effectBlock: u32,
5897    }
5898    #[allow(
5899        non_camel_case_types,
5900        non_snake_case,
5901        clippy::pub_underscore_fields,
5902        clippy::style
5903    )]
5904    const _: () = {
5905        use alloy::sol_types as alloy_sol_types;
5906        #[automatically_derived]
5907        impl alloy_sol_types::SolEvent for AllocationDelaySet {
5908            type DataTuple<'a> = (
5909                alloy::sol_types::sol_data::Address,
5910                alloy::sol_types::sol_data::Uint<32>,
5911                alloy::sol_types::sol_data::Uint<32>,
5912            );
5913            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
5914            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
5915            const SIGNATURE: &'static str = "AllocationDelaySet(address,uint32,uint32)";
5916            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
5917                alloy_sol_types::private::B256::new([
5918                    78u8, 133u8, 117u8, 29u8, 99u8, 49u8, 80u8, 108u8, 108u8, 98u8, 51u8, 95u8,
5919                    32u8, 126u8, 179u8, 31u8, 18u8, 166u8, 30u8, 87u8, 15u8, 52u8, 245u8, 193u8,
5920                    118u8, 64u8, 48u8, 135u8, 133u8, 198u8, 212u8, 219u8,
5921                ]);
5922            const ANONYMOUS: bool = false;
5923            #[allow(unused_variables)]
5924            #[inline]
5925            fn new(
5926                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5927                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5928            ) -> Self {
5929                Self {
5930                    operator: data.0,
5931                    delay: data.1,
5932                    effectBlock: data.2,
5933                }
5934            }
5935            #[inline]
5936            fn check_signature(
5937                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5938            ) -> alloy_sol_types::Result<()> {
5939                if topics.0 != Self::SIGNATURE_HASH {
5940                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
5941                        Self::SIGNATURE,
5942                        topics.0,
5943                        Self::SIGNATURE_HASH,
5944                    ));
5945                }
5946                Ok(())
5947            }
5948            #[inline]
5949            fn tokenize_body(&self) -> Self::DataToken<'_> {
5950                (
5951                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5952                        &self.operator,
5953                    ),
5954                    <alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
5955                        &self.delay,
5956                    ),
5957                    <alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
5958                        &self.effectBlock,
5959                    ),
5960                )
5961            }
5962            #[inline]
5963            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5964                (Self::SIGNATURE_HASH.into(),)
5965            }
5966            #[inline]
5967            fn encode_topics_raw(
5968                &self,
5969                out: &mut [alloy_sol_types::abi::token::WordToken],
5970            ) -> alloy_sol_types::Result<()> {
5971                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5972                    return Err(alloy_sol_types::Error::Overrun);
5973                }
5974                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
5975                Ok(())
5976            }
5977        }
5978        #[automatically_derived]
5979        impl alloy_sol_types::private::IntoLogData for AllocationDelaySet {
5980            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5981                From::from(self)
5982            }
5983            fn into_log_data(self) -> alloy_sol_types::private::LogData {
5984                From::from(&self)
5985            }
5986        }
5987        #[automatically_derived]
5988        impl From<&AllocationDelaySet> for alloy_sol_types::private::LogData {
5989            #[inline]
5990            fn from(this: &AllocationDelaySet) -> alloy_sol_types::private::LogData {
5991                alloy_sol_types::SolEvent::encode_log_data(this)
5992            }
5993        }
5994    };
5995    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
5996    /**Event with signature `AllocationUpdated(address,(address,uint32),address,uint64,uint32)` and selector `0x1487af5418c47ee5ea45ef4a93398668120890774a9e13487e61e9dc3baf76dd`.
5997    ```solidity
5998    event AllocationUpdated(address operator, OperatorSet operatorSet, address strategy, uint64 magnitude, uint32 effectBlock);
5999    ```*/
6000    #[allow(
6001        non_camel_case_types,
6002        non_snake_case,
6003        clippy::pub_underscore_fields,
6004        clippy::style
6005    )]
6006    #[derive(Clone)]
6007    pub struct AllocationUpdated {
6008        #[allow(missing_docs)]
6009        pub operator: alloy::sol_types::private::Address,
6010        #[allow(missing_docs)]
6011        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
6012        #[allow(missing_docs)]
6013        pub strategy: alloy::sol_types::private::Address,
6014        #[allow(missing_docs)]
6015        pub magnitude: u64,
6016        #[allow(missing_docs)]
6017        pub effectBlock: u32,
6018    }
6019    #[allow(
6020        non_camel_case_types,
6021        non_snake_case,
6022        clippy::pub_underscore_fields,
6023        clippy::style
6024    )]
6025    const _: () = {
6026        use alloy::sol_types as alloy_sol_types;
6027        #[automatically_derived]
6028        impl alloy_sol_types::SolEvent for AllocationUpdated {
6029            type DataTuple<'a> = (
6030                alloy::sol_types::sol_data::Address,
6031                OperatorSet,
6032                alloy::sol_types::sol_data::Address,
6033                alloy::sol_types::sol_data::Uint<64>,
6034                alloy::sol_types::sol_data::Uint<32>,
6035            );
6036            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
6037            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
6038            const SIGNATURE: &'static str =
6039                "AllocationUpdated(address,(address,uint32),address,uint64,uint32)";
6040            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
6041                alloy_sol_types::private::B256::new([
6042                    20u8, 135u8, 175u8, 84u8, 24u8, 196u8, 126u8, 229u8, 234u8, 69u8, 239u8, 74u8,
6043                    147u8, 57u8, 134u8, 104u8, 18u8, 8u8, 144u8, 119u8, 74u8, 158u8, 19u8, 72u8,
6044                    126u8, 97u8, 233u8, 220u8, 59u8, 175u8, 118u8, 221u8,
6045                ]);
6046            const ANONYMOUS: bool = false;
6047            #[allow(unused_variables)]
6048            #[inline]
6049            fn new(
6050                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
6051                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
6052            ) -> Self {
6053                Self {
6054                    operator: data.0,
6055                    operatorSet: data.1,
6056                    strategy: data.2,
6057                    magnitude: data.3,
6058                    effectBlock: data.4,
6059                }
6060            }
6061            #[inline]
6062            fn check_signature(
6063                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
6064            ) -> alloy_sol_types::Result<()> {
6065                if topics.0 != Self::SIGNATURE_HASH {
6066                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
6067                        Self::SIGNATURE,
6068                        topics.0,
6069                        Self::SIGNATURE_HASH,
6070                    ));
6071                }
6072                Ok(())
6073            }
6074            #[inline]
6075            fn tokenize_body(&self) -> Self::DataToken<'_> {
6076                (
6077                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6078                        &self.operator,
6079                    ),
6080                    <OperatorSet as alloy_sol_types::SolType>::tokenize(&self.operatorSet),
6081                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6082                        &self.strategy,
6083                    ),
6084                    <alloy::sol_types::sol_data::Uint<64> as alloy_sol_types::SolType>::tokenize(
6085                        &self.magnitude,
6086                    ),
6087                    <alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
6088                        &self.effectBlock,
6089                    ),
6090                )
6091            }
6092            #[inline]
6093            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
6094                (Self::SIGNATURE_HASH.into(),)
6095            }
6096            #[inline]
6097            fn encode_topics_raw(
6098                &self,
6099                out: &mut [alloy_sol_types::abi::token::WordToken],
6100            ) -> alloy_sol_types::Result<()> {
6101                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
6102                    return Err(alloy_sol_types::Error::Overrun);
6103                }
6104                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
6105                Ok(())
6106            }
6107        }
6108        #[automatically_derived]
6109        impl alloy_sol_types::private::IntoLogData for AllocationUpdated {
6110            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
6111                From::from(self)
6112            }
6113            fn into_log_data(self) -> alloy_sol_types::private::LogData {
6114                From::from(&self)
6115            }
6116        }
6117        #[automatically_derived]
6118        impl From<&AllocationUpdated> for alloy_sol_types::private::LogData {
6119            #[inline]
6120            fn from(this: &AllocationUpdated) -> alloy_sol_types::private::LogData {
6121                alloy_sol_types::SolEvent::encode_log_data(this)
6122            }
6123        }
6124    };
6125    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
6126    /**Event with signature `EncumberedMagnitudeUpdated(address,address,uint64)` and selector `0xacf9095feb3a370c9cf692421c69ef320d4db5c66e6a7d29c7694eb02364fc55`.
6127    ```solidity
6128    event EncumberedMagnitudeUpdated(address operator, address strategy, uint64 encumberedMagnitude);
6129    ```*/
6130    #[allow(
6131        non_camel_case_types,
6132        non_snake_case,
6133        clippy::pub_underscore_fields,
6134        clippy::style
6135    )]
6136    #[derive(Clone)]
6137    pub struct EncumberedMagnitudeUpdated {
6138        #[allow(missing_docs)]
6139        pub operator: alloy::sol_types::private::Address,
6140        #[allow(missing_docs)]
6141        pub strategy: alloy::sol_types::private::Address,
6142        #[allow(missing_docs)]
6143        pub encumberedMagnitude: u64,
6144    }
6145    #[allow(
6146        non_camel_case_types,
6147        non_snake_case,
6148        clippy::pub_underscore_fields,
6149        clippy::style
6150    )]
6151    const _: () = {
6152        use alloy::sol_types as alloy_sol_types;
6153        #[automatically_derived]
6154        impl alloy_sol_types::SolEvent for EncumberedMagnitudeUpdated {
6155            type DataTuple<'a> = (
6156                alloy::sol_types::sol_data::Address,
6157                alloy::sol_types::sol_data::Address,
6158                alloy::sol_types::sol_data::Uint<64>,
6159            );
6160            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
6161            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
6162            const SIGNATURE: &'static str = "EncumberedMagnitudeUpdated(address,address,uint64)";
6163            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
6164                alloy_sol_types::private::B256::new([
6165                    172u8, 249u8, 9u8, 95u8, 235u8, 58u8, 55u8, 12u8, 156u8, 246u8, 146u8, 66u8,
6166                    28u8, 105u8, 239u8, 50u8, 13u8, 77u8, 181u8, 198u8, 110u8, 106u8, 125u8, 41u8,
6167                    199u8, 105u8, 78u8, 176u8, 35u8, 100u8, 252u8, 85u8,
6168                ]);
6169            const ANONYMOUS: bool = false;
6170            #[allow(unused_variables)]
6171            #[inline]
6172            fn new(
6173                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
6174                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
6175            ) -> Self {
6176                Self {
6177                    operator: data.0,
6178                    strategy: data.1,
6179                    encumberedMagnitude: data.2,
6180                }
6181            }
6182            #[inline]
6183            fn check_signature(
6184                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
6185            ) -> alloy_sol_types::Result<()> {
6186                if topics.0 != Self::SIGNATURE_HASH {
6187                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
6188                        Self::SIGNATURE,
6189                        topics.0,
6190                        Self::SIGNATURE_HASH,
6191                    ));
6192                }
6193                Ok(())
6194            }
6195            #[inline]
6196            fn tokenize_body(&self) -> Self::DataToken<'_> {
6197                (
6198                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6199                        &self.operator,
6200                    ),
6201                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6202                        &self.strategy,
6203                    ),
6204                    <alloy::sol_types::sol_data::Uint<64> as alloy_sol_types::SolType>::tokenize(
6205                        &self.encumberedMagnitude,
6206                    ),
6207                )
6208            }
6209            #[inline]
6210            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
6211                (Self::SIGNATURE_HASH.into(),)
6212            }
6213            #[inline]
6214            fn encode_topics_raw(
6215                &self,
6216                out: &mut [alloy_sol_types::abi::token::WordToken],
6217            ) -> alloy_sol_types::Result<()> {
6218                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
6219                    return Err(alloy_sol_types::Error::Overrun);
6220                }
6221                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
6222                Ok(())
6223            }
6224        }
6225        #[automatically_derived]
6226        impl alloy_sol_types::private::IntoLogData for EncumberedMagnitudeUpdated {
6227            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
6228                From::from(self)
6229            }
6230            fn into_log_data(self) -> alloy_sol_types::private::LogData {
6231                From::from(&self)
6232            }
6233        }
6234        #[automatically_derived]
6235        impl From<&EncumberedMagnitudeUpdated> for alloy_sol_types::private::LogData {
6236            #[inline]
6237            fn from(this: &EncumberedMagnitudeUpdated) -> alloy_sol_types::private::LogData {
6238                alloy_sol_types::SolEvent::encode_log_data(this)
6239            }
6240        }
6241    };
6242    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
6243    /**Event with signature `Initialized(uint8)` and selector `0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498`.
6244    ```solidity
6245    event Initialized(uint8 version);
6246    ```*/
6247    #[allow(
6248        non_camel_case_types,
6249        non_snake_case,
6250        clippy::pub_underscore_fields,
6251        clippy::style
6252    )]
6253    #[derive(Clone)]
6254    pub struct Initialized {
6255        #[allow(missing_docs)]
6256        pub version: u8,
6257    }
6258    #[allow(
6259        non_camel_case_types,
6260        non_snake_case,
6261        clippy::pub_underscore_fields,
6262        clippy::style
6263    )]
6264    const _: () = {
6265        use alloy::sol_types as alloy_sol_types;
6266        #[automatically_derived]
6267        impl alloy_sol_types::SolEvent for Initialized {
6268            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
6269            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
6270            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
6271            const SIGNATURE: &'static str = "Initialized(uint8)";
6272            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
6273                alloy_sol_types::private::B256::new([
6274                    127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8, 19u8,
6275                    56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8, 146u8, 20u8,
6276                    96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8,
6277                ]);
6278            const ANONYMOUS: bool = false;
6279            #[allow(unused_variables)]
6280            #[inline]
6281            fn new(
6282                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
6283                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
6284            ) -> Self {
6285                Self { version: data.0 }
6286            }
6287            #[inline]
6288            fn check_signature(
6289                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
6290            ) -> alloy_sol_types::Result<()> {
6291                if topics.0 != Self::SIGNATURE_HASH {
6292                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
6293                        Self::SIGNATURE,
6294                        topics.0,
6295                        Self::SIGNATURE_HASH,
6296                    ));
6297                }
6298                Ok(())
6299            }
6300            #[inline]
6301            fn tokenize_body(&self) -> Self::DataToken<'_> {
6302                (
6303                    <alloy::sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(
6304                        &self.version,
6305                    ),
6306                )
6307            }
6308            #[inline]
6309            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
6310                (Self::SIGNATURE_HASH.into(),)
6311            }
6312            #[inline]
6313            fn encode_topics_raw(
6314                &self,
6315                out: &mut [alloy_sol_types::abi::token::WordToken],
6316            ) -> alloy_sol_types::Result<()> {
6317                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
6318                    return Err(alloy_sol_types::Error::Overrun);
6319                }
6320                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
6321                Ok(())
6322            }
6323        }
6324        #[automatically_derived]
6325        impl alloy_sol_types::private::IntoLogData for Initialized {
6326            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
6327                From::from(self)
6328            }
6329            fn into_log_data(self) -> alloy_sol_types::private::LogData {
6330                From::from(&self)
6331            }
6332        }
6333        #[automatically_derived]
6334        impl From<&Initialized> for alloy_sol_types::private::LogData {
6335            #[inline]
6336            fn from(this: &Initialized) -> alloy_sol_types::private::LogData {
6337                alloy_sol_types::SolEvent::encode_log_data(this)
6338            }
6339        }
6340    };
6341    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
6342    /**Event with signature `MaxMagnitudeUpdated(address,address,uint64)` and selector `0x1c6458079a41077d003c11faf9bf097e693bd67979e4e6500bac7b29db779b5c`.
6343    ```solidity
6344    event MaxMagnitudeUpdated(address operator, address strategy, uint64 maxMagnitude);
6345    ```*/
6346    #[allow(
6347        non_camel_case_types,
6348        non_snake_case,
6349        clippy::pub_underscore_fields,
6350        clippy::style
6351    )]
6352    #[derive(Clone)]
6353    pub struct MaxMagnitudeUpdated {
6354        #[allow(missing_docs)]
6355        pub operator: alloy::sol_types::private::Address,
6356        #[allow(missing_docs)]
6357        pub strategy: alloy::sol_types::private::Address,
6358        #[allow(missing_docs)]
6359        pub maxMagnitude: u64,
6360    }
6361    #[allow(
6362        non_camel_case_types,
6363        non_snake_case,
6364        clippy::pub_underscore_fields,
6365        clippy::style
6366    )]
6367    const _: () = {
6368        use alloy::sol_types as alloy_sol_types;
6369        #[automatically_derived]
6370        impl alloy_sol_types::SolEvent for MaxMagnitudeUpdated {
6371            type DataTuple<'a> = (
6372                alloy::sol_types::sol_data::Address,
6373                alloy::sol_types::sol_data::Address,
6374                alloy::sol_types::sol_data::Uint<64>,
6375            );
6376            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
6377            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
6378            const SIGNATURE: &'static str = "MaxMagnitudeUpdated(address,address,uint64)";
6379            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
6380                alloy_sol_types::private::B256::new([
6381                    28u8, 100u8, 88u8, 7u8, 154u8, 65u8, 7u8, 125u8, 0u8, 60u8, 17u8, 250u8, 249u8,
6382                    191u8, 9u8, 126u8, 105u8, 59u8, 214u8, 121u8, 121u8, 228u8, 230u8, 80u8, 11u8,
6383                    172u8, 123u8, 41u8, 219u8, 119u8, 155u8, 92u8,
6384                ]);
6385            const ANONYMOUS: bool = false;
6386            #[allow(unused_variables)]
6387            #[inline]
6388            fn new(
6389                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
6390                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
6391            ) -> Self {
6392                Self {
6393                    operator: data.0,
6394                    strategy: data.1,
6395                    maxMagnitude: data.2,
6396                }
6397            }
6398            #[inline]
6399            fn check_signature(
6400                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
6401            ) -> alloy_sol_types::Result<()> {
6402                if topics.0 != Self::SIGNATURE_HASH {
6403                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
6404                        Self::SIGNATURE,
6405                        topics.0,
6406                        Self::SIGNATURE_HASH,
6407                    ));
6408                }
6409                Ok(())
6410            }
6411            #[inline]
6412            fn tokenize_body(&self) -> Self::DataToken<'_> {
6413                (
6414                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6415                        &self.operator,
6416                    ),
6417                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6418                        &self.strategy,
6419                    ),
6420                    <alloy::sol_types::sol_data::Uint<64> as alloy_sol_types::SolType>::tokenize(
6421                        &self.maxMagnitude,
6422                    ),
6423                )
6424            }
6425            #[inline]
6426            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
6427                (Self::SIGNATURE_HASH.into(),)
6428            }
6429            #[inline]
6430            fn encode_topics_raw(
6431                &self,
6432                out: &mut [alloy_sol_types::abi::token::WordToken],
6433            ) -> alloy_sol_types::Result<()> {
6434                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
6435                    return Err(alloy_sol_types::Error::Overrun);
6436                }
6437                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
6438                Ok(())
6439            }
6440        }
6441        #[automatically_derived]
6442        impl alloy_sol_types::private::IntoLogData for MaxMagnitudeUpdated {
6443            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
6444                From::from(self)
6445            }
6446            fn into_log_data(self) -> alloy_sol_types::private::LogData {
6447                From::from(&self)
6448            }
6449        }
6450        #[automatically_derived]
6451        impl From<&MaxMagnitudeUpdated> for alloy_sol_types::private::LogData {
6452            #[inline]
6453            fn from(this: &MaxMagnitudeUpdated) -> alloy_sol_types::private::LogData {
6454                alloy_sol_types::SolEvent::encode_log_data(this)
6455            }
6456        }
6457    };
6458    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
6459    /**Event with signature `OperatorAddedToOperatorSet(address,(address,uint32))` and selector `0x43232edf9071753d2321e5fa7e018363ee248e5f2142e6c08edd3265bfb4895e`.
6460    ```solidity
6461    event OperatorAddedToOperatorSet(address indexed operator, OperatorSet operatorSet);
6462    ```*/
6463    #[allow(
6464        non_camel_case_types,
6465        non_snake_case,
6466        clippy::pub_underscore_fields,
6467        clippy::style
6468    )]
6469    #[derive(Clone)]
6470    pub struct OperatorAddedToOperatorSet {
6471        #[allow(missing_docs)]
6472        pub operator: alloy::sol_types::private::Address,
6473        #[allow(missing_docs)]
6474        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
6475    }
6476    #[allow(
6477        non_camel_case_types,
6478        non_snake_case,
6479        clippy::pub_underscore_fields,
6480        clippy::style
6481    )]
6482    const _: () = {
6483        use alloy::sol_types as alloy_sol_types;
6484        #[automatically_derived]
6485        impl alloy_sol_types::SolEvent for OperatorAddedToOperatorSet {
6486            type DataTuple<'a> = (OperatorSet,);
6487            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
6488            type TopicList = (
6489                alloy_sol_types::sol_data::FixedBytes<32>,
6490                alloy::sol_types::sol_data::Address,
6491            );
6492            const SIGNATURE: &'static str = "OperatorAddedToOperatorSet(address,(address,uint32))";
6493            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
6494                alloy_sol_types::private::B256::new([
6495                    67u8, 35u8, 46u8, 223u8, 144u8, 113u8, 117u8, 61u8, 35u8, 33u8, 229u8, 250u8,
6496                    126u8, 1u8, 131u8, 99u8, 238u8, 36u8, 142u8, 95u8, 33u8, 66u8, 230u8, 192u8,
6497                    142u8, 221u8, 50u8, 101u8, 191u8, 180u8, 137u8, 94u8,
6498                ]);
6499            const ANONYMOUS: bool = false;
6500            #[allow(unused_variables)]
6501            #[inline]
6502            fn new(
6503                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
6504                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
6505            ) -> Self {
6506                Self {
6507                    operator: topics.1,
6508                    operatorSet: data.0,
6509                }
6510            }
6511            #[inline]
6512            fn check_signature(
6513                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
6514            ) -> alloy_sol_types::Result<()> {
6515                if topics.0 != Self::SIGNATURE_HASH {
6516                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
6517                        Self::SIGNATURE,
6518                        topics.0,
6519                        Self::SIGNATURE_HASH,
6520                    ));
6521                }
6522                Ok(())
6523            }
6524            #[inline]
6525            fn tokenize_body(&self) -> Self::DataToken<'_> {
6526                (<OperatorSet as alloy_sol_types::SolType>::tokenize(
6527                    &self.operatorSet,
6528                ),)
6529            }
6530            #[inline]
6531            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
6532                (Self::SIGNATURE_HASH.into(), self.operator.clone())
6533            }
6534            #[inline]
6535            fn encode_topics_raw(
6536                &self,
6537                out: &mut [alloy_sol_types::abi::token::WordToken],
6538            ) -> alloy_sol_types::Result<()> {
6539                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
6540                    return Err(alloy_sol_types::Error::Overrun);
6541                }
6542                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
6543                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
6544                    &self.operator,
6545                );
6546                Ok(())
6547            }
6548        }
6549        #[automatically_derived]
6550        impl alloy_sol_types::private::IntoLogData for OperatorAddedToOperatorSet {
6551            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
6552                From::from(self)
6553            }
6554            fn into_log_data(self) -> alloy_sol_types::private::LogData {
6555                From::from(&self)
6556            }
6557        }
6558        #[automatically_derived]
6559        impl From<&OperatorAddedToOperatorSet> for alloy_sol_types::private::LogData {
6560            #[inline]
6561            fn from(this: &OperatorAddedToOperatorSet) -> alloy_sol_types::private::LogData {
6562                alloy_sol_types::SolEvent::encode_log_data(this)
6563            }
6564        }
6565    };
6566    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
6567    /**Event with signature `OperatorRemovedFromOperatorSet(address,(address,uint32))` and selector `0xad34c3070be1dffbcaa499d000ba2b8d9848aefcac3059df245dd95c4ece14fe`.
6568    ```solidity
6569    event OperatorRemovedFromOperatorSet(address indexed operator, OperatorSet operatorSet);
6570    ```*/
6571    #[allow(
6572        non_camel_case_types,
6573        non_snake_case,
6574        clippy::pub_underscore_fields,
6575        clippy::style
6576    )]
6577    #[derive(Clone)]
6578    pub struct OperatorRemovedFromOperatorSet {
6579        #[allow(missing_docs)]
6580        pub operator: alloy::sol_types::private::Address,
6581        #[allow(missing_docs)]
6582        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
6583    }
6584    #[allow(
6585        non_camel_case_types,
6586        non_snake_case,
6587        clippy::pub_underscore_fields,
6588        clippy::style
6589    )]
6590    const _: () = {
6591        use alloy::sol_types as alloy_sol_types;
6592        #[automatically_derived]
6593        impl alloy_sol_types::SolEvent for OperatorRemovedFromOperatorSet {
6594            type DataTuple<'a> = (OperatorSet,);
6595            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
6596            type TopicList = (
6597                alloy_sol_types::sol_data::FixedBytes<32>,
6598                alloy::sol_types::sol_data::Address,
6599            );
6600            const SIGNATURE: &'static str =
6601                "OperatorRemovedFromOperatorSet(address,(address,uint32))";
6602            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
6603                alloy_sol_types::private::B256::new([
6604                    173u8, 52u8, 195u8, 7u8, 11u8, 225u8, 223u8, 251u8, 202u8, 164u8, 153u8, 208u8,
6605                    0u8, 186u8, 43u8, 141u8, 152u8, 72u8, 174u8, 252u8, 172u8, 48u8, 89u8, 223u8,
6606                    36u8, 93u8, 217u8, 92u8, 78u8, 206u8, 20u8, 254u8,
6607                ]);
6608            const ANONYMOUS: bool = false;
6609            #[allow(unused_variables)]
6610            #[inline]
6611            fn new(
6612                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
6613                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
6614            ) -> Self {
6615                Self {
6616                    operator: topics.1,
6617                    operatorSet: data.0,
6618                }
6619            }
6620            #[inline]
6621            fn check_signature(
6622                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
6623            ) -> alloy_sol_types::Result<()> {
6624                if topics.0 != Self::SIGNATURE_HASH {
6625                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
6626                        Self::SIGNATURE,
6627                        topics.0,
6628                        Self::SIGNATURE_HASH,
6629                    ));
6630                }
6631                Ok(())
6632            }
6633            #[inline]
6634            fn tokenize_body(&self) -> Self::DataToken<'_> {
6635                (<OperatorSet as alloy_sol_types::SolType>::tokenize(
6636                    &self.operatorSet,
6637                ),)
6638            }
6639            #[inline]
6640            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
6641                (Self::SIGNATURE_HASH.into(), self.operator.clone())
6642            }
6643            #[inline]
6644            fn encode_topics_raw(
6645                &self,
6646                out: &mut [alloy_sol_types::abi::token::WordToken],
6647            ) -> alloy_sol_types::Result<()> {
6648                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
6649                    return Err(alloy_sol_types::Error::Overrun);
6650                }
6651                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
6652                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
6653                    &self.operator,
6654                );
6655                Ok(())
6656            }
6657        }
6658        #[automatically_derived]
6659        impl alloy_sol_types::private::IntoLogData for OperatorRemovedFromOperatorSet {
6660            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
6661                From::from(self)
6662            }
6663            fn into_log_data(self) -> alloy_sol_types::private::LogData {
6664                From::from(&self)
6665            }
6666        }
6667        #[automatically_derived]
6668        impl From<&OperatorRemovedFromOperatorSet> for alloy_sol_types::private::LogData {
6669            #[inline]
6670            fn from(this: &OperatorRemovedFromOperatorSet) -> alloy_sol_types::private::LogData {
6671                alloy_sol_types::SolEvent::encode_log_data(this)
6672            }
6673        }
6674    };
6675    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
6676    /**Event with signature `OperatorSetCreated((address,uint32))` and selector `0x31629285ead2335ae0933f86ed2ae63321f7af77b4e6eaabc42c057880977e6c`.
6677    ```solidity
6678    event OperatorSetCreated(OperatorSet operatorSet);
6679    ```*/
6680    #[allow(
6681        non_camel_case_types,
6682        non_snake_case,
6683        clippy::pub_underscore_fields,
6684        clippy::style
6685    )]
6686    #[derive(Clone)]
6687    pub struct OperatorSetCreated {
6688        #[allow(missing_docs)]
6689        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
6690    }
6691    #[allow(
6692        non_camel_case_types,
6693        non_snake_case,
6694        clippy::pub_underscore_fields,
6695        clippy::style
6696    )]
6697    const _: () = {
6698        use alloy::sol_types as alloy_sol_types;
6699        #[automatically_derived]
6700        impl alloy_sol_types::SolEvent for OperatorSetCreated {
6701            type DataTuple<'a> = (OperatorSet,);
6702            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
6703            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
6704            const SIGNATURE: &'static str = "OperatorSetCreated((address,uint32))";
6705            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
6706                alloy_sol_types::private::B256::new([
6707                    49u8, 98u8, 146u8, 133u8, 234u8, 210u8, 51u8, 90u8, 224u8, 147u8, 63u8, 134u8,
6708                    237u8, 42u8, 230u8, 51u8, 33u8, 247u8, 175u8, 119u8, 180u8, 230u8, 234u8,
6709                    171u8, 196u8, 44u8, 5u8, 120u8, 128u8, 151u8, 126u8, 108u8,
6710                ]);
6711            const ANONYMOUS: bool = false;
6712            #[allow(unused_variables)]
6713            #[inline]
6714            fn new(
6715                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
6716                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
6717            ) -> Self {
6718                Self {
6719                    operatorSet: data.0,
6720                }
6721            }
6722            #[inline]
6723            fn check_signature(
6724                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
6725            ) -> alloy_sol_types::Result<()> {
6726                if topics.0 != Self::SIGNATURE_HASH {
6727                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
6728                        Self::SIGNATURE,
6729                        topics.0,
6730                        Self::SIGNATURE_HASH,
6731                    ));
6732                }
6733                Ok(())
6734            }
6735            #[inline]
6736            fn tokenize_body(&self) -> Self::DataToken<'_> {
6737                (<OperatorSet as alloy_sol_types::SolType>::tokenize(
6738                    &self.operatorSet,
6739                ),)
6740            }
6741            #[inline]
6742            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
6743                (Self::SIGNATURE_HASH.into(),)
6744            }
6745            #[inline]
6746            fn encode_topics_raw(
6747                &self,
6748                out: &mut [alloy_sol_types::abi::token::WordToken],
6749            ) -> alloy_sol_types::Result<()> {
6750                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
6751                    return Err(alloy_sol_types::Error::Overrun);
6752                }
6753                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
6754                Ok(())
6755            }
6756        }
6757        #[automatically_derived]
6758        impl alloy_sol_types::private::IntoLogData for OperatorSetCreated {
6759            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
6760                From::from(self)
6761            }
6762            fn into_log_data(self) -> alloy_sol_types::private::LogData {
6763                From::from(&self)
6764            }
6765        }
6766        #[automatically_derived]
6767        impl From<&OperatorSetCreated> for alloy_sol_types::private::LogData {
6768            #[inline]
6769            fn from(this: &OperatorSetCreated) -> alloy_sol_types::private::LogData {
6770                alloy_sol_types::SolEvent::encode_log_data(this)
6771            }
6772        }
6773    };
6774    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
6775    /**Event with signature `OperatorSlashed(address,(address,uint32),address[],uint256[],string)` and selector `0x80969ad29428d6797ee7aad084f9e4a42a82fc506dcd2ca3b6fb431f85ccebe5`.
6776    ```solidity
6777    event OperatorSlashed(address operator, OperatorSet operatorSet, address[] strategies, uint256[] wadSlashed, string description);
6778    ```*/
6779    #[allow(
6780        non_camel_case_types,
6781        non_snake_case,
6782        clippy::pub_underscore_fields,
6783        clippy::style
6784    )]
6785    #[derive(Clone)]
6786    pub struct OperatorSlashed {
6787        #[allow(missing_docs)]
6788        pub operator: alloy::sol_types::private::Address,
6789        #[allow(missing_docs)]
6790        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
6791        #[allow(missing_docs)]
6792        pub strategies: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
6793        #[allow(missing_docs)]
6794        pub wadSlashed:
6795            alloy::sol_types::private::Vec<alloy::sol_types::private::primitives::aliases::U256>,
6796        #[allow(missing_docs)]
6797        pub description: alloy::sol_types::private::String,
6798    }
6799    #[allow(
6800        non_camel_case_types,
6801        non_snake_case,
6802        clippy::pub_underscore_fields,
6803        clippy::style
6804    )]
6805    const _: () = {
6806        use alloy::sol_types as alloy_sol_types;
6807        #[automatically_derived]
6808        impl alloy_sol_types::SolEvent for OperatorSlashed {
6809            type DataTuple<'a> = (
6810                alloy::sol_types::sol_data::Address,
6811                OperatorSet,
6812                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
6813                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
6814                alloy::sol_types::sol_data::String,
6815            );
6816            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
6817            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
6818            const SIGNATURE: &'static str =
6819                "OperatorSlashed(address,(address,uint32),address[],uint256[],string)";
6820            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
6821                alloy_sol_types::private::B256::new([
6822                    128u8, 150u8, 154u8, 210u8, 148u8, 40u8, 214u8, 121u8, 126u8, 231u8, 170u8,
6823                    208u8, 132u8, 249u8, 228u8, 164u8, 42u8, 130u8, 252u8, 80u8, 109u8, 205u8,
6824                    44u8, 163u8, 182u8, 251u8, 67u8, 31u8, 133u8, 204u8, 235u8, 229u8,
6825                ]);
6826            const ANONYMOUS: bool = false;
6827            #[allow(unused_variables)]
6828            #[inline]
6829            fn new(
6830                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
6831                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
6832            ) -> Self {
6833                Self {
6834                    operator: data.0,
6835                    operatorSet: data.1,
6836                    strategies: data.2,
6837                    wadSlashed: data.3,
6838                    description: data.4,
6839                }
6840            }
6841            #[inline]
6842            fn check_signature(
6843                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
6844            ) -> alloy_sol_types::Result<()> {
6845                if topics.0 != Self::SIGNATURE_HASH {
6846                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
6847                        Self::SIGNATURE,
6848                        topics.0,
6849                        Self::SIGNATURE_HASH,
6850                    ));
6851                }
6852                Ok(())
6853            }
6854            #[inline]
6855            fn tokenize_body(&self) -> Self::DataToken<'_> {
6856                (
6857                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6858                        &self.operator,
6859                    ),
6860                    <OperatorSet as alloy_sol_types::SolType>::tokenize(
6861                        &self.operatorSet,
6862                    ),
6863                    <alloy::sol_types::sol_data::Array<
6864                        alloy::sol_types::sol_data::Address,
6865                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
6866                    <alloy::sol_types::sol_data::Array<
6867                        alloy::sol_types::sol_data::Uint<256>,
6868                    > as alloy_sol_types::SolType>::tokenize(&self.wadSlashed),
6869                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
6870                        &self.description,
6871                    ),
6872                )
6873            }
6874            #[inline]
6875            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
6876                (Self::SIGNATURE_HASH.into(),)
6877            }
6878            #[inline]
6879            fn encode_topics_raw(
6880                &self,
6881                out: &mut [alloy_sol_types::abi::token::WordToken],
6882            ) -> alloy_sol_types::Result<()> {
6883                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
6884                    return Err(alloy_sol_types::Error::Overrun);
6885                }
6886                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
6887                Ok(())
6888            }
6889        }
6890        #[automatically_derived]
6891        impl alloy_sol_types::private::IntoLogData for OperatorSlashed {
6892            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
6893                From::from(self)
6894            }
6895            fn into_log_data(self) -> alloy_sol_types::private::LogData {
6896                From::from(&self)
6897            }
6898        }
6899        #[automatically_derived]
6900        impl From<&OperatorSlashed> for alloy_sol_types::private::LogData {
6901            #[inline]
6902            fn from(this: &OperatorSlashed) -> alloy_sol_types::private::LogData {
6903                alloy_sol_types::SolEvent::encode_log_data(this)
6904            }
6905        }
6906    };
6907    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
6908    /**Event with signature `OwnershipTransferred(address,address)` and selector `0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0`.
6909    ```solidity
6910    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
6911    ```*/
6912    #[allow(
6913        non_camel_case_types,
6914        non_snake_case,
6915        clippy::pub_underscore_fields,
6916        clippy::style
6917    )]
6918    #[derive(Clone)]
6919    pub struct OwnershipTransferred {
6920        #[allow(missing_docs)]
6921        pub previousOwner: alloy::sol_types::private::Address,
6922        #[allow(missing_docs)]
6923        pub newOwner: alloy::sol_types::private::Address,
6924    }
6925    #[allow(
6926        non_camel_case_types,
6927        non_snake_case,
6928        clippy::pub_underscore_fields,
6929        clippy::style
6930    )]
6931    const _: () = {
6932        use alloy::sol_types as alloy_sol_types;
6933        #[automatically_derived]
6934        impl alloy_sol_types::SolEvent for OwnershipTransferred {
6935            type DataTuple<'a> = ();
6936            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
6937            type TopicList = (
6938                alloy_sol_types::sol_data::FixedBytes<32>,
6939                alloy::sol_types::sol_data::Address,
6940                alloy::sol_types::sol_data::Address,
6941            );
6942            const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
6943            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
6944                alloy_sol_types::private::B256::new([
6945                    139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8,
6946                    208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8,
6947                    175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
6948                ]);
6949            const ANONYMOUS: bool = false;
6950            #[allow(unused_variables)]
6951            #[inline]
6952            fn new(
6953                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
6954                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
6955            ) -> Self {
6956                Self {
6957                    previousOwner: topics.1,
6958                    newOwner: topics.2,
6959                }
6960            }
6961            #[inline]
6962            fn check_signature(
6963                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
6964            ) -> alloy_sol_types::Result<()> {
6965                if topics.0 != Self::SIGNATURE_HASH {
6966                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
6967                        Self::SIGNATURE,
6968                        topics.0,
6969                        Self::SIGNATURE_HASH,
6970                    ));
6971                }
6972                Ok(())
6973            }
6974            #[inline]
6975            fn tokenize_body(&self) -> Self::DataToken<'_> {
6976                ()
6977            }
6978            #[inline]
6979            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
6980                (
6981                    Self::SIGNATURE_HASH.into(),
6982                    self.previousOwner.clone(),
6983                    self.newOwner.clone(),
6984                )
6985            }
6986            #[inline]
6987            fn encode_topics_raw(
6988                &self,
6989                out: &mut [alloy_sol_types::abi::token::WordToken],
6990            ) -> alloy_sol_types::Result<()> {
6991                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
6992                    return Err(alloy_sol_types::Error::Overrun);
6993                }
6994                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
6995                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
6996                    &self.previousOwner,
6997                );
6998                out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
6999                    &self.newOwner,
7000                );
7001                Ok(())
7002            }
7003        }
7004        #[automatically_derived]
7005        impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
7006            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
7007                From::from(self)
7008            }
7009            fn into_log_data(self) -> alloy_sol_types::private::LogData {
7010                From::from(&self)
7011            }
7012        }
7013        #[automatically_derived]
7014        impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
7015            #[inline]
7016            fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
7017                alloy_sol_types::SolEvent::encode_log_data(this)
7018            }
7019        }
7020    };
7021    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
7022    /**Event with signature `Paused(address,uint256)` and selector `0xab40a374bc51de372200a8bc981af8c9ecdc08dfdaef0bb6e09f88f3c616ef3d`.
7023    ```solidity
7024    event Paused(address indexed account, uint256 newPausedStatus);
7025    ```*/
7026    #[allow(
7027        non_camel_case_types,
7028        non_snake_case,
7029        clippy::pub_underscore_fields,
7030        clippy::style
7031    )]
7032    #[derive(Clone)]
7033    pub struct Paused {
7034        #[allow(missing_docs)]
7035        pub account: alloy::sol_types::private::Address,
7036        #[allow(missing_docs)]
7037        pub newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
7038    }
7039    #[allow(
7040        non_camel_case_types,
7041        non_snake_case,
7042        clippy::pub_underscore_fields,
7043        clippy::style
7044    )]
7045    const _: () = {
7046        use alloy::sol_types as alloy_sol_types;
7047        #[automatically_derived]
7048        impl alloy_sol_types::SolEvent for Paused {
7049            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
7050            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
7051            type TopicList = (
7052                alloy_sol_types::sol_data::FixedBytes<32>,
7053                alloy::sol_types::sol_data::Address,
7054            );
7055            const SIGNATURE: &'static str = "Paused(address,uint256)";
7056            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
7057                alloy_sol_types::private::B256::new([
7058                    171u8, 64u8, 163u8, 116u8, 188u8, 81u8, 222u8, 55u8, 34u8, 0u8, 168u8, 188u8,
7059                    152u8, 26u8, 248u8, 201u8, 236u8, 220u8, 8u8, 223u8, 218u8, 239u8, 11u8, 182u8,
7060                    224u8, 159u8, 136u8, 243u8, 198u8, 22u8, 239u8, 61u8,
7061                ]);
7062            const ANONYMOUS: bool = false;
7063            #[allow(unused_variables)]
7064            #[inline]
7065            fn new(
7066                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
7067                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
7068            ) -> Self {
7069                Self {
7070                    account: topics.1,
7071                    newPausedStatus: data.0,
7072                }
7073            }
7074            #[inline]
7075            fn check_signature(
7076                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
7077            ) -> alloy_sol_types::Result<()> {
7078                if topics.0 != Self::SIGNATURE_HASH {
7079                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
7080                        Self::SIGNATURE,
7081                        topics.0,
7082                        Self::SIGNATURE_HASH,
7083                    ));
7084                }
7085                Ok(())
7086            }
7087            #[inline]
7088            fn tokenize_body(&self) -> Self::DataToken<'_> {
7089                (
7090                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
7091                        &self.newPausedStatus,
7092                    ),
7093                )
7094            }
7095            #[inline]
7096            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
7097                (Self::SIGNATURE_HASH.into(), self.account.clone())
7098            }
7099            #[inline]
7100            fn encode_topics_raw(
7101                &self,
7102                out: &mut [alloy_sol_types::abi::token::WordToken],
7103            ) -> alloy_sol_types::Result<()> {
7104                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
7105                    return Err(alloy_sol_types::Error::Overrun);
7106                }
7107                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
7108                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
7109                    &self.account,
7110                );
7111                Ok(())
7112            }
7113        }
7114        #[automatically_derived]
7115        impl alloy_sol_types::private::IntoLogData for Paused {
7116            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
7117                From::from(self)
7118            }
7119            fn into_log_data(self) -> alloy_sol_types::private::LogData {
7120                From::from(&self)
7121            }
7122        }
7123        #[automatically_derived]
7124        impl From<&Paused> for alloy_sol_types::private::LogData {
7125            #[inline]
7126            fn from(this: &Paused) -> alloy_sol_types::private::LogData {
7127                alloy_sol_types::SolEvent::encode_log_data(this)
7128            }
7129        }
7130    };
7131    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
7132    /**Event with signature `StrategyAddedToOperatorSet((address,uint32),address)` and selector `0x7ab260fe0af193db5f4986770d831bda4ea46099dc817e8b6716dcae8af8e88b`.
7133    ```solidity
7134    event StrategyAddedToOperatorSet(OperatorSet operatorSet, address strategy);
7135    ```*/
7136    #[allow(
7137        non_camel_case_types,
7138        non_snake_case,
7139        clippy::pub_underscore_fields,
7140        clippy::style
7141    )]
7142    #[derive(Clone)]
7143    pub struct StrategyAddedToOperatorSet {
7144        #[allow(missing_docs)]
7145        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
7146        #[allow(missing_docs)]
7147        pub strategy: alloy::sol_types::private::Address,
7148    }
7149    #[allow(
7150        non_camel_case_types,
7151        non_snake_case,
7152        clippy::pub_underscore_fields,
7153        clippy::style
7154    )]
7155    const _: () = {
7156        use alloy::sol_types as alloy_sol_types;
7157        #[automatically_derived]
7158        impl alloy_sol_types::SolEvent for StrategyAddedToOperatorSet {
7159            type DataTuple<'a> = (OperatorSet, alloy::sol_types::sol_data::Address);
7160            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
7161            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
7162            const SIGNATURE: &'static str = "StrategyAddedToOperatorSet((address,uint32),address)";
7163            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
7164                alloy_sol_types::private::B256::new([
7165                    122u8, 178u8, 96u8, 254u8, 10u8, 241u8, 147u8, 219u8, 95u8, 73u8, 134u8, 119u8,
7166                    13u8, 131u8, 27u8, 218u8, 78u8, 164u8, 96u8, 153u8, 220u8, 129u8, 126u8, 139u8,
7167                    103u8, 22u8, 220u8, 174u8, 138u8, 248u8, 232u8, 139u8,
7168                ]);
7169            const ANONYMOUS: bool = false;
7170            #[allow(unused_variables)]
7171            #[inline]
7172            fn new(
7173                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
7174                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
7175            ) -> Self {
7176                Self {
7177                    operatorSet: data.0,
7178                    strategy: data.1,
7179                }
7180            }
7181            #[inline]
7182            fn check_signature(
7183                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
7184            ) -> alloy_sol_types::Result<()> {
7185                if topics.0 != Self::SIGNATURE_HASH {
7186                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
7187                        Self::SIGNATURE,
7188                        topics.0,
7189                        Self::SIGNATURE_HASH,
7190                    ));
7191                }
7192                Ok(())
7193            }
7194            #[inline]
7195            fn tokenize_body(&self) -> Self::DataToken<'_> {
7196                (
7197                    <OperatorSet as alloy_sol_types::SolType>::tokenize(&self.operatorSet),
7198                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7199                        &self.strategy,
7200                    ),
7201                )
7202            }
7203            #[inline]
7204            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
7205                (Self::SIGNATURE_HASH.into(),)
7206            }
7207            #[inline]
7208            fn encode_topics_raw(
7209                &self,
7210                out: &mut [alloy_sol_types::abi::token::WordToken],
7211            ) -> alloy_sol_types::Result<()> {
7212                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
7213                    return Err(alloy_sol_types::Error::Overrun);
7214                }
7215                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
7216                Ok(())
7217            }
7218        }
7219        #[automatically_derived]
7220        impl alloy_sol_types::private::IntoLogData for StrategyAddedToOperatorSet {
7221            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
7222                From::from(self)
7223            }
7224            fn into_log_data(self) -> alloy_sol_types::private::LogData {
7225                From::from(&self)
7226            }
7227        }
7228        #[automatically_derived]
7229        impl From<&StrategyAddedToOperatorSet> for alloy_sol_types::private::LogData {
7230            #[inline]
7231            fn from(this: &StrategyAddedToOperatorSet) -> alloy_sol_types::private::LogData {
7232                alloy_sol_types::SolEvent::encode_log_data(this)
7233            }
7234        }
7235    };
7236    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
7237    /**Event with signature `StrategyRemovedFromOperatorSet((address,uint32),address)` and selector `0x7b4b073d80dcac55a11177d8459ad9f664ceeb91f71f27167bb14f8152a7eeee`.
7238    ```solidity
7239    event StrategyRemovedFromOperatorSet(OperatorSet operatorSet, address strategy);
7240    ```*/
7241    #[allow(
7242        non_camel_case_types,
7243        non_snake_case,
7244        clippy::pub_underscore_fields,
7245        clippy::style
7246    )]
7247    #[derive(Clone)]
7248    pub struct StrategyRemovedFromOperatorSet {
7249        #[allow(missing_docs)]
7250        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
7251        #[allow(missing_docs)]
7252        pub strategy: alloy::sol_types::private::Address,
7253    }
7254    #[allow(
7255        non_camel_case_types,
7256        non_snake_case,
7257        clippy::pub_underscore_fields,
7258        clippy::style
7259    )]
7260    const _: () = {
7261        use alloy::sol_types as alloy_sol_types;
7262        #[automatically_derived]
7263        impl alloy_sol_types::SolEvent for StrategyRemovedFromOperatorSet {
7264            type DataTuple<'a> = (OperatorSet, alloy::sol_types::sol_data::Address);
7265            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
7266            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
7267            const SIGNATURE: &'static str =
7268                "StrategyRemovedFromOperatorSet((address,uint32),address)";
7269            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
7270                alloy_sol_types::private::B256::new([
7271                    123u8, 75u8, 7u8, 61u8, 128u8, 220u8, 172u8, 85u8, 161u8, 17u8, 119u8, 216u8,
7272                    69u8, 154u8, 217u8, 246u8, 100u8, 206u8, 235u8, 145u8, 247u8, 31u8, 39u8, 22u8,
7273                    123u8, 177u8, 79u8, 129u8, 82u8, 167u8, 238u8, 238u8,
7274                ]);
7275            const ANONYMOUS: bool = false;
7276            #[allow(unused_variables)]
7277            #[inline]
7278            fn new(
7279                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
7280                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
7281            ) -> Self {
7282                Self {
7283                    operatorSet: data.0,
7284                    strategy: data.1,
7285                }
7286            }
7287            #[inline]
7288            fn check_signature(
7289                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
7290            ) -> alloy_sol_types::Result<()> {
7291                if topics.0 != Self::SIGNATURE_HASH {
7292                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
7293                        Self::SIGNATURE,
7294                        topics.0,
7295                        Self::SIGNATURE_HASH,
7296                    ));
7297                }
7298                Ok(())
7299            }
7300            #[inline]
7301            fn tokenize_body(&self) -> Self::DataToken<'_> {
7302                (
7303                    <OperatorSet as alloy_sol_types::SolType>::tokenize(&self.operatorSet),
7304                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7305                        &self.strategy,
7306                    ),
7307                )
7308            }
7309            #[inline]
7310            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
7311                (Self::SIGNATURE_HASH.into(),)
7312            }
7313            #[inline]
7314            fn encode_topics_raw(
7315                &self,
7316                out: &mut [alloy_sol_types::abi::token::WordToken],
7317            ) -> alloy_sol_types::Result<()> {
7318                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
7319                    return Err(alloy_sol_types::Error::Overrun);
7320                }
7321                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
7322                Ok(())
7323            }
7324        }
7325        #[automatically_derived]
7326        impl alloy_sol_types::private::IntoLogData for StrategyRemovedFromOperatorSet {
7327            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
7328                From::from(self)
7329            }
7330            fn into_log_data(self) -> alloy_sol_types::private::LogData {
7331                From::from(&self)
7332            }
7333        }
7334        #[automatically_derived]
7335        impl From<&StrategyRemovedFromOperatorSet> for alloy_sol_types::private::LogData {
7336            #[inline]
7337            fn from(this: &StrategyRemovedFromOperatorSet) -> alloy_sol_types::private::LogData {
7338                alloy_sol_types::SolEvent::encode_log_data(this)
7339            }
7340        }
7341    };
7342    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
7343    /**Event with signature `Unpaused(address,uint256)` and selector `0x3582d1828e26bf56bd801502bc021ac0bc8afb57c826e4986b45593c8fad389c`.
7344    ```solidity
7345    event Unpaused(address indexed account, uint256 newPausedStatus);
7346    ```*/
7347    #[allow(
7348        non_camel_case_types,
7349        non_snake_case,
7350        clippy::pub_underscore_fields,
7351        clippy::style
7352    )]
7353    #[derive(Clone)]
7354    pub struct Unpaused {
7355        #[allow(missing_docs)]
7356        pub account: alloy::sol_types::private::Address,
7357        #[allow(missing_docs)]
7358        pub newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
7359    }
7360    #[allow(
7361        non_camel_case_types,
7362        non_snake_case,
7363        clippy::pub_underscore_fields,
7364        clippy::style
7365    )]
7366    const _: () = {
7367        use alloy::sol_types as alloy_sol_types;
7368        #[automatically_derived]
7369        impl alloy_sol_types::SolEvent for Unpaused {
7370            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
7371            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
7372            type TopicList = (
7373                alloy_sol_types::sol_data::FixedBytes<32>,
7374                alloy::sol_types::sol_data::Address,
7375            );
7376            const SIGNATURE: &'static str = "Unpaused(address,uint256)";
7377            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
7378                alloy_sol_types::private::B256::new([
7379                    53u8, 130u8, 209u8, 130u8, 142u8, 38u8, 191u8, 86u8, 189u8, 128u8, 21u8, 2u8,
7380                    188u8, 2u8, 26u8, 192u8, 188u8, 138u8, 251u8, 87u8, 200u8, 38u8, 228u8, 152u8,
7381                    107u8, 69u8, 89u8, 60u8, 143u8, 173u8, 56u8, 156u8,
7382                ]);
7383            const ANONYMOUS: bool = false;
7384            #[allow(unused_variables)]
7385            #[inline]
7386            fn new(
7387                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
7388                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
7389            ) -> Self {
7390                Self {
7391                    account: topics.1,
7392                    newPausedStatus: data.0,
7393                }
7394            }
7395            #[inline]
7396            fn check_signature(
7397                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
7398            ) -> alloy_sol_types::Result<()> {
7399                if topics.0 != Self::SIGNATURE_HASH {
7400                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
7401                        Self::SIGNATURE,
7402                        topics.0,
7403                        Self::SIGNATURE_HASH,
7404                    ));
7405                }
7406                Ok(())
7407            }
7408            #[inline]
7409            fn tokenize_body(&self) -> Self::DataToken<'_> {
7410                (
7411                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
7412                        &self.newPausedStatus,
7413                    ),
7414                )
7415            }
7416            #[inline]
7417            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
7418                (Self::SIGNATURE_HASH.into(), self.account.clone())
7419            }
7420            #[inline]
7421            fn encode_topics_raw(
7422                &self,
7423                out: &mut [alloy_sol_types::abi::token::WordToken],
7424            ) -> alloy_sol_types::Result<()> {
7425                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
7426                    return Err(alloy_sol_types::Error::Overrun);
7427                }
7428                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
7429                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
7430                    &self.account,
7431                );
7432                Ok(())
7433            }
7434        }
7435        #[automatically_derived]
7436        impl alloy_sol_types::private::IntoLogData for Unpaused {
7437            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
7438                From::from(self)
7439            }
7440            fn into_log_data(self) -> alloy_sol_types::private::LogData {
7441                From::from(&self)
7442            }
7443        }
7444        #[automatically_derived]
7445        impl From<&Unpaused> for alloy_sol_types::private::LogData {
7446            #[inline]
7447            fn from(this: &Unpaused) -> alloy_sol_types::private::LogData {
7448                alloy_sol_types::SolEvent::encode_log_data(this)
7449            }
7450        }
7451    };
7452    /**Constructor`.
7453    ```solidity
7454    constructor(address _delegation, address _pauserRegistry, address _permissionController, uint32 _DEALLOCATION_DELAY, uint32 _ALLOCATION_CONFIGURATION_DELAY, string _version);
7455    ```*/
7456    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7457    #[derive(Clone)]
7458    pub struct constructorCall {
7459        #[allow(missing_docs)]
7460        pub _delegation: alloy::sol_types::private::Address,
7461        #[allow(missing_docs)]
7462        pub _pauserRegistry: alloy::sol_types::private::Address,
7463        #[allow(missing_docs)]
7464        pub _permissionController: alloy::sol_types::private::Address,
7465        #[allow(missing_docs)]
7466        pub _DEALLOCATION_DELAY: u32,
7467        #[allow(missing_docs)]
7468        pub _ALLOCATION_CONFIGURATION_DELAY: u32,
7469        #[allow(missing_docs)]
7470        pub _version: alloy::sol_types::private::String,
7471    }
7472    const _: () = {
7473        use alloy::sol_types as alloy_sol_types;
7474        {
7475            #[doc(hidden)]
7476            type UnderlyingSolTuple<'a> = (
7477                alloy::sol_types::sol_data::Address,
7478                alloy::sol_types::sol_data::Address,
7479                alloy::sol_types::sol_data::Address,
7480                alloy::sol_types::sol_data::Uint<32>,
7481                alloy::sol_types::sol_data::Uint<32>,
7482                alloy::sol_types::sol_data::String,
7483            );
7484            #[doc(hidden)]
7485            type UnderlyingRustTuple<'a> = (
7486                alloy::sol_types::private::Address,
7487                alloy::sol_types::private::Address,
7488                alloy::sol_types::private::Address,
7489                u32,
7490                u32,
7491                alloy::sol_types::private::String,
7492            );
7493            #[cfg(test)]
7494            #[allow(dead_code, unreachable_patterns)]
7495            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7496                match _t {
7497                    alloy_sol_types::private::AssertTypeEq::<
7498                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7499                    >(_) => {}
7500                }
7501            }
7502            #[automatically_derived]
7503            #[doc(hidden)]
7504            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
7505                fn from(value: constructorCall) -> Self {
7506                    (
7507                        value._delegation,
7508                        value._pauserRegistry,
7509                        value._permissionController,
7510                        value._DEALLOCATION_DELAY,
7511                        value._ALLOCATION_CONFIGURATION_DELAY,
7512                        value._version,
7513                    )
7514                }
7515            }
7516            #[automatically_derived]
7517            #[doc(hidden)]
7518            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
7519                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7520                    Self {
7521                        _delegation: tuple.0,
7522                        _pauserRegistry: tuple.1,
7523                        _permissionController: tuple.2,
7524                        _DEALLOCATION_DELAY: tuple.3,
7525                        _ALLOCATION_CONFIGURATION_DELAY: tuple.4,
7526                        _version: tuple.5,
7527                    }
7528                }
7529            }
7530        }
7531        #[automatically_derived]
7532        impl alloy_sol_types::SolConstructor for constructorCall {
7533            type Parameters<'a> = (
7534                alloy::sol_types::sol_data::Address,
7535                alloy::sol_types::sol_data::Address,
7536                alloy::sol_types::sol_data::Address,
7537                alloy::sol_types::sol_data::Uint<32>,
7538                alloy::sol_types::sol_data::Uint<32>,
7539                alloy::sol_types::sol_data::String,
7540            );
7541            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
7542            #[inline]
7543            fn new<'a>(
7544                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7545            ) -> Self {
7546                tuple.into()
7547            }
7548            #[inline]
7549            fn tokenize(&self) -> Self::Token<'_> {
7550                (
7551                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7552                        &self._delegation,
7553                    ),
7554                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7555                        &self._pauserRegistry,
7556                    ),
7557                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7558                        &self._permissionController,
7559                    ),
7560                    <alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
7561                        &self._DEALLOCATION_DELAY,
7562                    ),
7563                    <alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
7564                        &self._ALLOCATION_CONFIGURATION_DELAY,
7565                    ),
7566                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
7567                        &self._version,
7568                    ),
7569                )
7570            }
7571        }
7572    };
7573    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
7574    /**Function with signature `ALLOCATION_CONFIGURATION_DELAY()` and selector `0x7bc1ef61`.
7575    ```solidity
7576    function ALLOCATION_CONFIGURATION_DELAY() external view returns (uint32);
7577    ```*/
7578    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7579    #[derive(Clone)]
7580    pub struct ALLOCATION_CONFIGURATION_DELAYCall;
7581    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
7582    ///Container type for the return parameters of the [`ALLOCATION_CONFIGURATION_DELAY()`](ALLOCATION_CONFIGURATION_DELAYCall) function.
7583    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7584    #[derive(Clone)]
7585    pub struct ALLOCATION_CONFIGURATION_DELAYReturn {
7586        #[allow(missing_docs)]
7587        pub _0: u32,
7588    }
7589    #[allow(
7590        non_camel_case_types,
7591        non_snake_case,
7592        clippy::pub_underscore_fields,
7593        clippy::style
7594    )]
7595    const _: () = {
7596        use alloy::sol_types as alloy_sol_types;
7597        {
7598            #[doc(hidden)]
7599            type UnderlyingSolTuple<'a> = ();
7600            #[doc(hidden)]
7601            type UnderlyingRustTuple<'a> = ();
7602            #[cfg(test)]
7603            #[allow(dead_code, unreachable_patterns)]
7604            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7605                match _t {
7606                    alloy_sol_types::private::AssertTypeEq::<
7607                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7608                    >(_) => {}
7609                }
7610            }
7611            #[automatically_derived]
7612            #[doc(hidden)]
7613            impl ::core::convert::From<ALLOCATION_CONFIGURATION_DELAYCall> for UnderlyingRustTuple<'_> {
7614                fn from(value: ALLOCATION_CONFIGURATION_DELAYCall) -> Self {
7615                    ()
7616                }
7617            }
7618            #[automatically_derived]
7619            #[doc(hidden)]
7620            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ALLOCATION_CONFIGURATION_DELAYCall {
7621                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7622                    Self
7623                }
7624            }
7625        }
7626        {
7627            #[doc(hidden)]
7628            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
7629            #[doc(hidden)]
7630            type UnderlyingRustTuple<'a> = (u32,);
7631            #[cfg(test)]
7632            #[allow(dead_code, unreachable_patterns)]
7633            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7634                match _t {
7635                    alloy_sol_types::private::AssertTypeEq::<
7636                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7637                    >(_) => {}
7638                }
7639            }
7640            #[automatically_derived]
7641            #[doc(hidden)]
7642            impl ::core::convert::From<ALLOCATION_CONFIGURATION_DELAYReturn> for UnderlyingRustTuple<'_> {
7643                fn from(value: ALLOCATION_CONFIGURATION_DELAYReturn) -> Self {
7644                    (value._0,)
7645                }
7646            }
7647            #[automatically_derived]
7648            #[doc(hidden)]
7649            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ALLOCATION_CONFIGURATION_DELAYReturn {
7650                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7651                    Self { _0: tuple.0 }
7652                }
7653            }
7654        }
7655        #[automatically_derived]
7656        impl alloy_sol_types::SolCall for ALLOCATION_CONFIGURATION_DELAYCall {
7657            type Parameters<'a> = ();
7658            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
7659            type Return = u32;
7660            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
7661            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
7662            const SIGNATURE: &'static str = "ALLOCATION_CONFIGURATION_DELAY()";
7663            const SELECTOR: [u8; 4] = [123u8, 193u8, 239u8, 97u8];
7664            #[inline]
7665            fn new<'a>(
7666                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7667            ) -> Self {
7668                tuple.into()
7669            }
7670            #[inline]
7671            fn tokenize(&self) -> Self::Token<'_> {
7672                ()
7673            }
7674            #[inline]
7675            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7676                (
7677                    <alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
7678                        ret,
7679                    ),
7680                )
7681            }
7682            #[inline]
7683            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7684                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
7685                    |r| {
7686                        let r: ALLOCATION_CONFIGURATION_DELAYReturn = r.into();
7687                        r._0
7688                    },
7689                )
7690            }
7691            #[inline]
7692            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7693                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
7694                    data,
7695                )
7696                .map(|r| {
7697                    let r: ALLOCATION_CONFIGURATION_DELAYReturn = r.into();
7698                    r._0
7699                })
7700            }
7701        }
7702    };
7703    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
7704    /**Function with signature `DEALLOCATION_DELAY()` and selector `0x2981eb77`.
7705    ```solidity
7706    function DEALLOCATION_DELAY() external view returns (uint32);
7707    ```*/
7708    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7709    #[derive(Clone)]
7710    pub struct DEALLOCATION_DELAYCall;
7711    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
7712    ///Container type for the return parameters of the [`DEALLOCATION_DELAY()`](DEALLOCATION_DELAYCall) function.
7713    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7714    #[derive(Clone)]
7715    pub struct DEALLOCATION_DELAYReturn {
7716        #[allow(missing_docs)]
7717        pub _0: u32,
7718    }
7719    #[allow(
7720        non_camel_case_types,
7721        non_snake_case,
7722        clippy::pub_underscore_fields,
7723        clippy::style
7724    )]
7725    const _: () = {
7726        use alloy::sol_types as alloy_sol_types;
7727        {
7728            #[doc(hidden)]
7729            type UnderlyingSolTuple<'a> = ();
7730            #[doc(hidden)]
7731            type UnderlyingRustTuple<'a> = ();
7732            #[cfg(test)]
7733            #[allow(dead_code, unreachable_patterns)]
7734            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7735                match _t {
7736                    alloy_sol_types::private::AssertTypeEq::<
7737                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7738                    >(_) => {}
7739                }
7740            }
7741            #[automatically_derived]
7742            #[doc(hidden)]
7743            impl ::core::convert::From<DEALLOCATION_DELAYCall> for UnderlyingRustTuple<'_> {
7744                fn from(value: DEALLOCATION_DELAYCall) -> Self {
7745                    ()
7746                }
7747            }
7748            #[automatically_derived]
7749            #[doc(hidden)]
7750            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DEALLOCATION_DELAYCall {
7751                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7752                    Self
7753                }
7754            }
7755        }
7756        {
7757            #[doc(hidden)]
7758            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
7759            #[doc(hidden)]
7760            type UnderlyingRustTuple<'a> = (u32,);
7761            #[cfg(test)]
7762            #[allow(dead_code, unreachable_patterns)]
7763            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7764                match _t {
7765                    alloy_sol_types::private::AssertTypeEq::<
7766                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7767                    >(_) => {}
7768                }
7769            }
7770            #[automatically_derived]
7771            #[doc(hidden)]
7772            impl ::core::convert::From<DEALLOCATION_DELAYReturn> for UnderlyingRustTuple<'_> {
7773                fn from(value: DEALLOCATION_DELAYReturn) -> Self {
7774                    (value._0,)
7775                }
7776            }
7777            #[automatically_derived]
7778            #[doc(hidden)]
7779            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DEALLOCATION_DELAYReturn {
7780                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7781                    Self { _0: tuple.0 }
7782                }
7783            }
7784        }
7785        #[automatically_derived]
7786        impl alloy_sol_types::SolCall for DEALLOCATION_DELAYCall {
7787            type Parameters<'a> = ();
7788            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
7789            type Return = u32;
7790            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
7791            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
7792            const SIGNATURE: &'static str = "DEALLOCATION_DELAY()";
7793            const SELECTOR: [u8; 4] = [41u8, 129u8, 235u8, 119u8];
7794            #[inline]
7795            fn new<'a>(
7796                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7797            ) -> Self {
7798                tuple.into()
7799            }
7800            #[inline]
7801            fn tokenize(&self) -> Self::Token<'_> {
7802                ()
7803            }
7804            #[inline]
7805            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7806                (
7807                    <alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
7808                        ret,
7809                    ),
7810                )
7811            }
7812            #[inline]
7813            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7814                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
7815                    |r| {
7816                        let r: DEALLOCATION_DELAYReturn = r.into();
7817                        r._0
7818                    },
7819                )
7820            }
7821            #[inline]
7822            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7823                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
7824                    data,
7825                )
7826                .map(|r| {
7827                    let r: DEALLOCATION_DELAYReturn = r.into();
7828                    r._0
7829                })
7830            }
7831        }
7832    };
7833    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
7834    /**Function with signature `addStrategiesToOperatorSet(address,uint32,address[])` and selector `0x50feea20`.
7835    ```solidity
7836    function addStrategiesToOperatorSet(address avs, uint32 operatorSetId, address[] memory strategies) external;
7837    ```*/
7838    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7839    #[derive(Clone)]
7840    pub struct addStrategiesToOperatorSetCall {
7841        #[allow(missing_docs)]
7842        pub avs: alloy::sol_types::private::Address,
7843        #[allow(missing_docs)]
7844        pub operatorSetId: u32,
7845        #[allow(missing_docs)]
7846        pub strategies: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
7847    }
7848    ///Container type for the return parameters of the [`addStrategiesToOperatorSet(address,uint32,address[])`](addStrategiesToOperatorSetCall) function.
7849    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7850    #[derive(Clone)]
7851    pub struct addStrategiesToOperatorSetReturn {}
7852    #[allow(
7853        non_camel_case_types,
7854        non_snake_case,
7855        clippy::pub_underscore_fields,
7856        clippy::style
7857    )]
7858    const _: () = {
7859        use alloy::sol_types as alloy_sol_types;
7860        {
7861            #[doc(hidden)]
7862            type UnderlyingSolTuple<'a> = (
7863                alloy::sol_types::sol_data::Address,
7864                alloy::sol_types::sol_data::Uint<32>,
7865                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
7866            );
7867            #[doc(hidden)]
7868            type UnderlyingRustTuple<'a> = (
7869                alloy::sol_types::private::Address,
7870                u32,
7871                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
7872            );
7873            #[cfg(test)]
7874            #[allow(dead_code, unreachable_patterns)]
7875            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7876                match _t {
7877                    alloy_sol_types::private::AssertTypeEq::<
7878                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7879                    >(_) => {}
7880                }
7881            }
7882            #[automatically_derived]
7883            #[doc(hidden)]
7884            impl ::core::convert::From<addStrategiesToOperatorSetCall> for UnderlyingRustTuple<'_> {
7885                fn from(value: addStrategiesToOperatorSetCall) -> Self {
7886                    (value.avs, value.operatorSetId, value.strategies)
7887                }
7888            }
7889            #[automatically_derived]
7890            #[doc(hidden)]
7891            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addStrategiesToOperatorSetCall {
7892                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7893                    Self {
7894                        avs: tuple.0,
7895                        operatorSetId: tuple.1,
7896                        strategies: tuple.2,
7897                    }
7898                }
7899            }
7900        }
7901        {
7902            #[doc(hidden)]
7903            type UnderlyingSolTuple<'a> = ();
7904            #[doc(hidden)]
7905            type UnderlyingRustTuple<'a> = ();
7906            #[cfg(test)]
7907            #[allow(dead_code, unreachable_patterns)]
7908            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7909                match _t {
7910                    alloy_sol_types::private::AssertTypeEq::<
7911                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7912                    >(_) => {}
7913                }
7914            }
7915            #[automatically_derived]
7916            #[doc(hidden)]
7917            impl ::core::convert::From<addStrategiesToOperatorSetReturn> for UnderlyingRustTuple<'_> {
7918                fn from(value: addStrategiesToOperatorSetReturn) -> Self {
7919                    ()
7920                }
7921            }
7922            #[automatically_derived]
7923            #[doc(hidden)]
7924            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addStrategiesToOperatorSetReturn {
7925                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7926                    Self {}
7927                }
7928            }
7929        }
7930        impl addStrategiesToOperatorSetReturn {
7931            fn _tokenize(
7932                &self,
7933            ) -> <addStrategiesToOperatorSetCall as alloy_sol_types::SolCall>::ReturnToken<'_>
7934            {
7935                ()
7936            }
7937        }
7938        #[automatically_derived]
7939        impl alloy_sol_types::SolCall for addStrategiesToOperatorSetCall {
7940            type Parameters<'a> = (
7941                alloy::sol_types::sol_data::Address,
7942                alloy::sol_types::sol_data::Uint<32>,
7943                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
7944            );
7945            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
7946            type Return = addStrategiesToOperatorSetReturn;
7947            type ReturnTuple<'a> = ();
7948            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
7949            const SIGNATURE: &'static str = "addStrategiesToOperatorSet(address,uint32,address[])";
7950            const SELECTOR: [u8; 4] = [80u8, 254u8, 234u8, 32u8];
7951            #[inline]
7952            fn new<'a>(
7953                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7954            ) -> Self {
7955                tuple.into()
7956            }
7957            #[inline]
7958            fn tokenize(&self) -> Self::Token<'_> {
7959                (
7960                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7961                        &self.avs,
7962                    ),
7963                    <alloy::sol_types::sol_data::Uint<
7964                        32,
7965                    > as alloy_sol_types::SolType>::tokenize(&self.operatorSetId),
7966                    <alloy::sol_types::sol_data::Array<
7967                        alloy::sol_types::sol_data::Address,
7968                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
7969                )
7970            }
7971            #[inline]
7972            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7973                addStrategiesToOperatorSetReturn::_tokenize(ret)
7974            }
7975            #[inline]
7976            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7977                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
7978                    .map(Into::into)
7979            }
7980            #[inline]
7981            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7982                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
7983                    data,
7984                )
7985                .map(Into::into)
7986            }
7987        }
7988    };
7989    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
7990    /**Function with signature `clearDeallocationQueue(address,address[],uint16[])` and selector `0x4b5046ef`.
7991    ```solidity
7992    function clearDeallocationQueue(address operator, address[] memory strategies, uint16[] memory numToClear) external;
7993    ```*/
7994    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7995    #[derive(Clone)]
7996    pub struct clearDeallocationQueueCall {
7997        #[allow(missing_docs)]
7998        pub operator: alloy::sol_types::private::Address,
7999        #[allow(missing_docs)]
8000        pub strategies: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
8001        #[allow(missing_docs)]
8002        pub numToClear: alloy::sol_types::private::Vec<u16>,
8003    }
8004    ///Container type for the return parameters of the [`clearDeallocationQueue(address,address[],uint16[])`](clearDeallocationQueueCall) function.
8005    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8006    #[derive(Clone)]
8007    pub struct clearDeallocationQueueReturn {}
8008    #[allow(
8009        non_camel_case_types,
8010        non_snake_case,
8011        clippy::pub_underscore_fields,
8012        clippy::style
8013    )]
8014    const _: () = {
8015        use alloy::sol_types as alloy_sol_types;
8016        {
8017            #[doc(hidden)]
8018            type UnderlyingSolTuple<'a> = (
8019                alloy::sol_types::sol_data::Address,
8020                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
8021                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<16>>,
8022            );
8023            #[doc(hidden)]
8024            type UnderlyingRustTuple<'a> = (
8025                alloy::sol_types::private::Address,
8026                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
8027                alloy::sol_types::private::Vec<u16>,
8028            );
8029            #[cfg(test)]
8030            #[allow(dead_code, unreachable_patterns)]
8031            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
8032                match _t {
8033                    alloy_sol_types::private::AssertTypeEq::<
8034                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8035                    >(_) => {}
8036                }
8037            }
8038            #[automatically_derived]
8039            #[doc(hidden)]
8040            impl ::core::convert::From<clearDeallocationQueueCall> for UnderlyingRustTuple<'_> {
8041                fn from(value: clearDeallocationQueueCall) -> Self {
8042                    (value.operator, value.strategies, value.numToClear)
8043                }
8044            }
8045            #[automatically_derived]
8046            #[doc(hidden)]
8047            impl ::core::convert::From<UnderlyingRustTuple<'_>> for clearDeallocationQueueCall {
8048                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8049                    Self {
8050                        operator: tuple.0,
8051                        strategies: tuple.1,
8052                        numToClear: tuple.2,
8053                    }
8054                }
8055            }
8056        }
8057        {
8058            #[doc(hidden)]
8059            type UnderlyingSolTuple<'a> = ();
8060            #[doc(hidden)]
8061            type UnderlyingRustTuple<'a> = ();
8062            #[cfg(test)]
8063            #[allow(dead_code, unreachable_patterns)]
8064            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
8065                match _t {
8066                    alloy_sol_types::private::AssertTypeEq::<
8067                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8068                    >(_) => {}
8069                }
8070            }
8071            #[automatically_derived]
8072            #[doc(hidden)]
8073            impl ::core::convert::From<clearDeallocationQueueReturn> for UnderlyingRustTuple<'_> {
8074                fn from(value: clearDeallocationQueueReturn) -> Self {
8075                    ()
8076                }
8077            }
8078            #[automatically_derived]
8079            #[doc(hidden)]
8080            impl ::core::convert::From<UnderlyingRustTuple<'_>> for clearDeallocationQueueReturn {
8081                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8082                    Self {}
8083                }
8084            }
8085        }
8086        impl clearDeallocationQueueReturn {
8087            fn _tokenize(
8088                &self,
8089            ) -> <clearDeallocationQueueCall as alloy_sol_types::SolCall>::ReturnToken<'_>
8090            {
8091                ()
8092            }
8093        }
8094        #[automatically_derived]
8095        impl alloy_sol_types::SolCall for clearDeallocationQueueCall {
8096            type Parameters<'a> = (
8097                alloy::sol_types::sol_data::Address,
8098                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
8099                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<16>>,
8100            );
8101            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
8102            type Return = clearDeallocationQueueReturn;
8103            type ReturnTuple<'a> = ();
8104            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
8105            const SIGNATURE: &'static str = "clearDeallocationQueue(address,address[],uint16[])";
8106            const SELECTOR: [u8; 4] = [75u8, 80u8, 70u8, 239u8];
8107            #[inline]
8108            fn new<'a>(
8109                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8110            ) -> Self {
8111                tuple.into()
8112            }
8113            #[inline]
8114            fn tokenize(&self) -> Self::Token<'_> {
8115                (
8116                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8117                        &self.operator,
8118                    ),
8119                    <alloy::sol_types::sol_data::Array<
8120                        alloy::sol_types::sol_data::Address,
8121                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
8122                    <alloy::sol_types::sol_data::Array<
8123                        alloy::sol_types::sol_data::Uint<16>,
8124                    > as alloy_sol_types::SolType>::tokenize(&self.numToClear),
8125                )
8126            }
8127            #[inline]
8128            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
8129                clearDeallocationQueueReturn::_tokenize(ret)
8130            }
8131            #[inline]
8132            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8133                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
8134                    .map(Into::into)
8135            }
8136            #[inline]
8137            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8138                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
8139                    data,
8140                )
8141                .map(Into::into)
8142            }
8143        }
8144    };
8145    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
8146    /**Function with signature `createOperatorSets(address,(uint32,address[])[])` and selector `0x261f84e0`.
8147    ```solidity
8148    function createOperatorSets(address avs, IAllocationManagerTypes.CreateSetParams[] memory params) external;
8149    ```*/
8150    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8151    #[derive(Clone)]
8152    pub struct createOperatorSetsCall {
8153        #[allow(missing_docs)]
8154        pub avs: alloy::sol_types::private::Address,
8155        #[allow(missing_docs)]
8156        pub params: alloy::sol_types::private::Vec<
8157            <IAllocationManagerTypes::CreateSetParams as alloy::sol_types::SolType>::RustType,
8158        >,
8159    }
8160    ///Container type for the return parameters of the [`createOperatorSets(address,(uint32,address[])[])`](createOperatorSetsCall) function.
8161    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8162    #[derive(Clone)]
8163    pub struct createOperatorSetsReturn {}
8164    #[allow(
8165        non_camel_case_types,
8166        non_snake_case,
8167        clippy::pub_underscore_fields,
8168        clippy::style
8169    )]
8170    const _: () = {
8171        use alloy::sol_types as alloy_sol_types;
8172        {
8173            #[doc(hidden)]
8174            type UnderlyingSolTuple<'a> = (
8175                alloy::sol_types::sol_data::Address,
8176                alloy::sol_types::sol_data::Array<IAllocationManagerTypes::CreateSetParams>,
8177            );
8178            #[doc(hidden)]
8179            type UnderlyingRustTuple<'a> = (
8180                alloy::sol_types::private::Address,
8181                alloy::sol_types::private::Vec<
8182                    <IAllocationManagerTypes::CreateSetParams as alloy::sol_types::SolType>::RustType,
8183                >,
8184            );
8185            #[cfg(test)]
8186            #[allow(dead_code, unreachable_patterns)]
8187            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
8188                match _t {
8189                    alloy_sol_types::private::AssertTypeEq::<
8190                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8191                    >(_) => {}
8192                }
8193            }
8194            #[automatically_derived]
8195            #[doc(hidden)]
8196            impl ::core::convert::From<createOperatorSetsCall> for UnderlyingRustTuple<'_> {
8197                fn from(value: createOperatorSetsCall) -> Self {
8198                    (value.avs, value.params)
8199                }
8200            }
8201            #[automatically_derived]
8202            #[doc(hidden)]
8203            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createOperatorSetsCall {
8204                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8205                    Self {
8206                        avs: tuple.0,
8207                        params: tuple.1,
8208                    }
8209                }
8210            }
8211        }
8212        {
8213            #[doc(hidden)]
8214            type UnderlyingSolTuple<'a> = ();
8215            #[doc(hidden)]
8216            type UnderlyingRustTuple<'a> = ();
8217            #[cfg(test)]
8218            #[allow(dead_code, unreachable_patterns)]
8219            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
8220                match _t {
8221                    alloy_sol_types::private::AssertTypeEq::<
8222                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8223                    >(_) => {}
8224                }
8225            }
8226            #[automatically_derived]
8227            #[doc(hidden)]
8228            impl ::core::convert::From<createOperatorSetsReturn> for UnderlyingRustTuple<'_> {
8229                fn from(value: createOperatorSetsReturn) -> Self {
8230                    ()
8231                }
8232            }
8233            #[automatically_derived]
8234            #[doc(hidden)]
8235            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createOperatorSetsReturn {
8236                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8237                    Self {}
8238                }
8239            }
8240        }
8241        impl createOperatorSetsReturn {
8242            fn _tokenize(
8243                &self,
8244            ) -> <createOperatorSetsCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
8245                ()
8246            }
8247        }
8248        #[automatically_derived]
8249        impl alloy_sol_types::SolCall for createOperatorSetsCall {
8250            type Parameters<'a> = (
8251                alloy::sol_types::sol_data::Address,
8252                alloy::sol_types::sol_data::Array<IAllocationManagerTypes::CreateSetParams>,
8253            );
8254            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
8255            type Return = createOperatorSetsReturn;
8256            type ReturnTuple<'a> = ();
8257            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
8258            const SIGNATURE: &'static str = "createOperatorSets(address,(uint32,address[])[])";
8259            const SELECTOR: [u8; 4] = [38u8, 31u8, 132u8, 224u8];
8260            #[inline]
8261            fn new<'a>(
8262                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8263            ) -> Self {
8264                tuple.into()
8265            }
8266            #[inline]
8267            fn tokenize(&self) -> Self::Token<'_> {
8268                (
8269                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8270                        &self.avs,
8271                    ),
8272                    <alloy::sol_types::sol_data::Array<
8273                        IAllocationManagerTypes::CreateSetParams,
8274                    > as alloy_sol_types::SolType>::tokenize(&self.params),
8275                )
8276            }
8277            #[inline]
8278            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
8279                createOperatorSetsReturn::_tokenize(ret)
8280            }
8281            #[inline]
8282            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8283                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
8284                    .map(Into::into)
8285            }
8286            #[inline]
8287            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8288                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
8289                    data,
8290                )
8291                .map(Into::into)
8292            }
8293        }
8294    };
8295    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
8296    /**Function with signature `delegation()` and selector `0xdf5cf723`.
8297    ```solidity
8298    function delegation() external view returns (address);
8299    ```*/
8300    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8301    #[derive(Clone)]
8302    pub struct delegationCall;
8303    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
8304    ///Container type for the return parameters of the [`delegation()`](delegationCall) function.
8305    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8306    #[derive(Clone)]
8307    pub struct delegationReturn {
8308        #[allow(missing_docs)]
8309        pub _0: alloy::sol_types::private::Address,
8310    }
8311    #[allow(
8312        non_camel_case_types,
8313        non_snake_case,
8314        clippy::pub_underscore_fields,
8315        clippy::style
8316    )]
8317    const _: () = {
8318        use alloy::sol_types as alloy_sol_types;
8319        {
8320            #[doc(hidden)]
8321            type UnderlyingSolTuple<'a> = ();
8322            #[doc(hidden)]
8323            type UnderlyingRustTuple<'a> = ();
8324            #[cfg(test)]
8325            #[allow(dead_code, unreachable_patterns)]
8326            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
8327                match _t {
8328                    alloy_sol_types::private::AssertTypeEq::<
8329                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8330                    >(_) => {}
8331                }
8332            }
8333            #[automatically_derived]
8334            #[doc(hidden)]
8335            impl ::core::convert::From<delegationCall> for UnderlyingRustTuple<'_> {
8336                fn from(value: delegationCall) -> Self {
8337                    ()
8338                }
8339            }
8340            #[automatically_derived]
8341            #[doc(hidden)]
8342            impl ::core::convert::From<UnderlyingRustTuple<'_>> for delegationCall {
8343                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8344                    Self
8345                }
8346            }
8347        }
8348        {
8349            #[doc(hidden)]
8350            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
8351            #[doc(hidden)]
8352            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
8353            #[cfg(test)]
8354            #[allow(dead_code, unreachable_patterns)]
8355            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
8356                match _t {
8357                    alloy_sol_types::private::AssertTypeEq::<
8358                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8359                    >(_) => {}
8360                }
8361            }
8362            #[automatically_derived]
8363            #[doc(hidden)]
8364            impl ::core::convert::From<delegationReturn> for UnderlyingRustTuple<'_> {
8365                fn from(value: delegationReturn) -> Self {
8366                    (value._0,)
8367                }
8368            }
8369            #[automatically_derived]
8370            #[doc(hidden)]
8371            impl ::core::convert::From<UnderlyingRustTuple<'_>> for delegationReturn {
8372                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8373                    Self { _0: tuple.0 }
8374                }
8375            }
8376        }
8377        #[automatically_derived]
8378        impl alloy_sol_types::SolCall for delegationCall {
8379            type Parameters<'a> = ();
8380            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
8381            type Return = alloy::sol_types::private::Address;
8382            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
8383            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
8384            const SIGNATURE: &'static str = "delegation()";
8385            const SELECTOR: [u8; 4] = [223u8, 92u8, 247u8, 35u8];
8386            #[inline]
8387            fn new<'a>(
8388                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8389            ) -> Self {
8390                tuple.into()
8391            }
8392            #[inline]
8393            fn tokenize(&self) -> Self::Token<'_> {
8394                ()
8395            }
8396            #[inline]
8397            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
8398                (
8399                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8400                        ret,
8401                    ),
8402                )
8403            }
8404            #[inline]
8405            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8406                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
8407                    |r| {
8408                        let r: delegationReturn = r.into();
8409                        r._0
8410                    },
8411                )
8412            }
8413            #[inline]
8414            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8415                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
8416                    data,
8417                )
8418                .map(|r| {
8419                    let r: delegationReturn = r.into();
8420                    r._0
8421                })
8422            }
8423        }
8424    };
8425    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
8426    /**Function with signature `deregisterFromOperatorSets((address,address,uint32[]))` and selector `0x6e3492b5`.
8427    ```solidity
8428    function deregisterFromOperatorSets(IAllocationManagerTypes.DeregisterParams memory params) external;
8429    ```*/
8430    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8431    #[derive(Clone)]
8432    pub struct deregisterFromOperatorSetsCall {
8433        #[allow(missing_docs)]
8434        pub params:
8435            <IAllocationManagerTypes::DeregisterParams as alloy::sol_types::SolType>::RustType,
8436    }
8437    ///Container type for the return parameters of the [`deregisterFromOperatorSets((address,address,uint32[]))`](deregisterFromOperatorSetsCall) function.
8438    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8439    #[derive(Clone)]
8440    pub struct deregisterFromOperatorSetsReturn {}
8441    #[allow(
8442        non_camel_case_types,
8443        non_snake_case,
8444        clippy::pub_underscore_fields,
8445        clippy::style
8446    )]
8447    const _: () = {
8448        use alloy::sol_types as alloy_sol_types;
8449        {
8450            #[doc(hidden)]
8451            type UnderlyingSolTuple<'a> = (IAllocationManagerTypes::DeregisterParams,);
8452            #[doc(hidden)]
8453            type UnderlyingRustTuple<'a> = (
8454                <IAllocationManagerTypes::DeregisterParams as alloy::sol_types::SolType>::RustType,
8455            );
8456            #[cfg(test)]
8457            #[allow(dead_code, unreachable_patterns)]
8458            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
8459                match _t {
8460                    alloy_sol_types::private::AssertTypeEq::<
8461                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8462                    >(_) => {}
8463                }
8464            }
8465            #[automatically_derived]
8466            #[doc(hidden)]
8467            impl ::core::convert::From<deregisterFromOperatorSetsCall> for UnderlyingRustTuple<'_> {
8468                fn from(value: deregisterFromOperatorSetsCall) -> Self {
8469                    (value.params,)
8470                }
8471            }
8472            #[automatically_derived]
8473            #[doc(hidden)]
8474            impl ::core::convert::From<UnderlyingRustTuple<'_>> for deregisterFromOperatorSetsCall {
8475                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8476                    Self { params: tuple.0 }
8477                }
8478            }
8479        }
8480        {
8481            #[doc(hidden)]
8482            type UnderlyingSolTuple<'a> = ();
8483            #[doc(hidden)]
8484            type UnderlyingRustTuple<'a> = ();
8485            #[cfg(test)]
8486            #[allow(dead_code, unreachable_patterns)]
8487            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
8488                match _t {
8489                    alloy_sol_types::private::AssertTypeEq::<
8490                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8491                    >(_) => {}
8492                }
8493            }
8494            #[automatically_derived]
8495            #[doc(hidden)]
8496            impl ::core::convert::From<deregisterFromOperatorSetsReturn> for UnderlyingRustTuple<'_> {
8497                fn from(value: deregisterFromOperatorSetsReturn) -> Self {
8498                    ()
8499                }
8500            }
8501            #[automatically_derived]
8502            #[doc(hidden)]
8503            impl ::core::convert::From<UnderlyingRustTuple<'_>> for deregisterFromOperatorSetsReturn {
8504                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8505                    Self {}
8506                }
8507            }
8508        }
8509        impl deregisterFromOperatorSetsReturn {
8510            fn _tokenize(
8511                &self,
8512            ) -> <deregisterFromOperatorSetsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
8513            {
8514                ()
8515            }
8516        }
8517        #[automatically_derived]
8518        impl alloy_sol_types::SolCall for deregisterFromOperatorSetsCall {
8519            type Parameters<'a> = (IAllocationManagerTypes::DeregisterParams,);
8520            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
8521            type Return = deregisterFromOperatorSetsReturn;
8522            type ReturnTuple<'a> = ();
8523            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
8524            const SIGNATURE: &'static str =
8525                "deregisterFromOperatorSets((address,address,uint32[]))";
8526            const SELECTOR: [u8; 4] = [110u8, 52u8, 146u8, 181u8];
8527            #[inline]
8528            fn new<'a>(
8529                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8530            ) -> Self {
8531                tuple.into()
8532            }
8533            #[inline]
8534            fn tokenize(&self) -> Self::Token<'_> {
8535                (
8536                    <IAllocationManagerTypes::DeregisterParams as alloy_sol_types::SolType>::tokenize(
8537                        &self.params,
8538                    ),
8539                )
8540            }
8541            #[inline]
8542            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
8543                deregisterFromOperatorSetsReturn::_tokenize(ret)
8544            }
8545            #[inline]
8546            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8547                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
8548                    .map(Into::into)
8549            }
8550            #[inline]
8551            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8552                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
8553                    data,
8554                )
8555                .map(Into::into)
8556            }
8557        }
8558    };
8559    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
8560    /**Function with signature `getAVSRegistrar(address)` and selector `0x304c10cd`.
8561    ```solidity
8562    function getAVSRegistrar(address avs) external view returns (address);
8563    ```*/
8564    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8565    #[derive(Clone)]
8566    pub struct getAVSRegistrarCall {
8567        #[allow(missing_docs)]
8568        pub avs: alloy::sol_types::private::Address,
8569    }
8570    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
8571    ///Container type for the return parameters of the [`getAVSRegistrar(address)`](getAVSRegistrarCall) function.
8572    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8573    #[derive(Clone)]
8574    pub struct getAVSRegistrarReturn {
8575        #[allow(missing_docs)]
8576        pub _0: alloy::sol_types::private::Address,
8577    }
8578    #[allow(
8579        non_camel_case_types,
8580        non_snake_case,
8581        clippy::pub_underscore_fields,
8582        clippy::style
8583    )]
8584    const _: () = {
8585        use alloy::sol_types as alloy_sol_types;
8586        {
8587            #[doc(hidden)]
8588            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
8589            #[doc(hidden)]
8590            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
8591            #[cfg(test)]
8592            #[allow(dead_code, unreachable_patterns)]
8593            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
8594                match _t {
8595                    alloy_sol_types::private::AssertTypeEq::<
8596                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8597                    >(_) => {}
8598                }
8599            }
8600            #[automatically_derived]
8601            #[doc(hidden)]
8602            impl ::core::convert::From<getAVSRegistrarCall> for UnderlyingRustTuple<'_> {
8603                fn from(value: getAVSRegistrarCall) -> Self {
8604                    (value.avs,)
8605                }
8606            }
8607            #[automatically_derived]
8608            #[doc(hidden)]
8609            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAVSRegistrarCall {
8610                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8611                    Self { avs: tuple.0 }
8612                }
8613            }
8614        }
8615        {
8616            #[doc(hidden)]
8617            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
8618            #[doc(hidden)]
8619            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
8620            #[cfg(test)]
8621            #[allow(dead_code, unreachable_patterns)]
8622            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
8623                match _t {
8624                    alloy_sol_types::private::AssertTypeEq::<
8625                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8626                    >(_) => {}
8627                }
8628            }
8629            #[automatically_derived]
8630            #[doc(hidden)]
8631            impl ::core::convert::From<getAVSRegistrarReturn> for UnderlyingRustTuple<'_> {
8632                fn from(value: getAVSRegistrarReturn) -> Self {
8633                    (value._0,)
8634                }
8635            }
8636            #[automatically_derived]
8637            #[doc(hidden)]
8638            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAVSRegistrarReturn {
8639                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8640                    Self { _0: tuple.0 }
8641                }
8642            }
8643        }
8644        #[automatically_derived]
8645        impl alloy_sol_types::SolCall for getAVSRegistrarCall {
8646            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
8647            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
8648            type Return = alloy::sol_types::private::Address;
8649            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
8650            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
8651            const SIGNATURE: &'static str = "getAVSRegistrar(address)";
8652            const SELECTOR: [u8; 4] = [48u8, 76u8, 16u8, 205u8];
8653            #[inline]
8654            fn new<'a>(
8655                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8656            ) -> Self {
8657                tuple.into()
8658            }
8659            #[inline]
8660            fn tokenize(&self) -> Self::Token<'_> {
8661                (
8662                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8663                        &self.avs,
8664                    ),
8665                )
8666            }
8667            #[inline]
8668            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
8669                (
8670                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8671                        ret,
8672                    ),
8673                )
8674            }
8675            #[inline]
8676            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8677                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
8678                    |r| {
8679                        let r: getAVSRegistrarReturn = r.into();
8680                        r._0
8681                    },
8682                )
8683            }
8684            #[inline]
8685            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8686                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
8687                    data,
8688                )
8689                .map(|r| {
8690                    let r: getAVSRegistrarReturn = r.into();
8691                    r._0
8692                })
8693            }
8694        }
8695    };
8696    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
8697    /**Function with signature `getAllocatableMagnitude(address,address)` and selector `0x6cfb4481`.
8698    ```solidity
8699    function getAllocatableMagnitude(address operator, address strategy) external view returns (uint64);
8700    ```*/
8701    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8702    #[derive(Clone)]
8703    pub struct getAllocatableMagnitudeCall {
8704        #[allow(missing_docs)]
8705        pub operator: alloy::sol_types::private::Address,
8706        #[allow(missing_docs)]
8707        pub strategy: alloy::sol_types::private::Address,
8708    }
8709    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
8710    ///Container type for the return parameters of the [`getAllocatableMagnitude(address,address)`](getAllocatableMagnitudeCall) function.
8711    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8712    #[derive(Clone)]
8713    pub struct getAllocatableMagnitudeReturn {
8714        #[allow(missing_docs)]
8715        pub _0: u64,
8716    }
8717    #[allow(
8718        non_camel_case_types,
8719        non_snake_case,
8720        clippy::pub_underscore_fields,
8721        clippy::style
8722    )]
8723    const _: () = {
8724        use alloy::sol_types as alloy_sol_types;
8725        {
8726            #[doc(hidden)]
8727            type UnderlyingSolTuple<'a> = (
8728                alloy::sol_types::sol_data::Address,
8729                alloy::sol_types::sol_data::Address,
8730            );
8731            #[doc(hidden)]
8732            type UnderlyingRustTuple<'a> = (
8733                alloy::sol_types::private::Address,
8734                alloy::sol_types::private::Address,
8735            );
8736            #[cfg(test)]
8737            #[allow(dead_code, unreachable_patterns)]
8738            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
8739                match _t {
8740                    alloy_sol_types::private::AssertTypeEq::<
8741                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8742                    >(_) => {}
8743                }
8744            }
8745            #[automatically_derived]
8746            #[doc(hidden)]
8747            impl ::core::convert::From<getAllocatableMagnitudeCall> for UnderlyingRustTuple<'_> {
8748                fn from(value: getAllocatableMagnitudeCall) -> Self {
8749                    (value.operator, value.strategy)
8750                }
8751            }
8752            #[automatically_derived]
8753            #[doc(hidden)]
8754            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAllocatableMagnitudeCall {
8755                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8756                    Self {
8757                        operator: tuple.0,
8758                        strategy: tuple.1,
8759                    }
8760                }
8761            }
8762        }
8763        {
8764            #[doc(hidden)]
8765            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
8766            #[doc(hidden)]
8767            type UnderlyingRustTuple<'a> = (u64,);
8768            #[cfg(test)]
8769            #[allow(dead_code, unreachable_patterns)]
8770            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
8771                match _t {
8772                    alloy_sol_types::private::AssertTypeEq::<
8773                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8774                    >(_) => {}
8775                }
8776            }
8777            #[automatically_derived]
8778            #[doc(hidden)]
8779            impl ::core::convert::From<getAllocatableMagnitudeReturn> for UnderlyingRustTuple<'_> {
8780                fn from(value: getAllocatableMagnitudeReturn) -> Self {
8781                    (value._0,)
8782                }
8783            }
8784            #[automatically_derived]
8785            #[doc(hidden)]
8786            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAllocatableMagnitudeReturn {
8787                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8788                    Self { _0: tuple.0 }
8789                }
8790            }
8791        }
8792        #[automatically_derived]
8793        impl alloy_sol_types::SolCall for getAllocatableMagnitudeCall {
8794            type Parameters<'a> = (
8795                alloy::sol_types::sol_data::Address,
8796                alloy::sol_types::sol_data::Address,
8797            );
8798            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
8799            type Return = u64;
8800            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
8801            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
8802            const SIGNATURE: &'static str = "getAllocatableMagnitude(address,address)";
8803            const SELECTOR: [u8; 4] = [108u8, 251u8, 68u8, 129u8];
8804            #[inline]
8805            fn new<'a>(
8806                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8807            ) -> Self {
8808                tuple.into()
8809            }
8810            #[inline]
8811            fn tokenize(&self) -> Self::Token<'_> {
8812                (
8813                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8814                        &self.operator,
8815                    ),
8816                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8817                        &self.strategy,
8818                    ),
8819                )
8820            }
8821            #[inline]
8822            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
8823                (
8824                    <alloy::sol_types::sol_data::Uint<64> as alloy_sol_types::SolType>::tokenize(
8825                        ret,
8826                    ),
8827                )
8828            }
8829            #[inline]
8830            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8831                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
8832                    |r| {
8833                        let r: getAllocatableMagnitudeReturn = r.into();
8834                        r._0
8835                    },
8836                )
8837            }
8838            #[inline]
8839            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8840                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
8841                    data,
8842                )
8843                .map(|r| {
8844                    let r: getAllocatableMagnitudeReturn = r.into();
8845                    r._0
8846                })
8847            }
8848        }
8849    };
8850    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
8851    /**Function with signature `getAllocatedSets(address)` and selector `0x15fe5028`.
8852    ```solidity
8853    function getAllocatedSets(address operator) external view returns (OperatorSet[] memory);
8854    ```*/
8855    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8856    #[derive(Clone)]
8857    pub struct getAllocatedSetsCall {
8858        #[allow(missing_docs)]
8859        pub operator: alloy::sol_types::private::Address,
8860    }
8861    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
8862    ///Container type for the return parameters of the [`getAllocatedSets(address)`](getAllocatedSetsCall) function.
8863    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8864    #[derive(Clone)]
8865    pub struct getAllocatedSetsReturn {
8866        #[allow(missing_docs)]
8867        pub _0:
8868            alloy::sol_types::private::Vec<<OperatorSet as alloy::sol_types::SolType>::RustType>,
8869    }
8870    #[allow(
8871        non_camel_case_types,
8872        non_snake_case,
8873        clippy::pub_underscore_fields,
8874        clippy::style
8875    )]
8876    const _: () = {
8877        use alloy::sol_types as alloy_sol_types;
8878        {
8879            #[doc(hidden)]
8880            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
8881            #[doc(hidden)]
8882            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
8883            #[cfg(test)]
8884            #[allow(dead_code, unreachable_patterns)]
8885            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
8886                match _t {
8887                    alloy_sol_types::private::AssertTypeEq::<
8888                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8889                    >(_) => {}
8890                }
8891            }
8892            #[automatically_derived]
8893            #[doc(hidden)]
8894            impl ::core::convert::From<getAllocatedSetsCall> for UnderlyingRustTuple<'_> {
8895                fn from(value: getAllocatedSetsCall) -> Self {
8896                    (value.operator,)
8897                }
8898            }
8899            #[automatically_derived]
8900            #[doc(hidden)]
8901            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAllocatedSetsCall {
8902                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8903                    Self { operator: tuple.0 }
8904                }
8905            }
8906        }
8907        {
8908            #[doc(hidden)]
8909            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Array<OperatorSet>,);
8910            #[doc(hidden)]
8911            type UnderlyingRustTuple<'a> = (
8912                alloy::sol_types::private::Vec<
8913                    <OperatorSet as alloy::sol_types::SolType>::RustType,
8914                >,
8915            );
8916            #[cfg(test)]
8917            #[allow(dead_code, unreachable_patterns)]
8918            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
8919                match _t {
8920                    alloy_sol_types::private::AssertTypeEq::<
8921                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8922                    >(_) => {}
8923                }
8924            }
8925            #[automatically_derived]
8926            #[doc(hidden)]
8927            impl ::core::convert::From<getAllocatedSetsReturn> for UnderlyingRustTuple<'_> {
8928                fn from(value: getAllocatedSetsReturn) -> Self {
8929                    (value._0,)
8930                }
8931            }
8932            #[automatically_derived]
8933            #[doc(hidden)]
8934            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAllocatedSetsReturn {
8935                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8936                    Self { _0: tuple.0 }
8937                }
8938            }
8939        }
8940        #[automatically_derived]
8941        impl alloy_sol_types::SolCall for getAllocatedSetsCall {
8942            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
8943            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
8944            type Return = alloy::sol_types::private::Vec<
8945                <OperatorSet as alloy::sol_types::SolType>::RustType,
8946            >;
8947            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Array<OperatorSet>,);
8948            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
8949            const SIGNATURE: &'static str = "getAllocatedSets(address)";
8950            const SELECTOR: [u8; 4] = [21u8, 254u8, 80u8, 40u8];
8951            #[inline]
8952            fn new<'a>(
8953                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8954            ) -> Self {
8955                tuple.into()
8956            }
8957            #[inline]
8958            fn tokenize(&self) -> Self::Token<'_> {
8959                (
8960                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8961                        &self.operator,
8962                    ),
8963                )
8964            }
8965            #[inline]
8966            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
8967                (
8968                    <alloy::sol_types::sol_data::Array<
8969                        OperatorSet,
8970                    > as alloy_sol_types::SolType>::tokenize(ret),
8971                )
8972            }
8973            #[inline]
8974            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8975                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
8976                    |r| {
8977                        let r: getAllocatedSetsReturn = r.into();
8978                        r._0
8979                    },
8980                )
8981            }
8982            #[inline]
8983            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8984                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
8985                    data,
8986                )
8987                .map(|r| {
8988                    let r: getAllocatedSetsReturn = r.into();
8989                    r._0
8990                })
8991            }
8992        }
8993    };
8994    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
8995    /**Function with signature `getAllocatedStake((address,uint32),address[],address[])` and selector `0x2b453a9a`.
8996    ```solidity
8997    function getAllocatedStake(OperatorSet memory operatorSet, address[] memory operators, address[] memory strategies) external view returns (uint256[][] memory);
8998    ```*/
8999    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9000    #[derive(Clone)]
9001    pub struct getAllocatedStakeCall {
9002        #[allow(missing_docs)]
9003        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
9004        #[allow(missing_docs)]
9005        pub operators: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9006        #[allow(missing_docs)]
9007        pub strategies: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9008    }
9009    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
9010    ///Container type for the return parameters of the [`getAllocatedStake((address,uint32),address[],address[])`](getAllocatedStakeCall) function.
9011    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9012    #[derive(Clone)]
9013    pub struct getAllocatedStakeReturn {
9014        #[allow(missing_docs)]
9015        pub _0: alloy::sol_types::private::Vec<
9016            alloy::sol_types::private::Vec<alloy::sol_types::private::primitives::aliases::U256>,
9017        >,
9018    }
9019    #[allow(
9020        non_camel_case_types,
9021        non_snake_case,
9022        clippy::pub_underscore_fields,
9023        clippy::style
9024    )]
9025    const _: () = {
9026        use alloy::sol_types as alloy_sol_types;
9027        {
9028            #[doc(hidden)]
9029            type UnderlyingSolTuple<'a> = (
9030                OperatorSet,
9031                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
9032                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
9033            );
9034            #[doc(hidden)]
9035            type UnderlyingRustTuple<'a> = (
9036                <OperatorSet as alloy::sol_types::SolType>::RustType,
9037                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9038                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9039            );
9040            #[cfg(test)]
9041            #[allow(dead_code, unreachable_patterns)]
9042            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
9043                match _t {
9044                    alloy_sol_types::private::AssertTypeEq::<
9045                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9046                    >(_) => {}
9047                }
9048            }
9049            #[automatically_derived]
9050            #[doc(hidden)]
9051            impl ::core::convert::From<getAllocatedStakeCall> for UnderlyingRustTuple<'_> {
9052                fn from(value: getAllocatedStakeCall) -> Self {
9053                    (value.operatorSet, value.operators, value.strategies)
9054                }
9055            }
9056            #[automatically_derived]
9057            #[doc(hidden)]
9058            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAllocatedStakeCall {
9059                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9060                    Self {
9061                        operatorSet: tuple.0,
9062                        operators: tuple.1,
9063                        strategies: tuple.2,
9064                    }
9065                }
9066            }
9067        }
9068        {
9069            #[doc(hidden)]
9070            type UnderlyingSolTuple<'a> = (
9071                alloy::sol_types::sol_data::Array<
9072                    alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
9073                >,
9074            );
9075            #[doc(hidden)]
9076            type UnderlyingRustTuple<'a> = (
9077                alloy::sol_types::private::Vec<
9078                    alloy::sol_types::private::Vec<
9079                        alloy::sol_types::private::primitives::aliases::U256,
9080                    >,
9081                >,
9082            );
9083            #[cfg(test)]
9084            #[allow(dead_code, unreachable_patterns)]
9085            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
9086                match _t {
9087                    alloy_sol_types::private::AssertTypeEq::<
9088                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9089                    >(_) => {}
9090                }
9091            }
9092            #[automatically_derived]
9093            #[doc(hidden)]
9094            impl ::core::convert::From<getAllocatedStakeReturn> for UnderlyingRustTuple<'_> {
9095                fn from(value: getAllocatedStakeReturn) -> Self {
9096                    (value._0,)
9097                }
9098            }
9099            #[automatically_derived]
9100            #[doc(hidden)]
9101            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAllocatedStakeReturn {
9102                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9103                    Self { _0: tuple.0 }
9104                }
9105            }
9106        }
9107        #[automatically_derived]
9108        impl alloy_sol_types::SolCall for getAllocatedStakeCall {
9109            type Parameters<'a> = (
9110                OperatorSet,
9111                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
9112                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
9113            );
9114            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
9115            type Return = alloy::sol_types::private::Vec<
9116                alloy::sol_types::private::Vec<
9117                    alloy::sol_types::private::primitives::aliases::U256,
9118                >,
9119            >;
9120            type ReturnTuple<'a> = (
9121                alloy::sol_types::sol_data::Array<
9122                    alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
9123                >,
9124            );
9125            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
9126            const SIGNATURE: &'static str =
9127                "getAllocatedStake((address,uint32),address[],address[])";
9128            const SELECTOR: [u8; 4] = [43u8, 69u8, 58u8, 154u8];
9129            #[inline]
9130            fn new<'a>(
9131                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9132            ) -> Self {
9133                tuple.into()
9134            }
9135            #[inline]
9136            fn tokenize(&self) -> Self::Token<'_> {
9137                (
9138                    <OperatorSet as alloy_sol_types::SolType>::tokenize(
9139                        &self.operatorSet,
9140                    ),
9141                    <alloy::sol_types::sol_data::Array<
9142                        alloy::sol_types::sol_data::Address,
9143                    > as alloy_sol_types::SolType>::tokenize(&self.operators),
9144                    <alloy::sol_types::sol_data::Array<
9145                        alloy::sol_types::sol_data::Address,
9146                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
9147                )
9148            }
9149            #[inline]
9150            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
9151                (<alloy::sol_types::sol_data::Array<
9152                    alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
9153                > as alloy_sol_types::SolType>::tokenize(ret),)
9154            }
9155            #[inline]
9156            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9157                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
9158                    |r| {
9159                        let r: getAllocatedStakeReturn = r.into();
9160                        r._0
9161                    },
9162                )
9163            }
9164            #[inline]
9165            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9166                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
9167                    data,
9168                )
9169                .map(|r| {
9170                    let r: getAllocatedStakeReturn = r.into();
9171                    r._0
9172                })
9173            }
9174        }
9175    };
9176    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
9177    /**Function with signature `getAllocatedStrategies(address,(address,uint32))` and selector `0xc221d8ae`.
9178    ```solidity
9179    function getAllocatedStrategies(address operator, OperatorSet memory operatorSet) external view returns (address[] memory);
9180    ```*/
9181    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9182    #[derive(Clone)]
9183    pub struct getAllocatedStrategiesCall {
9184        #[allow(missing_docs)]
9185        pub operator: alloy::sol_types::private::Address,
9186        #[allow(missing_docs)]
9187        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
9188    }
9189    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
9190    ///Container type for the return parameters of the [`getAllocatedStrategies(address,(address,uint32))`](getAllocatedStrategiesCall) function.
9191    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9192    #[derive(Clone)]
9193    pub struct getAllocatedStrategiesReturn {
9194        #[allow(missing_docs)]
9195        pub _0: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9196    }
9197    #[allow(
9198        non_camel_case_types,
9199        non_snake_case,
9200        clippy::pub_underscore_fields,
9201        clippy::style
9202    )]
9203    const _: () = {
9204        use alloy::sol_types as alloy_sol_types;
9205        {
9206            #[doc(hidden)]
9207            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address, OperatorSet);
9208            #[doc(hidden)]
9209            type UnderlyingRustTuple<'a> = (
9210                alloy::sol_types::private::Address,
9211                <OperatorSet as alloy::sol_types::SolType>::RustType,
9212            );
9213            #[cfg(test)]
9214            #[allow(dead_code, unreachable_patterns)]
9215            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
9216                match _t {
9217                    alloy_sol_types::private::AssertTypeEq::<
9218                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9219                    >(_) => {}
9220                }
9221            }
9222            #[automatically_derived]
9223            #[doc(hidden)]
9224            impl ::core::convert::From<getAllocatedStrategiesCall> for UnderlyingRustTuple<'_> {
9225                fn from(value: getAllocatedStrategiesCall) -> Self {
9226                    (value.operator, value.operatorSet)
9227                }
9228            }
9229            #[automatically_derived]
9230            #[doc(hidden)]
9231            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAllocatedStrategiesCall {
9232                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9233                    Self {
9234                        operator: tuple.0,
9235                        operatorSet: tuple.1,
9236                    }
9237                }
9238            }
9239        }
9240        {
9241            #[doc(hidden)]
9242            type UnderlyingSolTuple<'a> =
9243                (alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,);
9244            #[doc(hidden)]
9245            type UnderlyingRustTuple<'a> =
9246                (alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,);
9247            #[cfg(test)]
9248            #[allow(dead_code, unreachable_patterns)]
9249            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
9250                match _t {
9251                    alloy_sol_types::private::AssertTypeEq::<
9252                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9253                    >(_) => {}
9254                }
9255            }
9256            #[automatically_derived]
9257            #[doc(hidden)]
9258            impl ::core::convert::From<getAllocatedStrategiesReturn> for UnderlyingRustTuple<'_> {
9259                fn from(value: getAllocatedStrategiesReturn) -> Self {
9260                    (value._0,)
9261                }
9262            }
9263            #[automatically_derived]
9264            #[doc(hidden)]
9265            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAllocatedStrategiesReturn {
9266                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9267                    Self { _0: tuple.0 }
9268                }
9269            }
9270        }
9271        #[automatically_derived]
9272        impl alloy_sol_types::SolCall for getAllocatedStrategiesCall {
9273            type Parameters<'a> = (alloy::sol_types::sol_data::Address, OperatorSet);
9274            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
9275            type Return = alloy::sol_types::private::Vec<alloy::sol_types::private::Address>;
9276            type ReturnTuple<'a> =
9277                (alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,);
9278            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
9279            const SIGNATURE: &'static str = "getAllocatedStrategies(address,(address,uint32))";
9280            const SELECTOR: [u8; 4] = [194u8, 33u8, 216u8, 174u8];
9281            #[inline]
9282            fn new<'a>(
9283                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9284            ) -> Self {
9285                tuple.into()
9286            }
9287            #[inline]
9288            fn tokenize(&self) -> Self::Token<'_> {
9289                (
9290                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
9291                        &self.operator,
9292                    ),
9293                    <OperatorSet as alloy_sol_types::SolType>::tokenize(&self.operatorSet),
9294                )
9295            }
9296            #[inline]
9297            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
9298                (<alloy::sol_types::sol_data::Array<
9299                    alloy::sol_types::sol_data::Address,
9300                > as alloy_sol_types::SolType>::tokenize(ret),)
9301            }
9302            #[inline]
9303            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9304                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
9305                    |r| {
9306                        let r: getAllocatedStrategiesReturn = r.into();
9307                        r._0
9308                    },
9309                )
9310            }
9311            #[inline]
9312            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9313                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
9314                    data,
9315                )
9316                .map(|r| {
9317                    let r: getAllocatedStrategiesReturn = r.into();
9318                    r._0
9319                })
9320            }
9321        }
9322    };
9323    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
9324    /**Function with signature `getAllocation(address,(address,uint32),address)` and selector `0x10e1b9b8`.
9325    ```solidity
9326    function getAllocation(address operator, OperatorSet memory operatorSet, address strategy) external view returns (IAllocationManagerTypes.Allocation memory);
9327    ```*/
9328    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9329    #[derive(Clone)]
9330    pub struct getAllocationCall {
9331        #[allow(missing_docs)]
9332        pub operator: alloy::sol_types::private::Address,
9333        #[allow(missing_docs)]
9334        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
9335        #[allow(missing_docs)]
9336        pub strategy: alloy::sol_types::private::Address,
9337    }
9338    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
9339    ///Container type for the return parameters of the [`getAllocation(address,(address,uint32),address)`](getAllocationCall) function.
9340    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9341    #[derive(Clone)]
9342    pub struct getAllocationReturn {
9343        #[allow(missing_docs)]
9344        pub _0: <IAllocationManagerTypes::Allocation as alloy::sol_types::SolType>::RustType,
9345    }
9346    #[allow(
9347        non_camel_case_types,
9348        non_snake_case,
9349        clippy::pub_underscore_fields,
9350        clippy::style
9351    )]
9352    const _: () = {
9353        use alloy::sol_types as alloy_sol_types;
9354        {
9355            #[doc(hidden)]
9356            type UnderlyingSolTuple<'a> = (
9357                alloy::sol_types::sol_data::Address,
9358                OperatorSet,
9359                alloy::sol_types::sol_data::Address,
9360            );
9361            #[doc(hidden)]
9362            type UnderlyingRustTuple<'a> = (
9363                alloy::sol_types::private::Address,
9364                <OperatorSet as alloy::sol_types::SolType>::RustType,
9365                alloy::sol_types::private::Address,
9366            );
9367            #[cfg(test)]
9368            #[allow(dead_code, unreachable_patterns)]
9369            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
9370                match _t {
9371                    alloy_sol_types::private::AssertTypeEq::<
9372                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9373                    >(_) => {}
9374                }
9375            }
9376            #[automatically_derived]
9377            #[doc(hidden)]
9378            impl ::core::convert::From<getAllocationCall> for UnderlyingRustTuple<'_> {
9379                fn from(value: getAllocationCall) -> Self {
9380                    (value.operator, value.operatorSet, value.strategy)
9381                }
9382            }
9383            #[automatically_derived]
9384            #[doc(hidden)]
9385            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAllocationCall {
9386                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9387                    Self {
9388                        operator: tuple.0,
9389                        operatorSet: tuple.1,
9390                        strategy: tuple.2,
9391                    }
9392                }
9393            }
9394        }
9395        {
9396            #[doc(hidden)]
9397            type UnderlyingSolTuple<'a> = (IAllocationManagerTypes::Allocation,);
9398            #[doc(hidden)]
9399            type UnderlyingRustTuple<'a> =
9400                (<IAllocationManagerTypes::Allocation as alloy::sol_types::SolType>::RustType,);
9401            #[cfg(test)]
9402            #[allow(dead_code, unreachable_patterns)]
9403            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
9404                match _t {
9405                    alloy_sol_types::private::AssertTypeEq::<
9406                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9407                    >(_) => {}
9408                }
9409            }
9410            #[automatically_derived]
9411            #[doc(hidden)]
9412            impl ::core::convert::From<getAllocationReturn> for UnderlyingRustTuple<'_> {
9413                fn from(value: getAllocationReturn) -> Self {
9414                    (value._0,)
9415                }
9416            }
9417            #[automatically_derived]
9418            #[doc(hidden)]
9419            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAllocationReturn {
9420                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9421                    Self { _0: tuple.0 }
9422                }
9423            }
9424        }
9425        #[automatically_derived]
9426        impl alloy_sol_types::SolCall for getAllocationCall {
9427            type Parameters<'a> = (
9428                alloy::sol_types::sol_data::Address,
9429                OperatorSet,
9430                alloy::sol_types::sol_data::Address,
9431            );
9432            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
9433            type Return =
9434                <IAllocationManagerTypes::Allocation as alloy::sol_types::SolType>::RustType;
9435            type ReturnTuple<'a> = (IAllocationManagerTypes::Allocation,);
9436            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
9437            const SIGNATURE: &'static str = "getAllocation(address,(address,uint32),address)";
9438            const SELECTOR: [u8; 4] = [16u8, 225u8, 185u8, 184u8];
9439            #[inline]
9440            fn new<'a>(
9441                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9442            ) -> Self {
9443                tuple.into()
9444            }
9445            #[inline]
9446            fn tokenize(&self) -> Self::Token<'_> {
9447                (
9448                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
9449                        &self.operator,
9450                    ),
9451                    <OperatorSet as alloy_sol_types::SolType>::tokenize(&self.operatorSet),
9452                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
9453                        &self.strategy,
9454                    ),
9455                )
9456            }
9457            #[inline]
9458            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
9459                (
9460                    <IAllocationManagerTypes::Allocation as alloy_sol_types::SolType>::tokenize(
9461                        ret,
9462                    ),
9463                )
9464            }
9465            #[inline]
9466            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9467                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
9468                    |r| {
9469                        let r: getAllocationReturn = r.into();
9470                        r._0
9471                    },
9472                )
9473            }
9474            #[inline]
9475            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9476                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
9477                    data,
9478                )
9479                .map(|r| {
9480                    let r: getAllocationReturn = r.into();
9481                    r._0
9482                })
9483            }
9484        }
9485    };
9486    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
9487    /**Function with signature `getAllocationDelay(address)` and selector `0xb9fbaed1`.
9488    ```solidity
9489    function getAllocationDelay(address operator) external view returns (bool, uint32);
9490    ```*/
9491    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9492    #[derive(Clone)]
9493    pub struct getAllocationDelayCall {
9494        #[allow(missing_docs)]
9495        pub operator: alloy::sol_types::private::Address,
9496    }
9497    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
9498    ///Container type for the return parameters of the [`getAllocationDelay(address)`](getAllocationDelayCall) function.
9499    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9500    #[derive(Clone)]
9501    pub struct getAllocationDelayReturn {
9502        #[allow(missing_docs)]
9503        pub _0: bool,
9504        #[allow(missing_docs)]
9505        pub _1: u32,
9506    }
9507    #[allow(
9508        non_camel_case_types,
9509        non_snake_case,
9510        clippy::pub_underscore_fields,
9511        clippy::style
9512    )]
9513    const _: () = {
9514        use alloy::sol_types as alloy_sol_types;
9515        {
9516            #[doc(hidden)]
9517            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
9518            #[doc(hidden)]
9519            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
9520            #[cfg(test)]
9521            #[allow(dead_code, unreachable_patterns)]
9522            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
9523                match _t {
9524                    alloy_sol_types::private::AssertTypeEq::<
9525                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9526                    >(_) => {}
9527                }
9528            }
9529            #[automatically_derived]
9530            #[doc(hidden)]
9531            impl ::core::convert::From<getAllocationDelayCall> for UnderlyingRustTuple<'_> {
9532                fn from(value: getAllocationDelayCall) -> Self {
9533                    (value.operator,)
9534                }
9535            }
9536            #[automatically_derived]
9537            #[doc(hidden)]
9538            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAllocationDelayCall {
9539                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9540                    Self { operator: tuple.0 }
9541                }
9542            }
9543        }
9544        {
9545            #[doc(hidden)]
9546            type UnderlyingSolTuple<'a> = (
9547                alloy::sol_types::sol_data::Bool,
9548                alloy::sol_types::sol_data::Uint<32>,
9549            );
9550            #[doc(hidden)]
9551            type UnderlyingRustTuple<'a> = (bool, u32);
9552            #[cfg(test)]
9553            #[allow(dead_code, unreachable_patterns)]
9554            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
9555                match _t {
9556                    alloy_sol_types::private::AssertTypeEq::<
9557                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9558                    >(_) => {}
9559                }
9560            }
9561            #[automatically_derived]
9562            #[doc(hidden)]
9563            impl ::core::convert::From<getAllocationDelayReturn> for UnderlyingRustTuple<'_> {
9564                fn from(value: getAllocationDelayReturn) -> Self {
9565                    (value._0, value._1)
9566                }
9567            }
9568            #[automatically_derived]
9569            #[doc(hidden)]
9570            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAllocationDelayReturn {
9571                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9572                    Self {
9573                        _0: tuple.0,
9574                        _1: tuple.1,
9575                    }
9576                }
9577            }
9578        }
9579        impl getAllocationDelayReturn {
9580            fn _tokenize(
9581                &self,
9582            ) -> <getAllocationDelayCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
9583                (
9584                    <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
9585                        &self._0,
9586                    ),
9587                    <alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
9588                        &self._1,
9589                    ),
9590                )
9591            }
9592        }
9593        #[automatically_derived]
9594        impl alloy_sol_types::SolCall for getAllocationDelayCall {
9595            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
9596            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
9597            type Return = getAllocationDelayReturn;
9598            type ReturnTuple<'a> = (
9599                alloy::sol_types::sol_data::Bool,
9600                alloy::sol_types::sol_data::Uint<32>,
9601            );
9602            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
9603            const SIGNATURE: &'static str = "getAllocationDelay(address)";
9604            const SELECTOR: [u8; 4] = [185u8, 251u8, 174u8, 209u8];
9605            #[inline]
9606            fn new<'a>(
9607                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9608            ) -> Self {
9609                tuple.into()
9610            }
9611            #[inline]
9612            fn tokenize(&self) -> Self::Token<'_> {
9613                (
9614                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
9615                        &self.operator,
9616                    ),
9617                )
9618            }
9619            #[inline]
9620            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
9621                getAllocationDelayReturn::_tokenize(ret)
9622            }
9623            #[inline]
9624            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9625                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
9626                    .map(Into::into)
9627            }
9628            #[inline]
9629            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9630                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
9631                    data,
9632                )
9633                .map(Into::into)
9634            }
9635        }
9636    };
9637    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
9638    /**Function with signature `getAllocations(address[],(address,uint32),address)` and selector `0x8ce64854`.
9639    ```solidity
9640    function getAllocations(address[] memory operators, OperatorSet memory operatorSet, address strategy) external view returns (IAllocationManagerTypes.Allocation[] memory);
9641    ```*/
9642    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9643    #[derive(Clone)]
9644    pub struct getAllocationsCall {
9645        #[allow(missing_docs)]
9646        pub operators: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9647        #[allow(missing_docs)]
9648        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
9649        #[allow(missing_docs)]
9650        pub strategy: alloy::sol_types::private::Address,
9651    }
9652    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
9653    ///Container type for the return parameters of the [`getAllocations(address[],(address,uint32),address)`](getAllocationsCall) function.
9654    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9655    #[derive(Clone)]
9656    pub struct getAllocationsReturn {
9657        #[allow(missing_docs)]
9658        pub _0: alloy::sol_types::private::Vec<
9659            <IAllocationManagerTypes::Allocation as alloy::sol_types::SolType>::RustType,
9660        >,
9661    }
9662    #[allow(
9663        non_camel_case_types,
9664        non_snake_case,
9665        clippy::pub_underscore_fields,
9666        clippy::style
9667    )]
9668    const _: () = {
9669        use alloy::sol_types as alloy_sol_types;
9670        {
9671            #[doc(hidden)]
9672            type UnderlyingSolTuple<'a> = (
9673                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
9674                OperatorSet,
9675                alloy::sol_types::sol_data::Address,
9676            );
9677            #[doc(hidden)]
9678            type UnderlyingRustTuple<'a> = (
9679                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9680                <OperatorSet as alloy::sol_types::SolType>::RustType,
9681                alloy::sol_types::private::Address,
9682            );
9683            #[cfg(test)]
9684            #[allow(dead_code, unreachable_patterns)]
9685            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
9686                match _t {
9687                    alloy_sol_types::private::AssertTypeEq::<
9688                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9689                    >(_) => {}
9690                }
9691            }
9692            #[automatically_derived]
9693            #[doc(hidden)]
9694            impl ::core::convert::From<getAllocationsCall> for UnderlyingRustTuple<'_> {
9695                fn from(value: getAllocationsCall) -> Self {
9696                    (value.operators, value.operatorSet, value.strategy)
9697                }
9698            }
9699            #[automatically_derived]
9700            #[doc(hidden)]
9701            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAllocationsCall {
9702                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9703                    Self {
9704                        operators: tuple.0,
9705                        operatorSet: tuple.1,
9706                        strategy: tuple.2,
9707                    }
9708                }
9709            }
9710        }
9711        {
9712            #[doc(hidden)]
9713            type UnderlyingSolTuple<'a> =
9714                (alloy::sol_types::sol_data::Array<IAllocationManagerTypes::Allocation>,);
9715            #[doc(hidden)]
9716            type UnderlyingRustTuple<'a> = (
9717                alloy::sol_types::private::Vec<
9718                    <IAllocationManagerTypes::Allocation as alloy::sol_types::SolType>::RustType,
9719                >,
9720            );
9721            #[cfg(test)]
9722            #[allow(dead_code, unreachable_patterns)]
9723            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
9724                match _t {
9725                    alloy_sol_types::private::AssertTypeEq::<
9726                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9727                    >(_) => {}
9728                }
9729            }
9730            #[automatically_derived]
9731            #[doc(hidden)]
9732            impl ::core::convert::From<getAllocationsReturn> for UnderlyingRustTuple<'_> {
9733                fn from(value: getAllocationsReturn) -> Self {
9734                    (value._0,)
9735                }
9736            }
9737            #[automatically_derived]
9738            #[doc(hidden)]
9739            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAllocationsReturn {
9740                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9741                    Self { _0: tuple.0 }
9742                }
9743            }
9744        }
9745        #[automatically_derived]
9746        impl alloy_sol_types::SolCall for getAllocationsCall {
9747            type Parameters<'a> = (
9748                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
9749                OperatorSet,
9750                alloy::sol_types::sol_data::Address,
9751            );
9752            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
9753            type Return = alloy::sol_types::private::Vec<
9754                <IAllocationManagerTypes::Allocation as alloy::sol_types::SolType>::RustType,
9755            >;
9756            type ReturnTuple<'a> =
9757                (alloy::sol_types::sol_data::Array<IAllocationManagerTypes::Allocation>,);
9758            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
9759            const SIGNATURE: &'static str = "getAllocations(address[],(address,uint32),address)";
9760            const SELECTOR: [u8; 4] = [140u8, 230u8, 72u8, 84u8];
9761            #[inline]
9762            fn new<'a>(
9763                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9764            ) -> Self {
9765                tuple.into()
9766            }
9767            #[inline]
9768            fn tokenize(&self) -> Self::Token<'_> {
9769                (
9770                    <alloy::sol_types::sol_data::Array<
9771                        alloy::sol_types::sol_data::Address,
9772                    > as alloy_sol_types::SolType>::tokenize(&self.operators),
9773                    <OperatorSet as alloy_sol_types::SolType>::tokenize(
9774                        &self.operatorSet,
9775                    ),
9776                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
9777                        &self.strategy,
9778                    ),
9779                )
9780            }
9781            #[inline]
9782            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
9783                (<alloy::sol_types::sol_data::Array<
9784                    IAllocationManagerTypes::Allocation,
9785                > as alloy_sol_types::SolType>::tokenize(ret),)
9786            }
9787            #[inline]
9788            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9789                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
9790                    |r| {
9791                        let r: getAllocationsReturn = r.into();
9792                        r._0
9793                    },
9794                )
9795            }
9796            #[inline]
9797            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9798                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
9799                    data,
9800                )
9801                .map(|r| {
9802                    let r: getAllocationsReturn = r.into();
9803                    r._0
9804                })
9805            }
9806        }
9807    };
9808    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
9809    /**Function with signature `getEncumberedMagnitude(address,address)` and selector `0xf605ce08`.
9810    ```solidity
9811    function getEncumberedMagnitude(address operator, address strategy) external view returns (uint64);
9812    ```*/
9813    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9814    #[derive(Clone)]
9815    pub struct getEncumberedMagnitudeCall {
9816        #[allow(missing_docs)]
9817        pub operator: alloy::sol_types::private::Address,
9818        #[allow(missing_docs)]
9819        pub strategy: alloy::sol_types::private::Address,
9820    }
9821    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
9822    ///Container type for the return parameters of the [`getEncumberedMagnitude(address,address)`](getEncumberedMagnitudeCall) function.
9823    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9824    #[derive(Clone)]
9825    pub struct getEncumberedMagnitudeReturn {
9826        #[allow(missing_docs)]
9827        pub _0: u64,
9828    }
9829    #[allow(
9830        non_camel_case_types,
9831        non_snake_case,
9832        clippy::pub_underscore_fields,
9833        clippy::style
9834    )]
9835    const _: () = {
9836        use alloy::sol_types as alloy_sol_types;
9837        {
9838            #[doc(hidden)]
9839            type UnderlyingSolTuple<'a> = (
9840                alloy::sol_types::sol_data::Address,
9841                alloy::sol_types::sol_data::Address,
9842            );
9843            #[doc(hidden)]
9844            type UnderlyingRustTuple<'a> = (
9845                alloy::sol_types::private::Address,
9846                alloy::sol_types::private::Address,
9847            );
9848            #[cfg(test)]
9849            #[allow(dead_code, unreachable_patterns)]
9850            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
9851                match _t {
9852                    alloy_sol_types::private::AssertTypeEq::<
9853                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9854                    >(_) => {}
9855                }
9856            }
9857            #[automatically_derived]
9858            #[doc(hidden)]
9859            impl ::core::convert::From<getEncumberedMagnitudeCall> for UnderlyingRustTuple<'_> {
9860                fn from(value: getEncumberedMagnitudeCall) -> Self {
9861                    (value.operator, value.strategy)
9862                }
9863            }
9864            #[automatically_derived]
9865            #[doc(hidden)]
9866            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getEncumberedMagnitudeCall {
9867                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9868                    Self {
9869                        operator: tuple.0,
9870                        strategy: tuple.1,
9871                    }
9872                }
9873            }
9874        }
9875        {
9876            #[doc(hidden)]
9877            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
9878            #[doc(hidden)]
9879            type UnderlyingRustTuple<'a> = (u64,);
9880            #[cfg(test)]
9881            #[allow(dead_code, unreachable_patterns)]
9882            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
9883                match _t {
9884                    alloy_sol_types::private::AssertTypeEq::<
9885                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9886                    >(_) => {}
9887                }
9888            }
9889            #[automatically_derived]
9890            #[doc(hidden)]
9891            impl ::core::convert::From<getEncumberedMagnitudeReturn> for UnderlyingRustTuple<'_> {
9892                fn from(value: getEncumberedMagnitudeReturn) -> Self {
9893                    (value._0,)
9894                }
9895            }
9896            #[automatically_derived]
9897            #[doc(hidden)]
9898            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getEncumberedMagnitudeReturn {
9899                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9900                    Self { _0: tuple.0 }
9901                }
9902            }
9903        }
9904        #[automatically_derived]
9905        impl alloy_sol_types::SolCall for getEncumberedMagnitudeCall {
9906            type Parameters<'a> = (
9907                alloy::sol_types::sol_data::Address,
9908                alloy::sol_types::sol_data::Address,
9909            );
9910            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
9911            type Return = u64;
9912            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
9913            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
9914            const SIGNATURE: &'static str = "getEncumberedMagnitude(address,address)";
9915            const SELECTOR: [u8; 4] = [246u8, 5u8, 206u8, 8u8];
9916            #[inline]
9917            fn new<'a>(
9918                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9919            ) -> Self {
9920                tuple.into()
9921            }
9922            #[inline]
9923            fn tokenize(&self) -> Self::Token<'_> {
9924                (
9925                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
9926                        &self.operator,
9927                    ),
9928                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
9929                        &self.strategy,
9930                    ),
9931                )
9932            }
9933            #[inline]
9934            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
9935                (
9936                    <alloy::sol_types::sol_data::Uint<64> as alloy_sol_types::SolType>::tokenize(
9937                        ret,
9938                    ),
9939                )
9940            }
9941            #[inline]
9942            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9943                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
9944                    |r| {
9945                        let r: getEncumberedMagnitudeReturn = r.into();
9946                        r._0
9947                    },
9948                )
9949            }
9950            #[inline]
9951            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9952                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
9953                    data,
9954                )
9955                .map(|r| {
9956                    let r: getEncumberedMagnitudeReturn = r.into();
9957                    r._0
9958                })
9959            }
9960        }
9961    };
9962    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
9963    /**Function with signature `getMaxMagnitude(address,address)` and selector `0xa9333ec8`.
9964    ```solidity
9965    function getMaxMagnitude(address operator, address strategy) external view returns (uint64);
9966    ```*/
9967    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9968    #[derive(Clone)]
9969    pub struct getMaxMagnitudeCall {
9970        #[allow(missing_docs)]
9971        pub operator: alloy::sol_types::private::Address,
9972        #[allow(missing_docs)]
9973        pub strategy: alloy::sol_types::private::Address,
9974    }
9975    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
9976    ///Container type for the return parameters of the [`getMaxMagnitude(address,address)`](getMaxMagnitudeCall) function.
9977    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9978    #[derive(Clone)]
9979    pub struct getMaxMagnitudeReturn {
9980        #[allow(missing_docs)]
9981        pub _0: u64,
9982    }
9983    #[allow(
9984        non_camel_case_types,
9985        non_snake_case,
9986        clippy::pub_underscore_fields,
9987        clippy::style
9988    )]
9989    const _: () = {
9990        use alloy::sol_types as alloy_sol_types;
9991        {
9992            #[doc(hidden)]
9993            type UnderlyingSolTuple<'a> = (
9994                alloy::sol_types::sol_data::Address,
9995                alloy::sol_types::sol_data::Address,
9996            );
9997            #[doc(hidden)]
9998            type UnderlyingRustTuple<'a> = (
9999                alloy::sol_types::private::Address,
10000                alloy::sol_types::private::Address,
10001            );
10002            #[cfg(test)]
10003            #[allow(dead_code, unreachable_patterns)]
10004            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
10005                match _t {
10006                    alloy_sol_types::private::AssertTypeEq::<
10007                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10008                    >(_) => {}
10009                }
10010            }
10011            #[automatically_derived]
10012            #[doc(hidden)]
10013            impl ::core::convert::From<getMaxMagnitudeCall> for UnderlyingRustTuple<'_> {
10014                fn from(value: getMaxMagnitudeCall) -> Self {
10015                    (value.operator, value.strategy)
10016                }
10017            }
10018            #[automatically_derived]
10019            #[doc(hidden)]
10020            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMaxMagnitudeCall {
10021                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10022                    Self {
10023                        operator: tuple.0,
10024                        strategy: tuple.1,
10025                    }
10026                }
10027            }
10028        }
10029        {
10030            #[doc(hidden)]
10031            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
10032            #[doc(hidden)]
10033            type UnderlyingRustTuple<'a> = (u64,);
10034            #[cfg(test)]
10035            #[allow(dead_code, unreachable_patterns)]
10036            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
10037                match _t {
10038                    alloy_sol_types::private::AssertTypeEq::<
10039                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10040                    >(_) => {}
10041                }
10042            }
10043            #[automatically_derived]
10044            #[doc(hidden)]
10045            impl ::core::convert::From<getMaxMagnitudeReturn> for UnderlyingRustTuple<'_> {
10046                fn from(value: getMaxMagnitudeReturn) -> Self {
10047                    (value._0,)
10048                }
10049            }
10050            #[automatically_derived]
10051            #[doc(hidden)]
10052            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMaxMagnitudeReturn {
10053                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10054                    Self { _0: tuple.0 }
10055                }
10056            }
10057        }
10058        #[automatically_derived]
10059        impl alloy_sol_types::SolCall for getMaxMagnitudeCall {
10060            type Parameters<'a> = (
10061                alloy::sol_types::sol_data::Address,
10062                alloy::sol_types::sol_data::Address,
10063            );
10064            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
10065            type Return = u64;
10066            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
10067            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
10068            const SIGNATURE: &'static str = "getMaxMagnitude(address,address)";
10069            const SELECTOR: [u8; 4] = [169u8, 51u8, 62u8, 200u8];
10070            #[inline]
10071            fn new<'a>(
10072                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10073            ) -> Self {
10074                tuple.into()
10075            }
10076            #[inline]
10077            fn tokenize(&self) -> Self::Token<'_> {
10078                (
10079                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
10080                        &self.operator,
10081                    ),
10082                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
10083                        &self.strategy,
10084                    ),
10085                )
10086            }
10087            #[inline]
10088            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
10089                (
10090                    <alloy::sol_types::sol_data::Uint<64> as alloy_sol_types::SolType>::tokenize(
10091                        ret,
10092                    ),
10093                )
10094            }
10095            #[inline]
10096            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
10097                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
10098                    |r| {
10099                        let r: getMaxMagnitudeReturn = r.into();
10100                        r._0
10101                    },
10102                )
10103            }
10104            #[inline]
10105            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
10106                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
10107                    data,
10108                )
10109                .map(|r| {
10110                    let r: getMaxMagnitudeReturn = r.into();
10111                    r._0
10112                })
10113            }
10114        }
10115    };
10116    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
10117    /**Function with signature `getMaxMagnitudes(address[],address)` and selector `0x4a10ffe5`.
10118    ```solidity
10119    function getMaxMagnitudes(address[] memory operators, address strategy) external view returns (uint64[] memory);
10120    ```*/
10121    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10122    #[derive(Clone)]
10123    pub struct getMaxMagnitudes_0Call {
10124        #[allow(missing_docs)]
10125        pub operators: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
10126        #[allow(missing_docs)]
10127        pub strategy: alloy::sol_types::private::Address,
10128    }
10129    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
10130    ///Container type for the return parameters of the [`getMaxMagnitudes(address[],address)`](getMaxMagnitudes_0Call) function.
10131    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10132    #[derive(Clone)]
10133    pub struct getMaxMagnitudes_0Return {
10134        #[allow(missing_docs)]
10135        pub _0: alloy::sol_types::private::Vec<u64>,
10136    }
10137    #[allow(
10138        non_camel_case_types,
10139        non_snake_case,
10140        clippy::pub_underscore_fields,
10141        clippy::style
10142    )]
10143    const _: () = {
10144        use alloy::sol_types as alloy_sol_types;
10145        {
10146            #[doc(hidden)]
10147            type UnderlyingSolTuple<'a> = (
10148                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
10149                alloy::sol_types::sol_data::Address,
10150            );
10151            #[doc(hidden)]
10152            type UnderlyingRustTuple<'a> = (
10153                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
10154                alloy::sol_types::private::Address,
10155            );
10156            #[cfg(test)]
10157            #[allow(dead_code, unreachable_patterns)]
10158            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
10159                match _t {
10160                    alloy_sol_types::private::AssertTypeEq::<
10161                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10162                    >(_) => {}
10163                }
10164            }
10165            #[automatically_derived]
10166            #[doc(hidden)]
10167            impl ::core::convert::From<getMaxMagnitudes_0Call> for UnderlyingRustTuple<'_> {
10168                fn from(value: getMaxMagnitudes_0Call) -> Self {
10169                    (value.operators, value.strategy)
10170                }
10171            }
10172            #[automatically_derived]
10173            #[doc(hidden)]
10174            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMaxMagnitudes_0Call {
10175                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10176                    Self {
10177                        operators: tuple.0,
10178                        strategy: tuple.1,
10179                    }
10180                }
10181            }
10182        }
10183        {
10184            #[doc(hidden)]
10185            type UnderlyingSolTuple<'a> =
10186                (alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<64>>,);
10187            #[doc(hidden)]
10188            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Vec<u64>,);
10189            #[cfg(test)]
10190            #[allow(dead_code, unreachable_patterns)]
10191            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
10192                match _t {
10193                    alloy_sol_types::private::AssertTypeEq::<
10194                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10195                    >(_) => {}
10196                }
10197            }
10198            #[automatically_derived]
10199            #[doc(hidden)]
10200            impl ::core::convert::From<getMaxMagnitudes_0Return> for UnderlyingRustTuple<'_> {
10201                fn from(value: getMaxMagnitudes_0Return) -> Self {
10202                    (value._0,)
10203                }
10204            }
10205            #[automatically_derived]
10206            #[doc(hidden)]
10207            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMaxMagnitudes_0Return {
10208                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10209                    Self { _0: tuple.0 }
10210                }
10211            }
10212        }
10213        #[automatically_derived]
10214        impl alloy_sol_types::SolCall for getMaxMagnitudes_0Call {
10215            type Parameters<'a> = (
10216                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
10217                alloy::sol_types::sol_data::Address,
10218            );
10219            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
10220            type Return = alloy::sol_types::private::Vec<u64>;
10221            type ReturnTuple<'a> =
10222                (alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<64>>,);
10223            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
10224            const SIGNATURE: &'static str = "getMaxMagnitudes(address[],address)";
10225            const SELECTOR: [u8; 4] = [74u8, 16u8, 255u8, 229u8];
10226            #[inline]
10227            fn new<'a>(
10228                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10229            ) -> Self {
10230                tuple.into()
10231            }
10232            #[inline]
10233            fn tokenize(&self) -> Self::Token<'_> {
10234                (
10235                    <alloy::sol_types::sol_data::Array<
10236                        alloy::sol_types::sol_data::Address,
10237                    > as alloy_sol_types::SolType>::tokenize(&self.operators),
10238                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
10239                        &self.strategy,
10240                    ),
10241                )
10242            }
10243            #[inline]
10244            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
10245                (<alloy::sol_types::sol_data::Array<
10246                    alloy::sol_types::sol_data::Uint<64>,
10247                > as alloy_sol_types::SolType>::tokenize(ret),)
10248            }
10249            #[inline]
10250            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
10251                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
10252                    |r| {
10253                        let r: getMaxMagnitudes_0Return = r.into();
10254                        r._0
10255                    },
10256                )
10257            }
10258            #[inline]
10259            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
10260                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
10261                    data,
10262                )
10263                .map(|r| {
10264                    let r: getMaxMagnitudes_0Return = r.into();
10265                    r._0
10266                })
10267            }
10268        }
10269    };
10270    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
10271    /**Function with signature `getMaxMagnitudes(address,address[])` and selector `0x547afb87`.
10272    ```solidity
10273    function getMaxMagnitudes(address operator, address[] memory strategies) external view returns (uint64[] memory);
10274    ```*/
10275    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10276    #[derive(Clone)]
10277    pub struct getMaxMagnitudes_1Call {
10278        #[allow(missing_docs)]
10279        pub operator: alloy::sol_types::private::Address,
10280        #[allow(missing_docs)]
10281        pub strategies: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
10282    }
10283    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
10284    ///Container type for the return parameters of the [`getMaxMagnitudes(address,address[])`](getMaxMagnitudes_1Call) function.
10285    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10286    #[derive(Clone)]
10287    pub struct getMaxMagnitudes_1Return {
10288        #[allow(missing_docs)]
10289        pub _0: alloy::sol_types::private::Vec<u64>,
10290    }
10291    #[allow(
10292        non_camel_case_types,
10293        non_snake_case,
10294        clippy::pub_underscore_fields,
10295        clippy::style
10296    )]
10297    const _: () = {
10298        use alloy::sol_types as alloy_sol_types;
10299        {
10300            #[doc(hidden)]
10301            type UnderlyingSolTuple<'a> = (
10302                alloy::sol_types::sol_data::Address,
10303                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
10304            );
10305            #[doc(hidden)]
10306            type UnderlyingRustTuple<'a> = (
10307                alloy::sol_types::private::Address,
10308                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
10309            );
10310            #[cfg(test)]
10311            #[allow(dead_code, unreachable_patterns)]
10312            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
10313                match _t {
10314                    alloy_sol_types::private::AssertTypeEq::<
10315                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10316                    >(_) => {}
10317                }
10318            }
10319            #[automatically_derived]
10320            #[doc(hidden)]
10321            impl ::core::convert::From<getMaxMagnitudes_1Call> for UnderlyingRustTuple<'_> {
10322                fn from(value: getMaxMagnitudes_1Call) -> Self {
10323                    (value.operator, value.strategies)
10324                }
10325            }
10326            #[automatically_derived]
10327            #[doc(hidden)]
10328            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMaxMagnitudes_1Call {
10329                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10330                    Self {
10331                        operator: tuple.0,
10332                        strategies: tuple.1,
10333                    }
10334                }
10335            }
10336        }
10337        {
10338            #[doc(hidden)]
10339            type UnderlyingSolTuple<'a> =
10340                (alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<64>>,);
10341            #[doc(hidden)]
10342            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Vec<u64>,);
10343            #[cfg(test)]
10344            #[allow(dead_code, unreachable_patterns)]
10345            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
10346                match _t {
10347                    alloy_sol_types::private::AssertTypeEq::<
10348                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10349                    >(_) => {}
10350                }
10351            }
10352            #[automatically_derived]
10353            #[doc(hidden)]
10354            impl ::core::convert::From<getMaxMagnitudes_1Return> for UnderlyingRustTuple<'_> {
10355                fn from(value: getMaxMagnitudes_1Return) -> Self {
10356                    (value._0,)
10357                }
10358            }
10359            #[automatically_derived]
10360            #[doc(hidden)]
10361            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMaxMagnitudes_1Return {
10362                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10363                    Self { _0: tuple.0 }
10364                }
10365            }
10366        }
10367        #[automatically_derived]
10368        impl alloy_sol_types::SolCall for getMaxMagnitudes_1Call {
10369            type Parameters<'a> = (
10370                alloy::sol_types::sol_data::Address,
10371                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
10372            );
10373            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
10374            type Return = alloy::sol_types::private::Vec<u64>;
10375            type ReturnTuple<'a> =
10376                (alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<64>>,);
10377            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
10378            const SIGNATURE: &'static str = "getMaxMagnitudes(address,address[])";
10379            const SELECTOR: [u8; 4] = [84u8, 122u8, 251u8, 135u8];
10380            #[inline]
10381            fn new<'a>(
10382                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10383            ) -> Self {
10384                tuple.into()
10385            }
10386            #[inline]
10387            fn tokenize(&self) -> Self::Token<'_> {
10388                (
10389                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
10390                        &self.operator,
10391                    ),
10392                    <alloy::sol_types::sol_data::Array<
10393                        alloy::sol_types::sol_data::Address,
10394                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
10395                )
10396            }
10397            #[inline]
10398            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
10399                (<alloy::sol_types::sol_data::Array<
10400                    alloy::sol_types::sol_data::Uint<64>,
10401                > as alloy_sol_types::SolType>::tokenize(ret),)
10402            }
10403            #[inline]
10404            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
10405                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
10406                    |r| {
10407                        let r: getMaxMagnitudes_1Return = r.into();
10408                        r._0
10409                    },
10410                )
10411            }
10412            #[inline]
10413            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
10414                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
10415                    data,
10416                )
10417                .map(|r| {
10418                    let r: getMaxMagnitudes_1Return = r.into();
10419                    r._0
10420                })
10421            }
10422        }
10423    };
10424    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
10425    /**Function with signature `getMaxMagnitudesAtBlock(address,address[],uint32)` and selector `0x94d7d00c`.
10426    ```solidity
10427    function getMaxMagnitudesAtBlock(address operator, address[] memory strategies, uint32 blockNumber) external view returns (uint64[] memory);
10428    ```*/
10429    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10430    #[derive(Clone)]
10431    pub struct getMaxMagnitudesAtBlockCall {
10432        #[allow(missing_docs)]
10433        pub operator: alloy::sol_types::private::Address,
10434        #[allow(missing_docs)]
10435        pub strategies: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
10436        #[allow(missing_docs)]
10437        pub blockNumber: u32,
10438    }
10439    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
10440    ///Container type for the return parameters of the [`getMaxMagnitudesAtBlock(address,address[],uint32)`](getMaxMagnitudesAtBlockCall) function.
10441    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10442    #[derive(Clone)]
10443    pub struct getMaxMagnitudesAtBlockReturn {
10444        #[allow(missing_docs)]
10445        pub _0: alloy::sol_types::private::Vec<u64>,
10446    }
10447    #[allow(
10448        non_camel_case_types,
10449        non_snake_case,
10450        clippy::pub_underscore_fields,
10451        clippy::style
10452    )]
10453    const _: () = {
10454        use alloy::sol_types as alloy_sol_types;
10455        {
10456            #[doc(hidden)]
10457            type UnderlyingSolTuple<'a> = (
10458                alloy::sol_types::sol_data::Address,
10459                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
10460                alloy::sol_types::sol_data::Uint<32>,
10461            );
10462            #[doc(hidden)]
10463            type UnderlyingRustTuple<'a> = (
10464                alloy::sol_types::private::Address,
10465                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
10466                u32,
10467            );
10468            #[cfg(test)]
10469            #[allow(dead_code, unreachable_patterns)]
10470            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
10471                match _t {
10472                    alloy_sol_types::private::AssertTypeEq::<
10473                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10474                    >(_) => {}
10475                }
10476            }
10477            #[automatically_derived]
10478            #[doc(hidden)]
10479            impl ::core::convert::From<getMaxMagnitudesAtBlockCall> for UnderlyingRustTuple<'_> {
10480                fn from(value: getMaxMagnitudesAtBlockCall) -> Self {
10481                    (value.operator, value.strategies, value.blockNumber)
10482                }
10483            }
10484            #[automatically_derived]
10485            #[doc(hidden)]
10486            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMaxMagnitudesAtBlockCall {
10487                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10488                    Self {
10489                        operator: tuple.0,
10490                        strategies: tuple.1,
10491                        blockNumber: tuple.2,
10492                    }
10493                }
10494            }
10495        }
10496        {
10497            #[doc(hidden)]
10498            type UnderlyingSolTuple<'a> =
10499                (alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<64>>,);
10500            #[doc(hidden)]
10501            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Vec<u64>,);
10502            #[cfg(test)]
10503            #[allow(dead_code, unreachable_patterns)]
10504            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
10505                match _t {
10506                    alloy_sol_types::private::AssertTypeEq::<
10507                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10508                    >(_) => {}
10509                }
10510            }
10511            #[automatically_derived]
10512            #[doc(hidden)]
10513            impl ::core::convert::From<getMaxMagnitudesAtBlockReturn> for UnderlyingRustTuple<'_> {
10514                fn from(value: getMaxMagnitudesAtBlockReturn) -> Self {
10515                    (value._0,)
10516                }
10517            }
10518            #[automatically_derived]
10519            #[doc(hidden)]
10520            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMaxMagnitudesAtBlockReturn {
10521                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10522                    Self { _0: tuple.0 }
10523                }
10524            }
10525        }
10526        #[automatically_derived]
10527        impl alloy_sol_types::SolCall for getMaxMagnitudesAtBlockCall {
10528            type Parameters<'a> = (
10529                alloy::sol_types::sol_data::Address,
10530                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
10531                alloy::sol_types::sol_data::Uint<32>,
10532            );
10533            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
10534            type Return = alloy::sol_types::private::Vec<u64>;
10535            type ReturnTuple<'a> =
10536                (alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<64>>,);
10537            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
10538            const SIGNATURE: &'static str = "getMaxMagnitudesAtBlock(address,address[],uint32)";
10539            const SELECTOR: [u8; 4] = [148u8, 215u8, 208u8, 12u8];
10540            #[inline]
10541            fn new<'a>(
10542                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10543            ) -> Self {
10544                tuple.into()
10545            }
10546            #[inline]
10547            fn tokenize(&self) -> Self::Token<'_> {
10548                (
10549                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
10550                        &self.operator,
10551                    ),
10552                    <alloy::sol_types::sol_data::Array<
10553                        alloy::sol_types::sol_data::Address,
10554                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
10555                    <alloy::sol_types::sol_data::Uint<
10556                        32,
10557                    > as alloy_sol_types::SolType>::tokenize(&self.blockNumber),
10558                )
10559            }
10560            #[inline]
10561            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
10562                (<alloy::sol_types::sol_data::Array<
10563                    alloy::sol_types::sol_data::Uint<64>,
10564                > as alloy_sol_types::SolType>::tokenize(ret),)
10565            }
10566            #[inline]
10567            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
10568                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
10569                    |r| {
10570                        let r: getMaxMagnitudesAtBlockReturn = r.into();
10571                        r._0
10572                    },
10573                )
10574            }
10575            #[inline]
10576            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
10577                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
10578                    data,
10579                )
10580                .map(|r| {
10581                    let r: getMaxMagnitudesAtBlockReturn = r.into();
10582                    r._0
10583                })
10584            }
10585        }
10586    };
10587    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
10588    /**Function with signature `getMemberCount((address,uint32))` and selector `0xb2447af7`.
10589    ```solidity
10590    function getMemberCount(OperatorSet memory operatorSet) external view returns (uint256);
10591    ```*/
10592    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10593    #[derive(Clone)]
10594    pub struct getMemberCountCall {
10595        #[allow(missing_docs)]
10596        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
10597    }
10598    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
10599    ///Container type for the return parameters of the [`getMemberCount((address,uint32))`](getMemberCountCall) function.
10600    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10601    #[derive(Clone)]
10602    pub struct getMemberCountReturn {
10603        #[allow(missing_docs)]
10604        pub _0: alloy::sol_types::private::primitives::aliases::U256,
10605    }
10606    #[allow(
10607        non_camel_case_types,
10608        non_snake_case,
10609        clippy::pub_underscore_fields,
10610        clippy::style
10611    )]
10612    const _: () = {
10613        use alloy::sol_types as alloy_sol_types;
10614        {
10615            #[doc(hidden)]
10616            type UnderlyingSolTuple<'a> = (OperatorSet,);
10617            #[doc(hidden)]
10618            type UnderlyingRustTuple<'a> = (<OperatorSet as alloy::sol_types::SolType>::RustType,);
10619            #[cfg(test)]
10620            #[allow(dead_code, unreachable_patterns)]
10621            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
10622                match _t {
10623                    alloy_sol_types::private::AssertTypeEq::<
10624                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10625                    >(_) => {}
10626                }
10627            }
10628            #[automatically_derived]
10629            #[doc(hidden)]
10630            impl ::core::convert::From<getMemberCountCall> for UnderlyingRustTuple<'_> {
10631                fn from(value: getMemberCountCall) -> Self {
10632                    (value.operatorSet,)
10633                }
10634            }
10635            #[automatically_derived]
10636            #[doc(hidden)]
10637            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMemberCountCall {
10638                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10639                    Self {
10640                        operatorSet: tuple.0,
10641                    }
10642                }
10643            }
10644        }
10645        {
10646            #[doc(hidden)]
10647            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
10648            #[doc(hidden)]
10649            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
10650            #[cfg(test)]
10651            #[allow(dead_code, unreachable_patterns)]
10652            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
10653                match _t {
10654                    alloy_sol_types::private::AssertTypeEq::<
10655                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10656                    >(_) => {}
10657                }
10658            }
10659            #[automatically_derived]
10660            #[doc(hidden)]
10661            impl ::core::convert::From<getMemberCountReturn> for UnderlyingRustTuple<'_> {
10662                fn from(value: getMemberCountReturn) -> Self {
10663                    (value._0,)
10664                }
10665            }
10666            #[automatically_derived]
10667            #[doc(hidden)]
10668            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMemberCountReturn {
10669                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10670                    Self { _0: tuple.0 }
10671                }
10672            }
10673        }
10674        #[automatically_derived]
10675        impl alloy_sol_types::SolCall for getMemberCountCall {
10676            type Parameters<'a> = (OperatorSet,);
10677            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
10678            type Return = alloy::sol_types::private::primitives::aliases::U256;
10679            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
10680            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
10681            const SIGNATURE: &'static str = "getMemberCount((address,uint32))";
10682            const SELECTOR: [u8; 4] = [178u8, 68u8, 122u8, 247u8];
10683            #[inline]
10684            fn new<'a>(
10685                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10686            ) -> Self {
10687                tuple.into()
10688            }
10689            #[inline]
10690            fn tokenize(&self) -> Self::Token<'_> {
10691                (<OperatorSet as alloy_sol_types::SolType>::tokenize(
10692                    &self.operatorSet,
10693                ),)
10694            }
10695            #[inline]
10696            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
10697                (
10698                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
10699                        ret,
10700                    ),
10701                )
10702            }
10703            #[inline]
10704            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
10705                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
10706                    |r| {
10707                        let r: getMemberCountReturn = r.into();
10708                        r._0
10709                    },
10710                )
10711            }
10712            #[inline]
10713            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
10714                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
10715                    data,
10716                )
10717                .map(|r| {
10718                    let r: getMemberCountReturn = r.into();
10719                    r._0
10720                })
10721            }
10722        }
10723    };
10724    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
10725    /**Function with signature `getMembers((address,uint32))` and selector `0x6e875dba`.
10726    ```solidity
10727    function getMembers(OperatorSet memory operatorSet) external view returns (address[] memory);
10728    ```*/
10729    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10730    #[derive(Clone)]
10731    pub struct getMembersCall {
10732        #[allow(missing_docs)]
10733        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
10734    }
10735    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
10736    ///Container type for the return parameters of the [`getMembers((address,uint32))`](getMembersCall) function.
10737    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10738    #[derive(Clone)]
10739    pub struct getMembersReturn {
10740        #[allow(missing_docs)]
10741        pub _0: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
10742    }
10743    #[allow(
10744        non_camel_case_types,
10745        non_snake_case,
10746        clippy::pub_underscore_fields,
10747        clippy::style
10748    )]
10749    const _: () = {
10750        use alloy::sol_types as alloy_sol_types;
10751        {
10752            #[doc(hidden)]
10753            type UnderlyingSolTuple<'a> = (OperatorSet,);
10754            #[doc(hidden)]
10755            type UnderlyingRustTuple<'a> = (<OperatorSet as alloy::sol_types::SolType>::RustType,);
10756            #[cfg(test)]
10757            #[allow(dead_code, unreachable_patterns)]
10758            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
10759                match _t {
10760                    alloy_sol_types::private::AssertTypeEq::<
10761                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10762                    >(_) => {}
10763                }
10764            }
10765            #[automatically_derived]
10766            #[doc(hidden)]
10767            impl ::core::convert::From<getMembersCall> for UnderlyingRustTuple<'_> {
10768                fn from(value: getMembersCall) -> Self {
10769                    (value.operatorSet,)
10770                }
10771            }
10772            #[automatically_derived]
10773            #[doc(hidden)]
10774            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMembersCall {
10775                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10776                    Self {
10777                        operatorSet: tuple.0,
10778                    }
10779                }
10780            }
10781        }
10782        {
10783            #[doc(hidden)]
10784            type UnderlyingSolTuple<'a> =
10785                (alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,);
10786            #[doc(hidden)]
10787            type UnderlyingRustTuple<'a> =
10788                (alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,);
10789            #[cfg(test)]
10790            #[allow(dead_code, unreachable_patterns)]
10791            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
10792                match _t {
10793                    alloy_sol_types::private::AssertTypeEq::<
10794                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10795                    >(_) => {}
10796                }
10797            }
10798            #[automatically_derived]
10799            #[doc(hidden)]
10800            impl ::core::convert::From<getMembersReturn> for UnderlyingRustTuple<'_> {
10801                fn from(value: getMembersReturn) -> Self {
10802                    (value._0,)
10803                }
10804            }
10805            #[automatically_derived]
10806            #[doc(hidden)]
10807            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMembersReturn {
10808                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10809                    Self { _0: tuple.0 }
10810                }
10811            }
10812        }
10813        #[automatically_derived]
10814        impl alloy_sol_types::SolCall for getMembersCall {
10815            type Parameters<'a> = (OperatorSet,);
10816            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
10817            type Return = alloy::sol_types::private::Vec<alloy::sol_types::private::Address>;
10818            type ReturnTuple<'a> =
10819                (alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,);
10820            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
10821            const SIGNATURE: &'static str = "getMembers((address,uint32))";
10822            const SELECTOR: [u8; 4] = [110u8, 135u8, 93u8, 186u8];
10823            #[inline]
10824            fn new<'a>(
10825                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10826            ) -> Self {
10827                tuple.into()
10828            }
10829            #[inline]
10830            fn tokenize(&self) -> Self::Token<'_> {
10831                (<OperatorSet as alloy_sol_types::SolType>::tokenize(
10832                    &self.operatorSet,
10833                ),)
10834            }
10835            #[inline]
10836            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
10837                (<alloy::sol_types::sol_data::Array<
10838                    alloy::sol_types::sol_data::Address,
10839                > as alloy_sol_types::SolType>::tokenize(ret),)
10840            }
10841            #[inline]
10842            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
10843                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
10844                    |r| {
10845                        let r: getMembersReturn = r.into();
10846                        r._0
10847                    },
10848                )
10849            }
10850            #[inline]
10851            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
10852                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
10853                    data,
10854                )
10855                .map(|r| {
10856                    let r: getMembersReturn = r.into();
10857                    r._0
10858                })
10859            }
10860        }
10861    };
10862    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
10863    /**Function with signature `getMinimumSlashableStake((address,uint32),address[],address[],uint32)` and selector `0x2bab2c4a`.
10864    ```solidity
10865    function getMinimumSlashableStake(OperatorSet memory operatorSet, address[] memory operators, address[] memory strategies, uint32 futureBlock) external view returns (uint256[][] memory slashableStake);
10866    ```*/
10867    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10868    #[derive(Clone)]
10869    pub struct getMinimumSlashableStakeCall {
10870        #[allow(missing_docs)]
10871        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
10872        #[allow(missing_docs)]
10873        pub operators: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
10874        #[allow(missing_docs)]
10875        pub strategies: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
10876        #[allow(missing_docs)]
10877        pub futureBlock: u32,
10878    }
10879    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
10880    ///Container type for the return parameters of the [`getMinimumSlashableStake((address,uint32),address[],address[],uint32)`](getMinimumSlashableStakeCall) function.
10881    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10882    #[derive(Clone)]
10883    pub struct getMinimumSlashableStakeReturn {
10884        #[allow(missing_docs)]
10885        pub slashableStake: alloy::sol_types::private::Vec<
10886            alloy::sol_types::private::Vec<alloy::sol_types::private::primitives::aliases::U256>,
10887        >,
10888    }
10889    #[allow(
10890        non_camel_case_types,
10891        non_snake_case,
10892        clippy::pub_underscore_fields,
10893        clippy::style
10894    )]
10895    const _: () = {
10896        use alloy::sol_types as alloy_sol_types;
10897        {
10898            #[doc(hidden)]
10899            type UnderlyingSolTuple<'a> = (
10900                OperatorSet,
10901                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
10902                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
10903                alloy::sol_types::sol_data::Uint<32>,
10904            );
10905            #[doc(hidden)]
10906            type UnderlyingRustTuple<'a> = (
10907                <OperatorSet as alloy::sol_types::SolType>::RustType,
10908                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
10909                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
10910                u32,
10911            );
10912            #[cfg(test)]
10913            #[allow(dead_code, unreachable_patterns)]
10914            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
10915                match _t {
10916                    alloy_sol_types::private::AssertTypeEq::<
10917                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10918                    >(_) => {}
10919                }
10920            }
10921            #[automatically_derived]
10922            #[doc(hidden)]
10923            impl ::core::convert::From<getMinimumSlashableStakeCall> for UnderlyingRustTuple<'_> {
10924                fn from(value: getMinimumSlashableStakeCall) -> Self {
10925                    (
10926                        value.operatorSet,
10927                        value.operators,
10928                        value.strategies,
10929                        value.futureBlock,
10930                    )
10931                }
10932            }
10933            #[automatically_derived]
10934            #[doc(hidden)]
10935            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMinimumSlashableStakeCall {
10936                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10937                    Self {
10938                        operatorSet: tuple.0,
10939                        operators: tuple.1,
10940                        strategies: tuple.2,
10941                        futureBlock: tuple.3,
10942                    }
10943                }
10944            }
10945        }
10946        {
10947            #[doc(hidden)]
10948            type UnderlyingSolTuple<'a> = (
10949                alloy::sol_types::sol_data::Array<
10950                    alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
10951                >,
10952            );
10953            #[doc(hidden)]
10954            type UnderlyingRustTuple<'a> = (
10955                alloy::sol_types::private::Vec<
10956                    alloy::sol_types::private::Vec<
10957                        alloy::sol_types::private::primitives::aliases::U256,
10958                    >,
10959                >,
10960            );
10961            #[cfg(test)]
10962            #[allow(dead_code, unreachable_patterns)]
10963            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
10964                match _t {
10965                    alloy_sol_types::private::AssertTypeEq::<
10966                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10967                    >(_) => {}
10968                }
10969            }
10970            #[automatically_derived]
10971            #[doc(hidden)]
10972            impl ::core::convert::From<getMinimumSlashableStakeReturn> for UnderlyingRustTuple<'_> {
10973                fn from(value: getMinimumSlashableStakeReturn) -> Self {
10974                    (value.slashableStake,)
10975                }
10976            }
10977            #[automatically_derived]
10978            #[doc(hidden)]
10979            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMinimumSlashableStakeReturn {
10980                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10981                    Self {
10982                        slashableStake: tuple.0,
10983                    }
10984                }
10985            }
10986        }
10987        #[automatically_derived]
10988        impl alloy_sol_types::SolCall for getMinimumSlashableStakeCall {
10989            type Parameters<'a> = (
10990                OperatorSet,
10991                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
10992                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
10993                alloy::sol_types::sol_data::Uint<32>,
10994            );
10995            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
10996            type Return = alloy::sol_types::private::Vec<
10997                alloy::sol_types::private::Vec<
10998                    alloy::sol_types::private::primitives::aliases::U256,
10999                >,
11000            >;
11001            type ReturnTuple<'a> = (
11002                alloy::sol_types::sol_data::Array<
11003                    alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
11004                >,
11005            );
11006            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
11007            const SIGNATURE: &'static str =
11008                "getMinimumSlashableStake((address,uint32),address[],address[],uint32)";
11009            const SELECTOR: [u8; 4] = [43u8, 171u8, 44u8, 74u8];
11010            #[inline]
11011            fn new<'a>(
11012                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11013            ) -> Self {
11014                tuple.into()
11015            }
11016            #[inline]
11017            fn tokenize(&self) -> Self::Token<'_> {
11018                (
11019                    <OperatorSet as alloy_sol_types::SolType>::tokenize(
11020                        &self.operatorSet,
11021                    ),
11022                    <alloy::sol_types::sol_data::Array<
11023                        alloy::sol_types::sol_data::Address,
11024                    > as alloy_sol_types::SolType>::tokenize(&self.operators),
11025                    <alloy::sol_types::sol_data::Array<
11026                        alloy::sol_types::sol_data::Address,
11027                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
11028                    <alloy::sol_types::sol_data::Uint<
11029                        32,
11030                    > as alloy_sol_types::SolType>::tokenize(&self.futureBlock),
11031                )
11032            }
11033            #[inline]
11034            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
11035                (<alloy::sol_types::sol_data::Array<
11036                    alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
11037                > as alloy_sol_types::SolType>::tokenize(ret),)
11038            }
11039            #[inline]
11040            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11041                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
11042                    |r| {
11043                        let r: getMinimumSlashableStakeReturn = r.into();
11044                        r.slashableStake
11045                    },
11046                )
11047            }
11048            #[inline]
11049            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11050                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
11051                    data,
11052                )
11053                .map(|r| {
11054                    let r: getMinimumSlashableStakeReturn = r.into();
11055                    r.slashableStake
11056                })
11057            }
11058        }
11059    };
11060    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
11061    /**Function with signature `getOperatorSetCount(address)` and selector `0xba1a84e5`.
11062    ```solidity
11063    function getOperatorSetCount(address avs) external view returns (uint256);
11064    ```*/
11065    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11066    #[derive(Clone)]
11067    pub struct getOperatorSetCountCall {
11068        #[allow(missing_docs)]
11069        pub avs: alloy::sol_types::private::Address,
11070    }
11071    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
11072    ///Container type for the return parameters of the [`getOperatorSetCount(address)`](getOperatorSetCountCall) function.
11073    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11074    #[derive(Clone)]
11075    pub struct getOperatorSetCountReturn {
11076        #[allow(missing_docs)]
11077        pub _0: alloy::sol_types::private::primitives::aliases::U256,
11078    }
11079    #[allow(
11080        non_camel_case_types,
11081        non_snake_case,
11082        clippy::pub_underscore_fields,
11083        clippy::style
11084    )]
11085    const _: () = {
11086        use alloy::sol_types as alloy_sol_types;
11087        {
11088            #[doc(hidden)]
11089            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
11090            #[doc(hidden)]
11091            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
11092            #[cfg(test)]
11093            #[allow(dead_code, unreachable_patterns)]
11094            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
11095                match _t {
11096                    alloy_sol_types::private::AssertTypeEq::<
11097                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11098                    >(_) => {}
11099                }
11100            }
11101            #[automatically_derived]
11102            #[doc(hidden)]
11103            impl ::core::convert::From<getOperatorSetCountCall> for UnderlyingRustTuple<'_> {
11104                fn from(value: getOperatorSetCountCall) -> Self {
11105                    (value.avs,)
11106                }
11107            }
11108            #[automatically_derived]
11109            #[doc(hidden)]
11110            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOperatorSetCountCall {
11111                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11112                    Self { avs: tuple.0 }
11113                }
11114            }
11115        }
11116        {
11117            #[doc(hidden)]
11118            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
11119            #[doc(hidden)]
11120            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
11121            #[cfg(test)]
11122            #[allow(dead_code, unreachable_patterns)]
11123            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
11124                match _t {
11125                    alloy_sol_types::private::AssertTypeEq::<
11126                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11127                    >(_) => {}
11128                }
11129            }
11130            #[automatically_derived]
11131            #[doc(hidden)]
11132            impl ::core::convert::From<getOperatorSetCountReturn> for UnderlyingRustTuple<'_> {
11133                fn from(value: getOperatorSetCountReturn) -> Self {
11134                    (value._0,)
11135                }
11136            }
11137            #[automatically_derived]
11138            #[doc(hidden)]
11139            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOperatorSetCountReturn {
11140                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11141                    Self { _0: tuple.0 }
11142                }
11143            }
11144        }
11145        #[automatically_derived]
11146        impl alloy_sol_types::SolCall for getOperatorSetCountCall {
11147            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
11148            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
11149            type Return = alloy::sol_types::private::primitives::aliases::U256;
11150            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
11151            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
11152            const SIGNATURE: &'static str = "getOperatorSetCount(address)";
11153            const SELECTOR: [u8; 4] = [186u8, 26u8, 132u8, 229u8];
11154            #[inline]
11155            fn new<'a>(
11156                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11157            ) -> Self {
11158                tuple.into()
11159            }
11160            #[inline]
11161            fn tokenize(&self) -> Self::Token<'_> {
11162                (
11163                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
11164                        &self.avs,
11165                    ),
11166                )
11167            }
11168            #[inline]
11169            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
11170                (
11171                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
11172                        ret,
11173                    ),
11174                )
11175            }
11176            #[inline]
11177            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11178                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
11179                    |r| {
11180                        let r: getOperatorSetCountReturn = r.into();
11181                        r._0
11182                    },
11183                )
11184            }
11185            #[inline]
11186            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11187                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
11188                    data,
11189                )
11190                .map(|r| {
11191                    let r: getOperatorSetCountReturn = r.into();
11192                    r._0
11193                })
11194            }
11195        }
11196    };
11197    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
11198    /**Function with signature `getRegisteredSets(address)` and selector `0x79ae50cd`.
11199    ```solidity
11200    function getRegisteredSets(address operator) external view returns (OperatorSet[] memory);
11201    ```*/
11202    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11203    #[derive(Clone)]
11204    pub struct getRegisteredSetsCall {
11205        #[allow(missing_docs)]
11206        pub operator: alloy::sol_types::private::Address,
11207    }
11208    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
11209    ///Container type for the return parameters of the [`getRegisteredSets(address)`](getRegisteredSetsCall) function.
11210    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11211    #[derive(Clone)]
11212    pub struct getRegisteredSetsReturn {
11213        #[allow(missing_docs)]
11214        pub _0:
11215            alloy::sol_types::private::Vec<<OperatorSet as alloy::sol_types::SolType>::RustType>,
11216    }
11217    #[allow(
11218        non_camel_case_types,
11219        non_snake_case,
11220        clippy::pub_underscore_fields,
11221        clippy::style
11222    )]
11223    const _: () = {
11224        use alloy::sol_types as alloy_sol_types;
11225        {
11226            #[doc(hidden)]
11227            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
11228            #[doc(hidden)]
11229            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
11230            #[cfg(test)]
11231            #[allow(dead_code, unreachable_patterns)]
11232            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
11233                match _t {
11234                    alloy_sol_types::private::AssertTypeEq::<
11235                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11236                    >(_) => {}
11237                }
11238            }
11239            #[automatically_derived]
11240            #[doc(hidden)]
11241            impl ::core::convert::From<getRegisteredSetsCall> for UnderlyingRustTuple<'_> {
11242                fn from(value: getRegisteredSetsCall) -> Self {
11243                    (value.operator,)
11244                }
11245            }
11246            #[automatically_derived]
11247            #[doc(hidden)]
11248            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRegisteredSetsCall {
11249                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11250                    Self { operator: tuple.0 }
11251                }
11252            }
11253        }
11254        {
11255            #[doc(hidden)]
11256            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Array<OperatorSet>,);
11257            #[doc(hidden)]
11258            type UnderlyingRustTuple<'a> = (
11259                alloy::sol_types::private::Vec<
11260                    <OperatorSet as alloy::sol_types::SolType>::RustType,
11261                >,
11262            );
11263            #[cfg(test)]
11264            #[allow(dead_code, unreachable_patterns)]
11265            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
11266                match _t {
11267                    alloy_sol_types::private::AssertTypeEq::<
11268                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11269                    >(_) => {}
11270                }
11271            }
11272            #[automatically_derived]
11273            #[doc(hidden)]
11274            impl ::core::convert::From<getRegisteredSetsReturn> for UnderlyingRustTuple<'_> {
11275                fn from(value: getRegisteredSetsReturn) -> Self {
11276                    (value._0,)
11277                }
11278            }
11279            #[automatically_derived]
11280            #[doc(hidden)]
11281            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRegisteredSetsReturn {
11282                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11283                    Self { _0: tuple.0 }
11284                }
11285            }
11286        }
11287        #[automatically_derived]
11288        impl alloy_sol_types::SolCall for getRegisteredSetsCall {
11289            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
11290            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
11291            type Return = alloy::sol_types::private::Vec<
11292                <OperatorSet as alloy::sol_types::SolType>::RustType,
11293            >;
11294            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Array<OperatorSet>,);
11295            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
11296            const SIGNATURE: &'static str = "getRegisteredSets(address)";
11297            const SELECTOR: [u8; 4] = [121u8, 174u8, 80u8, 205u8];
11298            #[inline]
11299            fn new<'a>(
11300                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11301            ) -> Self {
11302                tuple.into()
11303            }
11304            #[inline]
11305            fn tokenize(&self) -> Self::Token<'_> {
11306                (
11307                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
11308                        &self.operator,
11309                    ),
11310                )
11311            }
11312            #[inline]
11313            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
11314                (
11315                    <alloy::sol_types::sol_data::Array<
11316                        OperatorSet,
11317                    > as alloy_sol_types::SolType>::tokenize(ret),
11318                )
11319            }
11320            #[inline]
11321            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11322                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
11323                    |r| {
11324                        let r: getRegisteredSetsReturn = r.into();
11325                        r._0
11326                    },
11327                )
11328            }
11329            #[inline]
11330            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11331                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
11332                    data,
11333                )
11334                .map(|r| {
11335                    let r: getRegisteredSetsReturn = r.into();
11336                    r._0
11337                })
11338            }
11339        }
11340    };
11341    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
11342    /**Function with signature `getStrategiesInOperatorSet((address,uint32))` and selector `0x4177a87c`.
11343    ```solidity
11344    function getStrategiesInOperatorSet(OperatorSet memory operatorSet) external view returns (address[] memory);
11345    ```*/
11346    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11347    #[derive(Clone)]
11348    pub struct getStrategiesInOperatorSetCall {
11349        #[allow(missing_docs)]
11350        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
11351    }
11352    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
11353    ///Container type for the return parameters of the [`getStrategiesInOperatorSet((address,uint32))`](getStrategiesInOperatorSetCall) function.
11354    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11355    #[derive(Clone)]
11356    pub struct getStrategiesInOperatorSetReturn {
11357        #[allow(missing_docs)]
11358        pub _0: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
11359    }
11360    #[allow(
11361        non_camel_case_types,
11362        non_snake_case,
11363        clippy::pub_underscore_fields,
11364        clippy::style
11365    )]
11366    const _: () = {
11367        use alloy::sol_types as alloy_sol_types;
11368        {
11369            #[doc(hidden)]
11370            type UnderlyingSolTuple<'a> = (OperatorSet,);
11371            #[doc(hidden)]
11372            type UnderlyingRustTuple<'a> = (<OperatorSet as alloy::sol_types::SolType>::RustType,);
11373            #[cfg(test)]
11374            #[allow(dead_code, unreachable_patterns)]
11375            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
11376                match _t {
11377                    alloy_sol_types::private::AssertTypeEq::<
11378                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11379                    >(_) => {}
11380                }
11381            }
11382            #[automatically_derived]
11383            #[doc(hidden)]
11384            impl ::core::convert::From<getStrategiesInOperatorSetCall> for UnderlyingRustTuple<'_> {
11385                fn from(value: getStrategiesInOperatorSetCall) -> Self {
11386                    (value.operatorSet,)
11387                }
11388            }
11389            #[automatically_derived]
11390            #[doc(hidden)]
11391            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStrategiesInOperatorSetCall {
11392                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11393                    Self {
11394                        operatorSet: tuple.0,
11395                    }
11396                }
11397            }
11398        }
11399        {
11400            #[doc(hidden)]
11401            type UnderlyingSolTuple<'a> =
11402                (alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,);
11403            #[doc(hidden)]
11404            type UnderlyingRustTuple<'a> =
11405                (alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,);
11406            #[cfg(test)]
11407            #[allow(dead_code, unreachable_patterns)]
11408            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
11409                match _t {
11410                    alloy_sol_types::private::AssertTypeEq::<
11411                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11412                    >(_) => {}
11413                }
11414            }
11415            #[automatically_derived]
11416            #[doc(hidden)]
11417            impl ::core::convert::From<getStrategiesInOperatorSetReturn> for UnderlyingRustTuple<'_> {
11418                fn from(value: getStrategiesInOperatorSetReturn) -> Self {
11419                    (value._0,)
11420                }
11421            }
11422            #[automatically_derived]
11423            #[doc(hidden)]
11424            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStrategiesInOperatorSetReturn {
11425                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11426                    Self { _0: tuple.0 }
11427                }
11428            }
11429        }
11430        #[automatically_derived]
11431        impl alloy_sol_types::SolCall for getStrategiesInOperatorSetCall {
11432            type Parameters<'a> = (OperatorSet,);
11433            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
11434            type Return = alloy::sol_types::private::Vec<alloy::sol_types::private::Address>;
11435            type ReturnTuple<'a> =
11436                (alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,);
11437            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
11438            const SIGNATURE: &'static str = "getStrategiesInOperatorSet((address,uint32))";
11439            const SELECTOR: [u8; 4] = [65u8, 119u8, 168u8, 124u8];
11440            #[inline]
11441            fn new<'a>(
11442                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11443            ) -> Self {
11444                tuple.into()
11445            }
11446            #[inline]
11447            fn tokenize(&self) -> Self::Token<'_> {
11448                (<OperatorSet as alloy_sol_types::SolType>::tokenize(
11449                    &self.operatorSet,
11450                ),)
11451            }
11452            #[inline]
11453            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
11454                (<alloy::sol_types::sol_data::Array<
11455                    alloy::sol_types::sol_data::Address,
11456                > as alloy_sol_types::SolType>::tokenize(ret),)
11457            }
11458            #[inline]
11459            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11460                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
11461                    |r| {
11462                        let r: getStrategiesInOperatorSetReturn = r.into();
11463                        r._0
11464                    },
11465                )
11466            }
11467            #[inline]
11468            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11469                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
11470                    data,
11471                )
11472                .map(|r| {
11473                    let r: getStrategiesInOperatorSetReturn = r.into();
11474                    r._0
11475                })
11476            }
11477        }
11478    };
11479    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
11480    /**Function with signature `getStrategyAllocations(address,address)` and selector `0x40120dab`.
11481    ```solidity
11482    function getStrategyAllocations(address operator, address strategy) external view returns (OperatorSet[] memory, IAllocationManagerTypes.Allocation[] memory);
11483    ```*/
11484    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11485    #[derive(Clone)]
11486    pub struct getStrategyAllocationsCall {
11487        #[allow(missing_docs)]
11488        pub operator: alloy::sol_types::private::Address,
11489        #[allow(missing_docs)]
11490        pub strategy: alloy::sol_types::private::Address,
11491    }
11492    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
11493    ///Container type for the return parameters of the [`getStrategyAllocations(address,address)`](getStrategyAllocationsCall) function.
11494    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11495    #[derive(Clone)]
11496    pub struct getStrategyAllocationsReturn {
11497        #[allow(missing_docs)]
11498        pub _0:
11499            alloy::sol_types::private::Vec<<OperatorSet as alloy::sol_types::SolType>::RustType>,
11500        #[allow(missing_docs)]
11501        pub _1: alloy::sol_types::private::Vec<
11502            <IAllocationManagerTypes::Allocation as alloy::sol_types::SolType>::RustType,
11503        >,
11504    }
11505    #[allow(
11506        non_camel_case_types,
11507        non_snake_case,
11508        clippy::pub_underscore_fields,
11509        clippy::style
11510    )]
11511    const _: () = {
11512        use alloy::sol_types as alloy_sol_types;
11513        {
11514            #[doc(hidden)]
11515            type UnderlyingSolTuple<'a> = (
11516                alloy::sol_types::sol_data::Address,
11517                alloy::sol_types::sol_data::Address,
11518            );
11519            #[doc(hidden)]
11520            type UnderlyingRustTuple<'a> = (
11521                alloy::sol_types::private::Address,
11522                alloy::sol_types::private::Address,
11523            );
11524            #[cfg(test)]
11525            #[allow(dead_code, unreachable_patterns)]
11526            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
11527                match _t {
11528                    alloy_sol_types::private::AssertTypeEq::<
11529                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11530                    >(_) => {}
11531                }
11532            }
11533            #[automatically_derived]
11534            #[doc(hidden)]
11535            impl ::core::convert::From<getStrategyAllocationsCall> for UnderlyingRustTuple<'_> {
11536                fn from(value: getStrategyAllocationsCall) -> Self {
11537                    (value.operator, value.strategy)
11538                }
11539            }
11540            #[automatically_derived]
11541            #[doc(hidden)]
11542            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStrategyAllocationsCall {
11543                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11544                    Self {
11545                        operator: tuple.0,
11546                        strategy: tuple.1,
11547                    }
11548                }
11549            }
11550        }
11551        {
11552            #[doc(hidden)]
11553            type UnderlyingSolTuple<'a> = (
11554                alloy::sol_types::sol_data::Array<OperatorSet>,
11555                alloy::sol_types::sol_data::Array<IAllocationManagerTypes::Allocation>,
11556            );
11557            #[doc(hidden)]
11558            type UnderlyingRustTuple<'a> = (
11559                alloy::sol_types::private::Vec<
11560                    <OperatorSet as alloy::sol_types::SolType>::RustType,
11561                >,
11562                alloy::sol_types::private::Vec<
11563                    <IAllocationManagerTypes::Allocation as alloy::sol_types::SolType>::RustType,
11564                >,
11565            );
11566            #[cfg(test)]
11567            #[allow(dead_code, unreachable_patterns)]
11568            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
11569                match _t {
11570                    alloy_sol_types::private::AssertTypeEq::<
11571                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11572                    >(_) => {}
11573                }
11574            }
11575            #[automatically_derived]
11576            #[doc(hidden)]
11577            impl ::core::convert::From<getStrategyAllocationsReturn> for UnderlyingRustTuple<'_> {
11578                fn from(value: getStrategyAllocationsReturn) -> Self {
11579                    (value._0, value._1)
11580                }
11581            }
11582            #[automatically_derived]
11583            #[doc(hidden)]
11584            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStrategyAllocationsReturn {
11585                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11586                    Self {
11587                        _0: tuple.0,
11588                        _1: tuple.1,
11589                    }
11590                }
11591            }
11592        }
11593        impl getStrategyAllocationsReturn {
11594            fn _tokenize(
11595                &self,
11596            ) -> <getStrategyAllocationsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
11597            {
11598                (
11599                    <alloy::sol_types::sol_data::Array<
11600                        OperatorSet,
11601                    > as alloy_sol_types::SolType>::tokenize(&self._0),
11602                    <alloy::sol_types::sol_data::Array<
11603                        IAllocationManagerTypes::Allocation,
11604                    > as alloy_sol_types::SolType>::tokenize(&self._1),
11605                )
11606            }
11607        }
11608        #[automatically_derived]
11609        impl alloy_sol_types::SolCall for getStrategyAllocationsCall {
11610            type Parameters<'a> = (
11611                alloy::sol_types::sol_data::Address,
11612                alloy::sol_types::sol_data::Address,
11613            );
11614            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
11615            type Return = getStrategyAllocationsReturn;
11616            type ReturnTuple<'a> = (
11617                alloy::sol_types::sol_data::Array<OperatorSet>,
11618                alloy::sol_types::sol_data::Array<IAllocationManagerTypes::Allocation>,
11619            );
11620            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
11621            const SIGNATURE: &'static str = "getStrategyAllocations(address,address)";
11622            const SELECTOR: [u8; 4] = [64u8, 18u8, 13u8, 171u8];
11623            #[inline]
11624            fn new<'a>(
11625                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11626            ) -> Self {
11627                tuple.into()
11628            }
11629            #[inline]
11630            fn tokenize(&self) -> Self::Token<'_> {
11631                (
11632                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
11633                        &self.operator,
11634                    ),
11635                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
11636                        &self.strategy,
11637                    ),
11638                )
11639            }
11640            #[inline]
11641            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
11642                getStrategyAllocationsReturn::_tokenize(ret)
11643            }
11644            #[inline]
11645            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11646                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
11647                    .map(Into::into)
11648            }
11649            #[inline]
11650            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11651                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
11652                    data,
11653                )
11654                .map(Into::into)
11655            }
11656        }
11657    };
11658    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
11659    /**Function with signature `initialize(address,uint256)` and selector `0xcd6dc687`.
11660    ```solidity
11661    function initialize(address initialOwner, uint256 initialPausedStatus) external;
11662    ```*/
11663    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11664    #[derive(Clone)]
11665    pub struct initializeCall {
11666        #[allow(missing_docs)]
11667        pub initialOwner: alloy::sol_types::private::Address,
11668        #[allow(missing_docs)]
11669        pub initialPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
11670    }
11671    ///Container type for the return parameters of the [`initialize(address,uint256)`](initializeCall) function.
11672    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11673    #[derive(Clone)]
11674    pub struct initializeReturn {}
11675    #[allow(
11676        non_camel_case_types,
11677        non_snake_case,
11678        clippy::pub_underscore_fields,
11679        clippy::style
11680    )]
11681    const _: () = {
11682        use alloy::sol_types as alloy_sol_types;
11683        {
11684            #[doc(hidden)]
11685            type UnderlyingSolTuple<'a> = (
11686                alloy::sol_types::sol_data::Address,
11687                alloy::sol_types::sol_data::Uint<256>,
11688            );
11689            #[doc(hidden)]
11690            type UnderlyingRustTuple<'a> = (
11691                alloy::sol_types::private::Address,
11692                alloy::sol_types::private::primitives::aliases::U256,
11693            );
11694            #[cfg(test)]
11695            #[allow(dead_code, unreachable_patterns)]
11696            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
11697                match _t {
11698                    alloy_sol_types::private::AssertTypeEq::<
11699                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11700                    >(_) => {}
11701                }
11702            }
11703            #[automatically_derived]
11704            #[doc(hidden)]
11705            impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
11706                fn from(value: initializeCall) -> Self {
11707                    (value.initialOwner, value.initialPausedStatus)
11708                }
11709            }
11710            #[automatically_derived]
11711            #[doc(hidden)]
11712            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
11713                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11714                    Self {
11715                        initialOwner: tuple.0,
11716                        initialPausedStatus: tuple.1,
11717                    }
11718                }
11719            }
11720        }
11721        {
11722            #[doc(hidden)]
11723            type UnderlyingSolTuple<'a> = ();
11724            #[doc(hidden)]
11725            type UnderlyingRustTuple<'a> = ();
11726            #[cfg(test)]
11727            #[allow(dead_code, unreachable_patterns)]
11728            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
11729                match _t {
11730                    alloy_sol_types::private::AssertTypeEq::<
11731                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11732                    >(_) => {}
11733                }
11734            }
11735            #[automatically_derived]
11736            #[doc(hidden)]
11737            impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
11738                fn from(value: initializeReturn) -> Self {
11739                    ()
11740                }
11741            }
11742            #[automatically_derived]
11743            #[doc(hidden)]
11744            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
11745                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11746                    Self {}
11747                }
11748            }
11749        }
11750        impl initializeReturn {
11751            fn _tokenize(&self) -> <initializeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
11752                ()
11753            }
11754        }
11755        #[automatically_derived]
11756        impl alloy_sol_types::SolCall for initializeCall {
11757            type Parameters<'a> = (
11758                alloy::sol_types::sol_data::Address,
11759                alloy::sol_types::sol_data::Uint<256>,
11760            );
11761            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
11762            type Return = initializeReturn;
11763            type ReturnTuple<'a> = ();
11764            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
11765            const SIGNATURE: &'static str = "initialize(address,uint256)";
11766            const SELECTOR: [u8; 4] = [205u8, 109u8, 198u8, 135u8];
11767            #[inline]
11768            fn new<'a>(
11769                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11770            ) -> Self {
11771                tuple.into()
11772            }
11773            #[inline]
11774            fn tokenize(&self) -> Self::Token<'_> {
11775                (
11776                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
11777                        &self.initialOwner,
11778                    ),
11779                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
11780                        &self.initialPausedStatus,
11781                    ),
11782                )
11783            }
11784            #[inline]
11785            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
11786                initializeReturn::_tokenize(ret)
11787            }
11788            #[inline]
11789            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11790                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
11791                    .map(Into::into)
11792            }
11793            #[inline]
11794            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11795                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
11796                    data,
11797                )
11798                .map(Into::into)
11799            }
11800        }
11801    };
11802    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
11803    /**Function with signature `isMemberOfOperatorSet(address,(address,uint32))` and selector `0x670d3ba2`.
11804    ```solidity
11805    function isMemberOfOperatorSet(address operator, OperatorSet memory operatorSet) external view returns (bool);
11806    ```*/
11807    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11808    #[derive(Clone)]
11809    pub struct isMemberOfOperatorSetCall {
11810        #[allow(missing_docs)]
11811        pub operator: alloy::sol_types::private::Address,
11812        #[allow(missing_docs)]
11813        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
11814    }
11815    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
11816    ///Container type for the return parameters of the [`isMemberOfOperatorSet(address,(address,uint32))`](isMemberOfOperatorSetCall) function.
11817    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11818    #[derive(Clone)]
11819    pub struct isMemberOfOperatorSetReturn {
11820        #[allow(missing_docs)]
11821        pub _0: bool,
11822    }
11823    #[allow(
11824        non_camel_case_types,
11825        non_snake_case,
11826        clippy::pub_underscore_fields,
11827        clippy::style
11828    )]
11829    const _: () = {
11830        use alloy::sol_types as alloy_sol_types;
11831        {
11832            #[doc(hidden)]
11833            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address, OperatorSet);
11834            #[doc(hidden)]
11835            type UnderlyingRustTuple<'a> = (
11836                alloy::sol_types::private::Address,
11837                <OperatorSet as alloy::sol_types::SolType>::RustType,
11838            );
11839            #[cfg(test)]
11840            #[allow(dead_code, unreachable_patterns)]
11841            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
11842                match _t {
11843                    alloy_sol_types::private::AssertTypeEq::<
11844                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11845                    >(_) => {}
11846                }
11847            }
11848            #[automatically_derived]
11849            #[doc(hidden)]
11850            impl ::core::convert::From<isMemberOfOperatorSetCall> for UnderlyingRustTuple<'_> {
11851                fn from(value: isMemberOfOperatorSetCall) -> Self {
11852                    (value.operator, value.operatorSet)
11853                }
11854            }
11855            #[automatically_derived]
11856            #[doc(hidden)]
11857            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isMemberOfOperatorSetCall {
11858                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11859                    Self {
11860                        operator: tuple.0,
11861                        operatorSet: tuple.1,
11862                    }
11863                }
11864            }
11865        }
11866        {
11867            #[doc(hidden)]
11868            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
11869            #[doc(hidden)]
11870            type UnderlyingRustTuple<'a> = (bool,);
11871            #[cfg(test)]
11872            #[allow(dead_code, unreachable_patterns)]
11873            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
11874                match _t {
11875                    alloy_sol_types::private::AssertTypeEq::<
11876                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11877                    >(_) => {}
11878                }
11879            }
11880            #[automatically_derived]
11881            #[doc(hidden)]
11882            impl ::core::convert::From<isMemberOfOperatorSetReturn> for UnderlyingRustTuple<'_> {
11883                fn from(value: isMemberOfOperatorSetReturn) -> Self {
11884                    (value._0,)
11885                }
11886            }
11887            #[automatically_derived]
11888            #[doc(hidden)]
11889            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isMemberOfOperatorSetReturn {
11890                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11891                    Self { _0: tuple.0 }
11892                }
11893            }
11894        }
11895        #[automatically_derived]
11896        impl alloy_sol_types::SolCall for isMemberOfOperatorSetCall {
11897            type Parameters<'a> = (alloy::sol_types::sol_data::Address, OperatorSet);
11898            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
11899            type Return = bool;
11900            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
11901            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
11902            const SIGNATURE: &'static str = "isMemberOfOperatorSet(address,(address,uint32))";
11903            const SELECTOR: [u8; 4] = [103u8, 13u8, 59u8, 162u8];
11904            #[inline]
11905            fn new<'a>(
11906                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11907            ) -> Self {
11908                tuple.into()
11909            }
11910            #[inline]
11911            fn tokenize(&self) -> Self::Token<'_> {
11912                (
11913                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
11914                        &self.operator,
11915                    ),
11916                    <OperatorSet as alloy_sol_types::SolType>::tokenize(&self.operatorSet),
11917                )
11918            }
11919            #[inline]
11920            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
11921                (<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
11922            }
11923            #[inline]
11924            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11925                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
11926                    |r| {
11927                        let r: isMemberOfOperatorSetReturn = r.into();
11928                        r._0
11929                    },
11930                )
11931            }
11932            #[inline]
11933            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11934                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
11935                    data,
11936                )
11937                .map(|r| {
11938                    let r: isMemberOfOperatorSetReturn = r.into();
11939                    r._0
11940                })
11941            }
11942        }
11943    };
11944    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
11945    /**Function with signature `isOperatorSet((address,uint32))` and selector `0x260dc758`.
11946    ```solidity
11947    function isOperatorSet(OperatorSet memory operatorSet) external view returns (bool);
11948    ```*/
11949    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11950    #[derive(Clone)]
11951    pub struct isOperatorSetCall {
11952        #[allow(missing_docs)]
11953        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
11954    }
11955    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
11956    ///Container type for the return parameters of the [`isOperatorSet((address,uint32))`](isOperatorSetCall) function.
11957    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11958    #[derive(Clone)]
11959    pub struct isOperatorSetReturn {
11960        #[allow(missing_docs)]
11961        pub _0: bool,
11962    }
11963    #[allow(
11964        non_camel_case_types,
11965        non_snake_case,
11966        clippy::pub_underscore_fields,
11967        clippy::style
11968    )]
11969    const _: () = {
11970        use alloy::sol_types as alloy_sol_types;
11971        {
11972            #[doc(hidden)]
11973            type UnderlyingSolTuple<'a> = (OperatorSet,);
11974            #[doc(hidden)]
11975            type UnderlyingRustTuple<'a> = (<OperatorSet as alloy::sol_types::SolType>::RustType,);
11976            #[cfg(test)]
11977            #[allow(dead_code, unreachable_patterns)]
11978            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
11979                match _t {
11980                    alloy_sol_types::private::AssertTypeEq::<
11981                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11982                    >(_) => {}
11983                }
11984            }
11985            #[automatically_derived]
11986            #[doc(hidden)]
11987            impl ::core::convert::From<isOperatorSetCall> for UnderlyingRustTuple<'_> {
11988                fn from(value: isOperatorSetCall) -> Self {
11989                    (value.operatorSet,)
11990                }
11991            }
11992            #[automatically_derived]
11993            #[doc(hidden)]
11994            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isOperatorSetCall {
11995                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11996                    Self {
11997                        operatorSet: tuple.0,
11998                    }
11999                }
12000            }
12001        }
12002        {
12003            #[doc(hidden)]
12004            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
12005            #[doc(hidden)]
12006            type UnderlyingRustTuple<'a> = (bool,);
12007            #[cfg(test)]
12008            #[allow(dead_code, unreachable_patterns)]
12009            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
12010                match _t {
12011                    alloy_sol_types::private::AssertTypeEq::<
12012                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12013                    >(_) => {}
12014                }
12015            }
12016            #[automatically_derived]
12017            #[doc(hidden)]
12018            impl ::core::convert::From<isOperatorSetReturn> for UnderlyingRustTuple<'_> {
12019                fn from(value: isOperatorSetReturn) -> Self {
12020                    (value._0,)
12021                }
12022            }
12023            #[automatically_derived]
12024            #[doc(hidden)]
12025            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isOperatorSetReturn {
12026                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12027                    Self { _0: tuple.0 }
12028                }
12029            }
12030        }
12031        #[automatically_derived]
12032        impl alloy_sol_types::SolCall for isOperatorSetCall {
12033            type Parameters<'a> = (OperatorSet,);
12034            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
12035            type Return = bool;
12036            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
12037            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
12038            const SIGNATURE: &'static str = "isOperatorSet((address,uint32))";
12039            const SELECTOR: [u8; 4] = [38u8, 13u8, 199u8, 88u8];
12040            #[inline]
12041            fn new<'a>(
12042                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
12043            ) -> Self {
12044                tuple.into()
12045            }
12046            #[inline]
12047            fn tokenize(&self) -> Self::Token<'_> {
12048                (<OperatorSet as alloy_sol_types::SolType>::tokenize(
12049                    &self.operatorSet,
12050                ),)
12051            }
12052            #[inline]
12053            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
12054                (<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
12055            }
12056            #[inline]
12057            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
12058                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
12059                    |r| {
12060                        let r: isOperatorSetReturn = r.into();
12061                        r._0
12062                    },
12063                )
12064            }
12065            #[inline]
12066            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
12067                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
12068                    data,
12069                )
12070                .map(|r| {
12071                    let r: isOperatorSetReturn = r.into();
12072                    r._0
12073                })
12074            }
12075        }
12076    };
12077    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
12078    /**Function with signature `isOperatorSlashable(address,(address,uint32))` and selector `0x1352c3e6`.
12079    ```solidity
12080    function isOperatorSlashable(address operator, OperatorSet memory operatorSet) external view returns (bool);
12081    ```*/
12082    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12083    #[derive(Clone)]
12084    pub struct isOperatorSlashableCall {
12085        #[allow(missing_docs)]
12086        pub operator: alloy::sol_types::private::Address,
12087        #[allow(missing_docs)]
12088        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
12089    }
12090    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
12091    ///Container type for the return parameters of the [`isOperatorSlashable(address,(address,uint32))`](isOperatorSlashableCall) function.
12092    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12093    #[derive(Clone)]
12094    pub struct isOperatorSlashableReturn {
12095        #[allow(missing_docs)]
12096        pub _0: bool,
12097    }
12098    #[allow(
12099        non_camel_case_types,
12100        non_snake_case,
12101        clippy::pub_underscore_fields,
12102        clippy::style
12103    )]
12104    const _: () = {
12105        use alloy::sol_types as alloy_sol_types;
12106        {
12107            #[doc(hidden)]
12108            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address, OperatorSet);
12109            #[doc(hidden)]
12110            type UnderlyingRustTuple<'a> = (
12111                alloy::sol_types::private::Address,
12112                <OperatorSet as alloy::sol_types::SolType>::RustType,
12113            );
12114            #[cfg(test)]
12115            #[allow(dead_code, unreachable_patterns)]
12116            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
12117                match _t {
12118                    alloy_sol_types::private::AssertTypeEq::<
12119                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12120                    >(_) => {}
12121                }
12122            }
12123            #[automatically_derived]
12124            #[doc(hidden)]
12125            impl ::core::convert::From<isOperatorSlashableCall> for UnderlyingRustTuple<'_> {
12126                fn from(value: isOperatorSlashableCall) -> Self {
12127                    (value.operator, value.operatorSet)
12128                }
12129            }
12130            #[automatically_derived]
12131            #[doc(hidden)]
12132            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isOperatorSlashableCall {
12133                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12134                    Self {
12135                        operator: tuple.0,
12136                        operatorSet: tuple.1,
12137                    }
12138                }
12139            }
12140        }
12141        {
12142            #[doc(hidden)]
12143            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
12144            #[doc(hidden)]
12145            type UnderlyingRustTuple<'a> = (bool,);
12146            #[cfg(test)]
12147            #[allow(dead_code, unreachable_patterns)]
12148            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
12149                match _t {
12150                    alloy_sol_types::private::AssertTypeEq::<
12151                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12152                    >(_) => {}
12153                }
12154            }
12155            #[automatically_derived]
12156            #[doc(hidden)]
12157            impl ::core::convert::From<isOperatorSlashableReturn> for UnderlyingRustTuple<'_> {
12158                fn from(value: isOperatorSlashableReturn) -> Self {
12159                    (value._0,)
12160                }
12161            }
12162            #[automatically_derived]
12163            #[doc(hidden)]
12164            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isOperatorSlashableReturn {
12165                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12166                    Self { _0: tuple.0 }
12167                }
12168            }
12169        }
12170        #[automatically_derived]
12171        impl alloy_sol_types::SolCall for isOperatorSlashableCall {
12172            type Parameters<'a> = (alloy::sol_types::sol_data::Address, OperatorSet);
12173            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
12174            type Return = bool;
12175            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
12176            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
12177            const SIGNATURE: &'static str = "isOperatorSlashable(address,(address,uint32))";
12178            const SELECTOR: [u8; 4] = [19u8, 82u8, 195u8, 230u8];
12179            #[inline]
12180            fn new<'a>(
12181                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
12182            ) -> Self {
12183                tuple.into()
12184            }
12185            #[inline]
12186            fn tokenize(&self) -> Self::Token<'_> {
12187                (
12188                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
12189                        &self.operator,
12190                    ),
12191                    <OperatorSet as alloy_sol_types::SolType>::tokenize(&self.operatorSet),
12192                )
12193            }
12194            #[inline]
12195            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
12196                (<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
12197            }
12198            #[inline]
12199            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
12200                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
12201                    |r| {
12202                        let r: isOperatorSlashableReturn = r.into();
12203                        r._0
12204                    },
12205                )
12206            }
12207            #[inline]
12208            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
12209                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
12210                    data,
12211                )
12212                .map(|r| {
12213                    let r: isOperatorSlashableReturn = r.into();
12214                    r._0
12215                })
12216            }
12217        }
12218    };
12219    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
12220    /**Function with signature `modifyAllocations(address,((address,uint32),address[],uint64[])[])` and selector `0x952899ee`.
12221    ```solidity
12222    function modifyAllocations(address operator, IAllocationManagerTypes.AllocateParams[] memory params) external;
12223    ```*/
12224    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12225    #[derive(Clone)]
12226    pub struct modifyAllocationsCall {
12227        #[allow(missing_docs)]
12228        pub operator: alloy::sol_types::private::Address,
12229        #[allow(missing_docs)]
12230        pub params: alloy::sol_types::private::Vec<
12231            <IAllocationManagerTypes::AllocateParams as alloy::sol_types::SolType>::RustType,
12232        >,
12233    }
12234    ///Container type for the return parameters of the [`modifyAllocations(address,((address,uint32),address[],uint64[])[])`](modifyAllocationsCall) function.
12235    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12236    #[derive(Clone)]
12237    pub struct modifyAllocationsReturn {}
12238    #[allow(
12239        non_camel_case_types,
12240        non_snake_case,
12241        clippy::pub_underscore_fields,
12242        clippy::style
12243    )]
12244    const _: () = {
12245        use alloy::sol_types as alloy_sol_types;
12246        {
12247            #[doc(hidden)]
12248            type UnderlyingSolTuple<'a> = (
12249                alloy::sol_types::sol_data::Address,
12250                alloy::sol_types::sol_data::Array<IAllocationManagerTypes::AllocateParams>,
12251            );
12252            #[doc(hidden)]
12253            type UnderlyingRustTuple<'a> = (
12254                alloy::sol_types::private::Address,
12255                alloy::sol_types::private::Vec<
12256                    <IAllocationManagerTypes::AllocateParams as alloy::sol_types::SolType>::RustType,
12257                >,
12258            );
12259            #[cfg(test)]
12260            #[allow(dead_code, unreachable_patterns)]
12261            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
12262                match _t {
12263                    alloy_sol_types::private::AssertTypeEq::<
12264                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12265                    >(_) => {}
12266                }
12267            }
12268            #[automatically_derived]
12269            #[doc(hidden)]
12270            impl ::core::convert::From<modifyAllocationsCall> for UnderlyingRustTuple<'_> {
12271                fn from(value: modifyAllocationsCall) -> Self {
12272                    (value.operator, value.params)
12273                }
12274            }
12275            #[automatically_derived]
12276            #[doc(hidden)]
12277            impl ::core::convert::From<UnderlyingRustTuple<'_>> for modifyAllocationsCall {
12278                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12279                    Self {
12280                        operator: tuple.0,
12281                        params: tuple.1,
12282                    }
12283                }
12284            }
12285        }
12286        {
12287            #[doc(hidden)]
12288            type UnderlyingSolTuple<'a> = ();
12289            #[doc(hidden)]
12290            type UnderlyingRustTuple<'a> = ();
12291            #[cfg(test)]
12292            #[allow(dead_code, unreachable_patterns)]
12293            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
12294                match _t {
12295                    alloy_sol_types::private::AssertTypeEq::<
12296                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12297                    >(_) => {}
12298                }
12299            }
12300            #[automatically_derived]
12301            #[doc(hidden)]
12302            impl ::core::convert::From<modifyAllocationsReturn> for UnderlyingRustTuple<'_> {
12303                fn from(value: modifyAllocationsReturn) -> Self {
12304                    ()
12305                }
12306            }
12307            #[automatically_derived]
12308            #[doc(hidden)]
12309            impl ::core::convert::From<UnderlyingRustTuple<'_>> for modifyAllocationsReturn {
12310                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12311                    Self {}
12312                }
12313            }
12314        }
12315        impl modifyAllocationsReturn {
12316            fn _tokenize(
12317                &self,
12318            ) -> <modifyAllocationsCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
12319                ()
12320            }
12321        }
12322        #[automatically_derived]
12323        impl alloy_sol_types::SolCall for modifyAllocationsCall {
12324            type Parameters<'a> = (
12325                alloy::sol_types::sol_data::Address,
12326                alloy::sol_types::sol_data::Array<IAllocationManagerTypes::AllocateParams>,
12327            );
12328            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
12329            type Return = modifyAllocationsReturn;
12330            type ReturnTuple<'a> = ();
12331            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
12332            const SIGNATURE: &'static str =
12333                "modifyAllocations(address,((address,uint32),address[],uint64[])[])";
12334            const SELECTOR: [u8; 4] = [149u8, 40u8, 153u8, 238u8];
12335            #[inline]
12336            fn new<'a>(
12337                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
12338            ) -> Self {
12339                tuple.into()
12340            }
12341            #[inline]
12342            fn tokenize(&self) -> Self::Token<'_> {
12343                (
12344                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
12345                        &self.operator,
12346                    ),
12347                    <alloy::sol_types::sol_data::Array<
12348                        IAllocationManagerTypes::AllocateParams,
12349                    > as alloy_sol_types::SolType>::tokenize(&self.params),
12350                )
12351            }
12352            #[inline]
12353            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
12354                modifyAllocationsReturn::_tokenize(ret)
12355            }
12356            #[inline]
12357            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
12358                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
12359                    .map(Into::into)
12360            }
12361            #[inline]
12362            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
12363                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
12364                    data,
12365                )
12366                .map(Into::into)
12367            }
12368        }
12369    };
12370    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
12371    /**Function with signature `owner()` and selector `0x8da5cb5b`.
12372    ```solidity
12373    function owner() external view returns (address);
12374    ```*/
12375    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12376    #[derive(Clone)]
12377    pub struct ownerCall;
12378    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
12379    ///Container type for the return parameters of the [`owner()`](ownerCall) function.
12380    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12381    #[derive(Clone)]
12382    pub struct ownerReturn {
12383        #[allow(missing_docs)]
12384        pub _0: alloy::sol_types::private::Address,
12385    }
12386    #[allow(
12387        non_camel_case_types,
12388        non_snake_case,
12389        clippy::pub_underscore_fields,
12390        clippy::style
12391    )]
12392    const _: () = {
12393        use alloy::sol_types as alloy_sol_types;
12394        {
12395            #[doc(hidden)]
12396            type UnderlyingSolTuple<'a> = ();
12397            #[doc(hidden)]
12398            type UnderlyingRustTuple<'a> = ();
12399            #[cfg(test)]
12400            #[allow(dead_code, unreachable_patterns)]
12401            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
12402                match _t {
12403                    alloy_sol_types::private::AssertTypeEq::<
12404                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12405                    >(_) => {}
12406                }
12407            }
12408            #[automatically_derived]
12409            #[doc(hidden)]
12410            impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
12411                fn from(value: ownerCall) -> Self {
12412                    ()
12413                }
12414            }
12415            #[automatically_derived]
12416            #[doc(hidden)]
12417            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
12418                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12419                    Self
12420                }
12421            }
12422        }
12423        {
12424            #[doc(hidden)]
12425            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
12426            #[doc(hidden)]
12427            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
12428            #[cfg(test)]
12429            #[allow(dead_code, unreachable_patterns)]
12430            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
12431                match _t {
12432                    alloy_sol_types::private::AssertTypeEq::<
12433                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12434                    >(_) => {}
12435                }
12436            }
12437            #[automatically_derived]
12438            #[doc(hidden)]
12439            impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
12440                fn from(value: ownerReturn) -> Self {
12441                    (value._0,)
12442                }
12443            }
12444            #[automatically_derived]
12445            #[doc(hidden)]
12446            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
12447                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12448                    Self { _0: tuple.0 }
12449                }
12450            }
12451        }
12452        #[automatically_derived]
12453        impl alloy_sol_types::SolCall for ownerCall {
12454            type Parameters<'a> = ();
12455            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
12456            type Return = alloy::sol_types::private::Address;
12457            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
12458            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
12459            const SIGNATURE: &'static str = "owner()";
12460            const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
12461            #[inline]
12462            fn new<'a>(
12463                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
12464            ) -> Self {
12465                tuple.into()
12466            }
12467            #[inline]
12468            fn tokenize(&self) -> Self::Token<'_> {
12469                ()
12470            }
12471            #[inline]
12472            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
12473                (
12474                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
12475                        ret,
12476                    ),
12477                )
12478            }
12479            #[inline]
12480            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
12481                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
12482                    |r| {
12483                        let r: ownerReturn = r.into();
12484                        r._0
12485                    },
12486                )
12487            }
12488            #[inline]
12489            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
12490                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
12491                    data,
12492                )
12493                .map(|r| {
12494                    let r: ownerReturn = r.into();
12495                    r._0
12496                })
12497            }
12498        }
12499    };
12500    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
12501    /**Function with signature `pause(uint256)` and selector `0x136439dd`.
12502    ```solidity
12503    function pause(uint256 newPausedStatus) external;
12504    ```*/
12505    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12506    #[derive(Clone)]
12507    pub struct pauseCall {
12508        #[allow(missing_docs)]
12509        pub newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
12510    }
12511    ///Container type for the return parameters of the [`pause(uint256)`](pauseCall) function.
12512    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12513    #[derive(Clone)]
12514    pub struct pauseReturn {}
12515    #[allow(
12516        non_camel_case_types,
12517        non_snake_case,
12518        clippy::pub_underscore_fields,
12519        clippy::style
12520    )]
12521    const _: () = {
12522        use alloy::sol_types as alloy_sol_types;
12523        {
12524            #[doc(hidden)]
12525            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
12526            #[doc(hidden)]
12527            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
12528            #[cfg(test)]
12529            #[allow(dead_code, unreachable_patterns)]
12530            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
12531                match _t {
12532                    alloy_sol_types::private::AssertTypeEq::<
12533                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12534                    >(_) => {}
12535                }
12536            }
12537            #[automatically_derived]
12538            #[doc(hidden)]
12539            impl ::core::convert::From<pauseCall> for UnderlyingRustTuple<'_> {
12540                fn from(value: pauseCall) -> Self {
12541                    (value.newPausedStatus,)
12542                }
12543            }
12544            #[automatically_derived]
12545            #[doc(hidden)]
12546            impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseCall {
12547                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12548                    Self {
12549                        newPausedStatus: tuple.0,
12550                    }
12551                }
12552            }
12553        }
12554        {
12555            #[doc(hidden)]
12556            type UnderlyingSolTuple<'a> = ();
12557            #[doc(hidden)]
12558            type UnderlyingRustTuple<'a> = ();
12559            #[cfg(test)]
12560            #[allow(dead_code, unreachable_patterns)]
12561            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
12562                match _t {
12563                    alloy_sol_types::private::AssertTypeEq::<
12564                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12565                    >(_) => {}
12566                }
12567            }
12568            #[automatically_derived]
12569            #[doc(hidden)]
12570            impl ::core::convert::From<pauseReturn> for UnderlyingRustTuple<'_> {
12571                fn from(value: pauseReturn) -> Self {
12572                    ()
12573                }
12574            }
12575            #[automatically_derived]
12576            #[doc(hidden)]
12577            impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseReturn {
12578                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12579                    Self {}
12580                }
12581            }
12582        }
12583        impl pauseReturn {
12584            fn _tokenize(&self) -> <pauseCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
12585                ()
12586            }
12587        }
12588        #[automatically_derived]
12589        impl alloy_sol_types::SolCall for pauseCall {
12590            type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
12591            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
12592            type Return = pauseReturn;
12593            type ReturnTuple<'a> = ();
12594            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
12595            const SIGNATURE: &'static str = "pause(uint256)";
12596            const SELECTOR: [u8; 4] = [19u8, 100u8, 57u8, 221u8];
12597            #[inline]
12598            fn new<'a>(
12599                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
12600            ) -> Self {
12601                tuple.into()
12602            }
12603            #[inline]
12604            fn tokenize(&self) -> Self::Token<'_> {
12605                (
12606                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
12607                        &self.newPausedStatus,
12608                    ),
12609                )
12610            }
12611            #[inline]
12612            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
12613                pauseReturn::_tokenize(ret)
12614            }
12615            #[inline]
12616            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
12617                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
12618                    .map(Into::into)
12619            }
12620            #[inline]
12621            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
12622                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
12623                    data,
12624                )
12625                .map(Into::into)
12626            }
12627        }
12628    };
12629    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
12630    /**Function with signature `pauseAll()` and selector `0x595c6a67`.
12631    ```solidity
12632    function pauseAll() external;
12633    ```*/
12634    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12635    #[derive(Clone)]
12636    pub struct pauseAllCall;
12637    ///Container type for the return parameters of the [`pauseAll()`](pauseAllCall) function.
12638    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12639    #[derive(Clone)]
12640    pub struct pauseAllReturn {}
12641    #[allow(
12642        non_camel_case_types,
12643        non_snake_case,
12644        clippy::pub_underscore_fields,
12645        clippy::style
12646    )]
12647    const _: () = {
12648        use alloy::sol_types as alloy_sol_types;
12649        {
12650            #[doc(hidden)]
12651            type UnderlyingSolTuple<'a> = ();
12652            #[doc(hidden)]
12653            type UnderlyingRustTuple<'a> = ();
12654            #[cfg(test)]
12655            #[allow(dead_code, unreachable_patterns)]
12656            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
12657                match _t {
12658                    alloy_sol_types::private::AssertTypeEq::<
12659                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12660                    >(_) => {}
12661                }
12662            }
12663            #[automatically_derived]
12664            #[doc(hidden)]
12665            impl ::core::convert::From<pauseAllCall> for UnderlyingRustTuple<'_> {
12666                fn from(value: pauseAllCall) -> Self {
12667                    ()
12668                }
12669            }
12670            #[automatically_derived]
12671            #[doc(hidden)]
12672            impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseAllCall {
12673                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12674                    Self
12675                }
12676            }
12677        }
12678        {
12679            #[doc(hidden)]
12680            type UnderlyingSolTuple<'a> = ();
12681            #[doc(hidden)]
12682            type UnderlyingRustTuple<'a> = ();
12683            #[cfg(test)]
12684            #[allow(dead_code, unreachable_patterns)]
12685            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
12686                match _t {
12687                    alloy_sol_types::private::AssertTypeEq::<
12688                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12689                    >(_) => {}
12690                }
12691            }
12692            #[automatically_derived]
12693            #[doc(hidden)]
12694            impl ::core::convert::From<pauseAllReturn> for UnderlyingRustTuple<'_> {
12695                fn from(value: pauseAllReturn) -> Self {
12696                    ()
12697                }
12698            }
12699            #[automatically_derived]
12700            #[doc(hidden)]
12701            impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseAllReturn {
12702                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12703                    Self {}
12704                }
12705            }
12706        }
12707        impl pauseAllReturn {
12708            fn _tokenize(&self) -> <pauseAllCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
12709                ()
12710            }
12711        }
12712        #[automatically_derived]
12713        impl alloy_sol_types::SolCall for pauseAllCall {
12714            type Parameters<'a> = ();
12715            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
12716            type Return = pauseAllReturn;
12717            type ReturnTuple<'a> = ();
12718            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
12719            const SIGNATURE: &'static str = "pauseAll()";
12720            const SELECTOR: [u8; 4] = [89u8, 92u8, 106u8, 103u8];
12721            #[inline]
12722            fn new<'a>(
12723                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
12724            ) -> Self {
12725                tuple.into()
12726            }
12727            #[inline]
12728            fn tokenize(&self) -> Self::Token<'_> {
12729                ()
12730            }
12731            #[inline]
12732            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
12733                pauseAllReturn::_tokenize(ret)
12734            }
12735            #[inline]
12736            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
12737                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
12738                    .map(Into::into)
12739            }
12740            #[inline]
12741            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
12742                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
12743                    data,
12744                )
12745                .map(Into::into)
12746            }
12747        }
12748    };
12749    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
12750    /**Function with signature `paused(uint8)` and selector `0x5ac86ab7`.
12751    ```solidity
12752    function paused(uint8 index) external view returns (bool);
12753    ```*/
12754    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12755    #[derive(Clone)]
12756    pub struct paused_0Call {
12757        #[allow(missing_docs)]
12758        pub index: u8,
12759    }
12760    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
12761    ///Container type for the return parameters of the [`paused(uint8)`](paused_0Call) function.
12762    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12763    #[derive(Clone)]
12764    pub struct paused_0Return {
12765        #[allow(missing_docs)]
12766        pub _0: bool,
12767    }
12768    #[allow(
12769        non_camel_case_types,
12770        non_snake_case,
12771        clippy::pub_underscore_fields,
12772        clippy::style
12773    )]
12774    const _: () = {
12775        use alloy::sol_types as alloy_sol_types;
12776        {
12777            #[doc(hidden)]
12778            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
12779            #[doc(hidden)]
12780            type UnderlyingRustTuple<'a> = (u8,);
12781            #[cfg(test)]
12782            #[allow(dead_code, unreachable_patterns)]
12783            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
12784                match _t {
12785                    alloy_sol_types::private::AssertTypeEq::<
12786                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12787                    >(_) => {}
12788                }
12789            }
12790            #[automatically_derived]
12791            #[doc(hidden)]
12792            impl ::core::convert::From<paused_0Call> for UnderlyingRustTuple<'_> {
12793                fn from(value: paused_0Call) -> Self {
12794                    (value.index,)
12795                }
12796            }
12797            #[automatically_derived]
12798            #[doc(hidden)]
12799            impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_0Call {
12800                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12801                    Self { index: tuple.0 }
12802                }
12803            }
12804        }
12805        {
12806            #[doc(hidden)]
12807            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
12808            #[doc(hidden)]
12809            type UnderlyingRustTuple<'a> = (bool,);
12810            #[cfg(test)]
12811            #[allow(dead_code, unreachable_patterns)]
12812            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
12813                match _t {
12814                    alloy_sol_types::private::AssertTypeEq::<
12815                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12816                    >(_) => {}
12817                }
12818            }
12819            #[automatically_derived]
12820            #[doc(hidden)]
12821            impl ::core::convert::From<paused_0Return> for UnderlyingRustTuple<'_> {
12822                fn from(value: paused_0Return) -> Self {
12823                    (value._0,)
12824                }
12825            }
12826            #[automatically_derived]
12827            #[doc(hidden)]
12828            impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_0Return {
12829                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12830                    Self { _0: tuple.0 }
12831                }
12832            }
12833        }
12834        #[automatically_derived]
12835        impl alloy_sol_types::SolCall for paused_0Call {
12836            type Parameters<'a> = (alloy::sol_types::sol_data::Uint<8>,);
12837            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
12838            type Return = bool;
12839            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
12840            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
12841            const SIGNATURE: &'static str = "paused(uint8)";
12842            const SELECTOR: [u8; 4] = [90u8, 200u8, 106u8, 183u8];
12843            #[inline]
12844            fn new<'a>(
12845                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
12846            ) -> Self {
12847                tuple.into()
12848            }
12849            #[inline]
12850            fn tokenize(&self) -> Self::Token<'_> {
12851                (
12852                    <alloy::sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(
12853                        &self.index,
12854                    ),
12855                )
12856            }
12857            #[inline]
12858            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
12859                (<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
12860            }
12861            #[inline]
12862            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
12863                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
12864                    |r| {
12865                        let r: paused_0Return = r.into();
12866                        r._0
12867                    },
12868                )
12869            }
12870            #[inline]
12871            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
12872                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
12873                    data,
12874                )
12875                .map(|r| {
12876                    let r: paused_0Return = r.into();
12877                    r._0
12878                })
12879            }
12880        }
12881    };
12882    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
12883    /**Function with signature `paused()` and selector `0x5c975abb`.
12884    ```solidity
12885    function paused() external view returns (uint256);
12886    ```*/
12887    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12888    #[derive(Clone)]
12889    pub struct paused_1Call;
12890    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
12891    ///Container type for the return parameters of the [`paused()`](paused_1Call) function.
12892    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12893    #[derive(Clone)]
12894    pub struct paused_1Return {
12895        #[allow(missing_docs)]
12896        pub _0: alloy::sol_types::private::primitives::aliases::U256,
12897    }
12898    #[allow(
12899        non_camel_case_types,
12900        non_snake_case,
12901        clippy::pub_underscore_fields,
12902        clippy::style
12903    )]
12904    const _: () = {
12905        use alloy::sol_types as alloy_sol_types;
12906        {
12907            #[doc(hidden)]
12908            type UnderlyingSolTuple<'a> = ();
12909            #[doc(hidden)]
12910            type UnderlyingRustTuple<'a> = ();
12911            #[cfg(test)]
12912            #[allow(dead_code, unreachable_patterns)]
12913            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
12914                match _t {
12915                    alloy_sol_types::private::AssertTypeEq::<
12916                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12917                    >(_) => {}
12918                }
12919            }
12920            #[automatically_derived]
12921            #[doc(hidden)]
12922            impl ::core::convert::From<paused_1Call> for UnderlyingRustTuple<'_> {
12923                fn from(value: paused_1Call) -> Self {
12924                    ()
12925                }
12926            }
12927            #[automatically_derived]
12928            #[doc(hidden)]
12929            impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_1Call {
12930                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12931                    Self
12932                }
12933            }
12934        }
12935        {
12936            #[doc(hidden)]
12937            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
12938            #[doc(hidden)]
12939            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
12940            #[cfg(test)]
12941            #[allow(dead_code, unreachable_patterns)]
12942            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
12943                match _t {
12944                    alloy_sol_types::private::AssertTypeEq::<
12945                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12946                    >(_) => {}
12947                }
12948            }
12949            #[automatically_derived]
12950            #[doc(hidden)]
12951            impl ::core::convert::From<paused_1Return> for UnderlyingRustTuple<'_> {
12952                fn from(value: paused_1Return) -> Self {
12953                    (value._0,)
12954                }
12955            }
12956            #[automatically_derived]
12957            #[doc(hidden)]
12958            impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_1Return {
12959                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12960                    Self { _0: tuple.0 }
12961                }
12962            }
12963        }
12964        #[automatically_derived]
12965        impl alloy_sol_types::SolCall for paused_1Call {
12966            type Parameters<'a> = ();
12967            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
12968            type Return = alloy::sol_types::private::primitives::aliases::U256;
12969            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
12970            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
12971            const SIGNATURE: &'static str = "paused()";
12972            const SELECTOR: [u8; 4] = [92u8, 151u8, 90u8, 187u8];
12973            #[inline]
12974            fn new<'a>(
12975                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
12976            ) -> Self {
12977                tuple.into()
12978            }
12979            #[inline]
12980            fn tokenize(&self) -> Self::Token<'_> {
12981                ()
12982            }
12983            #[inline]
12984            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
12985                (
12986                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
12987                        ret,
12988                    ),
12989                )
12990            }
12991            #[inline]
12992            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
12993                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
12994                    |r| {
12995                        let r: paused_1Return = r.into();
12996                        r._0
12997                    },
12998                )
12999            }
13000            #[inline]
13001            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
13002                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
13003                    data,
13004                )
13005                .map(|r| {
13006                    let r: paused_1Return = r.into();
13007                    r._0
13008                })
13009            }
13010        }
13011    };
13012    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
13013    /**Function with signature `pauserRegistry()` and selector `0x886f1195`.
13014    ```solidity
13015    function pauserRegistry() external view returns (address);
13016    ```*/
13017    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13018    #[derive(Clone)]
13019    pub struct pauserRegistryCall;
13020    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
13021    ///Container type for the return parameters of the [`pauserRegistry()`](pauserRegistryCall) function.
13022    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13023    #[derive(Clone)]
13024    pub struct pauserRegistryReturn {
13025        #[allow(missing_docs)]
13026        pub _0: alloy::sol_types::private::Address,
13027    }
13028    #[allow(
13029        non_camel_case_types,
13030        non_snake_case,
13031        clippy::pub_underscore_fields,
13032        clippy::style
13033    )]
13034    const _: () = {
13035        use alloy::sol_types as alloy_sol_types;
13036        {
13037            #[doc(hidden)]
13038            type UnderlyingSolTuple<'a> = ();
13039            #[doc(hidden)]
13040            type UnderlyingRustTuple<'a> = ();
13041            #[cfg(test)]
13042            #[allow(dead_code, unreachable_patterns)]
13043            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
13044                match _t {
13045                    alloy_sol_types::private::AssertTypeEq::<
13046                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13047                    >(_) => {}
13048                }
13049            }
13050            #[automatically_derived]
13051            #[doc(hidden)]
13052            impl ::core::convert::From<pauserRegistryCall> for UnderlyingRustTuple<'_> {
13053                fn from(value: pauserRegistryCall) -> Self {
13054                    ()
13055                }
13056            }
13057            #[automatically_derived]
13058            #[doc(hidden)]
13059            impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauserRegistryCall {
13060                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13061                    Self
13062                }
13063            }
13064        }
13065        {
13066            #[doc(hidden)]
13067            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
13068            #[doc(hidden)]
13069            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
13070            #[cfg(test)]
13071            #[allow(dead_code, unreachable_patterns)]
13072            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
13073                match _t {
13074                    alloy_sol_types::private::AssertTypeEq::<
13075                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13076                    >(_) => {}
13077                }
13078            }
13079            #[automatically_derived]
13080            #[doc(hidden)]
13081            impl ::core::convert::From<pauserRegistryReturn> for UnderlyingRustTuple<'_> {
13082                fn from(value: pauserRegistryReturn) -> Self {
13083                    (value._0,)
13084                }
13085            }
13086            #[automatically_derived]
13087            #[doc(hidden)]
13088            impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauserRegistryReturn {
13089                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13090                    Self { _0: tuple.0 }
13091                }
13092            }
13093        }
13094        #[automatically_derived]
13095        impl alloy_sol_types::SolCall for pauserRegistryCall {
13096            type Parameters<'a> = ();
13097            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
13098            type Return = alloy::sol_types::private::Address;
13099            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
13100            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
13101            const SIGNATURE: &'static str = "pauserRegistry()";
13102            const SELECTOR: [u8; 4] = [136u8, 111u8, 17u8, 149u8];
13103            #[inline]
13104            fn new<'a>(
13105                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
13106            ) -> Self {
13107                tuple.into()
13108            }
13109            #[inline]
13110            fn tokenize(&self) -> Self::Token<'_> {
13111                ()
13112            }
13113            #[inline]
13114            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
13115                (
13116                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
13117                        ret,
13118                    ),
13119                )
13120            }
13121            #[inline]
13122            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
13123                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
13124                    |r| {
13125                        let r: pauserRegistryReturn = r.into();
13126                        r._0
13127                    },
13128                )
13129            }
13130            #[inline]
13131            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
13132                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
13133                    data,
13134                )
13135                .map(|r| {
13136                    let r: pauserRegistryReturn = r.into();
13137                    r._0
13138                })
13139            }
13140        }
13141    };
13142    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
13143    /**Function with signature `permissionController()` and selector `0x4657e26a`.
13144    ```solidity
13145    function permissionController() external view returns (address);
13146    ```*/
13147    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13148    #[derive(Clone)]
13149    pub struct permissionControllerCall;
13150    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
13151    ///Container type for the return parameters of the [`permissionController()`](permissionControllerCall) function.
13152    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13153    #[derive(Clone)]
13154    pub struct permissionControllerReturn {
13155        #[allow(missing_docs)]
13156        pub _0: alloy::sol_types::private::Address,
13157    }
13158    #[allow(
13159        non_camel_case_types,
13160        non_snake_case,
13161        clippy::pub_underscore_fields,
13162        clippy::style
13163    )]
13164    const _: () = {
13165        use alloy::sol_types as alloy_sol_types;
13166        {
13167            #[doc(hidden)]
13168            type UnderlyingSolTuple<'a> = ();
13169            #[doc(hidden)]
13170            type UnderlyingRustTuple<'a> = ();
13171            #[cfg(test)]
13172            #[allow(dead_code, unreachable_patterns)]
13173            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
13174                match _t {
13175                    alloy_sol_types::private::AssertTypeEq::<
13176                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13177                    >(_) => {}
13178                }
13179            }
13180            #[automatically_derived]
13181            #[doc(hidden)]
13182            impl ::core::convert::From<permissionControllerCall> for UnderlyingRustTuple<'_> {
13183                fn from(value: permissionControllerCall) -> Self {
13184                    ()
13185                }
13186            }
13187            #[automatically_derived]
13188            #[doc(hidden)]
13189            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permissionControllerCall {
13190                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13191                    Self
13192                }
13193            }
13194        }
13195        {
13196            #[doc(hidden)]
13197            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
13198            #[doc(hidden)]
13199            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
13200            #[cfg(test)]
13201            #[allow(dead_code, unreachable_patterns)]
13202            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
13203                match _t {
13204                    alloy_sol_types::private::AssertTypeEq::<
13205                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13206                    >(_) => {}
13207                }
13208            }
13209            #[automatically_derived]
13210            #[doc(hidden)]
13211            impl ::core::convert::From<permissionControllerReturn> for UnderlyingRustTuple<'_> {
13212                fn from(value: permissionControllerReturn) -> Self {
13213                    (value._0,)
13214                }
13215            }
13216            #[automatically_derived]
13217            #[doc(hidden)]
13218            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permissionControllerReturn {
13219                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13220                    Self { _0: tuple.0 }
13221                }
13222            }
13223        }
13224        #[automatically_derived]
13225        impl alloy_sol_types::SolCall for permissionControllerCall {
13226            type Parameters<'a> = ();
13227            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
13228            type Return = alloy::sol_types::private::Address;
13229            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
13230            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
13231            const SIGNATURE: &'static str = "permissionController()";
13232            const SELECTOR: [u8; 4] = [70u8, 87u8, 226u8, 106u8];
13233            #[inline]
13234            fn new<'a>(
13235                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
13236            ) -> Self {
13237                tuple.into()
13238            }
13239            #[inline]
13240            fn tokenize(&self) -> Self::Token<'_> {
13241                ()
13242            }
13243            #[inline]
13244            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
13245                (
13246                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
13247                        ret,
13248                    ),
13249                )
13250            }
13251            #[inline]
13252            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
13253                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
13254                    |r| {
13255                        let r: permissionControllerReturn = r.into();
13256                        r._0
13257                    },
13258                )
13259            }
13260            #[inline]
13261            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
13262                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
13263                    data,
13264                )
13265                .map(|r| {
13266                    let r: permissionControllerReturn = r.into();
13267                    r._0
13268                })
13269            }
13270        }
13271    };
13272    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
13273    /**Function with signature `registerForOperatorSets(address,(address,uint32[],bytes))` and selector `0xadc2e3d9`.
13274    ```solidity
13275    function registerForOperatorSets(address operator, IAllocationManagerTypes.RegisterParams memory params) external;
13276    ```*/
13277    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13278    #[derive(Clone)]
13279    pub struct registerForOperatorSetsCall {
13280        #[allow(missing_docs)]
13281        pub operator: alloy::sol_types::private::Address,
13282        #[allow(missing_docs)]
13283        pub params:
13284            <IAllocationManagerTypes::RegisterParams as alloy::sol_types::SolType>::RustType,
13285    }
13286    ///Container type for the return parameters of the [`registerForOperatorSets(address,(address,uint32[],bytes))`](registerForOperatorSetsCall) function.
13287    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13288    #[derive(Clone)]
13289    pub struct registerForOperatorSetsReturn {}
13290    #[allow(
13291        non_camel_case_types,
13292        non_snake_case,
13293        clippy::pub_underscore_fields,
13294        clippy::style
13295    )]
13296    const _: () = {
13297        use alloy::sol_types as alloy_sol_types;
13298        {
13299            #[doc(hidden)]
13300            type UnderlyingSolTuple<'a> = (
13301                alloy::sol_types::sol_data::Address,
13302                IAllocationManagerTypes::RegisterParams,
13303            );
13304            #[doc(hidden)]
13305            type UnderlyingRustTuple<'a> = (
13306                alloy::sol_types::private::Address,
13307                <IAllocationManagerTypes::RegisterParams as alloy::sol_types::SolType>::RustType,
13308            );
13309            #[cfg(test)]
13310            #[allow(dead_code, unreachable_patterns)]
13311            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
13312                match _t {
13313                    alloy_sol_types::private::AssertTypeEq::<
13314                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13315                    >(_) => {}
13316                }
13317            }
13318            #[automatically_derived]
13319            #[doc(hidden)]
13320            impl ::core::convert::From<registerForOperatorSetsCall> for UnderlyingRustTuple<'_> {
13321                fn from(value: registerForOperatorSetsCall) -> Self {
13322                    (value.operator, value.params)
13323                }
13324            }
13325            #[automatically_derived]
13326            #[doc(hidden)]
13327            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerForOperatorSetsCall {
13328                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13329                    Self {
13330                        operator: tuple.0,
13331                        params: tuple.1,
13332                    }
13333                }
13334            }
13335        }
13336        {
13337            #[doc(hidden)]
13338            type UnderlyingSolTuple<'a> = ();
13339            #[doc(hidden)]
13340            type UnderlyingRustTuple<'a> = ();
13341            #[cfg(test)]
13342            #[allow(dead_code, unreachable_patterns)]
13343            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
13344                match _t {
13345                    alloy_sol_types::private::AssertTypeEq::<
13346                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13347                    >(_) => {}
13348                }
13349            }
13350            #[automatically_derived]
13351            #[doc(hidden)]
13352            impl ::core::convert::From<registerForOperatorSetsReturn> for UnderlyingRustTuple<'_> {
13353                fn from(value: registerForOperatorSetsReturn) -> Self {
13354                    ()
13355                }
13356            }
13357            #[automatically_derived]
13358            #[doc(hidden)]
13359            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerForOperatorSetsReturn {
13360                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13361                    Self {}
13362                }
13363            }
13364        }
13365        impl registerForOperatorSetsReturn {
13366            fn _tokenize(
13367                &self,
13368            ) -> <registerForOperatorSetsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
13369            {
13370                ()
13371            }
13372        }
13373        #[automatically_derived]
13374        impl alloy_sol_types::SolCall for registerForOperatorSetsCall {
13375            type Parameters<'a> = (
13376                alloy::sol_types::sol_data::Address,
13377                IAllocationManagerTypes::RegisterParams,
13378            );
13379            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
13380            type Return = registerForOperatorSetsReturn;
13381            type ReturnTuple<'a> = ();
13382            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
13383            const SIGNATURE: &'static str =
13384                "registerForOperatorSets(address,(address,uint32[],bytes))";
13385            const SELECTOR: [u8; 4] = [173u8, 194u8, 227u8, 217u8];
13386            #[inline]
13387            fn new<'a>(
13388                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
13389            ) -> Self {
13390                tuple.into()
13391            }
13392            #[inline]
13393            fn tokenize(&self) -> Self::Token<'_> {
13394                (
13395                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
13396                        &self.operator,
13397                    ),
13398                    <IAllocationManagerTypes::RegisterParams as alloy_sol_types::SolType>::tokenize(
13399                        &self.params,
13400                    ),
13401                )
13402            }
13403            #[inline]
13404            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
13405                registerForOperatorSetsReturn::_tokenize(ret)
13406            }
13407            #[inline]
13408            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
13409                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
13410                    .map(Into::into)
13411            }
13412            #[inline]
13413            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
13414                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
13415                    data,
13416                )
13417                .map(Into::into)
13418            }
13419        }
13420    };
13421    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
13422    /**Function with signature `removeStrategiesFromOperatorSet(address,uint32,address[])` and selector `0xb66bd989`.
13423    ```solidity
13424    function removeStrategiesFromOperatorSet(address avs, uint32 operatorSetId, address[] memory strategies) external;
13425    ```*/
13426    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13427    #[derive(Clone)]
13428    pub struct removeStrategiesFromOperatorSetCall {
13429        #[allow(missing_docs)]
13430        pub avs: alloy::sol_types::private::Address,
13431        #[allow(missing_docs)]
13432        pub operatorSetId: u32,
13433        #[allow(missing_docs)]
13434        pub strategies: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
13435    }
13436    ///Container type for the return parameters of the [`removeStrategiesFromOperatorSet(address,uint32,address[])`](removeStrategiesFromOperatorSetCall) function.
13437    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13438    #[derive(Clone)]
13439    pub struct removeStrategiesFromOperatorSetReturn {}
13440    #[allow(
13441        non_camel_case_types,
13442        non_snake_case,
13443        clippy::pub_underscore_fields,
13444        clippy::style
13445    )]
13446    const _: () = {
13447        use alloy::sol_types as alloy_sol_types;
13448        {
13449            #[doc(hidden)]
13450            type UnderlyingSolTuple<'a> = (
13451                alloy::sol_types::sol_data::Address,
13452                alloy::sol_types::sol_data::Uint<32>,
13453                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
13454            );
13455            #[doc(hidden)]
13456            type UnderlyingRustTuple<'a> = (
13457                alloy::sol_types::private::Address,
13458                u32,
13459                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
13460            );
13461            #[cfg(test)]
13462            #[allow(dead_code, unreachable_patterns)]
13463            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
13464                match _t {
13465                    alloy_sol_types::private::AssertTypeEq::<
13466                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13467                    >(_) => {}
13468                }
13469            }
13470            #[automatically_derived]
13471            #[doc(hidden)]
13472            impl ::core::convert::From<removeStrategiesFromOperatorSetCall> for UnderlyingRustTuple<'_> {
13473                fn from(value: removeStrategiesFromOperatorSetCall) -> Self {
13474                    (value.avs, value.operatorSetId, value.strategies)
13475                }
13476            }
13477            #[automatically_derived]
13478            #[doc(hidden)]
13479            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeStrategiesFromOperatorSetCall {
13480                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13481                    Self {
13482                        avs: tuple.0,
13483                        operatorSetId: tuple.1,
13484                        strategies: tuple.2,
13485                    }
13486                }
13487            }
13488        }
13489        {
13490            #[doc(hidden)]
13491            type UnderlyingSolTuple<'a> = ();
13492            #[doc(hidden)]
13493            type UnderlyingRustTuple<'a> = ();
13494            #[cfg(test)]
13495            #[allow(dead_code, unreachable_patterns)]
13496            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
13497                match _t {
13498                    alloy_sol_types::private::AssertTypeEq::<
13499                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13500                    >(_) => {}
13501                }
13502            }
13503            #[automatically_derived]
13504            #[doc(hidden)]
13505            impl ::core::convert::From<removeStrategiesFromOperatorSetReturn> for UnderlyingRustTuple<'_> {
13506                fn from(value: removeStrategiesFromOperatorSetReturn) -> Self {
13507                    ()
13508                }
13509            }
13510            #[automatically_derived]
13511            #[doc(hidden)]
13512            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeStrategiesFromOperatorSetReturn {
13513                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13514                    Self {}
13515                }
13516            }
13517        }
13518        impl removeStrategiesFromOperatorSetReturn {
13519            fn _tokenize(
13520                &self,
13521            ) -> <removeStrategiesFromOperatorSetCall as alloy_sol_types::SolCall>::ReturnToken<'_>
13522            {
13523                ()
13524            }
13525        }
13526        #[automatically_derived]
13527        impl alloy_sol_types::SolCall for removeStrategiesFromOperatorSetCall {
13528            type Parameters<'a> = (
13529                alloy::sol_types::sol_data::Address,
13530                alloy::sol_types::sol_data::Uint<32>,
13531                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
13532            );
13533            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
13534            type Return = removeStrategiesFromOperatorSetReturn;
13535            type ReturnTuple<'a> = ();
13536            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
13537            const SIGNATURE: &'static str =
13538                "removeStrategiesFromOperatorSet(address,uint32,address[])";
13539            const SELECTOR: [u8; 4] = [182u8, 107u8, 217u8, 137u8];
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.avs,
13551                    ),
13552                    <alloy::sol_types::sol_data::Uint<
13553                        32,
13554                    > as alloy_sol_types::SolType>::tokenize(&self.operatorSetId),
13555                    <alloy::sol_types::sol_data::Array<
13556                        alloy::sol_types::sol_data::Address,
13557                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
13558                )
13559            }
13560            #[inline]
13561            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
13562                removeStrategiesFromOperatorSetReturn::_tokenize(ret)
13563            }
13564            #[inline]
13565            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
13566                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
13567                    .map(Into::into)
13568            }
13569            #[inline]
13570            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
13571                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
13572                    data,
13573                )
13574                .map(Into::into)
13575            }
13576        }
13577    };
13578    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
13579    /**Function with signature `renounceOwnership()` and selector `0x715018a6`.
13580    ```solidity
13581    function renounceOwnership() external;
13582    ```*/
13583    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13584    #[derive(Clone)]
13585    pub struct renounceOwnershipCall;
13586    ///Container type for the return parameters of the [`renounceOwnership()`](renounceOwnershipCall) function.
13587    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13588    #[derive(Clone)]
13589    pub struct renounceOwnershipReturn {}
13590    #[allow(
13591        non_camel_case_types,
13592        non_snake_case,
13593        clippy::pub_underscore_fields,
13594        clippy::style
13595    )]
13596    const _: () = {
13597        use alloy::sol_types as alloy_sol_types;
13598        {
13599            #[doc(hidden)]
13600            type UnderlyingSolTuple<'a> = ();
13601            #[doc(hidden)]
13602            type UnderlyingRustTuple<'a> = ();
13603            #[cfg(test)]
13604            #[allow(dead_code, unreachable_patterns)]
13605            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
13606                match _t {
13607                    alloy_sol_types::private::AssertTypeEq::<
13608                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13609                    >(_) => {}
13610                }
13611            }
13612            #[automatically_derived]
13613            #[doc(hidden)]
13614            impl ::core::convert::From<renounceOwnershipCall> for UnderlyingRustTuple<'_> {
13615                fn from(value: renounceOwnershipCall) -> Self {
13616                    ()
13617                }
13618            }
13619            #[automatically_derived]
13620            #[doc(hidden)]
13621            impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceOwnershipCall {
13622                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13623                    Self
13624                }
13625            }
13626        }
13627        {
13628            #[doc(hidden)]
13629            type UnderlyingSolTuple<'a> = ();
13630            #[doc(hidden)]
13631            type UnderlyingRustTuple<'a> = ();
13632            #[cfg(test)]
13633            #[allow(dead_code, unreachable_patterns)]
13634            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
13635                match _t {
13636                    alloy_sol_types::private::AssertTypeEq::<
13637                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13638                    >(_) => {}
13639                }
13640            }
13641            #[automatically_derived]
13642            #[doc(hidden)]
13643            impl ::core::convert::From<renounceOwnershipReturn> for UnderlyingRustTuple<'_> {
13644                fn from(value: renounceOwnershipReturn) -> Self {
13645                    ()
13646                }
13647            }
13648            #[automatically_derived]
13649            #[doc(hidden)]
13650            impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceOwnershipReturn {
13651                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13652                    Self {}
13653                }
13654            }
13655        }
13656        impl renounceOwnershipReturn {
13657            fn _tokenize(
13658                &self,
13659            ) -> <renounceOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
13660                ()
13661            }
13662        }
13663        #[automatically_derived]
13664        impl alloy_sol_types::SolCall for renounceOwnershipCall {
13665            type Parameters<'a> = ();
13666            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
13667            type Return = renounceOwnershipReturn;
13668            type ReturnTuple<'a> = ();
13669            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
13670            const SIGNATURE: &'static str = "renounceOwnership()";
13671            const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
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            }
13682            #[inline]
13683            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
13684                renounceOwnershipReturn::_tokenize(ret)
13685            }
13686            #[inline]
13687            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
13688                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
13689                    .map(Into::into)
13690            }
13691            #[inline]
13692            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
13693                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
13694                    data,
13695                )
13696                .map(Into::into)
13697            }
13698        }
13699    };
13700    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
13701    /**Function with signature `setAVSRegistrar(address,address)` and selector `0xd3d96ff4`.
13702    ```solidity
13703    function setAVSRegistrar(address avs, address registrar) external;
13704    ```*/
13705    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13706    #[derive(Clone)]
13707    pub struct setAVSRegistrarCall {
13708        #[allow(missing_docs)]
13709        pub avs: alloy::sol_types::private::Address,
13710        #[allow(missing_docs)]
13711        pub registrar: alloy::sol_types::private::Address,
13712    }
13713    ///Container type for the return parameters of the [`setAVSRegistrar(address,address)`](setAVSRegistrarCall) function.
13714    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13715    #[derive(Clone)]
13716    pub struct setAVSRegistrarReturn {}
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> = (
13728                alloy::sol_types::sol_data::Address,
13729                alloy::sol_types::sol_data::Address,
13730            );
13731            #[doc(hidden)]
13732            type UnderlyingRustTuple<'a> = (
13733                alloy::sol_types::private::Address,
13734                alloy::sol_types::private::Address,
13735            );
13736            #[cfg(test)]
13737            #[allow(dead_code, unreachable_patterns)]
13738            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
13739                match _t {
13740                    alloy_sol_types::private::AssertTypeEq::<
13741                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13742                    >(_) => {}
13743                }
13744            }
13745            #[automatically_derived]
13746            #[doc(hidden)]
13747            impl ::core::convert::From<setAVSRegistrarCall> for UnderlyingRustTuple<'_> {
13748                fn from(value: setAVSRegistrarCall) -> Self {
13749                    (value.avs, value.registrar)
13750                }
13751            }
13752            #[automatically_derived]
13753            #[doc(hidden)]
13754            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAVSRegistrarCall {
13755                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13756                    Self {
13757                        avs: tuple.0,
13758                        registrar: tuple.1,
13759                    }
13760                }
13761            }
13762        }
13763        {
13764            #[doc(hidden)]
13765            type UnderlyingSolTuple<'a> = ();
13766            #[doc(hidden)]
13767            type UnderlyingRustTuple<'a> = ();
13768            #[cfg(test)]
13769            #[allow(dead_code, unreachable_patterns)]
13770            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
13771                match _t {
13772                    alloy_sol_types::private::AssertTypeEq::<
13773                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13774                    >(_) => {}
13775                }
13776            }
13777            #[automatically_derived]
13778            #[doc(hidden)]
13779            impl ::core::convert::From<setAVSRegistrarReturn> for UnderlyingRustTuple<'_> {
13780                fn from(value: setAVSRegistrarReturn) -> Self {
13781                    ()
13782                }
13783            }
13784            #[automatically_derived]
13785            #[doc(hidden)]
13786            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAVSRegistrarReturn {
13787                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13788                    Self {}
13789                }
13790            }
13791        }
13792        impl setAVSRegistrarReturn {
13793            fn _tokenize(
13794                &self,
13795            ) -> <setAVSRegistrarCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
13796                ()
13797            }
13798        }
13799        #[automatically_derived]
13800        impl alloy_sol_types::SolCall for setAVSRegistrarCall {
13801            type Parameters<'a> = (
13802                alloy::sol_types::sol_data::Address,
13803                alloy::sol_types::sol_data::Address,
13804            );
13805            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
13806            type Return = setAVSRegistrarReturn;
13807            type ReturnTuple<'a> = ();
13808            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
13809            const SIGNATURE: &'static str = "setAVSRegistrar(address,address)";
13810            const SELECTOR: [u8; 4] = [211u8, 217u8, 111u8, 244u8];
13811            #[inline]
13812            fn new<'a>(
13813                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
13814            ) -> Self {
13815                tuple.into()
13816            }
13817            #[inline]
13818            fn tokenize(&self) -> Self::Token<'_> {
13819                (
13820                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
13821                        &self.avs,
13822                    ),
13823                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
13824                        &self.registrar,
13825                    ),
13826                )
13827            }
13828            #[inline]
13829            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
13830                setAVSRegistrarReturn::_tokenize(ret)
13831            }
13832            #[inline]
13833            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
13834                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
13835                    .map(Into::into)
13836            }
13837            #[inline]
13838            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
13839                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
13840                    data,
13841                )
13842                .map(Into::into)
13843            }
13844        }
13845    };
13846    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
13847    /**Function with signature `setAllocationDelay(address,uint32)` and selector `0x56c483e6`.
13848    ```solidity
13849    function setAllocationDelay(address operator, uint32 delay) external;
13850    ```*/
13851    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13852    #[derive(Clone)]
13853    pub struct setAllocationDelayCall {
13854        #[allow(missing_docs)]
13855        pub operator: alloy::sol_types::private::Address,
13856        #[allow(missing_docs)]
13857        pub delay: u32,
13858    }
13859    ///Container type for the return parameters of the [`setAllocationDelay(address,uint32)`](setAllocationDelayCall) function.
13860    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13861    #[derive(Clone)]
13862    pub struct setAllocationDelayReturn {}
13863    #[allow(
13864        non_camel_case_types,
13865        non_snake_case,
13866        clippy::pub_underscore_fields,
13867        clippy::style
13868    )]
13869    const _: () = {
13870        use alloy::sol_types as alloy_sol_types;
13871        {
13872            #[doc(hidden)]
13873            type UnderlyingSolTuple<'a> = (
13874                alloy::sol_types::sol_data::Address,
13875                alloy::sol_types::sol_data::Uint<32>,
13876            );
13877            #[doc(hidden)]
13878            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address, u32);
13879            #[cfg(test)]
13880            #[allow(dead_code, unreachable_patterns)]
13881            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
13882                match _t {
13883                    alloy_sol_types::private::AssertTypeEq::<
13884                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13885                    >(_) => {}
13886                }
13887            }
13888            #[automatically_derived]
13889            #[doc(hidden)]
13890            impl ::core::convert::From<setAllocationDelayCall> for UnderlyingRustTuple<'_> {
13891                fn from(value: setAllocationDelayCall) -> Self {
13892                    (value.operator, value.delay)
13893                }
13894            }
13895            #[automatically_derived]
13896            #[doc(hidden)]
13897            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAllocationDelayCall {
13898                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13899                    Self {
13900                        operator: tuple.0,
13901                        delay: tuple.1,
13902                    }
13903                }
13904            }
13905        }
13906        {
13907            #[doc(hidden)]
13908            type UnderlyingSolTuple<'a> = ();
13909            #[doc(hidden)]
13910            type UnderlyingRustTuple<'a> = ();
13911            #[cfg(test)]
13912            #[allow(dead_code, unreachable_patterns)]
13913            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
13914                match _t {
13915                    alloy_sol_types::private::AssertTypeEq::<
13916                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
13917                    >(_) => {}
13918                }
13919            }
13920            #[automatically_derived]
13921            #[doc(hidden)]
13922            impl ::core::convert::From<setAllocationDelayReturn> for UnderlyingRustTuple<'_> {
13923                fn from(value: setAllocationDelayReturn) -> Self {
13924                    ()
13925                }
13926            }
13927            #[automatically_derived]
13928            #[doc(hidden)]
13929            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAllocationDelayReturn {
13930                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
13931                    Self {}
13932                }
13933            }
13934        }
13935        impl setAllocationDelayReturn {
13936            fn _tokenize(
13937                &self,
13938            ) -> <setAllocationDelayCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
13939                ()
13940            }
13941        }
13942        #[automatically_derived]
13943        impl alloy_sol_types::SolCall for setAllocationDelayCall {
13944            type Parameters<'a> = (
13945                alloy::sol_types::sol_data::Address,
13946                alloy::sol_types::sol_data::Uint<32>,
13947            );
13948            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
13949            type Return = setAllocationDelayReturn;
13950            type ReturnTuple<'a> = ();
13951            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
13952            const SIGNATURE: &'static str = "setAllocationDelay(address,uint32)";
13953            const SELECTOR: [u8; 4] = [86u8, 196u8, 131u8, 230u8];
13954            #[inline]
13955            fn new<'a>(
13956                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
13957            ) -> Self {
13958                tuple.into()
13959            }
13960            #[inline]
13961            fn tokenize(&self) -> Self::Token<'_> {
13962                (
13963                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
13964                        &self.operator,
13965                    ),
13966                    <alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
13967                        &self.delay,
13968                    ),
13969                )
13970            }
13971            #[inline]
13972            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
13973                setAllocationDelayReturn::_tokenize(ret)
13974            }
13975            #[inline]
13976            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
13977                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
13978                    .map(Into::into)
13979            }
13980            #[inline]
13981            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
13982                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
13983                    data,
13984                )
13985                .map(Into::into)
13986            }
13987        }
13988    };
13989    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
13990    /**Function with signature `slashOperator(address,(address,uint32,address[],uint256[],string))` and selector `0x36352057`.
13991    ```solidity
13992    function slashOperator(address avs, IAllocationManagerTypes.SlashingParams memory params) external;
13993    ```*/
13994    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
13995    #[derive(Clone)]
13996    pub struct slashOperatorCall {
13997        #[allow(missing_docs)]
13998        pub avs: alloy::sol_types::private::Address,
13999        #[allow(missing_docs)]
14000        pub params:
14001            <IAllocationManagerTypes::SlashingParams as alloy::sol_types::SolType>::RustType,
14002    }
14003    ///Container type for the return parameters of the [`slashOperator(address,(address,uint32,address[],uint256[],string))`](slashOperatorCall) function.
14004    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14005    #[derive(Clone)]
14006    pub struct slashOperatorReturn {}
14007    #[allow(
14008        non_camel_case_types,
14009        non_snake_case,
14010        clippy::pub_underscore_fields,
14011        clippy::style
14012    )]
14013    const _: () = {
14014        use alloy::sol_types as alloy_sol_types;
14015        {
14016            #[doc(hidden)]
14017            type UnderlyingSolTuple<'a> = (
14018                alloy::sol_types::sol_data::Address,
14019                IAllocationManagerTypes::SlashingParams,
14020            );
14021            #[doc(hidden)]
14022            type UnderlyingRustTuple<'a> = (
14023                alloy::sol_types::private::Address,
14024                <IAllocationManagerTypes::SlashingParams as alloy::sol_types::SolType>::RustType,
14025            );
14026            #[cfg(test)]
14027            #[allow(dead_code, unreachable_patterns)]
14028            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
14029                match _t {
14030                    alloy_sol_types::private::AssertTypeEq::<
14031                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14032                    >(_) => {}
14033                }
14034            }
14035            #[automatically_derived]
14036            #[doc(hidden)]
14037            impl ::core::convert::From<slashOperatorCall> for UnderlyingRustTuple<'_> {
14038                fn from(value: slashOperatorCall) -> Self {
14039                    (value.avs, value.params)
14040                }
14041            }
14042            #[automatically_derived]
14043            #[doc(hidden)]
14044            impl ::core::convert::From<UnderlyingRustTuple<'_>> for slashOperatorCall {
14045                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14046                    Self {
14047                        avs: tuple.0,
14048                        params: tuple.1,
14049                    }
14050                }
14051            }
14052        }
14053        {
14054            #[doc(hidden)]
14055            type UnderlyingSolTuple<'a> = ();
14056            #[doc(hidden)]
14057            type UnderlyingRustTuple<'a> = ();
14058            #[cfg(test)]
14059            #[allow(dead_code, unreachable_patterns)]
14060            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
14061                match _t {
14062                    alloy_sol_types::private::AssertTypeEq::<
14063                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14064                    >(_) => {}
14065                }
14066            }
14067            #[automatically_derived]
14068            #[doc(hidden)]
14069            impl ::core::convert::From<slashOperatorReturn> for UnderlyingRustTuple<'_> {
14070                fn from(value: slashOperatorReturn) -> Self {
14071                    ()
14072                }
14073            }
14074            #[automatically_derived]
14075            #[doc(hidden)]
14076            impl ::core::convert::From<UnderlyingRustTuple<'_>> for slashOperatorReturn {
14077                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14078                    Self {}
14079                }
14080            }
14081        }
14082        impl slashOperatorReturn {
14083            fn _tokenize(
14084                &self,
14085            ) -> <slashOperatorCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
14086                ()
14087            }
14088        }
14089        #[automatically_derived]
14090        impl alloy_sol_types::SolCall for slashOperatorCall {
14091            type Parameters<'a> = (
14092                alloy::sol_types::sol_data::Address,
14093                IAllocationManagerTypes::SlashingParams,
14094            );
14095            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
14096            type Return = slashOperatorReturn;
14097            type ReturnTuple<'a> = ();
14098            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
14099            const SIGNATURE: &'static str =
14100                "slashOperator(address,(address,uint32,address[],uint256[],string))";
14101            const SELECTOR: [u8; 4] = [54u8, 53u8, 32u8, 87u8];
14102            #[inline]
14103            fn new<'a>(
14104                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
14105            ) -> Self {
14106                tuple.into()
14107            }
14108            #[inline]
14109            fn tokenize(&self) -> Self::Token<'_> {
14110                (
14111                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
14112                        &self.avs,
14113                    ),
14114                    <IAllocationManagerTypes::SlashingParams as alloy_sol_types::SolType>::tokenize(
14115                        &self.params,
14116                    ),
14117                )
14118            }
14119            #[inline]
14120            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
14121                slashOperatorReturn::_tokenize(ret)
14122            }
14123            #[inline]
14124            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
14125                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
14126                    .map(Into::into)
14127            }
14128            #[inline]
14129            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
14130                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
14131                    data,
14132                )
14133                .map(Into::into)
14134            }
14135        }
14136    };
14137    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
14138    /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`.
14139    ```solidity
14140    function transferOwnership(address newOwner) external;
14141    ```*/
14142    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14143    #[derive(Clone)]
14144    pub struct transferOwnershipCall {
14145        #[allow(missing_docs)]
14146        pub newOwner: alloy::sol_types::private::Address,
14147    }
14148    ///Container type for the return parameters of the [`transferOwnership(address)`](transferOwnershipCall) function.
14149    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14150    #[derive(Clone)]
14151    pub struct transferOwnershipReturn {}
14152    #[allow(
14153        non_camel_case_types,
14154        non_snake_case,
14155        clippy::pub_underscore_fields,
14156        clippy::style
14157    )]
14158    const _: () = {
14159        use alloy::sol_types as alloy_sol_types;
14160        {
14161            #[doc(hidden)]
14162            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
14163            #[doc(hidden)]
14164            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
14165            #[cfg(test)]
14166            #[allow(dead_code, unreachable_patterns)]
14167            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
14168                match _t {
14169                    alloy_sol_types::private::AssertTypeEq::<
14170                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14171                    >(_) => {}
14172                }
14173            }
14174            #[automatically_derived]
14175            #[doc(hidden)]
14176            impl ::core::convert::From<transferOwnershipCall> for UnderlyingRustTuple<'_> {
14177                fn from(value: transferOwnershipCall) -> Self {
14178                    (value.newOwner,)
14179                }
14180            }
14181            #[automatically_derived]
14182            #[doc(hidden)]
14183            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferOwnershipCall {
14184                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14185                    Self { newOwner: tuple.0 }
14186                }
14187            }
14188        }
14189        {
14190            #[doc(hidden)]
14191            type UnderlyingSolTuple<'a> = ();
14192            #[doc(hidden)]
14193            type UnderlyingRustTuple<'a> = ();
14194            #[cfg(test)]
14195            #[allow(dead_code, unreachable_patterns)]
14196            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
14197                match _t {
14198                    alloy_sol_types::private::AssertTypeEq::<
14199                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14200                    >(_) => {}
14201                }
14202            }
14203            #[automatically_derived]
14204            #[doc(hidden)]
14205            impl ::core::convert::From<transferOwnershipReturn> for UnderlyingRustTuple<'_> {
14206                fn from(value: transferOwnershipReturn) -> Self {
14207                    ()
14208                }
14209            }
14210            #[automatically_derived]
14211            #[doc(hidden)]
14212            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferOwnershipReturn {
14213                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14214                    Self {}
14215                }
14216            }
14217        }
14218        impl transferOwnershipReturn {
14219            fn _tokenize(
14220                &self,
14221            ) -> <transferOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
14222                ()
14223            }
14224        }
14225        #[automatically_derived]
14226        impl alloy_sol_types::SolCall for transferOwnershipCall {
14227            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
14228            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
14229            type Return = transferOwnershipReturn;
14230            type ReturnTuple<'a> = ();
14231            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
14232            const SIGNATURE: &'static str = "transferOwnership(address)";
14233            const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
14234            #[inline]
14235            fn new<'a>(
14236                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
14237            ) -> Self {
14238                tuple.into()
14239            }
14240            #[inline]
14241            fn tokenize(&self) -> Self::Token<'_> {
14242                (
14243                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
14244                        &self.newOwner,
14245                    ),
14246                )
14247            }
14248            #[inline]
14249            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
14250                transferOwnershipReturn::_tokenize(ret)
14251            }
14252            #[inline]
14253            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
14254                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
14255                    .map(Into::into)
14256            }
14257            #[inline]
14258            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
14259                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
14260                    data,
14261                )
14262                .map(Into::into)
14263            }
14264        }
14265    };
14266    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
14267    /**Function with signature `unpause(uint256)` and selector `0xfabc1cbc`.
14268    ```solidity
14269    function unpause(uint256 newPausedStatus) external;
14270    ```*/
14271    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14272    #[derive(Clone)]
14273    pub struct unpauseCall {
14274        #[allow(missing_docs)]
14275        pub newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
14276    }
14277    ///Container type for the return parameters of the [`unpause(uint256)`](unpauseCall) function.
14278    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14279    #[derive(Clone)]
14280    pub struct unpauseReturn {}
14281    #[allow(
14282        non_camel_case_types,
14283        non_snake_case,
14284        clippy::pub_underscore_fields,
14285        clippy::style
14286    )]
14287    const _: () = {
14288        use alloy::sol_types as alloy_sol_types;
14289        {
14290            #[doc(hidden)]
14291            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
14292            #[doc(hidden)]
14293            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
14294            #[cfg(test)]
14295            #[allow(dead_code, unreachable_patterns)]
14296            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
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<unpauseCall> for UnderlyingRustTuple<'_> {
14306                fn from(value: unpauseCall) -> Self {
14307                    (value.newPausedStatus,)
14308                }
14309            }
14310            #[automatically_derived]
14311            #[doc(hidden)]
14312            impl ::core::convert::From<UnderlyingRustTuple<'_>> for unpauseCall {
14313                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14314                    Self {
14315                        newPausedStatus: tuple.0,
14316                    }
14317                }
14318            }
14319        }
14320        {
14321            #[doc(hidden)]
14322            type UnderlyingSolTuple<'a> = ();
14323            #[doc(hidden)]
14324            type UnderlyingRustTuple<'a> = ();
14325            #[cfg(test)]
14326            #[allow(dead_code, unreachable_patterns)]
14327            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
14328                match _t {
14329                    alloy_sol_types::private::AssertTypeEq::<
14330                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14331                    >(_) => {}
14332                }
14333            }
14334            #[automatically_derived]
14335            #[doc(hidden)]
14336            impl ::core::convert::From<unpauseReturn> for UnderlyingRustTuple<'_> {
14337                fn from(value: unpauseReturn) -> Self {
14338                    ()
14339                }
14340            }
14341            #[automatically_derived]
14342            #[doc(hidden)]
14343            impl ::core::convert::From<UnderlyingRustTuple<'_>> for unpauseReturn {
14344                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14345                    Self {}
14346                }
14347            }
14348        }
14349        impl unpauseReturn {
14350            fn _tokenize(&self) -> <unpauseCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
14351                ()
14352            }
14353        }
14354        #[automatically_derived]
14355        impl alloy_sol_types::SolCall for unpauseCall {
14356            type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
14357            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
14358            type Return = unpauseReturn;
14359            type ReturnTuple<'a> = ();
14360            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
14361            const SIGNATURE: &'static str = "unpause(uint256)";
14362            const SELECTOR: [u8; 4] = [250u8, 188u8, 28u8, 188u8];
14363            #[inline]
14364            fn new<'a>(
14365                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
14366            ) -> Self {
14367                tuple.into()
14368            }
14369            #[inline]
14370            fn tokenize(&self) -> Self::Token<'_> {
14371                (
14372                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
14373                        &self.newPausedStatus,
14374                    ),
14375                )
14376            }
14377            #[inline]
14378            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
14379                unpauseReturn::_tokenize(ret)
14380            }
14381            #[inline]
14382            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
14383                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
14384                    .map(Into::into)
14385            }
14386            #[inline]
14387            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
14388                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
14389                    data,
14390                )
14391                .map(Into::into)
14392            }
14393        }
14394    };
14395    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
14396    /**Function with signature `updateAVSMetadataURI(address,string)` and selector `0xa9821821`.
14397    ```solidity
14398    function updateAVSMetadataURI(address avs, string memory metadataURI) external;
14399    ```*/
14400    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14401    #[derive(Clone)]
14402    pub struct updateAVSMetadataURICall {
14403        #[allow(missing_docs)]
14404        pub avs: alloy::sol_types::private::Address,
14405        #[allow(missing_docs)]
14406        pub metadataURI: alloy::sol_types::private::String,
14407    }
14408    ///Container type for the return parameters of the [`updateAVSMetadataURI(address,string)`](updateAVSMetadataURICall) function.
14409    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14410    #[derive(Clone)]
14411    pub struct updateAVSMetadataURIReturn {}
14412    #[allow(
14413        non_camel_case_types,
14414        non_snake_case,
14415        clippy::pub_underscore_fields,
14416        clippy::style
14417    )]
14418    const _: () = {
14419        use alloy::sol_types as alloy_sol_types;
14420        {
14421            #[doc(hidden)]
14422            type UnderlyingSolTuple<'a> = (
14423                alloy::sol_types::sol_data::Address,
14424                alloy::sol_types::sol_data::String,
14425            );
14426            #[doc(hidden)]
14427            type UnderlyingRustTuple<'a> = (
14428                alloy::sol_types::private::Address,
14429                alloy::sol_types::private::String,
14430            );
14431            #[cfg(test)]
14432            #[allow(dead_code, unreachable_patterns)]
14433            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
14434                match _t {
14435                    alloy_sol_types::private::AssertTypeEq::<
14436                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14437                    >(_) => {}
14438                }
14439            }
14440            #[automatically_derived]
14441            #[doc(hidden)]
14442            impl ::core::convert::From<updateAVSMetadataURICall> for UnderlyingRustTuple<'_> {
14443                fn from(value: updateAVSMetadataURICall) -> Self {
14444                    (value.avs, value.metadataURI)
14445                }
14446            }
14447            #[automatically_derived]
14448            #[doc(hidden)]
14449            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateAVSMetadataURICall {
14450                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14451                    Self {
14452                        avs: tuple.0,
14453                        metadataURI: tuple.1,
14454                    }
14455                }
14456            }
14457        }
14458        {
14459            #[doc(hidden)]
14460            type UnderlyingSolTuple<'a> = ();
14461            #[doc(hidden)]
14462            type UnderlyingRustTuple<'a> = ();
14463            #[cfg(test)]
14464            #[allow(dead_code, unreachable_patterns)]
14465            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
14466                match _t {
14467                    alloy_sol_types::private::AssertTypeEq::<
14468                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14469                    >(_) => {}
14470                }
14471            }
14472            #[automatically_derived]
14473            #[doc(hidden)]
14474            impl ::core::convert::From<updateAVSMetadataURIReturn> for UnderlyingRustTuple<'_> {
14475                fn from(value: updateAVSMetadataURIReturn) -> Self {
14476                    ()
14477                }
14478            }
14479            #[automatically_derived]
14480            #[doc(hidden)]
14481            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateAVSMetadataURIReturn {
14482                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14483                    Self {}
14484                }
14485            }
14486        }
14487        impl updateAVSMetadataURIReturn {
14488            fn _tokenize(
14489                &self,
14490            ) -> <updateAVSMetadataURICall as alloy_sol_types::SolCall>::ReturnToken<'_>
14491            {
14492                ()
14493            }
14494        }
14495        #[automatically_derived]
14496        impl alloy_sol_types::SolCall for updateAVSMetadataURICall {
14497            type Parameters<'a> = (
14498                alloy::sol_types::sol_data::Address,
14499                alloy::sol_types::sol_data::String,
14500            );
14501            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
14502            type Return = updateAVSMetadataURIReturn;
14503            type ReturnTuple<'a> = ();
14504            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
14505            const SIGNATURE: &'static str = "updateAVSMetadataURI(address,string)";
14506            const SELECTOR: [u8; 4] = [169u8, 130u8, 24u8, 33u8];
14507            #[inline]
14508            fn new<'a>(
14509                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
14510            ) -> Self {
14511                tuple.into()
14512            }
14513            #[inline]
14514            fn tokenize(&self) -> Self::Token<'_> {
14515                (
14516                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
14517                        &self.avs,
14518                    ),
14519                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
14520                        &self.metadataURI,
14521                    ),
14522                )
14523            }
14524            #[inline]
14525            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
14526                updateAVSMetadataURIReturn::_tokenize(ret)
14527            }
14528            #[inline]
14529            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
14530                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
14531                    .map(Into::into)
14532            }
14533            #[inline]
14534            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
14535                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
14536                    data,
14537                )
14538                .map(Into::into)
14539            }
14540        }
14541    };
14542    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
14543    /**Function with signature `version()` and selector `0x54fd4d50`.
14544    ```solidity
14545    function version() external view returns (string memory);
14546    ```*/
14547    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14548    #[derive(Clone)]
14549    pub struct versionCall;
14550    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
14551    ///Container type for the return parameters of the [`version()`](versionCall) function.
14552    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
14553    #[derive(Clone)]
14554    pub struct versionReturn {
14555        #[allow(missing_docs)]
14556        pub _0: alloy::sol_types::private::String,
14557    }
14558    #[allow(
14559        non_camel_case_types,
14560        non_snake_case,
14561        clippy::pub_underscore_fields,
14562        clippy::style
14563    )]
14564    const _: () = {
14565        use alloy::sol_types as alloy_sol_types;
14566        {
14567            #[doc(hidden)]
14568            type UnderlyingSolTuple<'a> = ();
14569            #[doc(hidden)]
14570            type UnderlyingRustTuple<'a> = ();
14571            #[cfg(test)]
14572            #[allow(dead_code, unreachable_patterns)]
14573            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
14574                match _t {
14575                    alloy_sol_types::private::AssertTypeEq::<
14576                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14577                    >(_) => {}
14578                }
14579            }
14580            #[automatically_derived]
14581            #[doc(hidden)]
14582            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
14583                fn from(value: versionCall) -> Self {
14584                    ()
14585                }
14586            }
14587            #[automatically_derived]
14588            #[doc(hidden)]
14589            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
14590                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14591                    Self
14592                }
14593            }
14594        }
14595        {
14596            #[doc(hidden)]
14597            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
14598            #[doc(hidden)]
14599            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
14600            #[cfg(test)]
14601            #[allow(dead_code, unreachable_patterns)]
14602            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
14603                match _t {
14604                    alloy_sol_types::private::AssertTypeEq::<
14605                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
14606                    >(_) => {}
14607                }
14608            }
14609            #[automatically_derived]
14610            #[doc(hidden)]
14611            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
14612                fn from(value: versionReturn) -> Self {
14613                    (value._0,)
14614                }
14615            }
14616            #[automatically_derived]
14617            #[doc(hidden)]
14618            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
14619                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
14620                    Self { _0: tuple.0 }
14621                }
14622            }
14623        }
14624        #[automatically_derived]
14625        impl alloy_sol_types::SolCall for versionCall {
14626            type Parameters<'a> = ();
14627            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
14628            type Return = alloy::sol_types::private::String;
14629            type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
14630            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
14631            const SIGNATURE: &'static str = "version()";
14632            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
14633            #[inline]
14634            fn new<'a>(
14635                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
14636            ) -> Self {
14637                tuple.into()
14638            }
14639            #[inline]
14640            fn tokenize(&self) -> Self::Token<'_> {
14641                ()
14642            }
14643            #[inline]
14644            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
14645                (<alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
14646            }
14647            #[inline]
14648            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
14649                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
14650                    |r| {
14651                        let r: versionReturn = r.into();
14652                        r._0
14653                    },
14654                )
14655            }
14656            #[inline]
14657            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
14658                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
14659                    data,
14660                )
14661                .map(|r| {
14662                    let r: versionReturn = r.into();
14663                    r._0
14664                })
14665            }
14666        }
14667    };
14668    ///Container for all the [`AllocationManager`](self) function calls.
14669    #[derive(serde::Serialize, serde::Deserialize)]
14670    pub enum AllocationManagerCalls {
14671        #[allow(missing_docs)]
14672        ALLOCATION_CONFIGURATION_DELAY(ALLOCATION_CONFIGURATION_DELAYCall),
14673        #[allow(missing_docs)]
14674        DEALLOCATION_DELAY(DEALLOCATION_DELAYCall),
14675        #[allow(missing_docs)]
14676        addStrategiesToOperatorSet(addStrategiesToOperatorSetCall),
14677        #[allow(missing_docs)]
14678        clearDeallocationQueue(clearDeallocationQueueCall),
14679        #[allow(missing_docs)]
14680        createOperatorSets(createOperatorSetsCall),
14681        #[allow(missing_docs)]
14682        delegation(delegationCall),
14683        #[allow(missing_docs)]
14684        deregisterFromOperatorSets(deregisterFromOperatorSetsCall),
14685        #[allow(missing_docs)]
14686        getAVSRegistrar(getAVSRegistrarCall),
14687        #[allow(missing_docs)]
14688        getAllocatableMagnitude(getAllocatableMagnitudeCall),
14689        #[allow(missing_docs)]
14690        getAllocatedSets(getAllocatedSetsCall),
14691        #[allow(missing_docs)]
14692        getAllocatedStake(getAllocatedStakeCall),
14693        #[allow(missing_docs)]
14694        getAllocatedStrategies(getAllocatedStrategiesCall),
14695        #[allow(missing_docs)]
14696        getAllocation(getAllocationCall),
14697        #[allow(missing_docs)]
14698        getAllocationDelay(getAllocationDelayCall),
14699        #[allow(missing_docs)]
14700        getAllocations(getAllocationsCall),
14701        #[allow(missing_docs)]
14702        getEncumberedMagnitude(getEncumberedMagnitudeCall),
14703        #[allow(missing_docs)]
14704        getMaxMagnitude(getMaxMagnitudeCall),
14705        #[allow(missing_docs)]
14706        getMaxMagnitudes_0(getMaxMagnitudes_0Call),
14707        #[allow(missing_docs)]
14708        getMaxMagnitudes_1(getMaxMagnitudes_1Call),
14709        #[allow(missing_docs)]
14710        getMaxMagnitudesAtBlock(getMaxMagnitudesAtBlockCall),
14711        #[allow(missing_docs)]
14712        getMemberCount(getMemberCountCall),
14713        #[allow(missing_docs)]
14714        getMembers(getMembersCall),
14715        #[allow(missing_docs)]
14716        getMinimumSlashableStake(getMinimumSlashableStakeCall),
14717        #[allow(missing_docs)]
14718        getOperatorSetCount(getOperatorSetCountCall),
14719        #[allow(missing_docs)]
14720        getRegisteredSets(getRegisteredSetsCall),
14721        #[allow(missing_docs)]
14722        getStrategiesInOperatorSet(getStrategiesInOperatorSetCall),
14723        #[allow(missing_docs)]
14724        getStrategyAllocations(getStrategyAllocationsCall),
14725        #[allow(missing_docs)]
14726        initialize(initializeCall),
14727        #[allow(missing_docs)]
14728        isMemberOfOperatorSet(isMemberOfOperatorSetCall),
14729        #[allow(missing_docs)]
14730        isOperatorSet(isOperatorSetCall),
14731        #[allow(missing_docs)]
14732        isOperatorSlashable(isOperatorSlashableCall),
14733        #[allow(missing_docs)]
14734        modifyAllocations(modifyAllocationsCall),
14735        #[allow(missing_docs)]
14736        owner(ownerCall),
14737        #[allow(missing_docs)]
14738        pause(pauseCall),
14739        #[allow(missing_docs)]
14740        pauseAll(pauseAllCall),
14741        #[allow(missing_docs)]
14742        paused_0(paused_0Call),
14743        #[allow(missing_docs)]
14744        paused_1(paused_1Call),
14745        #[allow(missing_docs)]
14746        pauserRegistry(pauserRegistryCall),
14747        #[allow(missing_docs)]
14748        permissionController(permissionControllerCall),
14749        #[allow(missing_docs)]
14750        registerForOperatorSets(registerForOperatorSetsCall),
14751        #[allow(missing_docs)]
14752        removeStrategiesFromOperatorSet(removeStrategiesFromOperatorSetCall),
14753        #[allow(missing_docs)]
14754        renounceOwnership(renounceOwnershipCall),
14755        #[allow(missing_docs)]
14756        setAVSRegistrar(setAVSRegistrarCall),
14757        #[allow(missing_docs)]
14758        setAllocationDelay(setAllocationDelayCall),
14759        #[allow(missing_docs)]
14760        slashOperator(slashOperatorCall),
14761        #[allow(missing_docs)]
14762        transferOwnership(transferOwnershipCall),
14763        #[allow(missing_docs)]
14764        unpause(unpauseCall),
14765        #[allow(missing_docs)]
14766        updateAVSMetadataURI(updateAVSMetadataURICall),
14767        #[allow(missing_docs)]
14768        version(versionCall),
14769    }
14770    #[automatically_derived]
14771    impl AllocationManagerCalls {
14772        /// All the selectors of this enum.
14773        ///
14774        /// Note that the selectors might not be in the same order as the variants.
14775        /// No guarantees are made about the order of the selectors.
14776        ///
14777        /// Prefer using `SolInterface` methods instead.
14778        pub const SELECTORS: &'static [[u8; 4usize]] = &[
14779            [16u8, 225u8, 185u8, 184u8],
14780            [19u8, 82u8, 195u8, 230u8],
14781            [19u8, 100u8, 57u8, 221u8],
14782            [21u8, 254u8, 80u8, 40u8],
14783            [38u8, 13u8, 199u8, 88u8],
14784            [38u8, 31u8, 132u8, 224u8],
14785            [41u8, 129u8, 235u8, 119u8],
14786            [43u8, 69u8, 58u8, 154u8],
14787            [43u8, 171u8, 44u8, 74u8],
14788            [48u8, 76u8, 16u8, 205u8],
14789            [54u8, 53u8, 32u8, 87u8],
14790            [64u8, 18u8, 13u8, 171u8],
14791            [65u8, 119u8, 168u8, 124u8],
14792            [70u8, 87u8, 226u8, 106u8],
14793            [74u8, 16u8, 255u8, 229u8],
14794            [75u8, 80u8, 70u8, 239u8],
14795            [80u8, 254u8, 234u8, 32u8],
14796            [84u8, 122u8, 251u8, 135u8],
14797            [84u8, 253u8, 77u8, 80u8],
14798            [86u8, 196u8, 131u8, 230u8],
14799            [89u8, 92u8, 106u8, 103u8],
14800            [90u8, 200u8, 106u8, 183u8],
14801            [92u8, 151u8, 90u8, 187u8],
14802            [103u8, 13u8, 59u8, 162u8],
14803            [108u8, 251u8, 68u8, 129u8],
14804            [110u8, 52u8, 146u8, 181u8],
14805            [110u8, 135u8, 93u8, 186u8],
14806            [113u8, 80u8, 24u8, 166u8],
14807            [121u8, 174u8, 80u8, 205u8],
14808            [123u8, 193u8, 239u8, 97u8],
14809            [136u8, 111u8, 17u8, 149u8],
14810            [140u8, 230u8, 72u8, 84u8],
14811            [141u8, 165u8, 203u8, 91u8],
14812            [148u8, 215u8, 208u8, 12u8],
14813            [149u8, 40u8, 153u8, 238u8],
14814            [169u8, 51u8, 62u8, 200u8],
14815            [169u8, 130u8, 24u8, 33u8],
14816            [173u8, 194u8, 227u8, 217u8],
14817            [178u8, 68u8, 122u8, 247u8],
14818            [182u8, 107u8, 217u8, 137u8],
14819            [185u8, 251u8, 174u8, 209u8],
14820            [186u8, 26u8, 132u8, 229u8],
14821            [194u8, 33u8, 216u8, 174u8],
14822            [205u8, 109u8, 198u8, 135u8],
14823            [211u8, 217u8, 111u8, 244u8],
14824            [223u8, 92u8, 247u8, 35u8],
14825            [242u8, 253u8, 227u8, 139u8],
14826            [246u8, 5u8, 206u8, 8u8],
14827            [250u8, 188u8, 28u8, 188u8],
14828        ];
14829    }
14830    #[automatically_derived]
14831    impl alloy_sol_types::SolInterface for AllocationManagerCalls {
14832        const NAME: &'static str = "AllocationManagerCalls";
14833        const MIN_DATA_LENGTH: usize = 0usize;
14834        const COUNT: usize = 49usize;
14835        #[inline]
14836        fn selector(&self) -> [u8; 4] {
14837            match self {
14838                Self::ALLOCATION_CONFIGURATION_DELAY(_) => {
14839                    <ALLOCATION_CONFIGURATION_DELAYCall as alloy_sol_types::SolCall>::SELECTOR
14840                }
14841                Self::DEALLOCATION_DELAY(_) => {
14842                    <DEALLOCATION_DELAYCall as alloy_sol_types::SolCall>::SELECTOR
14843                }
14844                Self::addStrategiesToOperatorSet(_) => {
14845                    <addStrategiesToOperatorSetCall as alloy_sol_types::SolCall>::SELECTOR
14846                }
14847                Self::clearDeallocationQueue(_) => {
14848                    <clearDeallocationQueueCall as alloy_sol_types::SolCall>::SELECTOR
14849                }
14850                Self::createOperatorSets(_) => {
14851                    <createOperatorSetsCall as alloy_sol_types::SolCall>::SELECTOR
14852                }
14853                Self::delegation(_) => <delegationCall as alloy_sol_types::SolCall>::SELECTOR,
14854                Self::deregisterFromOperatorSets(_) => {
14855                    <deregisterFromOperatorSetsCall as alloy_sol_types::SolCall>::SELECTOR
14856                }
14857                Self::getAVSRegistrar(_) => {
14858                    <getAVSRegistrarCall as alloy_sol_types::SolCall>::SELECTOR
14859                }
14860                Self::getAllocatableMagnitude(_) => {
14861                    <getAllocatableMagnitudeCall as alloy_sol_types::SolCall>::SELECTOR
14862                }
14863                Self::getAllocatedSets(_) => {
14864                    <getAllocatedSetsCall as alloy_sol_types::SolCall>::SELECTOR
14865                }
14866                Self::getAllocatedStake(_) => {
14867                    <getAllocatedStakeCall as alloy_sol_types::SolCall>::SELECTOR
14868                }
14869                Self::getAllocatedStrategies(_) => {
14870                    <getAllocatedStrategiesCall as alloy_sol_types::SolCall>::SELECTOR
14871                }
14872                Self::getAllocation(_) => <getAllocationCall as alloy_sol_types::SolCall>::SELECTOR,
14873                Self::getAllocationDelay(_) => {
14874                    <getAllocationDelayCall as alloy_sol_types::SolCall>::SELECTOR
14875                }
14876                Self::getAllocations(_) => {
14877                    <getAllocationsCall as alloy_sol_types::SolCall>::SELECTOR
14878                }
14879                Self::getEncumberedMagnitude(_) => {
14880                    <getEncumberedMagnitudeCall as alloy_sol_types::SolCall>::SELECTOR
14881                }
14882                Self::getMaxMagnitude(_) => {
14883                    <getMaxMagnitudeCall as alloy_sol_types::SolCall>::SELECTOR
14884                }
14885                Self::getMaxMagnitudes_0(_) => {
14886                    <getMaxMagnitudes_0Call as alloy_sol_types::SolCall>::SELECTOR
14887                }
14888                Self::getMaxMagnitudes_1(_) => {
14889                    <getMaxMagnitudes_1Call as alloy_sol_types::SolCall>::SELECTOR
14890                }
14891                Self::getMaxMagnitudesAtBlock(_) => {
14892                    <getMaxMagnitudesAtBlockCall as alloy_sol_types::SolCall>::SELECTOR
14893                }
14894                Self::getMemberCount(_) => {
14895                    <getMemberCountCall as alloy_sol_types::SolCall>::SELECTOR
14896                }
14897                Self::getMembers(_) => <getMembersCall as alloy_sol_types::SolCall>::SELECTOR,
14898                Self::getMinimumSlashableStake(_) => {
14899                    <getMinimumSlashableStakeCall as alloy_sol_types::SolCall>::SELECTOR
14900                }
14901                Self::getOperatorSetCount(_) => {
14902                    <getOperatorSetCountCall as alloy_sol_types::SolCall>::SELECTOR
14903                }
14904                Self::getRegisteredSets(_) => {
14905                    <getRegisteredSetsCall as alloy_sol_types::SolCall>::SELECTOR
14906                }
14907                Self::getStrategiesInOperatorSet(_) => {
14908                    <getStrategiesInOperatorSetCall as alloy_sol_types::SolCall>::SELECTOR
14909                }
14910                Self::getStrategyAllocations(_) => {
14911                    <getStrategyAllocationsCall as alloy_sol_types::SolCall>::SELECTOR
14912                }
14913                Self::initialize(_) => <initializeCall as alloy_sol_types::SolCall>::SELECTOR,
14914                Self::isMemberOfOperatorSet(_) => {
14915                    <isMemberOfOperatorSetCall as alloy_sol_types::SolCall>::SELECTOR
14916                }
14917                Self::isOperatorSet(_) => <isOperatorSetCall as alloy_sol_types::SolCall>::SELECTOR,
14918                Self::isOperatorSlashable(_) => {
14919                    <isOperatorSlashableCall as alloy_sol_types::SolCall>::SELECTOR
14920                }
14921                Self::modifyAllocations(_) => {
14922                    <modifyAllocationsCall as alloy_sol_types::SolCall>::SELECTOR
14923                }
14924                Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
14925                Self::pause(_) => <pauseCall as alloy_sol_types::SolCall>::SELECTOR,
14926                Self::pauseAll(_) => <pauseAllCall as alloy_sol_types::SolCall>::SELECTOR,
14927                Self::paused_0(_) => <paused_0Call as alloy_sol_types::SolCall>::SELECTOR,
14928                Self::paused_1(_) => <paused_1Call as alloy_sol_types::SolCall>::SELECTOR,
14929                Self::pauserRegistry(_) => {
14930                    <pauserRegistryCall as alloy_sol_types::SolCall>::SELECTOR
14931                }
14932                Self::permissionController(_) => {
14933                    <permissionControllerCall as alloy_sol_types::SolCall>::SELECTOR
14934                }
14935                Self::registerForOperatorSets(_) => {
14936                    <registerForOperatorSetsCall as alloy_sol_types::SolCall>::SELECTOR
14937                }
14938                Self::removeStrategiesFromOperatorSet(_) => {
14939                    <removeStrategiesFromOperatorSetCall as alloy_sol_types::SolCall>::SELECTOR
14940                }
14941                Self::renounceOwnership(_) => {
14942                    <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
14943                }
14944                Self::setAVSRegistrar(_) => {
14945                    <setAVSRegistrarCall as alloy_sol_types::SolCall>::SELECTOR
14946                }
14947                Self::setAllocationDelay(_) => {
14948                    <setAllocationDelayCall as alloy_sol_types::SolCall>::SELECTOR
14949                }
14950                Self::slashOperator(_) => <slashOperatorCall as alloy_sol_types::SolCall>::SELECTOR,
14951                Self::transferOwnership(_) => {
14952                    <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
14953                }
14954                Self::unpause(_) => <unpauseCall as alloy_sol_types::SolCall>::SELECTOR,
14955                Self::updateAVSMetadataURI(_) => {
14956                    <updateAVSMetadataURICall as alloy_sol_types::SolCall>::SELECTOR
14957                }
14958                Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
14959            }
14960        }
14961        #[inline]
14962        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
14963            Self::SELECTORS.get(i).copied()
14964        }
14965        #[inline]
14966        fn valid_selector(selector: [u8; 4]) -> bool {
14967            Self::SELECTORS.binary_search(&selector).is_ok()
14968        }
14969        #[inline]
14970        #[allow(non_snake_case)]
14971        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
14972            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<AllocationManagerCalls>] =
14973                &[
14974                    {
14975                        fn getAllocation(
14976                            data: &[u8],
14977                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
14978                        {
14979                            <getAllocationCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
14980                                .map(AllocationManagerCalls::getAllocation)
14981                        }
14982                        getAllocation
14983                    },
14984                    {
14985                        fn isOperatorSlashable(
14986                            data: &[u8],
14987                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
14988                        {
14989                            <isOperatorSlashableCall as alloy_sol_types::SolCall>::abi_decode_raw(
14990                                data,
14991                            )
14992                            .map(AllocationManagerCalls::isOperatorSlashable)
14993                        }
14994                        isOperatorSlashable
14995                    },
14996                    {
14997                        fn pause(data: &[u8]) -> alloy_sol_types::Result<AllocationManagerCalls> {
14998                            <pauseCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
14999                                .map(AllocationManagerCalls::pause)
15000                        }
15001                        pause
15002                    },
15003                    {
15004                        fn getAllocatedSets(
15005                            data: &[u8],
15006                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15007                        {
15008                            <getAllocatedSetsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
15009                                .map(AllocationManagerCalls::getAllocatedSets)
15010                        }
15011                        getAllocatedSets
15012                    },
15013                    {
15014                        fn isOperatorSet(
15015                            data: &[u8],
15016                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15017                        {
15018                            <isOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
15019                                .map(AllocationManagerCalls::isOperatorSet)
15020                        }
15021                        isOperatorSet
15022                    },
15023                    {
15024                        fn createOperatorSets(
15025                            data: &[u8],
15026                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15027                        {
15028                            <createOperatorSetsCall as alloy_sol_types::SolCall>::abi_decode_raw(
15029                                data,
15030                            )
15031                            .map(AllocationManagerCalls::createOperatorSets)
15032                        }
15033                        createOperatorSets
15034                    },
15035                    {
15036                        fn DEALLOCATION_DELAY(
15037                            data: &[u8],
15038                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15039                        {
15040                            <DEALLOCATION_DELAYCall as alloy_sol_types::SolCall>::abi_decode_raw(
15041                                data,
15042                            )
15043                            .map(AllocationManagerCalls::DEALLOCATION_DELAY)
15044                        }
15045                        DEALLOCATION_DELAY
15046                    },
15047                    {
15048                        fn getAllocatedStake(
15049                            data: &[u8],
15050                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15051                        {
15052                            <getAllocatedStakeCall as alloy_sol_types::SolCall>::abi_decode_raw(
15053                                data,
15054                            )
15055                            .map(AllocationManagerCalls::getAllocatedStake)
15056                        }
15057                        getAllocatedStake
15058                    },
15059                    {
15060                        fn getMinimumSlashableStake(
15061                            data: &[u8],
15062                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15063                        {
15064                            <getMinimumSlashableStakeCall as alloy_sol_types::SolCall>::abi_decode_raw(
15065                                data,
15066                            )
15067                            .map(AllocationManagerCalls::getMinimumSlashableStake)
15068                        }
15069                        getMinimumSlashableStake
15070                    },
15071                    {
15072                        fn getAVSRegistrar(
15073                            data: &[u8],
15074                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15075                        {
15076                            <getAVSRegistrarCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
15077                                .map(AllocationManagerCalls::getAVSRegistrar)
15078                        }
15079                        getAVSRegistrar
15080                    },
15081                    {
15082                        fn slashOperator(
15083                            data: &[u8],
15084                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15085                        {
15086                            <slashOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
15087                                .map(AllocationManagerCalls::slashOperator)
15088                        }
15089                        slashOperator
15090                    },
15091                    {
15092                        fn getStrategyAllocations(
15093                            data: &[u8],
15094                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15095                        {
15096                            <getStrategyAllocationsCall as alloy_sol_types::SolCall>::abi_decode_raw(
15097                                data,
15098                            )
15099                            .map(AllocationManagerCalls::getStrategyAllocations)
15100                        }
15101                        getStrategyAllocations
15102                    },
15103                    {
15104                        fn getStrategiesInOperatorSet(
15105                            data: &[u8],
15106                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15107                        {
15108                            <getStrategiesInOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw(
15109                                data,
15110                            )
15111                            .map(AllocationManagerCalls::getStrategiesInOperatorSet)
15112                        }
15113                        getStrategiesInOperatorSet
15114                    },
15115                    {
15116                        fn permissionController(
15117                            data: &[u8],
15118                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15119                        {
15120                            <permissionControllerCall as alloy_sol_types::SolCall>::abi_decode_raw(
15121                                data,
15122                            )
15123                            .map(AllocationManagerCalls::permissionController)
15124                        }
15125                        permissionController
15126                    },
15127                    {
15128                        fn getMaxMagnitudes_0(
15129                            data: &[u8],
15130                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15131                        {
15132                            <getMaxMagnitudes_0Call as alloy_sol_types::SolCall>::abi_decode_raw(
15133                                data,
15134                            )
15135                            .map(AllocationManagerCalls::getMaxMagnitudes_0)
15136                        }
15137                        getMaxMagnitudes_0
15138                    },
15139                    {
15140                        fn clearDeallocationQueue(
15141                            data: &[u8],
15142                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15143                        {
15144                            <clearDeallocationQueueCall as alloy_sol_types::SolCall>::abi_decode_raw(
15145                                data,
15146                            )
15147                            .map(AllocationManagerCalls::clearDeallocationQueue)
15148                        }
15149                        clearDeallocationQueue
15150                    },
15151                    {
15152                        fn addStrategiesToOperatorSet(
15153                            data: &[u8],
15154                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15155                        {
15156                            <addStrategiesToOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw(
15157                                data,
15158                            )
15159                            .map(AllocationManagerCalls::addStrategiesToOperatorSet)
15160                        }
15161                        addStrategiesToOperatorSet
15162                    },
15163                    {
15164                        fn getMaxMagnitudes_1(
15165                            data: &[u8],
15166                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15167                        {
15168                            <getMaxMagnitudes_1Call as alloy_sol_types::SolCall>::abi_decode_raw(
15169                                data,
15170                            )
15171                            .map(AllocationManagerCalls::getMaxMagnitudes_1)
15172                        }
15173                        getMaxMagnitudes_1
15174                    },
15175                    {
15176                        fn version(data: &[u8]) -> alloy_sol_types::Result<AllocationManagerCalls> {
15177                            <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
15178                                .map(AllocationManagerCalls::version)
15179                        }
15180                        version
15181                    },
15182                    {
15183                        fn setAllocationDelay(
15184                            data: &[u8],
15185                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15186                        {
15187                            <setAllocationDelayCall as alloy_sol_types::SolCall>::abi_decode_raw(
15188                                data,
15189                            )
15190                            .map(AllocationManagerCalls::setAllocationDelay)
15191                        }
15192                        setAllocationDelay
15193                    },
15194                    {
15195                        fn pauseAll(
15196                            data: &[u8],
15197                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15198                        {
15199                            <pauseAllCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
15200                                .map(AllocationManagerCalls::pauseAll)
15201                        }
15202                        pauseAll
15203                    },
15204                    {
15205                        fn paused_0(
15206                            data: &[u8],
15207                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15208                        {
15209                            <paused_0Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
15210                                .map(AllocationManagerCalls::paused_0)
15211                        }
15212                        paused_0
15213                    },
15214                    {
15215                        fn paused_1(
15216                            data: &[u8],
15217                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15218                        {
15219                            <paused_1Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
15220                                .map(AllocationManagerCalls::paused_1)
15221                        }
15222                        paused_1
15223                    },
15224                    {
15225                        fn isMemberOfOperatorSet(
15226                            data: &[u8],
15227                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15228                        {
15229                            <isMemberOfOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw(
15230                                data,
15231                            )
15232                            .map(AllocationManagerCalls::isMemberOfOperatorSet)
15233                        }
15234                        isMemberOfOperatorSet
15235                    },
15236                    {
15237                        fn getAllocatableMagnitude(
15238                            data: &[u8],
15239                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15240                        {
15241                            <getAllocatableMagnitudeCall as alloy_sol_types::SolCall>::abi_decode_raw(
15242                                data,
15243                            )
15244                            .map(AllocationManagerCalls::getAllocatableMagnitude)
15245                        }
15246                        getAllocatableMagnitude
15247                    },
15248                    {
15249                        fn deregisterFromOperatorSets(
15250                            data: &[u8],
15251                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15252                        {
15253                            <deregisterFromOperatorSetsCall as alloy_sol_types::SolCall>::abi_decode_raw(
15254                                data,
15255                            )
15256                            .map(AllocationManagerCalls::deregisterFromOperatorSets)
15257                        }
15258                        deregisterFromOperatorSets
15259                    },
15260                    {
15261                        fn getMembers(
15262                            data: &[u8],
15263                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15264                        {
15265                            <getMembersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
15266                                .map(AllocationManagerCalls::getMembers)
15267                        }
15268                        getMembers
15269                    },
15270                    {
15271                        fn renounceOwnership(
15272                            data: &[u8],
15273                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15274                        {
15275                            <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
15276                                data,
15277                            )
15278                            .map(AllocationManagerCalls::renounceOwnership)
15279                        }
15280                        renounceOwnership
15281                    },
15282                    {
15283                        fn getRegisteredSets(
15284                            data: &[u8],
15285                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15286                        {
15287                            <getRegisteredSetsCall as alloy_sol_types::SolCall>::abi_decode_raw(
15288                                data,
15289                            )
15290                            .map(AllocationManagerCalls::getRegisteredSets)
15291                        }
15292                        getRegisteredSets
15293                    },
15294                    {
15295                        fn ALLOCATION_CONFIGURATION_DELAY(
15296                            data: &[u8],
15297                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15298                        {
15299                            <ALLOCATION_CONFIGURATION_DELAYCall as alloy_sol_types::SolCall>::abi_decode_raw(
15300                                data,
15301                            )
15302                            .map(AllocationManagerCalls::ALLOCATION_CONFIGURATION_DELAY)
15303                        }
15304                        ALLOCATION_CONFIGURATION_DELAY
15305                    },
15306                    {
15307                        fn pauserRegistry(
15308                            data: &[u8],
15309                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15310                        {
15311                            <pauserRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
15312                                .map(AllocationManagerCalls::pauserRegistry)
15313                        }
15314                        pauserRegistry
15315                    },
15316                    {
15317                        fn getAllocations(
15318                            data: &[u8],
15319                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15320                        {
15321                            <getAllocationsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
15322                                .map(AllocationManagerCalls::getAllocations)
15323                        }
15324                        getAllocations
15325                    },
15326                    {
15327                        fn owner(data: &[u8]) -> alloy_sol_types::Result<AllocationManagerCalls> {
15328                            <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
15329                                .map(AllocationManagerCalls::owner)
15330                        }
15331                        owner
15332                    },
15333                    {
15334                        fn getMaxMagnitudesAtBlock(
15335                            data: &[u8],
15336                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15337                        {
15338                            <getMaxMagnitudesAtBlockCall as alloy_sol_types::SolCall>::abi_decode_raw(
15339                                data,
15340                            )
15341                            .map(AllocationManagerCalls::getMaxMagnitudesAtBlock)
15342                        }
15343                        getMaxMagnitudesAtBlock
15344                    },
15345                    {
15346                        fn modifyAllocations(
15347                            data: &[u8],
15348                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15349                        {
15350                            <modifyAllocationsCall as alloy_sol_types::SolCall>::abi_decode_raw(
15351                                data,
15352                            )
15353                            .map(AllocationManagerCalls::modifyAllocations)
15354                        }
15355                        modifyAllocations
15356                    },
15357                    {
15358                        fn getMaxMagnitude(
15359                            data: &[u8],
15360                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15361                        {
15362                            <getMaxMagnitudeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
15363                                .map(AllocationManagerCalls::getMaxMagnitude)
15364                        }
15365                        getMaxMagnitude
15366                    },
15367                    {
15368                        fn updateAVSMetadataURI(
15369                            data: &[u8],
15370                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15371                        {
15372                            <updateAVSMetadataURICall as alloy_sol_types::SolCall>::abi_decode_raw(
15373                                data,
15374                            )
15375                            .map(AllocationManagerCalls::updateAVSMetadataURI)
15376                        }
15377                        updateAVSMetadataURI
15378                    },
15379                    {
15380                        fn registerForOperatorSets(
15381                            data: &[u8],
15382                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15383                        {
15384                            <registerForOperatorSetsCall as alloy_sol_types::SolCall>::abi_decode_raw(
15385                                data,
15386                            )
15387                            .map(AllocationManagerCalls::registerForOperatorSets)
15388                        }
15389                        registerForOperatorSets
15390                    },
15391                    {
15392                        fn getMemberCount(
15393                            data: &[u8],
15394                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15395                        {
15396                            <getMemberCountCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
15397                                .map(AllocationManagerCalls::getMemberCount)
15398                        }
15399                        getMemberCount
15400                    },
15401                    {
15402                        fn removeStrategiesFromOperatorSet(
15403                            data: &[u8],
15404                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15405                        {
15406                            <removeStrategiesFromOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw(
15407                                data,
15408                            )
15409                            .map(AllocationManagerCalls::removeStrategiesFromOperatorSet)
15410                        }
15411                        removeStrategiesFromOperatorSet
15412                    },
15413                    {
15414                        fn getAllocationDelay(
15415                            data: &[u8],
15416                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15417                        {
15418                            <getAllocationDelayCall as alloy_sol_types::SolCall>::abi_decode_raw(
15419                                data,
15420                            )
15421                            .map(AllocationManagerCalls::getAllocationDelay)
15422                        }
15423                        getAllocationDelay
15424                    },
15425                    {
15426                        fn getOperatorSetCount(
15427                            data: &[u8],
15428                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15429                        {
15430                            <getOperatorSetCountCall as alloy_sol_types::SolCall>::abi_decode_raw(
15431                                data,
15432                            )
15433                            .map(AllocationManagerCalls::getOperatorSetCount)
15434                        }
15435                        getOperatorSetCount
15436                    },
15437                    {
15438                        fn getAllocatedStrategies(
15439                            data: &[u8],
15440                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15441                        {
15442                            <getAllocatedStrategiesCall as alloy_sol_types::SolCall>::abi_decode_raw(
15443                                data,
15444                            )
15445                            .map(AllocationManagerCalls::getAllocatedStrategies)
15446                        }
15447                        getAllocatedStrategies
15448                    },
15449                    {
15450                        fn initialize(
15451                            data: &[u8],
15452                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15453                        {
15454                            <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
15455                                .map(AllocationManagerCalls::initialize)
15456                        }
15457                        initialize
15458                    },
15459                    {
15460                        fn setAVSRegistrar(
15461                            data: &[u8],
15462                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15463                        {
15464                            <setAVSRegistrarCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
15465                                .map(AllocationManagerCalls::setAVSRegistrar)
15466                        }
15467                        setAVSRegistrar
15468                    },
15469                    {
15470                        fn delegation(
15471                            data: &[u8],
15472                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15473                        {
15474                            <delegationCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
15475                                .map(AllocationManagerCalls::delegation)
15476                        }
15477                        delegation
15478                    },
15479                    {
15480                        fn transferOwnership(
15481                            data: &[u8],
15482                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15483                        {
15484                            <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
15485                                data,
15486                            )
15487                            .map(AllocationManagerCalls::transferOwnership)
15488                        }
15489                        transferOwnership
15490                    },
15491                    {
15492                        fn getEncumberedMagnitude(
15493                            data: &[u8],
15494                        ) -> alloy_sol_types::Result<AllocationManagerCalls>
15495                        {
15496                            <getEncumberedMagnitudeCall as alloy_sol_types::SolCall>::abi_decode_raw(
15497                                data,
15498                            )
15499                            .map(AllocationManagerCalls::getEncumberedMagnitude)
15500                        }
15501                        getEncumberedMagnitude
15502                    },
15503                    {
15504                        fn unpause(data: &[u8]) -> alloy_sol_types::Result<AllocationManagerCalls> {
15505                            <unpauseCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
15506                                .map(AllocationManagerCalls::unpause)
15507                        }
15508                        unpause
15509                    },
15510                ];
15511            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
15512                return Err(alloy_sol_types::Error::unknown_selector(
15513                    <Self as alloy_sol_types::SolInterface>::NAME,
15514                    selector,
15515                ));
15516            };
15517            DECODE_SHIMS[idx](data)
15518        }
15519        #[inline]
15520        #[allow(non_snake_case)]
15521        fn abi_decode_raw_validate(
15522            selector: [u8; 4],
15523            data: &[u8],
15524        ) -> alloy_sol_types::Result<Self> {
15525            static DECODE_VALIDATE_SHIMS: &[fn(
15526                &[u8],
15527            ) -> alloy_sol_types::Result<
15528                AllocationManagerCalls,
15529            >] = &[
15530                {
15531                    fn getAllocation(
15532                        data: &[u8],
15533                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15534                        <getAllocationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15535                            data,
15536                        )
15537                        .map(AllocationManagerCalls::getAllocation)
15538                    }
15539                    getAllocation
15540                },
15541                {
15542                    fn isOperatorSlashable(
15543                        data: &[u8],
15544                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15545                        <isOperatorSlashableCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15546                                data,
15547                            )
15548                            .map(AllocationManagerCalls::isOperatorSlashable)
15549                    }
15550                    isOperatorSlashable
15551                },
15552                {
15553                    fn pause(data: &[u8]) -> alloy_sol_types::Result<AllocationManagerCalls> {
15554                        <pauseCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
15555                            .map(AllocationManagerCalls::pause)
15556                    }
15557                    pause
15558                },
15559                {
15560                    fn getAllocatedSets(
15561                        data: &[u8],
15562                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15563                        <getAllocatedSetsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15564                            data,
15565                        )
15566                        .map(AllocationManagerCalls::getAllocatedSets)
15567                    }
15568                    getAllocatedSets
15569                },
15570                {
15571                    fn isOperatorSet(
15572                        data: &[u8],
15573                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15574                        <isOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15575                            data,
15576                        )
15577                        .map(AllocationManagerCalls::isOperatorSet)
15578                    }
15579                    isOperatorSet
15580                },
15581                {
15582                    fn createOperatorSets(
15583                        data: &[u8],
15584                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15585                        <createOperatorSetsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15586                                data,
15587                            )
15588                            .map(AllocationManagerCalls::createOperatorSets)
15589                    }
15590                    createOperatorSets
15591                },
15592                {
15593                    fn DEALLOCATION_DELAY(
15594                        data: &[u8],
15595                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15596                        <DEALLOCATION_DELAYCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15597                                data,
15598                            )
15599                            .map(AllocationManagerCalls::DEALLOCATION_DELAY)
15600                    }
15601                    DEALLOCATION_DELAY
15602                },
15603                {
15604                    fn getAllocatedStake(
15605                        data: &[u8],
15606                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15607                        <getAllocatedStakeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15608                                data,
15609                            )
15610                            .map(AllocationManagerCalls::getAllocatedStake)
15611                    }
15612                    getAllocatedStake
15613                },
15614                {
15615                    fn getMinimumSlashableStake(
15616                        data: &[u8],
15617                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15618                        <getMinimumSlashableStakeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15619                                data,
15620                            )
15621                            .map(AllocationManagerCalls::getMinimumSlashableStake)
15622                    }
15623                    getMinimumSlashableStake
15624                },
15625                {
15626                    fn getAVSRegistrar(
15627                        data: &[u8],
15628                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15629                        <getAVSRegistrarCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15630                            data,
15631                        )
15632                        .map(AllocationManagerCalls::getAVSRegistrar)
15633                    }
15634                    getAVSRegistrar
15635                },
15636                {
15637                    fn slashOperator(
15638                        data: &[u8],
15639                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15640                        <slashOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15641                            data,
15642                        )
15643                        .map(AllocationManagerCalls::slashOperator)
15644                    }
15645                    slashOperator
15646                },
15647                {
15648                    fn getStrategyAllocations(
15649                        data: &[u8],
15650                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15651                        <getStrategyAllocationsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15652                                data,
15653                            )
15654                            .map(AllocationManagerCalls::getStrategyAllocations)
15655                    }
15656                    getStrategyAllocations
15657                },
15658                {
15659                    fn getStrategiesInOperatorSet(
15660                        data: &[u8],
15661                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15662                        <getStrategiesInOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15663                                data,
15664                            )
15665                            .map(AllocationManagerCalls::getStrategiesInOperatorSet)
15666                    }
15667                    getStrategiesInOperatorSet
15668                },
15669                {
15670                    fn permissionController(
15671                        data: &[u8],
15672                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15673                        <permissionControllerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15674                                data,
15675                            )
15676                            .map(AllocationManagerCalls::permissionController)
15677                    }
15678                    permissionController
15679                },
15680                {
15681                    fn getMaxMagnitudes_0(
15682                        data: &[u8],
15683                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15684                        <getMaxMagnitudes_0Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15685                                data,
15686                            )
15687                            .map(AllocationManagerCalls::getMaxMagnitudes_0)
15688                    }
15689                    getMaxMagnitudes_0
15690                },
15691                {
15692                    fn clearDeallocationQueue(
15693                        data: &[u8],
15694                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15695                        <clearDeallocationQueueCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15696                                data,
15697                            )
15698                            .map(AllocationManagerCalls::clearDeallocationQueue)
15699                    }
15700                    clearDeallocationQueue
15701                },
15702                {
15703                    fn addStrategiesToOperatorSet(
15704                        data: &[u8],
15705                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15706                        <addStrategiesToOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15707                                data,
15708                            )
15709                            .map(AllocationManagerCalls::addStrategiesToOperatorSet)
15710                    }
15711                    addStrategiesToOperatorSet
15712                },
15713                {
15714                    fn getMaxMagnitudes_1(
15715                        data: &[u8],
15716                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15717                        <getMaxMagnitudes_1Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15718                                data,
15719                            )
15720                            .map(AllocationManagerCalls::getMaxMagnitudes_1)
15721                    }
15722                    getMaxMagnitudes_1
15723                },
15724                {
15725                    fn version(data: &[u8]) -> alloy_sol_types::Result<AllocationManagerCalls> {
15726                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
15727                            .map(AllocationManagerCalls::version)
15728                    }
15729                    version
15730                },
15731                {
15732                    fn setAllocationDelay(
15733                        data: &[u8],
15734                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15735                        <setAllocationDelayCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15736                                data,
15737                            )
15738                            .map(AllocationManagerCalls::setAllocationDelay)
15739                    }
15740                    setAllocationDelay
15741                },
15742                {
15743                    fn pauseAll(data: &[u8]) -> alloy_sol_types::Result<AllocationManagerCalls> {
15744                        <pauseAllCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
15745                            .map(AllocationManagerCalls::pauseAll)
15746                    }
15747                    pauseAll
15748                },
15749                {
15750                    fn paused_0(data: &[u8]) -> alloy_sol_types::Result<AllocationManagerCalls> {
15751                        <paused_0Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
15752                            .map(AllocationManagerCalls::paused_0)
15753                    }
15754                    paused_0
15755                },
15756                {
15757                    fn paused_1(data: &[u8]) -> alloy_sol_types::Result<AllocationManagerCalls> {
15758                        <paused_1Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
15759                            .map(AllocationManagerCalls::paused_1)
15760                    }
15761                    paused_1
15762                },
15763                {
15764                    fn isMemberOfOperatorSet(
15765                        data: &[u8],
15766                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15767                        <isMemberOfOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15768                                data,
15769                            )
15770                            .map(AllocationManagerCalls::isMemberOfOperatorSet)
15771                    }
15772                    isMemberOfOperatorSet
15773                },
15774                {
15775                    fn getAllocatableMagnitude(
15776                        data: &[u8],
15777                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15778                        <getAllocatableMagnitudeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15779                                data,
15780                            )
15781                            .map(AllocationManagerCalls::getAllocatableMagnitude)
15782                    }
15783                    getAllocatableMagnitude
15784                },
15785                {
15786                    fn deregisterFromOperatorSets(
15787                        data: &[u8],
15788                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15789                        <deregisterFromOperatorSetsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15790                                data,
15791                            )
15792                            .map(AllocationManagerCalls::deregisterFromOperatorSets)
15793                    }
15794                    deregisterFromOperatorSets
15795                },
15796                {
15797                    fn getMembers(data: &[u8]) -> alloy_sol_types::Result<AllocationManagerCalls> {
15798                        <getMembersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
15799                            .map(AllocationManagerCalls::getMembers)
15800                    }
15801                    getMembers
15802                },
15803                {
15804                    fn renounceOwnership(
15805                        data: &[u8],
15806                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15807                        <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15808                                data,
15809                            )
15810                            .map(AllocationManagerCalls::renounceOwnership)
15811                    }
15812                    renounceOwnership
15813                },
15814                {
15815                    fn getRegisteredSets(
15816                        data: &[u8],
15817                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15818                        <getRegisteredSetsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15819                                data,
15820                            )
15821                            .map(AllocationManagerCalls::getRegisteredSets)
15822                    }
15823                    getRegisteredSets
15824                },
15825                {
15826                    fn ALLOCATION_CONFIGURATION_DELAY(
15827                        data: &[u8],
15828                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15829                        <ALLOCATION_CONFIGURATION_DELAYCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15830                                data,
15831                            )
15832                            .map(AllocationManagerCalls::ALLOCATION_CONFIGURATION_DELAY)
15833                    }
15834                    ALLOCATION_CONFIGURATION_DELAY
15835                },
15836                {
15837                    fn pauserRegistry(
15838                        data: &[u8],
15839                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15840                        <pauserRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15841                            data,
15842                        )
15843                        .map(AllocationManagerCalls::pauserRegistry)
15844                    }
15845                    pauserRegistry
15846                },
15847                {
15848                    fn getAllocations(
15849                        data: &[u8],
15850                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15851                        <getAllocationsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15852                            data,
15853                        )
15854                        .map(AllocationManagerCalls::getAllocations)
15855                    }
15856                    getAllocations
15857                },
15858                {
15859                    fn owner(data: &[u8]) -> alloy_sol_types::Result<AllocationManagerCalls> {
15860                        <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
15861                            .map(AllocationManagerCalls::owner)
15862                    }
15863                    owner
15864                },
15865                {
15866                    fn getMaxMagnitudesAtBlock(
15867                        data: &[u8],
15868                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15869                        <getMaxMagnitudesAtBlockCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15870                                data,
15871                            )
15872                            .map(AllocationManagerCalls::getMaxMagnitudesAtBlock)
15873                    }
15874                    getMaxMagnitudesAtBlock
15875                },
15876                {
15877                    fn modifyAllocations(
15878                        data: &[u8],
15879                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15880                        <modifyAllocationsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15881                                data,
15882                            )
15883                            .map(AllocationManagerCalls::modifyAllocations)
15884                    }
15885                    modifyAllocations
15886                },
15887                {
15888                    fn getMaxMagnitude(
15889                        data: &[u8],
15890                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15891                        <getMaxMagnitudeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15892                            data,
15893                        )
15894                        .map(AllocationManagerCalls::getMaxMagnitude)
15895                    }
15896                    getMaxMagnitude
15897                },
15898                {
15899                    fn updateAVSMetadataURI(
15900                        data: &[u8],
15901                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15902                        <updateAVSMetadataURICall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15903                                data,
15904                            )
15905                            .map(AllocationManagerCalls::updateAVSMetadataURI)
15906                    }
15907                    updateAVSMetadataURI
15908                },
15909                {
15910                    fn registerForOperatorSets(
15911                        data: &[u8],
15912                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15913                        <registerForOperatorSetsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15914                                data,
15915                            )
15916                            .map(AllocationManagerCalls::registerForOperatorSets)
15917                    }
15918                    registerForOperatorSets
15919                },
15920                {
15921                    fn getMemberCount(
15922                        data: &[u8],
15923                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15924                        <getMemberCountCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15925                            data,
15926                        )
15927                        .map(AllocationManagerCalls::getMemberCount)
15928                    }
15929                    getMemberCount
15930                },
15931                {
15932                    fn removeStrategiesFromOperatorSet(
15933                        data: &[u8],
15934                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15935                        <removeStrategiesFromOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15936                                data,
15937                            )
15938                            .map(AllocationManagerCalls::removeStrategiesFromOperatorSet)
15939                    }
15940                    removeStrategiesFromOperatorSet
15941                },
15942                {
15943                    fn getAllocationDelay(
15944                        data: &[u8],
15945                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15946                        <getAllocationDelayCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15947                                data,
15948                            )
15949                            .map(AllocationManagerCalls::getAllocationDelay)
15950                    }
15951                    getAllocationDelay
15952                },
15953                {
15954                    fn getOperatorSetCount(
15955                        data: &[u8],
15956                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15957                        <getOperatorSetCountCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15958                                data,
15959                            )
15960                            .map(AllocationManagerCalls::getOperatorSetCount)
15961                    }
15962                    getOperatorSetCount
15963                },
15964                {
15965                    fn getAllocatedStrategies(
15966                        data: &[u8],
15967                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15968                        <getAllocatedStrategiesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15969                                data,
15970                            )
15971                            .map(AllocationManagerCalls::getAllocatedStrategies)
15972                    }
15973                    getAllocatedStrategies
15974                },
15975                {
15976                    fn initialize(data: &[u8]) -> alloy_sol_types::Result<AllocationManagerCalls> {
15977                        <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
15978                            .map(AllocationManagerCalls::initialize)
15979                    }
15980                    initialize
15981                },
15982                {
15983                    fn setAVSRegistrar(
15984                        data: &[u8],
15985                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
15986                        <setAVSRegistrarCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
15987                            data,
15988                        )
15989                        .map(AllocationManagerCalls::setAVSRegistrar)
15990                    }
15991                    setAVSRegistrar
15992                },
15993                {
15994                    fn delegation(data: &[u8]) -> alloy_sol_types::Result<AllocationManagerCalls> {
15995                        <delegationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
15996                            .map(AllocationManagerCalls::delegation)
15997                    }
15998                    delegation
15999                },
16000                {
16001                    fn transferOwnership(
16002                        data: &[u8],
16003                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
16004                        <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
16005                                data,
16006                            )
16007                            .map(AllocationManagerCalls::transferOwnership)
16008                    }
16009                    transferOwnership
16010                },
16011                {
16012                    fn getEncumberedMagnitude(
16013                        data: &[u8],
16014                    ) -> alloy_sol_types::Result<AllocationManagerCalls> {
16015                        <getEncumberedMagnitudeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
16016                                data,
16017                            )
16018                            .map(AllocationManagerCalls::getEncumberedMagnitude)
16019                    }
16020                    getEncumberedMagnitude
16021                },
16022                {
16023                    fn unpause(data: &[u8]) -> alloy_sol_types::Result<AllocationManagerCalls> {
16024                        <unpauseCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
16025                            .map(AllocationManagerCalls::unpause)
16026                    }
16027                    unpause
16028                },
16029            ];
16030            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
16031                return Err(alloy_sol_types::Error::unknown_selector(
16032                    <Self as alloy_sol_types::SolInterface>::NAME,
16033                    selector,
16034                ));
16035            };
16036            DECODE_VALIDATE_SHIMS[idx](data)
16037        }
16038        #[inline]
16039        fn abi_encoded_size(&self) -> usize {
16040            match self {
16041                Self::ALLOCATION_CONFIGURATION_DELAY(inner) => {
16042                    <ALLOCATION_CONFIGURATION_DELAYCall as alloy_sol_types::SolCall>::abi_encoded_size(
16043                        inner,
16044                    )
16045                }
16046                Self::DEALLOCATION_DELAY(inner) => {
16047                    <DEALLOCATION_DELAYCall as alloy_sol_types::SolCall>::abi_encoded_size(
16048                        inner,
16049                    )
16050                }
16051                Self::addStrategiesToOperatorSet(inner) => {
16052                    <addStrategiesToOperatorSetCall as alloy_sol_types::SolCall>::abi_encoded_size(
16053                        inner,
16054                    )
16055                }
16056                Self::clearDeallocationQueue(inner) => {
16057                    <clearDeallocationQueueCall as alloy_sol_types::SolCall>::abi_encoded_size(
16058                        inner,
16059                    )
16060                }
16061                Self::createOperatorSets(inner) => {
16062                    <createOperatorSetsCall as alloy_sol_types::SolCall>::abi_encoded_size(
16063                        inner,
16064                    )
16065                }
16066                Self::delegation(inner) => {
16067                    <delegationCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
16068                }
16069                Self::deregisterFromOperatorSets(inner) => {
16070                    <deregisterFromOperatorSetsCall as alloy_sol_types::SolCall>::abi_encoded_size(
16071                        inner,
16072                    )
16073                }
16074                Self::getAVSRegistrar(inner) => {
16075                    <getAVSRegistrarCall as alloy_sol_types::SolCall>::abi_encoded_size(
16076                        inner,
16077                    )
16078                }
16079                Self::getAllocatableMagnitude(inner) => {
16080                    <getAllocatableMagnitudeCall as alloy_sol_types::SolCall>::abi_encoded_size(
16081                        inner,
16082                    )
16083                }
16084                Self::getAllocatedSets(inner) => {
16085                    <getAllocatedSetsCall as alloy_sol_types::SolCall>::abi_encoded_size(
16086                        inner,
16087                    )
16088                }
16089                Self::getAllocatedStake(inner) => {
16090                    <getAllocatedStakeCall as alloy_sol_types::SolCall>::abi_encoded_size(
16091                        inner,
16092                    )
16093                }
16094                Self::getAllocatedStrategies(inner) => {
16095                    <getAllocatedStrategiesCall as alloy_sol_types::SolCall>::abi_encoded_size(
16096                        inner,
16097                    )
16098                }
16099                Self::getAllocation(inner) => {
16100                    <getAllocationCall as alloy_sol_types::SolCall>::abi_encoded_size(
16101                        inner,
16102                    )
16103                }
16104                Self::getAllocationDelay(inner) => {
16105                    <getAllocationDelayCall as alloy_sol_types::SolCall>::abi_encoded_size(
16106                        inner,
16107                    )
16108                }
16109                Self::getAllocations(inner) => {
16110                    <getAllocationsCall as alloy_sol_types::SolCall>::abi_encoded_size(
16111                        inner,
16112                    )
16113                }
16114                Self::getEncumberedMagnitude(inner) => {
16115                    <getEncumberedMagnitudeCall as alloy_sol_types::SolCall>::abi_encoded_size(
16116                        inner,
16117                    )
16118                }
16119                Self::getMaxMagnitude(inner) => {
16120                    <getMaxMagnitudeCall as alloy_sol_types::SolCall>::abi_encoded_size(
16121                        inner,
16122                    )
16123                }
16124                Self::getMaxMagnitudes_0(inner) => {
16125                    <getMaxMagnitudes_0Call as alloy_sol_types::SolCall>::abi_encoded_size(
16126                        inner,
16127                    )
16128                }
16129                Self::getMaxMagnitudes_1(inner) => {
16130                    <getMaxMagnitudes_1Call as alloy_sol_types::SolCall>::abi_encoded_size(
16131                        inner,
16132                    )
16133                }
16134                Self::getMaxMagnitudesAtBlock(inner) => {
16135                    <getMaxMagnitudesAtBlockCall as alloy_sol_types::SolCall>::abi_encoded_size(
16136                        inner,
16137                    )
16138                }
16139                Self::getMemberCount(inner) => {
16140                    <getMemberCountCall as alloy_sol_types::SolCall>::abi_encoded_size(
16141                        inner,
16142                    )
16143                }
16144                Self::getMembers(inner) => {
16145                    <getMembersCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
16146                }
16147                Self::getMinimumSlashableStake(inner) => {
16148                    <getMinimumSlashableStakeCall as alloy_sol_types::SolCall>::abi_encoded_size(
16149                        inner,
16150                    )
16151                }
16152                Self::getOperatorSetCount(inner) => {
16153                    <getOperatorSetCountCall as alloy_sol_types::SolCall>::abi_encoded_size(
16154                        inner,
16155                    )
16156                }
16157                Self::getRegisteredSets(inner) => {
16158                    <getRegisteredSetsCall as alloy_sol_types::SolCall>::abi_encoded_size(
16159                        inner,
16160                    )
16161                }
16162                Self::getStrategiesInOperatorSet(inner) => {
16163                    <getStrategiesInOperatorSetCall as alloy_sol_types::SolCall>::abi_encoded_size(
16164                        inner,
16165                    )
16166                }
16167                Self::getStrategyAllocations(inner) => {
16168                    <getStrategyAllocationsCall as alloy_sol_types::SolCall>::abi_encoded_size(
16169                        inner,
16170                    )
16171                }
16172                Self::initialize(inner) => {
16173                    <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
16174                }
16175                Self::isMemberOfOperatorSet(inner) => {
16176                    <isMemberOfOperatorSetCall as alloy_sol_types::SolCall>::abi_encoded_size(
16177                        inner,
16178                    )
16179                }
16180                Self::isOperatorSet(inner) => {
16181                    <isOperatorSetCall as alloy_sol_types::SolCall>::abi_encoded_size(
16182                        inner,
16183                    )
16184                }
16185                Self::isOperatorSlashable(inner) => {
16186                    <isOperatorSlashableCall as alloy_sol_types::SolCall>::abi_encoded_size(
16187                        inner,
16188                    )
16189                }
16190                Self::modifyAllocations(inner) => {
16191                    <modifyAllocationsCall as alloy_sol_types::SolCall>::abi_encoded_size(
16192                        inner,
16193                    )
16194                }
16195                Self::owner(inner) => {
16196                    <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
16197                }
16198                Self::pause(inner) => {
16199                    <pauseCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
16200                }
16201                Self::pauseAll(inner) => {
16202                    <pauseAllCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
16203                }
16204                Self::paused_0(inner) => {
16205                    <paused_0Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
16206                }
16207                Self::paused_1(inner) => {
16208                    <paused_1Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
16209                }
16210                Self::pauserRegistry(inner) => {
16211                    <pauserRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
16212                        inner,
16213                    )
16214                }
16215                Self::permissionController(inner) => {
16216                    <permissionControllerCall as alloy_sol_types::SolCall>::abi_encoded_size(
16217                        inner,
16218                    )
16219                }
16220                Self::registerForOperatorSets(inner) => {
16221                    <registerForOperatorSetsCall as alloy_sol_types::SolCall>::abi_encoded_size(
16222                        inner,
16223                    )
16224                }
16225                Self::removeStrategiesFromOperatorSet(inner) => {
16226                    <removeStrategiesFromOperatorSetCall as alloy_sol_types::SolCall>::abi_encoded_size(
16227                        inner,
16228                    )
16229                }
16230                Self::renounceOwnership(inner) => {
16231                    <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
16232                        inner,
16233                    )
16234                }
16235                Self::setAVSRegistrar(inner) => {
16236                    <setAVSRegistrarCall as alloy_sol_types::SolCall>::abi_encoded_size(
16237                        inner,
16238                    )
16239                }
16240                Self::setAllocationDelay(inner) => {
16241                    <setAllocationDelayCall as alloy_sol_types::SolCall>::abi_encoded_size(
16242                        inner,
16243                    )
16244                }
16245                Self::slashOperator(inner) => {
16246                    <slashOperatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
16247                        inner,
16248                    )
16249                }
16250                Self::transferOwnership(inner) => {
16251                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
16252                        inner,
16253                    )
16254                }
16255                Self::unpause(inner) => {
16256                    <unpauseCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
16257                }
16258                Self::updateAVSMetadataURI(inner) => {
16259                    <updateAVSMetadataURICall as alloy_sol_types::SolCall>::abi_encoded_size(
16260                        inner,
16261                    )
16262                }
16263                Self::version(inner) => {
16264                    <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
16265                }
16266            }
16267        }
16268        #[inline]
16269        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
16270            match self {
16271                Self::ALLOCATION_CONFIGURATION_DELAY(inner) => {
16272                    <ALLOCATION_CONFIGURATION_DELAYCall as alloy_sol_types::SolCall>::abi_encode_raw(
16273                        inner,
16274                        out,
16275                    )
16276                }
16277                Self::DEALLOCATION_DELAY(inner) => {
16278                    <DEALLOCATION_DELAYCall as alloy_sol_types::SolCall>::abi_encode_raw(
16279                        inner,
16280                        out,
16281                    )
16282                }
16283                Self::addStrategiesToOperatorSet(inner) => {
16284                    <addStrategiesToOperatorSetCall as alloy_sol_types::SolCall>::abi_encode_raw(
16285                        inner,
16286                        out,
16287                    )
16288                }
16289                Self::clearDeallocationQueue(inner) => {
16290                    <clearDeallocationQueueCall as alloy_sol_types::SolCall>::abi_encode_raw(
16291                        inner,
16292                        out,
16293                    )
16294                }
16295                Self::createOperatorSets(inner) => {
16296                    <createOperatorSetsCall as alloy_sol_types::SolCall>::abi_encode_raw(
16297                        inner,
16298                        out,
16299                    )
16300                }
16301                Self::delegation(inner) => {
16302                    <delegationCall as alloy_sol_types::SolCall>::abi_encode_raw(
16303                        inner,
16304                        out,
16305                    )
16306                }
16307                Self::deregisterFromOperatorSets(inner) => {
16308                    <deregisterFromOperatorSetsCall as alloy_sol_types::SolCall>::abi_encode_raw(
16309                        inner,
16310                        out,
16311                    )
16312                }
16313                Self::getAVSRegistrar(inner) => {
16314                    <getAVSRegistrarCall as alloy_sol_types::SolCall>::abi_encode_raw(
16315                        inner,
16316                        out,
16317                    )
16318                }
16319                Self::getAllocatableMagnitude(inner) => {
16320                    <getAllocatableMagnitudeCall as alloy_sol_types::SolCall>::abi_encode_raw(
16321                        inner,
16322                        out,
16323                    )
16324                }
16325                Self::getAllocatedSets(inner) => {
16326                    <getAllocatedSetsCall as alloy_sol_types::SolCall>::abi_encode_raw(
16327                        inner,
16328                        out,
16329                    )
16330                }
16331                Self::getAllocatedStake(inner) => {
16332                    <getAllocatedStakeCall as alloy_sol_types::SolCall>::abi_encode_raw(
16333                        inner,
16334                        out,
16335                    )
16336                }
16337                Self::getAllocatedStrategies(inner) => {
16338                    <getAllocatedStrategiesCall as alloy_sol_types::SolCall>::abi_encode_raw(
16339                        inner,
16340                        out,
16341                    )
16342                }
16343                Self::getAllocation(inner) => {
16344                    <getAllocationCall as alloy_sol_types::SolCall>::abi_encode_raw(
16345                        inner,
16346                        out,
16347                    )
16348                }
16349                Self::getAllocationDelay(inner) => {
16350                    <getAllocationDelayCall as alloy_sol_types::SolCall>::abi_encode_raw(
16351                        inner,
16352                        out,
16353                    )
16354                }
16355                Self::getAllocations(inner) => {
16356                    <getAllocationsCall as alloy_sol_types::SolCall>::abi_encode_raw(
16357                        inner,
16358                        out,
16359                    )
16360                }
16361                Self::getEncumberedMagnitude(inner) => {
16362                    <getEncumberedMagnitudeCall as alloy_sol_types::SolCall>::abi_encode_raw(
16363                        inner,
16364                        out,
16365                    )
16366                }
16367                Self::getMaxMagnitude(inner) => {
16368                    <getMaxMagnitudeCall as alloy_sol_types::SolCall>::abi_encode_raw(
16369                        inner,
16370                        out,
16371                    )
16372                }
16373                Self::getMaxMagnitudes_0(inner) => {
16374                    <getMaxMagnitudes_0Call as alloy_sol_types::SolCall>::abi_encode_raw(
16375                        inner,
16376                        out,
16377                    )
16378                }
16379                Self::getMaxMagnitudes_1(inner) => {
16380                    <getMaxMagnitudes_1Call as alloy_sol_types::SolCall>::abi_encode_raw(
16381                        inner,
16382                        out,
16383                    )
16384                }
16385                Self::getMaxMagnitudesAtBlock(inner) => {
16386                    <getMaxMagnitudesAtBlockCall as alloy_sol_types::SolCall>::abi_encode_raw(
16387                        inner,
16388                        out,
16389                    )
16390                }
16391                Self::getMemberCount(inner) => {
16392                    <getMemberCountCall as alloy_sol_types::SolCall>::abi_encode_raw(
16393                        inner,
16394                        out,
16395                    )
16396                }
16397                Self::getMembers(inner) => {
16398                    <getMembersCall as alloy_sol_types::SolCall>::abi_encode_raw(
16399                        inner,
16400                        out,
16401                    )
16402                }
16403                Self::getMinimumSlashableStake(inner) => {
16404                    <getMinimumSlashableStakeCall as alloy_sol_types::SolCall>::abi_encode_raw(
16405                        inner,
16406                        out,
16407                    )
16408                }
16409                Self::getOperatorSetCount(inner) => {
16410                    <getOperatorSetCountCall as alloy_sol_types::SolCall>::abi_encode_raw(
16411                        inner,
16412                        out,
16413                    )
16414                }
16415                Self::getRegisteredSets(inner) => {
16416                    <getRegisteredSetsCall as alloy_sol_types::SolCall>::abi_encode_raw(
16417                        inner,
16418                        out,
16419                    )
16420                }
16421                Self::getStrategiesInOperatorSet(inner) => {
16422                    <getStrategiesInOperatorSetCall as alloy_sol_types::SolCall>::abi_encode_raw(
16423                        inner,
16424                        out,
16425                    )
16426                }
16427                Self::getStrategyAllocations(inner) => {
16428                    <getStrategyAllocationsCall as alloy_sol_types::SolCall>::abi_encode_raw(
16429                        inner,
16430                        out,
16431                    )
16432                }
16433                Self::initialize(inner) => {
16434                    <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(
16435                        inner,
16436                        out,
16437                    )
16438                }
16439                Self::isMemberOfOperatorSet(inner) => {
16440                    <isMemberOfOperatorSetCall as alloy_sol_types::SolCall>::abi_encode_raw(
16441                        inner,
16442                        out,
16443                    )
16444                }
16445                Self::isOperatorSet(inner) => {
16446                    <isOperatorSetCall as alloy_sol_types::SolCall>::abi_encode_raw(
16447                        inner,
16448                        out,
16449                    )
16450                }
16451                Self::isOperatorSlashable(inner) => {
16452                    <isOperatorSlashableCall as alloy_sol_types::SolCall>::abi_encode_raw(
16453                        inner,
16454                        out,
16455                    )
16456                }
16457                Self::modifyAllocations(inner) => {
16458                    <modifyAllocationsCall as alloy_sol_types::SolCall>::abi_encode_raw(
16459                        inner,
16460                        out,
16461                    )
16462                }
16463                Self::owner(inner) => {
16464                    <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
16465                }
16466                Self::pause(inner) => {
16467                    <pauseCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
16468                }
16469                Self::pauseAll(inner) => {
16470                    <pauseAllCall as alloy_sol_types::SolCall>::abi_encode_raw(
16471                        inner,
16472                        out,
16473                    )
16474                }
16475                Self::paused_0(inner) => {
16476                    <paused_0Call as alloy_sol_types::SolCall>::abi_encode_raw(
16477                        inner,
16478                        out,
16479                    )
16480                }
16481                Self::paused_1(inner) => {
16482                    <paused_1Call as alloy_sol_types::SolCall>::abi_encode_raw(
16483                        inner,
16484                        out,
16485                    )
16486                }
16487                Self::pauserRegistry(inner) => {
16488                    <pauserRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
16489                        inner,
16490                        out,
16491                    )
16492                }
16493                Self::permissionController(inner) => {
16494                    <permissionControllerCall as alloy_sol_types::SolCall>::abi_encode_raw(
16495                        inner,
16496                        out,
16497                    )
16498                }
16499                Self::registerForOperatorSets(inner) => {
16500                    <registerForOperatorSetsCall as alloy_sol_types::SolCall>::abi_encode_raw(
16501                        inner,
16502                        out,
16503                    )
16504                }
16505                Self::removeStrategiesFromOperatorSet(inner) => {
16506                    <removeStrategiesFromOperatorSetCall as alloy_sol_types::SolCall>::abi_encode_raw(
16507                        inner,
16508                        out,
16509                    )
16510                }
16511                Self::renounceOwnership(inner) => {
16512                    <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
16513                        inner,
16514                        out,
16515                    )
16516                }
16517                Self::setAVSRegistrar(inner) => {
16518                    <setAVSRegistrarCall as alloy_sol_types::SolCall>::abi_encode_raw(
16519                        inner,
16520                        out,
16521                    )
16522                }
16523                Self::setAllocationDelay(inner) => {
16524                    <setAllocationDelayCall as alloy_sol_types::SolCall>::abi_encode_raw(
16525                        inner,
16526                        out,
16527                    )
16528                }
16529                Self::slashOperator(inner) => {
16530                    <slashOperatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
16531                        inner,
16532                        out,
16533                    )
16534                }
16535                Self::transferOwnership(inner) => {
16536                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
16537                        inner,
16538                        out,
16539                    )
16540                }
16541                Self::unpause(inner) => {
16542                    <unpauseCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
16543                }
16544                Self::updateAVSMetadataURI(inner) => {
16545                    <updateAVSMetadataURICall as alloy_sol_types::SolCall>::abi_encode_raw(
16546                        inner,
16547                        out,
16548                    )
16549                }
16550                Self::version(inner) => {
16551                    <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
16552                }
16553            }
16554        }
16555    }
16556    ///Container for all the [`AllocationManager`](self) custom errors.
16557    #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq, Eq, Hash)]
16558    pub enum AllocationManagerErrors {
16559        #[allow(missing_docs)]
16560        AlreadyMemberOfSet(AlreadyMemberOfSet),
16561        #[allow(missing_docs)]
16562        CurrentlyPaused(CurrentlyPaused),
16563        #[allow(missing_docs)]
16564        Empty(Empty),
16565        #[allow(missing_docs)]
16566        InputAddressZero(InputAddressZero),
16567        #[allow(missing_docs)]
16568        InputArrayLengthMismatch(InputArrayLengthMismatch),
16569        #[allow(missing_docs)]
16570        InsufficientMagnitude(InsufficientMagnitude),
16571        #[allow(missing_docs)]
16572        InvalidAVSRegistrar(InvalidAVSRegistrar),
16573        #[allow(missing_docs)]
16574        InvalidCaller(InvalidCaller),
16575        #[allow(missing_docs)]
16576        InvalidNewPausedStatus(InvalidNewPausedStatus),
16577        #[allow(missing_docs)]
16578        InvalidOperator(InvalidOperator),
16579        #[allow(missing_docs)]
16580        InvalidOperatorSet(InvalidOperatorSet),
16581        #[allow(missing_docs)]
16582        InvalidPermissions(InvalidPermissions),
16583        #[allow(missing_docs)]
16584        InvalidShortString(InvalidShortString),
16585        #[allow(missing_docs)]
16586        InvalidSnapshotOrdering(InvalidSnapshotOrdering),
16587        #[allow(missing_docs)]
16588        InvalidWadToSlash(InvalidWadToSlash),
16589        #[allow(missing_docs)]
16590        ModificationAlreadyPending(ModificationAlreadyPending),
16591        #[allow(missing_docs)]
16592        NonexistentAVSMetadata(NonexistentAVSMetadata),
16593        #[allow(missing_docs)]
16594        NotMemberOfSet(NotMemberOfSet),
16595        #[allow(missing_docs)]
16596        OnlyPauser(OnlyPauser),
16597        #[allow(missing_docs)]
16598        OnlyUnpauser(OnlyUnpauser),
16599        #[allow(missing_docs)]
16600        OperatorNotSlashable(OperatorNotSlashable),
16601        #[allow(missing_docs)]
16602        OutOfBounds(OutOfBounds),
16603        #[allow(missing_docs)]
16604        SameMagnitude(SameMagnitude),
16605        #[allow(missing_docs)]
16606        StrategiesMustBeInAscendingOrder(StrategiesMustBeInAscendingOrder),
16607        #[allow(missing_docs)]
16608        StrategyAlreadyInOperatorSet(StrategyAlreadyInOperatorSet),
16609        #[allow(missing_docs)]
16610        StrategyNotInOperatorSet(StrategyNotInOperatorSet),
16611        #[allow(missing_docs)]
16612        StringTooLong(StringTooLong),
16613        #[allow(missing_docs)]
16614        UninitializedAllocationDelay(UninitializedAllocationDelay),
16615    }
16616    #[automatically_derived]
16617    impl AllocationManagerErrors {
16618        /// All the selectors of this enum.
16619        ///
16620        /// Note that the selectors might not be in the same order as the variants.
16621        /// No guarantees are made about the order of the selectors.
16622        ///
16623        /// Prefer using `SolInterface` methods instead.
16624        pub const SELECTORS: &'static [[u8; 4usize]] = &[
16625            [19u8, 83u8, 96u8, 49u8],
16626            [37u8, 19u8, 29u8, 79u8],
16627            [42u8, 55u8, 28u8, 126u8],
16628            [48u8, 90u8, 39u8, 169u8],
16629            [61u8, 178u8, 161u8, 42u8],
16630            [67u8, 113u8, 74u8, 253u8],
16631            [72u8, 245u8, 195u8, 237u8],
16632            [72u8, 247u8, 219u8, 185u8],
16633            [88u8, 92u8, 251u8, 47u8],
16634            [99u8, 120u8, 104u8, 78u8],
16635            [108u8, 155u8, 224u8, 191u8],
16636            [115u8, 99u8, 33u8, 118u8],
16637            [117u8, 223u8, 81u8, 220u8],
16638            [121u8, 72u8, 33u8, 255u8],
16639            [126u8, 197u8, 193u8, 84u8],
16640            [132u8, 10u8, 72u8, 213u8],
16641            [140u8, 12u8, 47u8, 38u8],
16642            [147u8, 45u8, 148u8, 247u8],
16643            [159u8, 28u8, 128u8, 83u8],
16644            [179u8, 81u8, 43u8, 12u8],
16645            [180u8, 18u8, 15u8, 20u8],
16646            [198u8, 29u8, 202u8, 93u8],
16647            [204u8, 234u8, 158u8, 111u8],
16648            [216u8, 216u8, 220u8, 78u8],
16649            [216u8, 252u8, 190u8, 48u8],
16650            [232u8, 88u8, 158u8, 8u8],
16651            [235u8, 191u8, 244u8, 151u8],
16652            [250u8, 85u8, 252u8, 129u8],
16653        ];
16654    }
16655    #[automatically_derived]
16656    impl alloy_sol_types::SolInterface for AllocationManagerErrors {
16657        const NAME: &'static str = "AllocationManagerErrors";
16658        const MIN_DATA_LENGTH: usize = 0usize;
16659        const COUNT: usize = 28usize;
16660        #[inline]
16661        fn selector(&self) -> [u8; 4] {
16662            match self {
16663                Self::AlreadyMemberOfSet(_) => {
16664                    <AlreadyMemberOfSet as alloy_sol_types::SolError>::SELECTOR
16665                }
16666                Self::CurrentlyPaused(_) => {
16667                    <CurrentlyPaused as alloy_sol_types::SolError>::SELECTOR
16668                }
16669                Self::Empty(_) => <Empty as alloy_sol_types::SolError>::SELECTOR,
16670                Self::InputAddressZero(_) => {
16671                    <InputAddressZero as alloy_sol_types::SolError>::SELECTOR
16672                }
16673                Self::InputArrayLengthMismatch(_) => {
16674                    <InputArrayLengthMismatch as alloy_sol_types::SolError>::SELECTOR
16675                }
16676                Self::InsufficientMagnitude(_) => {
16677                    <InsufficientMagnitude as alloy_sol_types::SolError>::SELECTOR
16678                }
16679                Self::InvalidAVSRegistrar(_) => {
16680                    <InvalidAVSRegistrar as alloy_sol_types::SolError>::SELECTOR
16681                }
16682                Self::InvalidCaller(_) => <InvalidCaller as alloy_sol_types::SolError>::SELECTOR,
16683                Self::InvalidNewPausedStatus(_) => {
16684                    <InvalidNewPausedStatus as alloy_sol_types::SolError>::SELECTOR
16685                }
16686                Self::InvalidOperator(_) => {
16687                    <InvalidOperator as alloy_sol_types::SolError>::SELECTOR
16688                }
16689                Self::InvalidOperatorSet(_) => {
16690                    <InvalidOperatorSet as alloy_sol_types::SolError>::SELECTOR
16691                }
16692                Self::InvalidPermissions(_) => {
16693                    <InvalidPermissions as alloy_sol_types::SolError>::SELECTOR
16694                }
16695                Self::InvalidShortString(_) => {
16696                    <InvalidShortString as alloy_sol_types::SolError>::SELECTOR
16697                }
16698                Self::InvalidSnapshotOrdering(_) => {
16699                    <InvalidSnapshotOrdering as alloy_sol_types::SolError>::SELECTOR
16700                }
16701                Self::InvalidWadToSlash(_) => {
16702                    <InvalidWadToSlash as alloy_sol_types::SolError>::SELECTOR
16703                }
16704                Self::ModificationAlreadyPending(_) => {
16705                    <ModificationAlreadyPending as alloy_sol_types::SolError>::SELECTOR
16706                }
16707                Self::NonexistentAVSMetadata(_) => {
16708                    <NonexistentAVSMetadata as alloy_sol_types::SolError>::SELECTOR
16709                }
16710                Self::NotMemberOfSet(_) => <NotMemberOfSet as alloy_sol_types::SolError>::SELECTOR,
16711                Self::OnlyPauser(_) => <OnlyPauser as alloy_sol_types::SolError>::SELECTOR,
16712                Self::OnlyUnpauser(_) => <OnlyUnpauser as alloy_sol_types::SolError>::SELECTOR,
16713                Self::OperatorNotSlashable(_) => {
16714                    <OperatorNotSlashable as alloy_sol_types::SolError>::SELECTOR
16715                }
16716                Self::OutOfBounds(_) => <OutOfBounds as alloy_sol_types::SolError>::SELECTOR,
16717                Self::SameMagnitude(_) => <SameMagnitude as alloy_sol_types::SolError>::SELECTOR,
16718                Self::StrategiesMustBeInAscendingOrder(_) => {
16719                    <StrategiesMustBeInAscendingOrder as alloy_sol_types::SolError>::SELECTOR
16720                }
16721                Self::StrategyAlreadyInOperatorSet(_) => {
16722                    <StrategyAlreadyInOperatorSet as alloy_sol_types::SolError>::SELECTOR
16723                }
16724                Self::StrategyNotInOperatorSet(_) => {
16725                    <StrategyNotInOperatorSet as alloy_sol_types::SolError>::SELECTOR
16726                }
16727                Self::StringTooLong(_) => <StringTooLong as alloy_sol_types::SolError>::SELECTOR,
16728                Self::UninitializedAllocationDelay(_) => {
16729                    <UninitializedAllocationDelay as alloy_sol_types::SolError>::SELECTOR
16730                }
16731            }
16732        }
16733        #[inline]
16734        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
16735            Self::SELECTORS.get(i).copied()
16736        }
16737        #[inline]
16738        fn valid_selector(selector: [u8; 4]) -> bool {
16739            Self::SELECTORS.binary_search(&selector).is_ok()
16740        }
16741        #[inline]
16742        #[allow(non_snake_case)]
16743        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
16744            static DECODE_SHIMS: &[fn(
16745                &[u8],
16746            )
16747                -> alloy_sol_types::Result<AllocationManagerErrors>] = &[
16748                {
16749                    fn InvalidWadToSlash(
16750                        data: &[u8],
16751                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16752                        <InvalidWadToSlash as alloy_sol_types::SolError>::abi_decode_raw(data)
16753                            .map(AllocationManagerErrors::InvalidWadToSlash)
16754                    }
16755                    InvalidWadToSlash
16756                },
16757                {
16758                    fn NotMemberOfSet(
16759                        data: &[u8],
16760                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16761                        <NotMemberOfSet as alloy_sol_types::SolError>::abi_decode_raw(data)
16762                            .map(AllocationManagerErrors::NotMemberOfSet)
16763                    }
16764                    NotMemberOfSet
16765                },
16766                {
16767                    fn InvalidSnapshotOrdering(
16768                        data: &[u8],
16769                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16770                        <InvalidSnapshotOrdering as alloy_sol_types::SolError>::abi_decode_raw(data)
16771                            .map(AllocationManagerErrors::InvalidSnapshotOrdering)
16772                    }
16773                    InvalidSnapshotOrdering
16774                },
16775                {
16776                    fn StringTooLong(
16777                        data: &[u8],
16778                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16779                        <StringTooLong as alloy_sol_types::SolError>::abi_decode_raw(data)
16780                            .map(AllocationManagerErrors::StringTooLong)
16781                    }
16782                    StringTooLong
16783                },
16784                {
16785                    fn Empty(data: &[u8]) -> alloy_sol_types::Result<AllocationManagerErrors> {
16786                        <Empty as alloy_sol_types::SolError>::abi_decode_raw(data)
16787                            .map(AllocationManagerErrors::Empty)
16788                    }
16789                    Empty
16790                },
16791                {
16792                    fn InputArrayLengthMismatch(
16793                        data: &[u8],
16794                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16795                        <InputArrayLengthMismatch as alloy_sol_types::SolError>::abi_decode_raw(
16796                            data,
16797                        )
16798                        .map(AllocationManagerErrors::InputArrayLengthMismatch)
16799                    }
16800                    InputArrayLengthMismatch
16801                },
16802                {
16803                    fn InvalidCaller(
16804                        data: &[u8],
16805                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16806                        <InvalidCaller as alloy_sol_types::SolError>::abi_decode_raw(data)
16807                            .map(AllocationManagerErrors::InvalidCaller)
16808                    }
16809                    InvalidCaller
16810                },
16811                {
16812                    fn NonexistentAVSMetadata(
16813                        data: &[u8],
16814                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16815                        <NonexistentAVSMetadata as alloy_sol_types::SolError>::abi_decode_raw(data)
16816                            .map(AllocationManagerErrors::NonexistentAVSMetadata)
16817                    }
16818                    NonexistentAVSMetadata
16819                },
16820                {
16821                    fn StrategyAlreadyInOperatorSet(
16822                        data: &[u8],
16823                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16824                        <StrategyAlreadyInOperatorSet as alloy_sol_types::SolError>::abi_decode_raw(
16825                            data,
16826                        )
16827                        .map(AllocationManagerErrors::StrategyAlreadyInOperatorSet)
16828                    }
16829                    StrategyAlreadyInOperatorSet
16830                },
16831                {
16832                    fn StrategyNotInOperatorSet(
16833                        data: &[u8],
16834                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16835                        <StrategyNotInOperatorSet as alloy_sol_types::SolError>::abi_decode_raw(
16836                            data,
16837                        )
16838                        .map(AllocationManagerErrors::StrategyNotInOperatorSet)
16839                    }
16840                    StrategyNotInOperatorSet
16841                },
16842                {
16843                    fn InsufficientMagnitude(
16844                        data: &[u8],
16845                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16846                        <InsufficientMagnitude as alloy_sol_types::SolError>::abi_decode_raw(data)
16847                            .map(AllocationManagerErrors::InsufficientMagnitude)
16848                    }
16849                    InsufficientMagnitude
16850                },
16851                {
16852                    fn InputAddressZero(
16853                        data: &[u8],
16854                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16855                        <InputAddressZero as alloy_sol_types::SolError>::abi_decode_raw(data)
16856                            .map(AllocationManagerErrors::InputAddressZero)
16857                    }
16858                    InputAddressZero
16859                },
16860                {
16861                    fn OnlyPauser(data: &[u8]) -> alloy_sol_types::Result<AllocationManagerErrors> {
16862                        <OnlyPauser as alloy_sol_types::SolError>::abi_decode_raw(data)
16863                            .map(AllocationManagerErrors::OnlyPauser)
16864                    }
16865                    OnlyPauser
16866                },
16867                {
16868                    fn OnlyUnpauser(
16869                        data: &[u8],
16870                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16871                        <OnlyUnpauser as alloy_sol_types::SolError>::abi_decode_raw(data)
16872                            .map(AllocationManagerErrors::OnlyUnpauser)
16873                    }
16874                    OnlyUnpauser
16875                },
16876                {
16877                    fn InvalidOperatorSet(
16878                        data: &[u8],
16879                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16880                        <InvalidOperatorSet as alloy_sol_types::SolError>::abi_decode_raw(data)
16881                            .map(AllocationManagerErrors::InvalidOperatorSet)
16882                    }
16883                    InvalidOperatorSet
16884                },
16885                {
16886                    fn CurrentlyPaused(
16887                        data: &[u8],
16888                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16889                        <CurrentlyPaused as alloy_sol_types::SolError>::abi_decode_raw(data)
16890                            .map(AllocationManagerErrors::CurrentlyPaused)
16891                    }
16892                    CurrentlyPaused
16893                },
16894                {
16895                    fn SameMagnitude(
16896                        data: &[u8],
16897                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16898                        <SameMagnitude as alloy_sol_types::SolError>::abi_decode_raw(data)
16899                            .map(AllocationManagerErrors::SameMagnitude)
16900                    }
16901                    SameMagnitude
16902                },
16903                {
16904                    fn InvalidPermissions(
16905                        data: &[u8],
16906                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16907                        <InvalidPermissions as alloy_sol_types::SolError>::abi_decode_raw(data)
16908                            .map(AllocationManagerErrors::InvalidPermissions)
16909                    }
16910                    InvalidPermissions
16911                },
16912                {
16913                    fn StrategiesMustBeInAscendingOrder(
16914                        data: &[u8],
16915                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16916                        <StrategiesMustBeInAscendingOrder as alloy_sol_types::SolError>::abi_decode_raw(
16917                                data,
16918                            )
16919                            .map(
16920                                AllocationManagerErrors::StrategiesMustBeInAscendingOrder,
16921                            )
16922                    }
16923                    StrategiesMustBeInAscendingOrder
16924                },
16925                {
16926                    fn InvalidShortString(
16927                        data: &[u8],
16928                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16929                        <InvalidShortString as alloy_sol_types::SolError>::abi_decode_raw(data)
16930                            .map(AllocationManagerErrors::InvalidShortString)
16931                    }
16932                    InvalidShortString
16933                },
16934                {
16935                    fn OutOfBounds(
16936                        data: &[u8],
16937                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16938                        <OutOfBounds as alloy_sol_types::SolError>::abi_decode_raw(data)
16939                            .map(AllocationManagerErrors::OutOfBounds)
16940                    }
16941                    OutOfBounds
16942                },
16943                {
16944                    fn InvalidNewPausedStatus(
16945                        data: &[u8],
16946                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16947                        <InvalidNewPausedStatus as alloy_sol_types::SolError>::abi_decode_raw(data)
16948                            .map(AllocationManagerErrors::InvalidNewPausedStatus)
16949                    }
16950                    InvalidNewPausedStatus
16951                },
16952                {
16953                    fn InvalidOperator(
16954                        data: &[u8],
16955                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16956                        <InvalidOperator as alloy_sol_types::SolError>::abi_decode_raw(data)
16957                            .map(AllocationManagerErrors::InvalidOperator)
16958                    }
16959                    InvalidOperator
16960                },
16961                {
16962                    fn AlreadyMemberOfSet(
16963                        data: &[u8],
16964                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16965                        <AlreadyMemberOfSet as alloy_sol_types::SolError>::abi_decode_raw(data)
16966                            .map(AllocationManagerErrors::AlreadyMemberOfSet)
16967                    }
16968                    AlreadyMemberOfSet
16969                },
16970                {
16971                    fn ModificationAlreadyPending(
16972                        data: &[u8],
16973                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16974                        <ModificationAlreadyPending as alloy_sol_types::SolError>::abi_decode_raw(
16975                            data,
16976                        )
16977                        .map(AllocationManagerErrors::ModificationAlreadyPending)
16978                    }
16979                    ModificationAlreadyPending
16980                },
16981                {
16982                    fn InvalidAVSRegistrar(
16983                        data: &[u8],
16984                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16985                        <InvalidAVSRegistrar as alloy_sol_types::SolError>::abi_decode_raw(data)
16986                            .map(AllocationManagerErrors::InvalidAVSRegistrar)
16987                    }
16988                    InvalidAVSRegistrar
16989                },
16990                {
16991                    fn OperatorNotSlashable(
16992                        data: &[u8],
16993                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
16994                        <OperatorNotSlashable as alloy_sol_types::SolError>::abi_decode_raw(data)
16995                            .map(AllocationManagerErrors::OperatorNotSlashable)
16996                    }
16997                    OperatorNotSlashable
16998                },
16999                {
17000                    fn UninitializedAllocationDelay(
17001                        data: &[u8],
17002                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17003                        <UninitializedAllocationDelay as alloy_sol_types::SolError>::abi_decode_raw(
17004                            data,
17005                        )
17006                        .map(AllocationManagerErrors::UninitializedAllocationDelay)
17007                    }
17008                    UninitializedAllocationDelay
17009                },
17010            ];
17011            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
17012                return Err(alloy_sol_types::Error::unknown_selector(
17013                    <Self as alloy_sol_types::SolInterface>::NAME,
17014                    selector,
17015                ));
17016            };
17017            DECODE_SHIMS[idx](data)
17018        }
17019        #[inline]
17020        #[allow(non_snake_case)]
17021        fn abi_decode_raw_validate(
17022            selector: [u8; 4],
17023            data: &[u8],
17024        ) -> alloy_sol_types::Result<Self> {
17025            static DECODE_VALIDATE_SHIMS: &[fn(
17026                &[u8],
17027            ) -> alloy_sol_types::Result<
17028                AllocationManagerErrors,
17029            >] = &[
17030                {
17031                    fn InvalidWadToSlash(
17032                        data: &[u8],
17033                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17034                        <InvalidWadToSlash as alloy_sol_types::SolError>::abi_decode_raw_validate(
17035                            data,
17036                        )
17037                        .map(AllocationManagerErrors::InvalidWadToSlash)
17038                    }
17039                    InvalidWadToSlash
17040                },
17041                {
17042                    fn NotMemberOfSet(
17043                        data: &[u8],
17044                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17045                        <NotMemberOfSet as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
17046                            .map(AllocationManagerErrors::NotMemberOfSet)
17047                    }
17048                    NotMemberOfSet
17049                },
17050                {
17051                    fn InvalidSnapshotOrdering(
17052                        data: &[u8],
17053                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17054                        <InvalidSnapshotOrdering as alloy_sol_types::SolError>::abi_decode_raw_validate(
17055                                data,
17056                            )
17057                            .map(AllocationManagerErrors::InvalidSnapshotOrdering)
17058                    }
17059                    InvalidSnapshotOrdering
17060                },
17061                {
17062                    fn StringTooLong(
17063                        data: &[u8],
17064                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17065                        <StringTooLong as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
17066                            .map(AllocationManagerErrors::StringTooLong)
17067                    }
17068                    StringTooLong
17069                },
17070                {
17071                    fn Empty(data: &[u8]) -> alloy_sol_types::Result<AllocationManagerErrors> {
17072                        <Empty as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
17073                            .map(AllocationManagerErrors::Empty)
17074                    }
17075                    Empty
17076                },
17077                {
17078                    fn InputArrayLengthMismatch(
17079                        data: &[u8],
17080                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17081                        <InputArrayLengthMismatch as alloy_sol_types::SolError>::abi_decode_raw_validate(
17082                                data,
17083                            )
17084                            .map(AllocationManagerErrors::InputArrayLengthMismatch)
17085                    }
17086                    InputArrayLengthMismatch
17087                },
17088                {
17089                    fn InvalidCaller(
17090                        data: &[u8],
17091                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17092                        <InvalidCaller as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
17093                            .map(AllocationManagerErrors::InvalidCaller)
17094                    }
17095                    InvalidCaller
17096                },
17097                {
17098                    fn NonexistentAVSMetadata(
17099                        data: &[u8],
17100                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17101                        <NonexistentAVSMetadata as alloy_sol_types::SolError>::abi_decode_raw_validate(
17102                                data,
17103                            )
17104                            .map(AllocationManagerErrors::NonexistentAVSMetadata)
17105                    }
17106                    NonexistentAVSMetadata
17107                },
17108                {
17109                    fn StrategyAlreadyInOperatorSet(
17110                        data: &[u8],
17111                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17112                        <StrategyAlreadyInOperatorSet as alloy_sol_types::SolError>::abi_decode_raw_validate(
17113                                data,
17114                            )
17115                            .map(AllocationManagerErrors::StrategyAlreadyInOperatorSet)
17116                    }
17117                    StrategyAlreadyInOperatorSet
17118                },
17119                {
17120                    fn StrategyNotInOperatorSet(
17121                        data: &[u8],
17122                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17123                        <StrategyNotInOperatorSet as alloy_sol_types::SolError>::abi_decode_raw_validate(
17124                                data,
17125                            )
17126                            .map(AllocationManagerErrors::StrategyNotInOperatorSet)
17127                    }
17128                    StrategyNotInOperatorSet
17129                },
17130                {
17131                    fn InsufficientMagnitude(
17132                        data: &[u8],
17133                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17134                        <InsufficientMagnitude as alloy_sol_types::SolError>::abi_decode_raw_validate(
17135                                data,
17136                            )
17137                            .map(AllocationManagerErrors::InsufficientMagnitude)
17138                    }
17139                    InsufficientMagnitude
17140                },
17141                {
17142                    fn InputAddressZero(
17143                        data: &[u8],
17144                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17145                        <InputAddressZero as alloy_sol_types::SolError>::abi_decode_raw_validate(
17146                            data,
17147                        )
17148                        .map(AllocationManagerErrors::InputAddressZero)
17149                    }
17150                    InputAddressZero
17151                },
17152                {
17153                    fn OnlyPauser(data: &[u8]) -> alloy_sol_types::Result<AllocationManagerErrors> {
17154                        <OnlyPauser as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
17155                            .map(AllocationManagerErrors::OnlyPauser)
17156                    }
17157                    OnlyPauser
17158                },
17159                {
17160                    fn OnlyUnpauser(
17161                        data: &[u8],
17162                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17163                        <OnlyUnpauser as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
17164                            .map(AllocationManagerErrors::OnlyUnpauser)
17165                    }
17166                    OnlyUnpauser
17167                },
17168                {
17169                    fn InvalidOperatorSet(
17170                        data: &[u8],
17171                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17172                        <InvalidOperatorSet as alloy_sol_types::SolError>::abi_decode_raw_validate(
17173                            data,
17174                        )
17175                        .map(AllocationManagerErrors::InvalidOperatorSet)
17176                    }
17177                    InvalidOperatorSet
17178                },
17179                {
17180                    fn CurrentlyPaused(
17181                        data: &[u8],
17182                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17183                        <CurrentlyPaused as alloy_sol_types::SolError>::abi_decode_raw_validate(
17184                            data,
17185                        )
17186                        .map(AllocationManagerErrors::CurrentlyPaused)
17187                    }
17188                    CurrentlyPaused
17189                },
17190                {
17191                    fn SameMagnitude(
17192                        data: &[u8],
17193                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17194                        <SameMagnitude as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
17195                            .map(AllocationManagerErrors::SameMagnitude)
17196                    }
17197                    SameMagnitude
17198                },
17199                {
17200                    fn InvalidPermissions(
17201                        data: &[u8],
17202                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17203                        <InvalidPermissions as alloy_sol_types::SolError>::abi_decode_raw_validate(
17204                            data,
17205                        )
17206                        .map(AllocationManagerErrors::InvalidPermissions)
17207                    }
17208                    InvalidPermissions
17209                },
17210                {
17211                    fn StrategiesMustBeInAscendingOrder(
17212                        data: &[u8],
17213                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17214                        <StrategiesMustBeInAscendingOrder as alloy_sol_types::SolError>::abi_decode_raw_validate(
17215                                data,
17216                            )
17217                            .map(
17218                                AllocationManagerErrors::StrategiesMustBeInAscendingOrder,
17219                            )
17220                    }
17221                    StrategiesMustBeInAscendingOrder
17222                },
17223                {
17224                    fn InvalidShortString(
17225                        data: &[u8],
17226                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17227                        <InvalidShortString as alloy_sol_types::SolError>::abi_decode_raw_validate(
17228                            data,
17229                        )
17230                        .map(AllocationManagerErrors::InvalidShortString)
17231                    }
17232                    InvalidShortString
17233                },
17234                {
17235                    fn OutOfBounds(
17236                        data: &[u8],
17237                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17238                        <OutOfBounds as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
17239                            .map(AllocationManagerErrors::OutOfBounds)
17240                    }
17241                    OutOfBounds
17242                },
17243                {
17244                    fn InvalidNewPausedStatus(
17245                        data: &[u8],
17246                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17247                        <InvalidNewPausedStatus as alloy_sol_types::SolError>::abi_decode_raw_validate(
17248                                data,
17249                            )
17250                            .map(AllocationManagerErrors::InvalidNewPausedStatus)
17251                    }
17252                    InvalidNewPausedStatus
17253                },
17254                {
17255                    fn InvalidOperator(
17256                        data: &[u8],
17257                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17258                        <InvalidOperator as alloy_sol_types::SolError>::abi_decode_raw_validate(
17259                            data,
17260                        )
17261                        .map(AllocationManagerErrors::InvalidOperator)
17262                    }
17263                    InvalidOperator
17264                },
17265                {
17266                    fn AlreadyMemberOfSet(
17267                        data: &[u8],
17268                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17269                        <AlreadyMemberOfSet as alloy_sol_types::SolError>::abi_decode_raw_validate(
17270                            data,
17271                        )
17272                        .map(AllocationManagerErrors::AlreadyMemberOfSet)
17273                    }
17274                    AlreadyMemberOfSet
17275                },
17276                {
17277                    fn ModificationAlreadyPending(
17278                        data: &[u8],
17279                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17280                        <ModificationAlreadyPending as alloy_sol_types::SolError>::abi_decode_raw_validate(
17281                                data,
17282                            )
17283                            .map(AllocationManagerErrors::ModificationAlreadyPending)
17284                    }
17285                    ModificationAlreadyPending
17286                },
17287                {
17288                    fn InvalidAVSRegistrar(
17289                        data: &[u8],
17290                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17291                        <InvalidAVSRegistrar as alloy_sol_types::SolError>::abi_decode_raw_validate(
17292                            data,
17293                        )
17294                        .map(AllocationManagerErrors::InvalidAVSRegistrar)
17295                    }
17296                    InvalidAVSRegistrar
17297                },
17298                {
17299                    fn OperatorNotSlashable(
17300                        data: &[u8],
17301                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17302                        <OperatorNotSlashable as alloy_sol_types::SolError>::abi_decode_raw_validate(
17303                                data,
17304                            )
17305                            .map(AllocationManagerErrors::OperatorNotSlashable)
17306                    }
17307                    OperatorNotSlashable
17308                },
17309                {
17310                    fn UninitializedAllocationDelay(
17311                        data: &[u8],
17312                    ) -> alloy_sol_types::Result<AllocationManagerErrors> {
17313                        <UninitializedAllocationDelay as alloy_sol_types::SolError>::abi_decode_raw_validate(
17314                                data,
17315                            )
17316                            .map(AllocationManagerErrors::UninitializedAllocationDelay)
17317                    }
17318                    UninitializedAllocationDelay
17319                },
17320            ];
17321            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
17322                return Err(alloy_sol_types::Error::unknown_selector(
17323                    <Self as alloy_sol_types::SolInterface>::NAME,
17324                    selector,
17325                ));
17326            };
17327            DECODE_VALIDATE_SHIMS[idx](data)
17328        }
17329        #[inline]
17330        fn abi_encoded_size(&self) -> usize {
17331            match self {
17332                Self::AlreadyMemberOfSet(inner) => {
17333                    <AlreadyMemberOfSet as alloy_sol_types::SolError>::abi_encoded_size(
17334                        inner,
17335                    )
17336                }
17337                Self::CurrentlyPaused(inner) => {
17338                    <CurrentlyPaused as alloy_sol_types::SolError>::abi_encoded_size(
17339                        inner,
17340                    )
17341                }
17342                Self::Empty(inner) => {
17343                    <Empty as alloy_sol_types::SolError>::abi_encoded_size(inner)
17344                }
17345                Self::InputAddressZero(inner) => {
17346                    <InputAddressZero as alloy_sol_types::SolError>::abi_encoded_size(
17347                        inner,
17348                    )
17349                }
17350                Self::InputArrayLengthMismatch(inner) => {
17351                    <InputArrayLengthMismatch as alloy_sol_types::SolError>::abi_encoded_size(
17352                        inner,
17353                    )
17354                }
17355                Self::InsufficientMagnitude(inner) => {
17356                    <InsufficientMagnitude as alloy_sol_types::SolError>::abi_encoded_size(
17357                        inner,
17358                    )
17359                }
17360                Self::InvalidAVSRegistrar(inner) => {
17361                    <InvalidAVSRegistrar as alloy_sol_types::SolError>::abi_encoded_size(
17362                        inner,
17363                    )
17364                }
17365                Self::InvalidCaller(inner) => {
17366                    <InvalidCaller as alloy_sol_types::SolError>::abi_encoded_size(inner)
17367                }
17368                Self::InvalidNewPausedStatus(inner) => {
17369                    <InvalidNewPausedStatus as alloy_sol_types::SolError>::abi_encoded_size(
17370                        inner,
17371                    )
17372                }
17373                Self::InvalidOperator(inner) => {
17374                    <InvalidOperator as alloy_sol_types::SolError>::abi_encoded_size(
17375                        inner,
17376                    )
17377                }
17378                Self::InvalidOperatorSet(inner) => {
17379                    <InvalidOperatorSet as alloy_sol_types::SolError>::abi_encoded_size(
17380                        inner,
17381                    )
17382                }
17383                Self::InvalidPermissions(inner) => {
17384                    <InvalidPermissions as alloy_sol_types::SolError>::abi_encoded_size(
17385                        inner,
17386                    )
17387                }
17388                Self::InvalidShortString(inner) => {
17389                    <InvalidShortString as alloy_sol_types::SolError>::abi_encoded_size(
17390                        inner,
17391                    )
17392                }
17393                Self::InvalidSnapshotOrdering(inner) => {
17394                    <InvalidSnapshotOrdering as alloy_sol_types::SolError>::abi_encoded_size(
17395                        inner,
17396                    )
17397                }
17398                Self::InvalidWadToSlash(inner) => {
17399                    <InvalidWadToSlash as alloy_sol_types::SolError>::abi_encoded_size(
17400                        inner,
17401                    )
17402                }
17403                Self::ModificationAlreadyPending(inner) => {
17404                    <ModificationAlreadyPending as alloy_sol_types::SolError>::abi_encoded_size(
17405                        inner,
17406                    )
17407                }
17408                Self::NonexistentAVSMetadata(inner) => {
17409                    <NonexistentAVSMetadata as alloy_sol_types::SolError>::abi_encoded_size(
17410                        inner,
17411                    )
17412                }
17413                Self::NotMemberOfSet(inner) => {
17414                    <NotMemberOfSet as alloy_sol_types::SolError>::abi_encoded_size(
17415                        inner,
17416                    )
17417                }
17418                Self::OnlyPauser(inner) => {
17419                    <OnlyPauser as alloy_sol_types::SolError>::abi_encoded_size(inner)
17420                }
17421                Self::OnlyUnpauser(inner) => {
17422                    <OnlyUnpauser as alloy_sol_types::SolError>::abi_encoded_size(inner)
17423                }
17424                Self::OperatorNotSlashable(inner) => {
17425                    <OperatorNotSlashable as alloy_sol_types::SolError>::abi_encoded_size(
17426                        inner,
17427                    )
17428                }
17429                Self::OutOfBounds(inner) => {
17430                    <OutOfBounds as alloy_sol_types::SolError>::abi_encoded_size(inner)
17431                }
17432                Self::SameMagnitude(inner) => {
17433                    <SameMagnitude as alloy_sol_types::SolError>::abi_encoded_size(inner)
17434                }
17435                Self::StrategiesMustBeInAscendingOrder(inner) => {
17436                    <StrategiesMustBeInAscendingOrder as alloy_sol_types::SolError>::abi_encoded_size(
17437                        inner,
17438                    )
17439                }
17440                Self::StrategyAlreadyInOperatorSet(inner) => {
17441                    <StrategyAlreadyInOperatorSet as alloy_sol_types::SolError>::abi_encoded_size(
17442                        inner,
17443                    )
17444                }
17445                Self::StrategyNotInOperatorSet(inner) => {
17446                    <StrategyNotInOperatorSet as alloy_sol_types::SolError>::abi_encoded_size(
17447                        inner,
17448                    )
17449                }
17450                Self::StringTooLong(inner) => {
17451                    <StringTooLong as alloy_sol_types::SolError>::abi_encoded_size(inner)
17452                }
17453                Self::UninitializedAllocationDelay(inner) => {
17454                    <UninitializedAllocationDelay as alloy_sol_types::SolError>::abi_encoded_size(
17455                        inner,
17456                    )
17457                }
17458            }
17459        }
17460        #[inline]
17461        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
17462            match self {
17463                Self::AlreadyMemberOfSet(inner) => {
17464                    <AlreadyMemberOfSet as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
17465                }
17466                Self::CurrentlyPaused(inner) => {
17467                    <CurrentlyPaused as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
17468                }
17469                Self::Empty(inner) => {
17470                    <Empty as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
17471                }
17472                Self::InputAddressZero(inner) => {
17473                    <InputAddressZero as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
17474                }
17475                Self::InputArrayLengthMismatch(inner) => {
17476                    <InputArrayLengthMismatch as alloy_sol_types::SolError>::abi_encode_raw(
17477                        inner, out,
17478                    )
17479                }
17480                Self::InsufficientMagnitude(inner) => {
17481                    <InsufficientMagnitude as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
17482                }
17483                Self::InvalidAVSRegistrar(inner) => {
17484                    <InvalidAVSRegistrar as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
17485                }
17486                Self::InvalidCaller(inner) => {
17487                    <InvalidCaller as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
17488                }
17489                Self::InvalidNewPausedStatus(inner) => {
17490                    <InvalidNewPausedStatus as alloy_sol_types::SolError>::abi_encode_raw(
17491                        inner, out,
17492                    )
17493                }
17494                Self::InvalidOperator(inner) => {
17495                    <InvalidOperator as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
17496                }
17497                Self::InvalidOperatorSet(inner) => {
17498                    <InvalidOperatorSet as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
17499                }
17500                Self::InvalidPermissions(inner) => {
17501                    <InvalidPermissions as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
17502                }
17503                Self::InvalidShortString(inner) => {
17504                    <InvalidShortString as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
17505                }
17506                Self::InvalidSnapshotOrdering(inner) => {
17507                    <InvalidSnapshotOrdering as alloy_sol_types::SolError>::abi_encode_raw(
17508                        inner, out,
17509                    )
17510                }
17511                Self::InvalidWadToSlash(inner) => {
17512                    <InvalidWadToSlash as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
17513                }
17514                Self::ModificationAlreadyPending(inner) => {
17515                    <ModificationAlreadyPending as alloy_sol_types::SolError>::abi_encode_raw(
17516                        inner, out,
17517                    )
17518                }
17519                Self::NonexistentAVSMetadata(inner) => {
17520                    <NonexistentAVSMetadata as alloy_sol_types::SolError>::abi_encode_raw(
17521                        inner, out,
17522                    )
17523                }
17524                Self::NotMemberOfSet(inner) => {
17525                    <NotMemberOfSet as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
17526                }
17527                Self::OnlyPauser(inner) => {
17528                    <OnlyPauser as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
17529                }
17530                Self::OnlyUnpauser(inner) => {
17531                    <OnlyUnpauser as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
17532                }
17533                Self::OperatorNotSlashable(inner) => {
17534                    <OperatorNotSlashable as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
17535                }
17536                Self::OutOfBounds(inner) => {
17537                    <OutOfBounds as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
17538                }
17539                Self::SameMagnitude(inner) => {
17540                    <SameMagnitude as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
17541                }
17542                Self::StrategiesMustBeInAscendingOrder(inner) => {
17543                    <StrategiesMustBeInAscendingOrder as alloy_sol_types::SolError>::abi_encode_raw(
17544                        inner, out,
17545                    )
17546                }
17547                Self::StrategyAlreadyInOperatorSet(inner) => {
17548                    <StrategyAlreadyInOperatorSet as alloy_sol_types::SolError>::abi_encode_raw(
17549                        inner, out,
17550                    )
17551                }
17552                Self::StrategyNotInOperatorSet(inner) => {
17553                    <StrategyNotInOperatorSet as alloy_sol_types::SolError>::abi_encode_raw(
17554                        inner, out,
17555                    )
17556                }
17557                Self::StringTooLong(inner) => {
17558                    <StringTooLong as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
17559                }
17560                Self::UninitializedAllocationDelay(inner) => {
17561                    <UninitializedAllocationDelay as alloy_sol_types::SolError>::abi_encode_raw(
17562                        inner, out,
17563                    )
17564                }
17565            }
17566        }
17567    }
17568    ///Container for all the [`AllocationManager`](self) events.
17569    #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq, Eq, Hash)]
17570    pub enum AllocationManagerEvents {
17571        #[allow(missing_docs)]
17572        AVSMetadataURIUpdated(AVSMetadataURIUpdated),
17573        #[allow(missing_docs)]
17574        AVSRegistrarSet(AVSRegistrarSet),
17575        #[allow(missing_docs)]
17576        AllocationDelaySet(AllocationDelaySet),
17577        #[allow(missing_docs)]
17578        AllocationUpdated(AllocationUpdated),
17579        #[allow(missing_docs)]
17580        EncumberedMagnitudeUpdated(EncumberedMagnitudeUpdated),
17581        #[allow(missing_docs)]
17582        Initialized(Initialized),
17583        #[allow(missing_docs)]
17584        MaxMagnitudeUpdated(MaxMagnitudeUpdated),
17585        #[allow(missing_docs)]
17586        OperatorAddedToOperatorSet(OperatorAddedToOperatorSet),
17587        #[allow(missing_docs)]
17588        OperatorRemovedFromOperatorSet(OperatorRemovedFromOperatorSet),
17589        #[allow(missing_docs)]
17590        OperatorSetCreated(OperatorSetCreated),
17591        #[allow(missing_docs)]
17592        OperatorSlashed(OperatorSlashed),
17593        #[allow(missing_docs)]
17594        OwnershipTransferred(OwnershipTransferred),
17595        #[allow(missing_docs)]
17596        Paused(Paused),
17597        #[allow(missing_docs)]
17598        StrategyAddedToOperatorSet(StrategyAddedToOperatorSet),
17599        #[allow(missing_docs)]
17600        StrategyRemovedFromOperatorSet(StrategyRemovedFromOperatorSet),
17601        #[allow(missing_docs)]
17602        Unpaused(Unpaused),
17603    }
17604    #[automatically_derived]
17605    impl AllocationManagerEvents {
17606        /// All the selectors of this enum.
17607        ///
17608        /// Note that the selectors might not be in the same order as the variants.
17609        /// No guarantees are made about the order of the selectors.
17610        ///
17611        /// Prefer using `SolInterface` methods instead.
17612        pub const SELECTORS: &'static [[u8; 32usize]] = &[
17613            [
17614                20u8, 135u8, 175u8, 84u8, 24u8, 196u8, 126u8, 229u8, 234u8, 69u8, 239u8, 74u8,
17615                147u8, 57u8, 134u8, 104u8, 18u8, 8u8, 144u8, 119u8, 74u8, 158u8, 19u8, 72u8, 126u8,
17616                97u8, 233u8, 220u8, 59u8, 175u8, 118u8, 221u8,
17617            ],
17618            [
17619                28u8, 100u8, 88u8, 7u8, 154u8, 65u8, 7u8, 125u8, 0u8, 60u8, 17u8, 250u8, 249u8,
17620                191u8, 9u8, 126u8, 105u8, 59u8, 214u8, 121u8, 121u8, 228u8, 230u8, 80u8, 11u8,
17621                172u8, 123u8, 41u8, 219u8, 119u8, 155u8, 92u8,
17622            ],
17623            [
17624                42u8, 233u8, 69u8, 196u8, 12u8, 68u8, 220u8, 14u8, 194u8, 99u8, 249u8, 86u8, 9u8,
17625                195u8, 253u8, 198u8, 149u8, 46u8, 10u8, 239u8, 162u8, 45u8, 99u8, 116u8, 228u8,
17626                79u8, 44u8, 153u8, 122u8, 206u8, 223u8, 133u8,
17627            ],
17628            [
17629                49u8, 98u8, 146u8, 133u8, 234u8, 210u8, 51u8, 90u8, 224u8, 147u8, 63u8, 134u8,
17630                237u8, 42u8, 230u8, 51u8, 33u8, 247u8, 175u8, 119u8, 180u8, 230u8, 234u8, 171u8,
17631                196u8, 44u8, 5u8, 120u8, 128u8, 151u8, 126u8, 108u8,
17632            ],
17633            [
17634                53u8, 130u8, 209u8, 130u8, 142u8, 38u8, 191u8, 86u8, 189u8, 128u8, 21u8, 2u8,
17635                188u8, 2u8, 26u8, 192u8, 188u8, 138u8, 251u8, 87u8, 200u8, 38u8, 228u8, 152u8,
17636                107u8, 69u8, 89u8, 60u8, 143u8, 173u8, 56u8, 156u8,
17637            ],
17638            [
17639                67u8, 35u8, 46u8, 223u8, 144u8, 113u8, 117u8, 61u8, 35u8, 33u8, 229u8, 250u8,
17640                126u8, 1u8, 131u8, 99u8, 238u8, 36u8, 142u8, 95u8, 33u8, 66u8, 230u8, 192u8, 142u8,
17641                221u8, 50u8, 101u8, 191u8, 180u8, 137u8, 94u8,
17642            ],
17643            [
17644                78u8, 133u8, 117u8, 29u8, 99u8, 49u8, 80u8, 108u8, 108u8, 98u8, 51u8, 95u8, 32u8,
17645                126u8, 179u8, 31u8, 18u8, 166u8, 30u8, 87u8, 15u8, 52u8, 245u8, 193u8, 118u8, 64u8,
17646                48u8, 135u8, 133u8, 198u8, 212u8, 219u8,
17647            ],
17648            [
17649                122u8, 178u8, 96u8, 254u8, 10u8, 241u8, 147u8, 219u8, 95u8, 73u8, 134u8, 119u8,
17650                13u8, 131u8, 27u8, 218u8, 78u8, 164u8, 96u8, 153u8, 220u8, 129u8, 126u8, 139u8,
17651                103u8, 22u8, 220u8, 174u8, 138u8, 248u8, 232u8, 139u8,
17652            ],
17653            [
17654                123u8, 75u8, 7u8, 61u8, 128u8, 220u8, 172u8, 85u8, 161u8, 17u8, 119u8, 216u8, 69u8,
17655                154u8, 217u8, 246u8, 100u8, 206u8, 235u8, 145u8, 247u8, 31u8, 39u8, 22u8, 123u8,
17656                177u8, 79u8, 129u8, 82u8, 167u8, 238u8, 238u8,
17657            ],
17658            [
17659                127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8, 19u8, 56u8,
17660                82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8, 146u8, 20u8, 96u8,
17661                206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8,
17662            ],
17663            [
17664                128u8, 150u8, 154u8, 210u8, 148u8, 40u8, 214u8, 121u8, 126u8, 231u8, 170u8, 208u8,
17665                132u8, 249u8, 228u8, 164u8, 42u8, 130u8, 252u8, 80u8, 109u8, 205u8, 44u8, 163u8,
17666                182u8, 251u8, 67u8, 31u8, 133u8, 204u8, 235u8, 229u8,
17667            ],
17668            [
17669                139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8, 208u8,
17670                164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8, 175u8, 227u8,
17671                180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
17672            ],
17673            [
17674                168u8, 156u8, 29u8, 194u8, 67u8, 216u8, 144u8, 138u8, 150u8, 221u8, 132u8, 148u8,
17675                75u8, 204u8, 151u8, 214u8, 188u8, 106u8, 192u8, 13u8, 215u8, 142u8, 32u8, 98u8,
17676                21u8, 118u8, 190u8, 106u8, 60u8, 148u8, 55u8, 19u8,
17677            ],
17678            [
17679                171u8, 64u8, 163u8, 116u8, 188u8, 81u8, 222u8, 55u8, 34u8, 0u8, 168u8, 188u8,
17680                152u8, 26u8, 248u8, 201u8, 236u8, 220u8, 8u8, 223u8, 218u8, 239u8, 11u8, 182u8,
17681                224u8, 159u8, 136u8, 243u8, 198u8, 22u8, 239u8, 61u8,
17682            ],
17683            [
17684                172u8, 249u8, 9u8, 95u8, 235u8, 58u8, 55u8, 12u8, 156u8, 246u8, 146u8, 66u8, 28u8,
17685                105u8, 239u8, 50u8, 13u8, 77u8, 181u8, 198u8, 110u8, 106u8, 125u8, 41u8, 199u8,
17686                105u8, 78u8, 176u8, 35u8, 100u8, 252u8, 85u8,
17687            ],
17688            [
17689                173u8, 52u8, 195u8, 7u8, 11u8, 225u8, 223u8, 251u8, 202u8, 164u8, 153u8, 208u8,
17690                0u8, 186u8, 43u8, 141u8, 152u8, 72u8, 174u8, 252u8, 172u8, 48u8, 89u8, 223u8, 36u8,
17691                93u8, 217u8, 92u8, 78u8, 206u8, 20u8, 254u8,
17692            ],
17693        ];
17694    }
17695    #[automatically_derived]
17696    impl alloy_sol_types::SolEventInterface for AllocationManagerEvents {
17697        const NAME: &'static str = "AllocationManagerEvents";
17698        const COUNT: usize = 16usize;
17699        fn decode_raw_log(
17700            topics: &[alloy_sol_types::Word],
17701            data: &[u8],
17702        ) -> alloy_sol_types::Result<Self> {
17703            match topics.first().copied() {
17704                Some(<AVSMetadataURIUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
17705                    <AVSMetadataURIUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
17706                        topics, data,
17707                    )
17708                    .map(Self::AVSMetadataURIUpdated)
17709                }
17710                Some(<AVSRegistrarSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
17711                    <AVSRegistrarSet as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
17712                        .map(Self::AVSRegistrarSet)
17713                }
17714                Some(<AllocationDelaySet as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
17715                    <AllocationDelaySet as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
17716                        .map(Self::AllocationDelaySet)
17717                }
17718                Some(<AllocationUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
17719                    <AllocationUpdated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
17720                        .map(Self::AllocationUpdated)
17721                }
17722                Some(<EncumberedMagnitudeUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
17723                    <EncumberedMagnitudeUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
17724                        topics, data,
17725                    )
17726                    .map(Self::EncumberedMagnitudeUpdated)
17727                }
17728                Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
17729                    <Initialized as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
17730                        .map(Self::Initialized)
17731                }
17732                Some(<MaxMagnitudeUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
17733                    <MaxMagnitudeUpdated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
17734                        .map(Self::MaxMagnitudeUpdated)
17735                }
17736                Some(<OperatorAddedToOperatorSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
17737                    <OperatorAddedToOperatorSet as alloy_sol_types::SolEvent>::decode_raw_log(
17738                        topics, data,
17739                    )
17740                    .map(Self::OperatorAddedToOperatorSet)
17741                }
17742                Some(
17743                    <OperatorRemovedFromOperatorSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
17744                ) => <OperatorRemovedFromOperatorSet as alloy_sol_types::SolEvent>::decode_raw_log(
17745                    topics, data,
17746                )
17747                .map(Self::OperatorRemovedFromOperatorSet),
17748                Some(<OperatorSetCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
17749                    <OperatorSetCreated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
17750                        .map(Self::OperatorSetCreated)
17751                }
17752                Some(<OperatorSlashed as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
17753                    <OperatorSlashed as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
17754                        .map(Self::OperatorSlashed)
17755                }
17756                Some(<OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
17757                    <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
17758                        topics, data,
17759                    )
17760                    .map(Self::OwnershipTransferred)
17761                }
17762                Some(<Paused as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
17763                    <Paused as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
17764                        .map(Self::Paused)
17765                }
17766                Some(<StrategyAddedToOperatorSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
17767                    <StrategyAddedToOperatorSet as alloy_sol_types::SolEvent>::decode_raw_log(
17768                        topics, data,
17769                    )
17770                    .map(Self::StrategyAddedToOperatorSet)
17771                }
17772                Some(
17773                    <StrategyRemovedFromOperatorSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
17774                ) => <StrategyRemovedFromOperatorSet as alloy_sol_types::SolEvent>::decode_raw_log(
17775                    topics, data,
17776                )
17777                .map(Self::StrategyRemovedFromOperatorSet),
17778                Some(<Unpaused as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
17779                    <Unpaused as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
17780                        .map(Self::Unpaused)
17781                }
17782                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
17783                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
17784                    log: alloy_sol_types::private::Box::new(
17785                        alloy_sol_types::private::LogData::new_unchecked(
17786                            topics.to_vec(),
17787                            data.to_vec().into(),
17788                        ),
17789                    ),
17790                }),
17791            }
17792        }
17793    }
17794    #[automatically_derived]
17795    impl alloy_sol_types::private::IntoLogData for AllocationManagerEvents {
17796        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
17797            match self {
17798                Self::AVSMetadataURIUpdated(inner) => {
17799                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
17800                }
17801                Self::AVSRegistrarSet(inner) => {
17802                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
17803                }
17804                Self::AllocationDelaySet(inner) => {
17805                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
17806                }
17807                Self::AllocationUpdated(inner) => {
17808                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
17809                }
17810                Self::EncumberedMagnitudeUpdated(inner) => {
17811                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
17812                }
17813                Self::Initialized(inner) => {
17814                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
17815                }
17816                Self::MaxMagnitudeUpdated(inner) => {
17817                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
17818                }
17819                Self::OperatorAddedToOperatorSet(inner) => {
17820                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
17821                }
17822                Self::OperatorRemovedFromOperatorSet(inner) => {
17823                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
17824                }
17825                Self::OperatorSetCreated(inner) => {
17826                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
17827                }
17828                Self::OperatorSlashed(inner) => {
17829                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
17830                }
17831                Self::OwnershipTransferred(inner) => {
17832                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
17833                }
17834                Self::Paused(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
17835                Self::StrategyAddedToOperatorSet(inner) => {
17836                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
17837                }
17838                Self::StrategyRemovedFromOperatorSet(inner) => {
17839                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
17840                }
17841                Self::Unpaused(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
17842            }
17843        }
17844        fn into_log_data(self) -> alloy_sol_types::private::LogData {
17845            match self {
17846                Self::AVSMetadataURIUpdated(inner) => {
17847                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
17848                }
17849                Self::AVSRegistrarSet(inner) => {
17850                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
17851                }
17852                Self::AllocationDelaySet(inner) => {
17853                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
17854                }
17855                Self::AllocationUpdated(inner) => {
17856                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
17857                }
17858                Self::EncumberedMagnitudeUpdated(inner) => {
17859                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
17860                }
17861                Self::Initialized(inner) => {
17862                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
17863                }
17864                Self::MaxMagnitudeUpdated(inner) => {
17865                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
17866                }
17867                Self::OperatorAddedToOperatorSet(inner) => {
17868                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
17869                }
17870                Self::OperatorRemovedFromOperatorSet(inner) => {
17871                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
17872                }
17873                Self::OperatorSetCreated(inner) => {
17874                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
17875                }
17876                Self::OperatorSlashed(inner) => {
17877                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
17878                }
17879                Self::OwnershipTransferred(inner) => {
17880                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
17881                }
17882                Self::Paused(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
17883                Self::StrategyAddedToOperatorSet(inner) => {
17884                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
17885                }
17886                Self::StrategyRemovedFromOperatorSet(inner) => {
17887                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
17888                }
17889                Self::Unpaused(inner) => {
17890                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
17891                }
17892            }
17893        }
17894    }
17895    use alloy::contract as alloy_contract;
17896    /**Creates a new wrapper around an on-chain [`AllocationManager`](self) contract instance.
17897
17898    See the [wrapper's documentation](`AllocationManagerInstance`) for more details.*/
17899    #[inline]
17900    pub const fn new<
17901        P: alloy_contract::private::Provider<N>,
17902        N: alloy_contract::private::Network,
17903    >(
17904        address: alloy_sol_types::private::Address,
17905        provider: P,
17906    ) -> AllocationManagerInstance<P, N> {
17907        AllocationManagerInstance::<P, N>::new(address, provider)
17908    }
17909    /**Deploys this contract using the given `provider` and constructor arguments, if any.
17910
17911    Returns a new instance of the contract, if the deployment was successful.
17912
17913    For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
17914    #[inline]
17915    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
17916        provider: P,
17917        _delegation: alloy::sol_types::private::Address,
17918        _pauserRegistry: alloy::sol_types::private::Address,
17919        _permissionController: alloy::sol_types::private::Address,
17920        _DEALLOCATION_DELAY: u32,
17921        _ALLOCATION_CONFIGURATION_DELAY: u32,
17922        _version: alloy::sol_types::private::String,
17923    ) -> impl ::core::future::Future<Output = alloy_contract::Result<AllocationManagerInstance<P, N>>>
17924    {
17925        AllocationManagerInstance::<P, N>::deploy(
17926            provider,
17927            _delegation,
17928            _pauserRegistry,
17929            _permissionController,
17930            _DEALLOCATION_DELAY,
17931            _ALLOCATION_CONFIGURATION_DELAY,
17932            _version,
17933        )
17934    }
17935    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
17936    and constructor arguments, if any.
17937
17938    This is a simple wrapper around creating a `RawCallBuilder` with the data set to
17939    the bytecode concatenated with the constructor's ABI-encoded arguments.*/
17940    #[inline]
17941    pub fn deploy_builder<
17942        P: alloy_contract::private::Provider<N>,
17943        N: alloy_contract::private::Network,
17944    >(
17945        provider: P,
17946        _delegation: alloy::sol_types::private::Address,
17947        _pauserRegistry: alloy::sol_types::private::Address,
17948        _permissionController: alloy::sol_types::private::Address,
17949        _DEALLOCATION_DELAY: u32,
17950        _ALLOCATION_CONFIGURATION_DELAY: u32,
17951        _version: alloy::sol_types::private::String,
17952    ) -> alloy_contract::RawCallBuilder<P, N> {
17953        AllocationManagerInstance::<P, N>::deploy_builder(
17954            provider,
17955            _delegation,
17956            _pauserRegistry,
17957            _permissionController,
17958            _DEALLOCATION_DELAY,
17959            _ALLOCATION_CONFIGURATION_DELAY,
17960            _version,
17961        )
17962    }
17963    /**A [`AllocationManager`](self) instance.
17964
17965    Contains type-safe methods for interacting with an on-chain instance of the
17966    [`AllocationManager`](self) contract located at a given `address`, using a given
17967    provider `P`.
17968
17969    If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
17970    documentation on how to provide it), the `deploy` and `deploy_builder` methods can
17971    be used to deploy a new instance of the contract.
17972
17973    See the [module-level documentation](self) for all the available methods.*/
17974    #[derive(Clone)]
17975    pub struct AllocationManagerInstance<P, N = alloy_contract::private::Ethereum> {
17976        address: alloy_sol_types::private::Address,
17977        provider: P,
17978        _network: ::core::marker::PhantomData<N>,
17979    }
17980    #[automatically_derived]
17981    impl<P, N> ::core::fmt::Debug for AllocationManagerInstance<P, N> {
17982        #[inline]
17983        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
17984            f.debug_tuple("AllocationManagerInstance")
17985                .field(&self.address)
17986                .finish()
17987        }
17988    }
17989    /// Instantiation and getters/setters.
17990    #[automatically_derived]
17991    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
17992        AllocationManagerInstance<P, N>
17993    {
17994        /**Creates a new wrapper around an on-chain [`AllocationManager`](self) contract instance.
17995
17996        See the [wrapper's documentation](`AllocationManagerInstance`) for more details.*/
17997        #[inline]
17998        pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self {
17999            Self {
18000                address,
18001                provider,
18002                _network: ::core::marker::PhantomData,
18003            }
18004        }
18005        /**Deploys this contract using the given `provider` and constructor arguments, if any.
18006
18007        Returns a new instance of the contract, if the deployment was successful.
18008
18009        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
18010        #[inline]
18011        pub async fn deploy(
18012            provider: P,
18013            _delegation: alloy::sol_types::private::Address,
18014            _pauserRegistry: alloy::sol_types::private::Address,
18015            _permissionController: alloy::sol_types::private::Address,
18016            _DEALLOCATION_DELAY: u32,
18017            _ALLOCATION_CONFIGURATION_DELAY: u32,
18018            _version: alloy::sol_types::private::String,
18019        ) -> alloy_contract::Result<AllocationManagerInstance<P, N>> {
18020            let call_builder = Self::deploy_builder(
18021                provider,
18022                _delegation,
18023                _pauserRegistry,
18024                _permissionController,
18025                _DEALLOCATION_DELAY,
18026                _ALLOCATION_CONFIGURATION_DELAY,
18027                _version,
18028            );
18029            let contract_address = call_builder.deploy().await?;
18030            Ok(Self::new(contract_address, call_builder.provider))
18031        }
18032        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
18033        and constructor arguments, if any.
18034
18035        This is a simple wrapper around creating a `RawCallBuilder` with the data set to
18036        the bytecode concatenated with the constructor's ABI-encoded arguments.*/
18037        #[inline]
18038        pub fn deploy_builder(
18039            provider: P,
18040            _delegation: alloy::sol_types::private::Address,
18041            _pauserRegistry: alloy::sol_types::private::Address,
18042            _permissionController: alloy::sol_types::private::Address,
18043            _DEALLOCATION_DELAY: u32,
18044            _ALLOCATION_CONFIGURATION_DELAY: u32,
18045            _version: alloy::sol_types::private::String,
18046        ) -> alloy_contract::RawCallBuilder<P, N> {
18047            alloy_contract::RawCallBuilder::new_raw_deploy(
18048                provider,
18049                [
18050                    &BYTECODE[..],
18051                    &alloy_sol_types::SolConstructor::abi_encode(&constructorCall {
18052                        _delegation,
18053                        _pauserRegistry,
18054                        _permissionController,
18055                        _DEALLOCATION_DELAY,
18056                        _ALLOCATION_CONFIGURATION_DELAY,
18057                        _version,
18058                    })[..],
18059                ]
18060                .concat()
18061                .into(),
18062            )
18063        }
18064        /// Returns a reference to the address.
18065        #[inline]
18066        pub const fn address(&self) -> &alloy_sol_types::private::Address {
18067            &self.address
18068        }
18069        /// Sets the address.
18070        #[inline]
18071        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
18072            self.address = address;
18073        }
18074        /// Sets the address and returns `self`.
18075        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
18076            self.set_address(address);
18077            self
18078        }
18079        /// Returns a reference to the provider.
18080        #[inline]
18081        pub const fn provider(&self) -> &P {
18082            &self.provider
18083        }
18084    }
18085    impl<P: ::core::clone::Clone, N> AllocationManagerInstance<&P, N> {
18086        /// Clones the provider and returns a new instance with the cloned provider.
18087        #[inline]
18088        pub fn with_cloned_provider(self) -> AllocationManagerInstance<P, N> {
18089            AllocationManagerInstance {
18090                address: self.address,
18091                provider: ::core::clone::Clone::clone(&self.provider),
18092                _network: ::core::marker::PhantomData,
18093            }
18094        }
18095    }
18096    /// Function calls.
18097    #[automatically_derived]
18098    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
18099        AllocationManagerInstance<P, N>
18100    {
18101        /// Creates a new call builder using this contract instance's provider and address.
18102        ///
18103        /// Note that the call can be any function call, not just those defined in this
18104        /// contract. Prefer using the other methods for building type-safe contract calls.
18105        pub fn call_builder<C: alloy_sol_types::SolCall>(
18106            &self,
18107            call: &C,
18108        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
18109            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
18110        }
18111        ///Creates a new call builder for the [`ALLOCATION_CONFIGURATION_DELAY`] function.
18112        pub fn ALLOCATION_CONFIGURATION_DELAY(
18113            &self,
18114        ) -> alloy_contract::SolCallBuilder<&P, ALLOCATION_CONFIGURATION_DELAYCall, N> {
18115            self.call_builder(&ALLOCATION_CONFIGURATION_DELAYCall)
18116        }
18117        ///Creates a new call builder for the [`DEALLOCATION_DELAY`] function.
18118        pub fn DEALLOCATION_DELAY(
18119            &self,
18120        ) -> alloy_contract::SolCallBuilder<&P, DEALLOCATION_DELAYCall, N> {
18121            self.call_builder(&DEALLOCATION_DELAYCall)
18122        }
18123        ///Creates a new call builder for the [`addStrategiesToOperatorSet`] function.
18124        pub fn addStrategiesToOperatorSet(
18125            &self,
18126            avs: alloy::sol_types::private::Address,
18127            operatorSetId: u32,
18128            strategies: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
18129        ) -> alloy_contract::SolCallBuilder<&P, addStrategiesToOperatorSetCall, N> {
18130            self.call_builder(&addStrategiesToOperatorSetCall {
18131                avs,
18132                operatorSetId,
18133                strategies,
18134            })
18135        }
18136        ///Creates a new call builder for the [`clearDeallocationQueue`] function.
18137        pub fn clearDeallocationQueue(
18138            &self,
18139            operator: alloy::sol_types::private::Address,
18140            strategies: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
18141            numToClear: alloy::sol_types::private::Vec<u16>,
18142        ) -> alloy_contract::SolCallBuilder<&P, clearDeallocationQueueCall, N> {
18143            self.call_builder(&clearDeallocationQueueCall {
18144                operator,
18145                strategies,
18146                numToClear,
18147            })
18148        }
18149        ///Creates a new call builder for the [`createOperatorSets`] function.
18150        pub fn createOperatorSets(
18151            &self,
18152            avs: alloy::sol_types::private::Address,
18153            params: alloy::sol_types::private::Vec<
18154                <IAllocationManagerTypes::CreateSetParams as alloy::sol_types::SolType>::RustType,
18155            >,
18156        ) -> alloy_contract::SolCallBuilder<&P, createOperatorSetsCall, N> {
18157            self.call_builder(&createOperatorSetsCall { avs, params })
18158        }
18159        ///Creates a new call builder for the [`delegation`] function.
18160        pub fn delegation(&self) -> alloy_contract::SolCallBuilder<&P, delegationCall, N> {
18161            self.call_builder(&delegationCall)
18162        }
18163        ///Creates a new call builder for the [`deregisterFromOperatorSets`] function.
18164        pub fn deregisterFromOperatorSets(
18165            &self,
18166            params: <IAllocationManagerTypes::DeregisterParams as alloy::sol_types::SolType>::RustType,
18167        ) -> alloy_contract::SolCallBuilder<&P, deregisterFromOperatorSetsCall, N> {
18168            self.call_builder(&deregisterFromOperatorSetsCall { params })
18169        }
18170        ///Creates a new call builder for the [`getAVSRegistrar`] function.
18171        pub fn getAVSRegistrar(
18172            &self,
18173            avs: alloy::sol_types::private::Address,
18174        ) -> alloy_contract::SolCallBuilder<&P, getAVSRegistrarCall, N> {
18175            self.call_builder(&getAVSRegistrarCall { avs })
18176        }
18177        ///Creates a new call builder for the [`getAllocatableMagnitude`] function.
18178        pub fn getAllocatableMagnitude(
18179            &self,
18180            operator: alloy::sol_types::private::Address,
18181            strategy: alloy::sol_types::private::Address,
18182        ) -> alloy_contract::SolCallBuilder<&P, getAllocatableMagnitudeCall, N> {
18183            self.call_builder(&getAllocatableMagnitudeCall { operator, strategy })
18184        }
18185        ///Creates a new call builder for the [`getAllocatedSets`] function.
18186        pub fn getAllocatedSets(
18187            &self,
18188            operator: alloy::sol_types::private::Address,
18189        ) -> alloy_contract::SolCallBuilder<&P, getAllocatedSetsCall, N> {
18190            self.call_builder(&getAllocatedSetsCall { operator })
18191        }
18192        ///Creates a new call builder for the [`getAllocatedStake`] function.
18193        pub fn getAllocatedStake(
18194            &self,
18195            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
18196            operators: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
18197            strategies: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
18198        ) -> alloy_contract::SolCallBuilder<&P, getAllocatedStakeCall, N> {
18199            self.call_builder(&getAllocatedStakeCall {
18200                operatorSet,
18201                operators,
18202                strategies,
18203            })
18204        }
18205        ///Creates a new call builder for the [`getAllocatedStrategies`] function.
18206        pub fn getAllocatedStrategies(
18207            &self,
18208            operator: alloy::sol_types::private::Address,
18209            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
18210        ) -> alloy_contract::SolCallBuilder<&P, getAllocatedStrategiesCall, N> {
18211            self.call_builder(&getAllocatedStrategiesCall {
18212                operator,
18213                operatorSet,
18214            })
18215        }
18216        ///Creates a new call builder for the [`getAllocation`] function.
18217        pub fn getAllocation(
18218            &self,
18219            operator: alloy::sol_types::private::Address,
18220            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
18221            strategy: alloy::sol_types::private::Address,
18222        ) -> alloy_contract::SolCallBuilder<&P, getAllocationCall, N> {
18223            self.call_builder(&getAllocationCall {
18224                operator,
18225                operatorSet,
18226                strategy,
18227            })
18228        }
18229        ///Creates a new call builder for the [`getAllocationDelay`] function.
18230        pub fn getAllocationDelay(
18231            &self,
18232            operator: alloy::sol_types::private::Address,
18233        ) -> alloy_contract::SolCallBuilder<&P, getAllocationDelayCall, N> {
18234            self.call_builder(&getAllocationDelayCall { operator })
18235        }
18236        ///Creates a new call builder for the [`getAllocations`] function.
18237        pub fn getAllocations(
18238            &self,
18239            operators: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
18240            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
18241            strategy: alloy::sol_types::private::Address,
18242        ) -> alloy_contract::SolCallBuilder<&P, getAllocationsCall, N> {
18243            self.call_builder(&getAllocationsCall {
18244                operators,
18245                operatorSet,
18246                strategy,
18247            })
18248        }
18249        ///Creates a new call builder for the [`getEncumberedMagnitude`] function.
18250        pub fn getEncumberedMagnitude(
18251            &self,
18252            operator: alloy::sol_types::private::Address,
18253            strategy: alloy::sol_types::private::Address,
18254        ) -> alloy_contract::SolCallBuilder<&P, getEncumberedMagnitudeCall, N> {
18255            self.call_builder(&getEncumberedMagnitudeCall { operator, strategy })
18256        }
18257        ///Creates a new call builder for the [`getMaxMagnitude`] function.
18258        pub fn getMaxMagnitude(
18259            &self,
18260            operator: alloy::sol_types::private::Address,
18261            strategy: alloy::sol_types::private::Address,
18262        ) -> alloy_contract::SolCallBuilder<&P, getMaxMagnitudeCall, N> {
18263            self.call_builder(&getMaxMagnitudeCall { operator, strategy })
18264        }
18265        ///Creates a new call builder for the [`getMaxMagnitudes_0`] function.
18266        pub fn getMaxMagnitudes_0(
18267            &self,
18268            operators: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
18269            strategy: alloy::sol_types::private::Address,
18270        ) -> alloy_contract::SolCallBuilder<&P, getMaxMagnitudes_0Call, N> {
18271            self.call_builder(&getMaxMagnitudes_0Call {
18272                operators,
18273                strategy,
18274            })
18275        }
18276        ///Creates a new call builder for the [`getMaxMagnitudes_1`] function.
18277        pub fn getMaxMagnitudes_1(
18278            &self,
18279            operator: alloy::sol_types::private::Address,
18280            strategies: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
18281        ) -> alloy_contract::SolCallBuilder<&P, getMaxMagnitudes_1Call, N> {
18282            self.call_builder(&getMaxMagnitudes_1Call {
18283                operator,
18284                strategies,
18285            })
18286        }
18287        ///Creates a new call builder for the [`getMaxMagnitudesAtBlock`] function.
18288        pub fn getMaxMagnitudesAtBlock(
18289            &self,
18290            operator: alloy::sol_types::private::Address,
18291            strategies: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
18292            blockNumber: u32,
18293        ) -> alloy_contract::SolCallBuilder<&P, getMaxMagnitudesAtBlockCall, N> {
18294            self.call_builder(&getMaxMagnitudesAtBlockCall {
18295                operator,
18296                strategies,
18297                blockNumber,
18298            })
18299        }
18300        ///Creates a new call builder for the [`getMemberCount`] function.
18301        pub fn getMemberCount(
18302            &self,
18303            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
18304        ) -> alloy_contract::SolCallBuilder<&P, getMemberCountCall, N> {
18305            self.call_builder(&getMemberCountCall { operatorSet })
18306        }
18307        ///Creates a new call builder for the [`getMembers`] function.
18308        pub fn getMembers(
18309            &self,
18310            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
18311        ) -> alloy_contract::SolCallBuilder<&P, getMembersCall, N> {
18312            self.call_builder(&getMembersCall { operatorSet })
18313        }
18314        ///Creates a new call builder for the [`getMinimumSlashableStake`] function.
18315        pub fn getMinimumSlashableStake(
18316            &self,
18317            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
18318            operators: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
18319            strategies: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
18320            futureBlock: u32,
18321        ) -> alloy_contract::SolCallBuilder<&P, getMinimumSlashableStakeCall, N> {
18322            self.call_builder(&getMinimumSlashableStakeCall {
18323                operatorSet,
18324                operators,
18325                strategies,
18326                futureBlock,
18327            })
18328        }
18329        ///Creates a new call builder for the [`getOperatorSetCount`] function.
18330        pub fn getOperatorSetCount(
18331            &self,
18332            avs: alloy::sol_types::private::Address,
18333        ) -> alloy_contract::SolCallBuilder<&P, getOperatorSetCountCall, N> {
18334            self.call_builder(&getOperatorSetCountCall { avs })
18335        }
18336        ///Creates a new call builder for the [`getRegisteredSets`] function.
18337        pub fn getRegisteredSets(
18338            &self,
18339            operator: alloy::sol_types::private::Address,
18340        ) -> alloy_contract::SolCallBuilder<&P, getRegisteredSetsCall, N> {
18341            self.call_builder(&getRegisteredSetsCall { operator })
18342        }
18343        ///Creates a new call builder for the [`getStrategiesInOperatorSet`] function.
18344        pub fn getStrategiesInOperatorSet(
18345            &self,
18346            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
18347        ) -> alloy_contract::SolCallBuilder<&P, getStrategiesInOperatorSetCall, N> {
18348            self.call_builder(&getStrategiesInOperatorSetCall { operatorSet })
18349        }
18350        ///Creates a new call builder for the [`getStrategyAllocations`] function.
18351        pub fn getStrategyAllocations(
18352            &self,
18353            operator: alloy::sol_types::private::Address,
18354            strategy: alloy::sol_types::private::Address,
18355        ) -> alloy_contract::SolCallBuilder<&P, getStrategyAllocationsCall, N> {
18356            self.call_builder(&getStrategyAllocationsCall { operator, strategy })
18357        }
18358        ///Creates a new call builder for the [`initialize`] function.
18359        pub fn initialize(
18360            &self,
18361            initialOwner: alloy::sol_types::private::Address,
18362            initialPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
18363        ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> {
18364            self.call_builder(&initializeCall {
18365                initialOwner,
18366                initialPausedStatus,
18367            })
18368        }
18369        ///Creates a new call builder for the [`isMemberOfOperatorSet`] function.
18370        pub fn isMemberOfOperatorSet(
18371            &self,
18372            operator: alloy::sol_types::private::Address,
18373            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
18374        ) -> alloy_contract::SolCallBuilder<&P, isMemberOfOperatorSetCall, N> {
18375            self.call_builder(&isMemberOfOperatorSetCall {
18376                operator,
18377                operatorSet,
18378            })
18379        }
18380        ///Creates a new call builder for the [`isOperatorSet`] function.
18381        pub fn isOperatorSet(
18382            &self,
18383            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
18384        ) -> alloy_contract::SolCallBuilder<&P, isOperatorSetCall, N> {
18385            self.call_builder(&isOperatorSetCall { operatorSet })
18386        }
18387        ///Creates a new call builder for the [`isOperatorSlashable`] function.
18388        pub fn isOperatorSlashable(
18389            &self,
18390            operator: alloy::sol_types::private::Address,
18391            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
18392        ) -> alloy_contract::SolCallBuilder<&P, isOperatorSlashableCall, N> {
18393            self.call_builder(&isOperatorSlashableCall {
18394                operator,
18395                operatorSet,
18396            })
18397        }
18398        ///Creates a new call builder for the [`modifyAllocations`] function.
18399        pub fn modifyAllocations(
18400            &self,
18401            operator: alloy::sol_types::private::Address,
18402            params: alloy::sol_types::private::Vec<
18403                <IAllocationManagerTypes::AllocateParams as alloy::sol_types::SolType>::RustType,
18404            >,
18405        ) -> alloy_contract::SolCallBuilder<&P, modifyAllocationsCall, N> {
18406            self.call_builder(&modifyAllocationsCall { operator, params })
18407        }
18408        ///Creates a new call builder for the [`owner`] function.
18409        pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
18410            self.call_builder(&ownerCall)
18411        }
18412        ///Creates a new call builder for the [`pause`] function.
18413        pub fn pause(
18414            &self,
18415            newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
18416        ) -> alloy_contract::SolCallBuilder<&P, pauseCall, N> {
18417            self.call_builder(&pauseCall { newPausedStatus })
18418        }
18419        ///Creates a new call builder for the [`pauseAll`] function.
18420        pub fn pauseAll(&self) -> alloy_contract::SolCallBuilder<&P, pauseAllCall, N> {
18421            self.call_builder(&pauseAllCall)
18422        }
18423        ///Creates a new call builder for the [`paused_0`] function.
18424        pub fn paused_0(&self, index: u8) -> alloy_contract::SolCallBuilder<&P, paused_0Call, N> {
18425            self.call_builder(&paused_0Call { index })
18426        }
18427        ///Creates a new call builder for the [`paused_1`] function.
18428        pub fn paused_1(&self) -> alloy_contract::SolCallBuilder<&P, paused_1Call, N> {
18429            self.call_builder(&paused_1Call)
18430        }
18431        ///Creates a new call builder for the [`pauserRegistry`] function.
18432        pub fn pauserRegistry(&self) -> alloy_contract::SolCallBuilder<&P, pauserRegistryCall, N> {
18433            self.call_builder(&pauserRegistryCall)
18434        }
18435        ///Creates a new call builder for the [`permissionController`] function.
18436        pub fn permissionController(
18437            &self,
18438        ) -> alloy_contract::SolCallBuilder<&P, permissionControllerCall, N> {
18439            self.call_builder(&permissionControllerCall)
18440        }
18441        ///Creates a new call builder for the [`registerForOperatorSets`] function.
18442        pub fn registerForOperatorSets(
18443            &self,
18444            operator: alloy::sol_types::private::Address,
18445            params: <IAllocationManagerTypes::RegisterParams as alloy::sol_types::SolType>::RustType,
18446        ) -> alloy_contract::SolCallBuilder<&P, registerForOperatorSetsCall, N> {
18447            self.call_builder(&registerForOperatorSetsCall { operator, params })
18448        }
18449        ///Creates a new call builder for the [`removeStrategiesFromOperatorSet`] function.
18450        pub fn removeStrategiesFromOperatorSet(
18451            &self,
18452            avs: alloy::sol_types::private::Address,
18453            operatorSetId: u32,
18454            strategies: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
18455        ) -> alloy_contract::SolCallBuilder<&P, removeStrategiesFromOperatorSetCall, N> {
18456            self.call_builder(&removeStrategiesFromOperatorSetCall {
18457                avs,
18458                operatorSetId,
18459                strategies,
18460            })
18461        }
18462        ///Creates a new call builder for the [`renounceOwnership`] function.
18463        pub fn renounceOwnership(
18464            &self,
18465        ) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> {
18466            self.call_builder(&renounceOwnershipCall)
18467        }
18468        ///Creates a new call builder for the [`setAVSRegistrar`] function.
18469        pub fn setAVSRegistrar(
18470            &self,
18471            avs: alloy::sol_types::private::Address,
18472            registrar: alloy::sol_types::private::Address,
18473        ) -> alloy_contract::SolCallBuilder<&P, setAVSRegistrarCall, N> {
18474            self.call_builder(&setAVSRegistrarCall { avs, registrar })
18475        }
18476        ///Creates a new call builder for the [`setAllocationDelay`] function.
18477        pub fn setAllocationDelay(
18478            &self,
18479            operator: alloy::sol_types::private::Address,
18480            delay: u32,
18481        ) -> alloy_contract::SolCallBuilder<&P, setAllocationDelayCall, N> {
18482            self.call_builder(&setAllocationDelayCall { operator, delay })
18483        }
18484        ///Creates a new call builder for the [`slashOperator`] function.
18485        pub fn slashOperator(
18486            &self,
18487            avs: alloy::sol_types::private::Address,
18488            params: <IAllocationManagerTypes::SlashingParams as alloy::sol_types::SolType>::RustType,
18489        ) -> alloy_contract::SolCallBuilder<&P, slashOperatorCall, N> {
18490            self.call_builder(&slashOperatorCall { avs, params })
18491        }
18492        ///Creates a new call builder for the [`transferOwnership`] function.
18493        pub fn transferOwnership(
18494            &self,
18495            newOwner: alloy::sol_types::private::Address,
18496        ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> {
18497            self.call_builder(&transferOwnershipCall { newOwner })
18498        }
18499        ///Creates a new call builder for the [`unpause`] function.
18500        pub fn unpause(
18501            &self,
18502            newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
18503        ) -> alloy_contract::SolCallBuilder<&P, unpauseCall, N> {
18504            self.call_builder(&unpauseCall { newPausedStatus })
18505        }
18506        ///Creates a new call builder for the [`updateAVSMetadataURI`] function.
18507        pub fn updateAVSMetadataURI(
18508            &self,
18509            avs: alloy::sol_types::private::Address,
18510            metadataURI: alloy::sol_types::private::String,
18511        ) -> alloy_contract::SolCallBuilder<&P, updateAVSMetadataURICall, N> {
18512            self.call_builder(&updateAVSMetadataURICall { avs, metadataURI })
18513        }
18514        ///Creates a new call builder for the [`version`] function.
18515        pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
18516            self.call_builder(&versionCall)
18517        }
18518    }
18519    /// Event filters.
18520    #[automatically_derived]
18521    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
18522        AllocationManagerInstance<P, N>
18523    {
18524        /// Creates a new event filter using this contract instance's provider and address.
18525        ///
18526        /// Note that the type can be any event, not just those defined in this contract.
18527        /// Prefer using the other methods for building type-safe event filters.
18528        pub fn event_filter<E: alloy_sol_types::SolEvent>(
18529            &self,
18530        ) -> alloy_contract::Event<&P, E, N> {
18531            alloy_contract::Event::new_sol(&self.provider, &self.address)
18532        }
18533        ///Creates a new event filter for the [`AVSMetadataURIUpdated`] event.
18534        pub fn AVSMetadataURIUpdated_filter(
18535            &self,
18536        ) -> alloy_contract::Event<&P, AVSMetadataURIUpdated, N> {
18537            self.event_filter::<AVSMetadataURIUpdated>()
18538        }
18539        ///Creates a new event filter for the [`AVSRegistrarSet`] event.
18540        pub fn AVSRegistrarSet_filter(&self) -> alloy_contract::Event<&P, AVSRegistrarSet, N> {
18541            self.event_filter::<AVSRegistrarSet>()
18542        }
18543        ///Creates a new event filter for the [`AllocationDelaySet`] event.
18544        pub fn AllocationDelaySet_filter(
18545            &self,
18546        ) -> alloy_contract::Event<&P, AllocationDelaySet, N> {
18547            self.event_filter::<AllocationDelaySet>()
18548        }
18549        ///Creates a new event filter for the [`AllocationUpdated`] event.
18550        pub fn AllocationUpdated_filter(&self) -> alloy_contract::Event<&P, AllocationUpdated, N> {
18551            self.event_filter::<AllocationUpdated>()
18552        }
18553        ///Creates a new event filter for the [`EncumberedMagnitudeUpdated`] event.
18554        pub fn EncumberedMagnitudeUpdated_filter(
18555            &self,
18556        ) -> alloy_contract::Event<&P, EncumberedMagnitudeUpdated, N> {
18557            self.event_filter::<EncumberedMagnitudeUpdated>()
18558        }
18559        ///Creates a new event filter for the [`Initialized`] event.
18560        pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> {
18561            self.event_filter::<Initialized>()
18562        }
18563        ///Creates a new event filter for the [`MaxMagnitudeUpdated`] event.
18564        pub fn MaxMagnitudeUpdated_filter(
18565            &self,
18566        ) -> alloy_contract::Event<&P, MaxMagnitudeUpdated, N> {
18567            self.event_filter::<MaxMagnitudeUpdated>()
18568        }
18569        ///Creates a new event filter for the [`OperatorAddedToOperatorSet`] event.
18570        pub fn OperatorAddedToOperatorSet_filter(
18571            &self,
18572        ) -> alloy_contract::Event<&P, OperatorAddedToOperatorSet, N> {
18573            self.event_filter::<OperatorAddedToOperatorSet>()
18574        }
18575        ///Creates a new event filter for the [`OperatorRemovedFromOperatorSet`] event.
18576        pub fn OperatorRemovedFromOperatorSet_filter(
18577            &self,
18578        ) -> alloy_contract::Event<&P, OperatorRemovedFromOperatorSet, N> {
18579            self.event_filter::<OperatorRemovedFromOperatorSet>()
18580        }
18581        ///Creates a new event filter for the [`OperatorSetCreated`] event.
18582        pub fn OperatorSetCreated_filter(
18583            &self,
18584        ) -> alloy_contract::Event<&P, OperatorSetCreated, N> {
18585            self.event_filter::<OperatorSetCreated>()
18586        }
18587        ///Creates a new event filter for the [`OperatorSlashed`] event.
18588        pub fn OperatorSlashed_filter(&self) -> alloy_contract::Event<&P, OperatorSlashed, N> {
18589            self.event_filter::<OperatorSlashed>()
18590        }
18591        ///Creates a new event filter for the [`OwnershipTransferred`] event.
18592        pub fn OwnershipTransferred_filter(
18593            &self,
18594        ) -> alloy_contract::Event<&P, OwnershipTransferred, N> {
18595            self.event_filter::<OwnershipTransferred>()
18596        }
18597        ///Creates a new event filter for the [`Paused`] event.
18598        pub fn Paused_filter(&self) -> alloy_contract::Event<&P, Paused, N> {
18599            self.event_filter::<Paused>()
18600        }
18601        ///Creates a new event filter for the [`StrategyAddedToOperatorSet`] event.
18602        pub fn StrategyAddedToOperatorSet_filter(
18603            &self,
18604        ) -> alloy_contract::Event<&P, StrategyAddedToOperatorSet, N> {
18605            self.event_filter::<StrategyAddedToOperatorSet>()
18606        }
18607        ///Creates a new event filter for the [`StrategyRemovedFromOperatorSet`] event.
18608        pub fn StrategyRemovedFromOperatorSet_filter(
18609            &self,
18610        ) -> alloy_contract::Event<&P, StrategyRemovedFromOperatorSet, N> {
18611            self.event_filter::<StrategyRemovedFromOperatorSet>()
18612        }
18613        ///Creates a new event filter for the [`Unpaused`] event.
18614        pub fn Unpaused_filter(&self) -> alloy_contract::Event<&P, Unpaused, N> {
18615            self.event_filter::<Unpaused>()
18616        }
18617    }
18618}
eigen_utils/slashing/core/allocation_manager.rs

eigen_utils/slashing/core/
allocation_manager.rs
