//! > Expansion of a contract with a component with conflicting interfaces.

//! > test_runner_name
ExpandContractTestRunner(expect_diagnostics: warnings_only)

//! > cairo_code
>>> file: test_data/interfaces.cairo

//! > generated_cairo_code
lib.cairo:

#[starknet::interface]
trait Interface1<TContractState> {
    fn foo(ref self: TContractState);
}

#[starknet::interface]
trait Interface2<TContractState> {
    fn foo(ref self: TContractState);
}

#[starknet::component]
mod comp {
    #[storage]
    struct Storage {}

    #[embeddable_as(I1I1)]
    impl Interface1_Implementation1<
        TContractState, impl X: HasComponent<TContractState>,
    > of super::Interface1<ComponentState<TContractState>> {
        fn foo(ref self: ComponentState<TContractState>) {}
    }

    #[embeddable_as(I1I2)]
    impl Interface1_Implementation2<
        TContractState, impl X: HasComponent<TContractState>,
    > of super::Interface1<ComponentState<TContractState>> {
        fn foo(ref self: ComponentState<TContractState>) {}
    }

    #[embeddable_as(I2I)]
    impl Interface2_Implementation<
        TContractState, impl X: HasComponent<TContractState>,
    > of super::Interface2<ComponentState<TContractState>> {
        fn foo(ref self: ComponentState<TContractState>) {}
    }
}

#[starknet::contract]
mod counter_contract {
    component!(path: super::comp, storage: comp_storage, event: CompEvent);

    #[storage]
    struct Storage {
        #[substorage(v0)]
        comp_storage: super::comp::Storage,
    }

    #[event]
    #[derive(Drop, starknet::Event)]
    enum Event {
        CompEvent: super::comp::Event,
    }

    #[abi(embed_v0)]
    impl EmbeddedI1I1 = super::comp::I1I1<ContractState>;
    #[abi(embed_v0)]
    impl EmbeddedI1I2 = super::comp::I1I2<ContractState>;
    #[abi(embed_v0)]
    impl EmbeddedI2I = super::comp::I2I<ContractState>;

    #[external(v0)]
    fn foo(self: @ContractState) {}
}


lib.cairo:1:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
Interface1DispatcherTrait:

trait Interface1DispatcherTrait<T> {
    fn foo(self: T);
}

#[derive(Copy, Drop, starknet::Store, Serde)]
struct Interface1Dispatcher {
    pub contract_address: starknet::ContractAddress,
}

impl Interface1DispatcherImpl of Interface1DispatcherTrait<Interface1Dispatcher> {
    fn foo(self: Interface1Dispatcher) {
        let mut __calldata__ = core::traits::Default::default();

        let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall(
            self.contract_address,
            selector!("foo"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__);
        ()
    }

}

#[derive(Copy, Drop, starknet::Store, Serde)]
struct Interface1LibraryDispatcher {
    pub class_hash: starknet::ClassHash,
}

impl Interface1LibraryDispatcherImpl of Interface1DispatcherTrait<Interface1LibraryDispatcher> {
    fn foo(self: Interface1LibraryDispatcher) {
        let mut __calldata__ = core::traits::Default::default();

        let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall(
            self.class_hash,
            selector!("foo"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__);
        ()
    }

}

trait Interface1SafeDispatcherTrait<T> {
    #[unstable(feature: "safe_dispatcher")]
    fn foo(self: T) -> starknet::SyscallResult<()>;
}

#[derive(Copy, Drop, starknet::Store, Serde)]
struct Interface1SafeLibraryDispatcher {
    pub class_hash: starknet::ClassHash,
}

impl Interface1SafeLibraryDispatcherImpl of Interface1SafeDispatcherTrait<Interface1SafeLibraryDispatcher> {
    fn foo(self: Interface1SafeLibraryDispatcher) -> starknet::SyscallResult<()> {
        let mut __calldata__ = core::traits::Default::default();

        let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall(
            self.class_hash,
            selector!("foo"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = __dispatcher_return_data__?;
        Result::Ok(())
    }

}


#[derive(Copy, Drop, starknet::Store, Serde)]
struct Interface1SafeDispatcher {
    pub contract_address: starknet::ContractAddress,
}

impl Interface1SafeDispatcherImpl of Interface1SafeDispatcherTrait<Interface1SafeDispatcher> {
    fn foo(self: Interface1SafeDispatcher) -> starknet::SyscallResult<()> {
        let mut __calldata__ = core::traits::Default::default();

        let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall(
            self.contract_address,
            selector!("foo"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = __dispatcher_return_data__?;
        Result::Ok(())
    }

}


lib.cairo:6:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
Interface2DispatcherTrait:

trait Interface2DispatcherTrait<T> {
    fn foo(self: T);
}

#[derive(Copy, Drop, starknet::Store, Serde)]
struct Interface2Dispatcher {
    pub contract_address: starknet::ContractAddress,
}

impl Interface2DispatcherImpl of Interface2DispatcherTrait<Interface2Dispatcher> {
    fn foo(self: Interface2Dispatcher) {
        let mut __calldata__ = core::traits::Default::default();

        let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall(
            self.contract_address,
            selector!("foo"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__);
        ()
    }

}

#[derive(Copy, Drop, starknet::Store, Serde)]
struct Interface2LibraryDispatcher {
    pub class_hash: starknet::ClassHash,
}

impl Interface2LibraryDispatcherImpl of Interface2DispatcherTrait<Interface2LibraryDispatcher> {
    fn foo(self: Interface2LibraryDispatcher) {
        let mut __calldata__ = core::traits::Default::default();

        let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall(
            self.class_hash,
            selector!("foo"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__);
        ()
    }

}

trait Interface2SafeDispatcherTrait<T> {
    #[unstable(feature: "safe_dispatcher")]
    fn foo(self: T) -> starknet::SyscallResult<()>;
}

#[derive(Copy, Drop, starknet::Store, Serde)]
struct Interface2SafeLibraryDispatcher {
    pub class_hash: starknet::ClassHash,
}

impl Interface2SafeLibraryDispatcherImpl of Interface2SafeDispatcherTrait<Interface2SafeLibraryDispatcher> {
    fn foo(self: Interface2SafeLibraryDispatcher) -> starknet::SyscallResult<()> {
        let mut __calldata__ = core::traits::Default::default();

        let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall(
            self.class_hash,
            selector!("foo"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = __dispatcher_return_data__?;
        Result::Ok(())
    }

}


#[derive(Copy, Drop, starknet::Store, Serde)]
struct Interface2SafeDispatcher {
    pub contract_address: starknet::ContractAddress,
}

impl Interface2SafeDispatcherImpl of Interface2SafeDispatcherTrait<Interface2SafeDispatcher> {
    fn foo(self: Interface2SafeDispatcher) -> starknet::SyscallResult<()> {
        let mut __calldata__ = core::traits::Default::default();

        let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall(
            self.contract_address,
            selector!("foo"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = __dispatcher_return_data__?;
        Result::Ok(())
    }

}


lib.cairo:1:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface1DispatcherCopy<> of core::traits::Copy::<Interface1Dispatcher>;
impl Interface1DispatcherDrop<> of core::traits::Drop::<Interface1Dispatcher>;
impl Interface1DispatcherSerde<> of core::serde::Serde::<Interface1Dispatcher> {
    fn serialize(self: @Interface1Dispatcher, ref output: core::array::Array<felt252>) {
        core::serde::Serde::<starknet::ContractAddress>::serialize(self.contract_address, ref output)
    }
    fn deserialize(ref serialized: core::array::Span<felt252>) -> core::option::Option<Interface1Dispatcher> {
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: core::serde::Serde::<starknet::ContractAddress>::deserialize(ref serialized)? };
        core::option::Option::Some(Interface1Dispatcher {
            contract_address: contract_address.value,
        })
    }
}


lib.cairo:1:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
starknet_derive:

impl Interface1DispatcherStore<> of starknet::Store::<Interface1Dispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<Interface1Dispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: starknet::Store::<starknet::ContractAddress>::read(__store_derive_address_domain__, __store_derive_base__)? };
        starknet::SyscallResult::Ok(
            Interface1Dispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Interface1Dispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let Interface1Dispatcher {
            contract_address,
        } = value;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: contract_address };
        starknet::Store::<starknet::ContractAddress>::write(__store_derive_address_domain__, __store_derive_base__, contract_address.value)?;
        starknet::SyscallResult::Ok(())
    }
    fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult<Interface1Dispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: starknet::Store::<starknet::ContractAddress>::read_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__)? };
        starknet::SyscallResult::Ok(
            Interface1Dispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Interface1Dispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let Interface1Dispatcher {
            contract_address,
        } = value;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: contract_address };
        starknet::Store::<starknet::ContractAddress>::write_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__, contract_address.value)?;
        starknet::SyscallResult::Ok(())
    }
    #[inline(always)]
    fn size() -> u8 {
        starknet::Store::<starknet::ContractAddress>::size()
    }
}

#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct Interface1DispatcherSubPointers {
    pub contract_address: starknet::storage::StoragePointer<starknet::ContractAddress>,
}
#[doc(hidden)]
impl Interface1DispatcherSubPointersImpl of starknet::storage::SubPointers<Interface1Dispatcher> {
    type SubPointersType = Interface1DispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<Interface1Dispatcher>) -> Interface1DispatcherSubPointers {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __contract_address_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                Interface1DispatcherSubPointers {
           contract_address: __contract_address_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct Interface1DispatcherSubPointersMut {
    pub contract_address: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ContractAddress>>,
}
#[doc(hidden)]
impl Interface1DispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<Interface1Dispatcher> {
    type SubPointersType = Interface1DispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<Interface1Dispatcher>>) -> Interface1DispatcherSubPointersMut {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __contract_address_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                Interface1DispatcherSubPointersMut {
           contract_address: __contract_address_value__,
        }
    }
}


lib.cairo:1:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface1LibraryDispatcherCopy<> of core::traits::Copy::<Interface1LibraryDispatcher>;
impl Interface1LibraryDispatcherDrop<> of core::traits::Drop::<Interface1LibraryDispatcher>;
impl Interface1LibraryDispatcherSerde<> of core::serde::Serde::<Interface1LibraryDispatcher> {
    fn serialize(self: @Interface1LibraryDispatcher, ref output: core::array::Array<felt252>) {
        core::serde::Serde::<starknet::ClassHash>::serialize(self.class_hash, ref output)
    }
    fn deserialize(ref serialized: core::array::Span<felt252>) -> core::option::Option<Interface1LibraryDispatcher> {
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: core::serde::Serde::<starknet::ClassHash>::deserialize(ref serialized)? };
        core::option::Option::Some(Interface1LibraryDispatcher {
            class_hash: class_hash.value,
        })
    }
}


lib.cairo:1:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
starknet_derive:

impl Interface1LibraryDispatcherStore<> of starknet::Store::<Interface1LibraryDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<Interface1LibraryDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: starknet::Store::<starknet::ClassHash>::read(__store_derive_address_domain__, __store_derive_base__)? };
        starknet::SyscallResult::Ok(
            Interface1LibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Interface1LibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let Interface1LibraryDispatcher {
            class_hash,
        } = value;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: class_hash };
        starknet::Store::<starknet::ClassHash>::write(__store_derive_address_domain__, __store_derive_base__, class_hash.value)?;
        starknet::SyscallResult::Ok(())
    }
    fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult<Interface1LibraryDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: starknet::Store::<starknet::ClassHash>::read_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__)? };
        starknet::SyscallResult::Ok(
            Interface1LibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Interface1LibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let Interface1LibraryDispatcher {
            class_hash,
        } = value;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: class_hash };
        starknet::Store::<starknet::ClassHash>::write_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__, class_hash.value)?;
        starknet::SyscallResult::Ok(())
    }
    #[inline(always)]
    fn size() -> u8 {
        starknet::Store::<starknet::ClassHash>::size()
    }
}

#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct Interface1LibraryDispatcherSubPointers {
    pub class_hash: starknet::storage::StoragePointer<starknet::ClassHash>,
}
#[doc(hidden)]
impl Interface1LibraryDispatcherSubPointersImpl of starknet::storage::SubPointers<Interface1LibraryDispatcher> {
    type SubPointersType = Interface1LibraryDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<Interface1LibraryDispatcher>) -> Interface1LibraryDispatcherSubPointers {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __class_hash_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                Interface1LibraryDispatcherSubPointers {
           class_hash: __class_hash_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct Interface1LibraryDispatcherSubPointersMut {
    pub class_hash: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ClassHash>>,
}
#[doc(hidden)]
impl Interface1LibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<Interface1LibraryDispatcher> {
    type SubPointersType = Interface1LibraryDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<Interface1LibraryDispatcher>>) -> Interface1LibraryDispatcherSubPointersMut {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __class_hash_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                Interface1LibraryDispatcherSubPointersMut {
           class_hash: __class_hash_value__,
        }
    }
}


lib.cairo:1:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface1SafeLibraryDispatcherCopy<> of core::traits::Copy::<Interface1SafeLibraryDispatcher>;
impl Interface1SafeLibraryDispatcherDrop<> of core::traits::Drop::<Interface1SafeLibraryDispatcher>;
impl Interface1SafeLibraryDispatcherSerde<> of core::serde::Serde::<Interface1SafeLibraryDispatcher> {
    fn serialize(self: @Interface1SafeLibraryDispatcher, ref output: core::array::Array<felt252>) {
        core::serde::Serde::<starknet::ClassHash>::serialize(self.class_hash, ref output)
    }
    fn deserialize(ref serialized: core::array::Span<felt252>) -> core::option::Option<Interface1SafeLibraryDispatcher> {
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: core::serde::Serde::<starknet::ClassHash>::deserialize(ref serialized)? };
        core::option::Option::Some(Interface1SafeLibraryDispatcher {
            class_hash: class_hash.value,
        })
    }
}


lib.cairo:1:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
starknet_derive:

impl Interface1SafeLibraryDispatcherStore<> of starknet::Store::<Interface1SafeLibraryDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<Interface1SafeLibraryDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: starknet::Store::<starknet::ClassHash>::read(__store_derive_address_domain__, __store_derive_base__)? };
        starknet::SyscallResult::Ok(
            Interface1SafeLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Interface1SafeLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let Interface1SafeLibraryDispatcher {
            class_hash,
        } = value;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: class_hash };
        starknet::Store::<starknet::ClassHash>::write(__store_derive_address_domain__, __store_derive_base__, class_hash.value)?;
        starknet::SyscallResult::Ok(())
    }
    fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult<Interface1SafeLibraryDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: starknet::Store::<starknet::ClassHash>::read_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__)? };
        starknet::SyscallResult::Ok(
            Interface1SafeLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Interface1SafeLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let Interface1SafeLibraryDispatcher {
            class_hash,
        } = value;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: class_hash };
        starknet::Store::<starknet::ClassHash>::write_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__, class_hash.value)?;
        starknet::SyscallResult::Ok(())
    }
    #[inline(always)]
    fn size() -> u8 {
        starknet::Store::<starknet::ClassHash>::size()
    }
}

#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct Interface1SafeLibraryDispatcherSubPointers {
    pub class_hash: starknet::storage::StoragePointer<starknet::ClassHash>,
}
#[doc(hidden)]
impl Interface1SafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers<Interface1SafeLibraryDispatcher> {
    type SubPointersType = Interface1SafeLibraryDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<Interface1SafeLibraryDispatcher>) -> Interface1SafeLibraryDispatcherSubPointers {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __class_hash_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                Interface1SafeLibraryDispatcherSubPointers {
           class_hash: __class_hash_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct Interface1SafeLibraryDispatcherSubPointersMut {
    pub class_hash: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ClassHash>>,
}
#[doc(hidden)]
impl Interface1SafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<Interface1SafeLibraryDispatcher> {
    type SubPointersType = Interface1SafeLibraryDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<Interface1SafeLibraryDispatcher>>) -> Interface1SafeLibraryDispatcherSubPointersMut {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __class_hash_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                Interface1SafeLibraryDispatcherSubPointersMut {
           class_hash: __class_hash_value__,
        }
    }
}


lib.cairo:1:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface1SafeDispatcherCopy<> of core::traits::Copy::<Interface1SafeDispatcher>;
impl Interface1SafeDispatcherDrop<> of core::traits::Drop::<Interface1SafeDispatcher>;
impl Interface1SafeDispatcherSerde<> of core::serde::Serde::<Interface1SafeDispatcher> {
    fn serialize(self: @Interface1SafeDispatcher, ref output: core::array::Array<felt252>) {
        core::serde::Serde::<starknet::ContractAddress>::serialize(self.contract_address, ref output)
    }
    fn deserialize(ref serialized: core::array::Span<felt252>) -> core::option::Option<Interface1SafeDispatcher> {
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: core::serde::Serde::<starknet::ContractAddress>::deserialize(ref serialized)? };
        core::option::Option::Some(Interface1SafeDispatcher {
            contract_address: contract_address.value,
        })
    }
}


lib.cairo:1:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
starknet_derive:

impl Interface1SafeDispatcherStore<> of starknet::Store::<Interface1SafeDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<Interface1SafeDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: starknet::Store::<starknet::ContractAddress>::read(__store_derive_address_domain__, __store_derive_base__)? };
        starknet::SyscallResult::Ok(
            Interface1SafeDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Interface1SafeDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let Interface1SafeDispatcher {
            contract_address,
        } = value;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: contract_address };
        starknet::Store::<starknet::ContractAddress>::write(__store_derive_address_domain__, __store_derive_base__, contract_address.value)?;
        starknet::SyscallResult::Ok(())
    }
    fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult<Interface1SafeDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: starknet::Store::<starknet::ContractAddress>::read_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__)? };
        starknet::SyscallResult::Ok(
            Interface1SafeDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Interface1SafeDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let Interface1SafeDispatcher {
            contract_address,
        } = value;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: contract_address };
        starknet::Store::<starknet::ContractAddress>::write_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__, contract_address.value)?;
        starknet::SyscallResult::Ok(())
    }
    #[inline(always)]
    fn size() -> u8 {
        starknet::Store::<starknet::ContractAddress>::size()
    }
}

#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct Interface1SafeDispatcherSubPointers {
    pub contract_address: starknet::storage::StoragePointer<starknet::ContractAddress>,
}
#[doc(hidden)]
impl Interface1SafeDispatcherSubPointersImpl of starknet::storage::SubPointers<Interface1SafeDispatcher> {
    type SubPointersType = Interface1SafeDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<Interface1SafeDispatcher>) -> Interface1SafeDispatcherSubPointers {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __contract_address_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                Interface1SafeDispatcherSubPointers {
           contract_address: __contract_address_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct Interface1SafeDispatcherSubPointersMut {
    pub contract_address: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ContractAddress>>,
}
#[doc(hidden)]
impl Interface1SafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<Interface1SafeDispatcher> {
    type SubPointersType = Interface1SafeDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<Interface1SafeDispatcher>>) -> Interface1SafeDispatcherSubPointersMut {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __contract_address_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                Interface1SafeDispatcherSubPointersMut {
           contract_address: __contract_address_value__,
        }
    }
}


lib.cairo:6:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface2DispatcherCopy<> of core::traits::Copy::<Interface2Dispatcher>;
impl Interface2DispatcherDrop<> of core::traits::Drop::<Interface2Dispatcher>;
impl Interface2DispatcherSerde<> of core::serde::Serde::<Interface2Dispatcher> {
    fn serialize(self: @Interface2Dispatcher, ref output: core::array::Array<felt252>) {
        core::serde::Serde::<starknet::ContractAddress>::serialize(self.contract_address, ref output)
    }
    fn deserialize(ref serialized: core::array::Span<felt252>) -> core::option::Option<Interface2Dispatcher> {
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: core::serde::Serde::<starknet::ContractAddress>::deserialize(ref serialized)? };
        core::option::Option::Some(Interface2Dispatcher {
            contract_address: contract_address.value,
        })
    }
}


lib.cairo:6:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
starknet_derive:

impl Interface2DispatcherStore<> of starknet::Store::<Interface2Dispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<Interface2Dispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: starknet::Store::<starknet::ContractAddress>::read(__store_derive_address_domain__, __store_derive_base__)? };
        starknet::SyscallResult::Ok(
            Interface2Dispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Interface2Dispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let Interface2Dispatcher {
            contract_address,
        } = value;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: contract_address };
        starknet::Store::<starknet::ContractAddress>::write(__store_derive_address_domain__, __store_derive_base__, contract_address.value)?;
        starknet::SyscallResult::Ok(())
    }
    fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult<Interface2Dispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: starknet::Store::<starknet::ContractAddress>::read_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__)? };
        starknet::SyscallResult::Ok(
            Interface2Dispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Interface2Dispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let Interface2Dispatcher {
            contract_address,
        } = value;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: contract_address };
        starknet::Store::<starknet::ContractAddress>::write_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__, contract_address.value)?;
        starknet::SyscallResult::Ok(())
    }
    #[inline(always)]
    fn size() -> u8 {
        starknet::Store::<starknet::ContractAddress>::size()
    }
}

#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct Interface2DispatcherSubPointers {
    pub contract_address: starknet::storage::StoragePointer<starknet::ContractAddress>,
}
#[doc(hidden)]
impl Interface2DispatcherSubPointersImpl of starknet::storage::SubPointers<Interface2Dispatcher> {
    type SubPointersType = Interface2DispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<Interface2Dispatcher>) -> Interface2DispatcherSubPointers {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __contract_address_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                Interface2DispatcherSubPointers {
           contract_address: __contract_address_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct Interface2DispatcherSubPointersMut {
    pub contract_address: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ContractAddress>>,
}
#[doc(hidden)]
impl Interface2DispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<Interface2Dispatcher> {
    type SubPointersType = Interface2DispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<Interface2Dispatcher>>) -> Interface2DispatcherSubPointersMut {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __contract_address_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                Interface2DispatcherSubPointersMut {
           contract_address: __contract_address_value__,
        }
    }
}


lib.cairo:6:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface2LibraryDispatcherCopy<> of core::traits::Copy::<Interface2LibraryDispatcher>;
impl Interface2LibraryDispatcherDrop<> of core::traits::Drop::<Interface2LibraryDispatcher>;
impl Interface2LibraryDispatcherSerde<> of core::serde::Serde::<Interface2LibraryDispatcher> {
    fn serialize(self: @Interface2LibraryDispatcher, ref output: core::array::Array<felt252>) {
        core::serde::Serde::<starknet::ClassHash>::serialize(self.class_hash, ref output)
    }
    fn deserialize(ref serialized: core::array::Span<felt252>) -> core::option::Option<Interface2LibraryDispatcher> {
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: core::serde::Serde::<starknet::ClassHash>::deserialize(ref serialized)? };
        core::option::Option::Some(Interface2LibraryDispatcher {
            class_hash: class_hash.value,
        })
    }
}


lib.cairo:6:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
starknet_derive:

impl Interface2LibraryDispatcherStore<> of starknet::Store::<Interface2LibraryDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<Interface2LibraryDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: starknet::Store::<starknet::ClassHash>::read(__store_derive_address_domain__, __store_derive_base__)? };
        starknet::SyscallResult::Ok(
            Interface2LibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Interface2LibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let Interface2LibraryDispatcher {
            class_hash,
        } = value;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: class_hash };
        starknet::Store::<starknet::ClassHash>::write(__store_derive_address_domain__, __store_derive_base__, class_hash.value)?;
        starknet::SyscallResult::Ok(())
    }
    fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult<Interface2LibraryDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: starknet::Store::<starknet::ClassHash>::read_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__)? };
        starknet::SyscallResult::Ok(
            Interface2LibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Interface2LibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let Interface2LibraryDispatcher {
            class_hash,
        } = value;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: class_hash };
        starknet::Store::<starknet::ClassHash>::write_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__, class_hash.value)?;
        starknet::SyscallResult::Ok(())
    }
    #[inline(always)]
    fn size() -> u8 {
        starknet::Store::<starknet::ClassHash>::size()
    }
}

#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct Interface2LibraryDispatcherSubPointers {
    pub class_hash: starknet::storage::StoragePointer<starknet::ClassHash>,
}
#[doc(hidden)]
impl Interface2LibraryDispatcherSubPointersImpl of starknet::storage::SubPointers<Interface2LibraryDispatcher> {
    type SubPointersType = Interface2LibraryDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<Interface2LibraryDispatcher>) -> Interface2LibraryDispatcherSubPointers {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __class_hash_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                Interface2LibraryDispatcherSubPointers {
           class_hash: __class_hash_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct Interface2LibraryDispatcherSubPointersMut {
    pub class_hash: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ClassHash>>,
}
#[doc(hidden)]
impl Interface2LibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<Interface2LibraryDispatcher> {
    type SubPointersType = Interface2LibraryDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<Interface2LibraryDispatcher>>) -> Interface2LibraryDispatcherSubPointersMut {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __class_hash_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                Interface2LibraryDispatcherSubPointersMut {
           class_hash: __class_hash_value__,
        }
    }
}


lib.cairo:6:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface2SafeLibraryDispatcherCopy<> of core::traits::Copy::<Interface2SafeLibraryDispatcher>;
impl Interface2SafeLibraryDispatcherDrop<> of core::traits::Drop::<Interface2SafeLibraryDispatcher>;
impl Interface2SafeLibraryDispatcherSerde<> of core::serde::Serde::<Interface2SafeLibraryDispatcher> {
    fn serialize(self: @Interface2SafeLibraryDispatcher, ref output: core::array::Array<felt252>) {
        core::serde::Serde::<starknet::ClassHash>::serialize(self.class_hash, ref output)
    }
    fn deserialize(ref serialized: core::array::Span<felt252>) -> core::option::Option<Interface2SafeLibraryDispatcher> {
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: core::serde::Serde::<starknet::ClassHash>::deserialize(ref serialized)? };
        core::option::Option::Some(Interface2SafeLibraryDispatcher {
            class_hash: class_hash.value,
        })
    }
}


lib.cairo:6:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
starknet_derive:

impl Interface2SafeLibraryDispatcherStore<> of starknet::Store::<Interface2SafeLibraryDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<Interface2SafeLibraryDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: starknet::Store::<starknet::ClassHash>::read(__store_derive_address_domain__, __store_derive_base__)? };
        starknet::SyscallResult::Ok(
            Interface2SafeLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Interface2SafeLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let Interface2SafeLibraryDispatcher {
            class_hash,
        } = value;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: class_hash };
        starknet::Store::<starknet::ClassHash>::write(__store_derive_address_domain__, __store_derive_base__, class_hash.value)?;
        starknet::SyscallResult::Ok(())
    }
    fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult<Interface2SafeLibraryDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: starknet::Store::<starknet::ClassHash>::read_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__)? };
        starknet::SyscallResult::Ok(
            Interface2SafeLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Interface2SafeLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let Interface2SafeLibraryDispatcher {
            class_hash,
        } = value;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: class_hash };
        starknet::Store::<starknet::ClassHash>::write_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__, class_hash.value)?;
        starknet::SyscallResult::Ok(())
    }
    #[inline(always)]
    fn size() -> u8 {
        starknet::Store::<starknet::ClassHash>::size()
    }
}

#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct Interface2SafeLibraryDispatcherSubPointers {
    pub class_hash: starknet::storage::StoragePointer<starknet::ClassHash>,
}
#[doc(hidden)]
impl Interface2SafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers<Interface2SafeLibraryDispatcher> {
    type SubPointersType = Interface2SafeLibraryDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<Interface2SafeLibraryDispatcher>) -> Interface2SafeLibraryDispatcherSubPointers {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __class_hash_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                Interface2SafeLibraryDispatcherSubPointers {
           class_hash: __class_hash_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct Interface2SafeLibraryDispatcherSubPointersMut {
    pub class_hash: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ClassHash>>,
}
#[doc(hidden)]
impl Interface2SafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<Interface2SafeLibraryDispatcher> {
    type SubPointersType = Interface2SafeLibraryDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<Interface2SafeLibraryDispatcher>>) -> Interface2SafeLibraryDispatcherSubPointersMut {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __class_hash_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                Interface2SafeLibraryDispatcherSubPointersMut {
           class_hash: __class_hash_value__,
        }
    }
}


lib.cairo:6:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface2SafeDispatcherCopy<> of core::traits::Copy::<Interface2SafeDispatcher>;
impl Interface2SafeDispatcherDrop<> of core::traits::Drop::<Interface2SafeDispatcher>;
impl Interface2SafeDispatcherSerde<> of core::serde::Serde::<Interface2SafeDispatcher> {
    fn serialize(self: @Interface2SafeDispatcher, ref output: core::array::Array<felt252>) {
        core::serde::Serde::<starknet::ContractAddress>::serialize(self.contract_address, ref output)
    }
    fn deserialize(ref serialized: core::array::Span<felt252>) -> core::option::Option<Interface2SafeDispatcher> {
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: core::serde::Serde::<starknet::ContractAddress>::deserialize(ref serialized)? };
        core::option::Option::Some(Interface2SafeDispatcher {
            contract_address: contract_address.value,
        })
    }
}


lib.cairo:6:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
starknet_derive:

impl Interface2SafeDispatcherStore<> of starknet::Store::<Interface2SafeDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<Interface2SafeDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: starknet::Store::<starknet::ContractAddress>::read(__store_derive_address_domain__, __store_derive_base__)? };
        starknet::SyscallResult::Ok(
            Interface2SafeDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Interface2SafeDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let Interface2SafeDispatcher {
            contract_address,
        } = value;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: contract_address };
        starknet::Store::<starknet::ContractAddress>::write(__store_derive_address_domain__, __store_derive_base__, contract_address.value)?;
        starknet::SyscallResult::Ok(())
    }
    fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult<Interface2SafeDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: starknet::Store::<starknet::ContractAddress>::read_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__)? };
        starknet::SyscallResult::Ok(
            Interface2SafeDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Interface2SafeDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let Interface2SafeDispatcher {
            contract_address,
        } = value;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: contract_address };
        starknet::Store::<starknet::ContractAddress>::write_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__, contract_address.value)?;
        starknet::SyscallResult::Ok(())
    }
    #[inline(always)]
    fn size() -> u8 {
        starknet::Store::<starknet::ContractAddress>::size()
    }
}

#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct Interface2SafeDispatcherSubPointers {
    pub contract_address: starknet::storage::StoragePointer<starknet::ContractAddress>,
}
#[doc(hidden)]
impl Interface2SafeDispatcherSubPointersImpl of starknet::storage::SubPointers<Interface2SafeDispatcher> {
    type SubPointersType = Interface2SafeDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<Interface2SafeDispatcher>) -> Interface2SafeDispatcherSubPointers {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __contract_address_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                Interface2SafeDispatcherSubPointers {
           contract_address: __contract_address_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct Interface2SafeDispatcherSubPointersMut {
    pub contract_address: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ContractAddress>>,
}
#[doc(hidden)]
impl Interface2SafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<Interface2SafeDispatcher> {
    type SubPointersType = Interface2SafeDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<Interface2SafeDispatcher>>) -> Interface2SafeDispatcherSubPointersMut {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __contract_address_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                Interface2SafeDispatcherSubPointersMut {
           contract_address: __contract_address_value__,
        }
    }
}


lib.cairo:1:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface1DispatcherSubPointersDrop<> of core::traits::Drop::<Interface1DispatcherSubPointers>;
impl Interface1DispatcherSubPointersCopy<> of core::traits::Copy::<Interface1DispatcherSubPointers>;


lib.cairo:1:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface1DispatcherSubPointersMutDrop<> of core::traits::Drop::<Interface1DispatcherSubPointersMut>;
impl Interface1DispatcherSubPointersMutCopy<> of core::traits::Copy::<Interface1DispatcherSubPointersMut>;


lib.cairo:1:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface1LibraryDispatcherSubPointersDrop<> of core::traits::Drop::<Interface1LibraryDispatcherSubPointers>;
impl Interface1LibraryDispatcherSubPointersCopy<> of core::traits::Copy::<Interface1LibraryDispatcherSubPointers>;


lib.cairo:1:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface1LibraryDispatcherSubPointersMutDrop<> of core::traits::Drop::<Interface1LibraryDispatcherSubPointersMut>;
impl Interface1LibraryDispatcherSubPointersMutCopy<> of core::traits::Copy::<Interface1LibraryDispatcherSubPointersMut>;


lib.cairo:1:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface1SafeLibraryDispatcherSubPointersDrop<> of core::traits::Drop::<Interface1SafeLibraryDispatcherSubPointers>;
impl Interface1SafeLibraryDispatcherSubPointersCopy<> of core::traits::Copy::<Interface1SafeLibraryDispatcherSubPointers>;


lib.cairo:1:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface1SafeLibraryDispatcherSubPointersMutDrop<> of core::traits::Drop::<Interface1SafeLibraryDispatcherSubPointersMut>;
impl Interface1SafeLibraryDispatcherSubPointersMutCopy<> of core::traits::Copy::<Interface1SafeLibraryDispatcherSubPointersMut>;


lib.cairo:1:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface1SafeDispatcherSubPointersDrop<> of core::traits::Drop::<Interface1SafeDispatcherSubPointers>;
impl Interface1SafeDispatcherSubPointersCopy<> of core::traits::Copy::<Interface1SafeDispatcherSubPointers>;


lib.cairo:1:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface1SafeDispatcherSubPointersMutDrop<> of core::traits::Drop::<Interface1SafeDispatcherSubPointersMut>;
impl Interface1SafeDispatcherSubPointersMutCopy<> of core::traits::Copy::<Interface1SafeDispatcherSubPointersMut>;


lib.cairo:6:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface2DispatcherSubPointersDrop<> of core::traits::Drop::<Interface2DispatcherSubPointers>;
impl Interface2DispatcherSubPointersCopy<> of core::traits::Copy::<Interface2DispatcherSubPointers>;


lib.cairo:6:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface2DispatcherSubPointersMutDrop<> of core::traits::Drop::<Interface2DispatcherSubPointersMut>;
impl Interface2DispatcherSubPointersMutCopy<> of core::traits::Copy::<Interface2DispatcherSubPointersMut>;


lib.cairo:6:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface2LibraryDispatcherSubPointersDrop<> of core::traits::Drop::<Interface2LibraryDispatcherSubPointers>;
impl Interface2LibraryDispatcherSubPointersCopy<> of core::traits::Copy::<Interface2LibraryDispatcherSubPointers>;


lib.cairo:6:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface2LibraryDispatcherSubPointersMutDrop<> of core::traits::Drop::<Interface2LibraryDispatcherSubPointersMut>;
impl Interface2LibraryDispatcherSubPointersMutCopy<> of core::traits::Copy::<Interface2LibraryDispatcherSubPointersMut>;


lib.cairo:6:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface2SafeLibraryDispatcherSubPointersDrop<> of core::traits::Drop::<Interface2SafeLibraryDispatcherSubPointers>;
impl Interface2SafeLibraryDispatcherSubPointersCopy<> of core::traits::Copy::<Interface2SafeLibraryDispatcherSubPointers>;


lib.cairo:6:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface2SafeLibraryDispatcherSubPointersMutDrop<> of core::traits::Drop::<Interface2SafeLibraryDispatcherSubPointersMut>;
impl Interface2SafeLibraryDispatcherSubPointersMutCopy<> of core::traits::Copy::<Interface2SafeLibraryDispatcherSubPointersMut>;


lib.cairo:6:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface2SafeDispatcherSubPointersDrop<> of core::traits::Drop::<Interface2SafeDispatcherSubPointers>;
impl Interface2SafeDispatcherSubPointersCopy<> of core::traits::Copy::<Interface2SafeDispatcherSubPointers>;


lib.cairo:6:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl Interface2SafeDispatcherSubPointersMutDrop<> of core::traits::Drop::<Interface2SafeDispatcherSubPointersMut>;
impl Interface2SafeDispatcherSubPointersMutCopy<> of core::traits::Copy::<Interface2SafeDispatcherSubPointersMut>;


lib.cairo:11:1
#[starknet::component]
^^^^^^^^^^^^^^^^^^^^^^
component:

#[event]
#[derive(Drop, starknet::Event)]
pub enum Event {}


#[phantom]
pub struct Storage {
}

#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct StorageStorageBase {
}
#[doc(hidden)]
impl StorageStorageImpl of starknet::storage::StorageTrait<Storage> {
    type BaseType = StorageStorageBase;
    fn storage(self: starknet::storage::FlattenedStorage<Storage>) -> StorageStorageBase {
        StorageStorageBase {
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct StorageStorageBaseMut {
}
#[doc(hidden)]
impl StorageStorageMutImpl of starknet::storage::StorageTraitMut<Storage> {
    type BaseType = StorageStorageBaseMut;
    fn storage_mut(self: starknet::storage::FlattenedStorage<starknet::storage::Mutable::<Storage>>) -> StorageStorageBaseMut {
        StorageStorageBaseMut {
        }
    }
}

pub struct ComponentState<TContractState> {
}

impl ComponentStateDrop<TContractState> of Drop<ComponentState<TContractState>> {}
 
impl ComponentStateDeref<TContractState> of core::ops::Deref<@ComponentState<TContractState>> {
    type Target = starknet::storage::FlattenedStorage<Storage>;
    fn deref(self: @ComponentState<TContractState>) -> starknet::storage::FlattenedStorage<Storage> {
        starknet::storage::FlattenedStorage {}
    }
}
impl ComponentStateDerefMut<TContractState> of core::ops::DerefMut<ComponentState<TContractState>> {
    type Target = starknet::storage::FlattenedStorage<starknet::storage::Mutable<Storage>> ;
    fn deref_mut(ref self: ComponentState<TContractState>) -> starknet::storage::FlattenedStorage<starknet::storage::Mutable<Storage>> {
        starknet::storage::FlattenedStorage {}
    }
}
pub fn unsafe_new_component_state<TContractState>() -> ComponentState<TContractState> {
    ComponentState::<TContractState> {
    }
}
#[cfg(target: 'test')]
#[inline(always)]
pub fn component_state_for_testing<TContractState>() -> ComponentState<TContractState> {
    unsafe_new_component_state::<TContractState>()
}


// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one.
#[deprecated(
    feature: "deprecated_legacy_map",
    note: "Use `starknet::storage::Map` instead."
)]
#[allow(unused_imports)]
use starknet::storage::Map as LegacyMap;
pub trait HasComponent<TContractState> {
    fn get_component(self: @TContractState) -> @ComponentState<TContractState>;
    fn get_component_mut(ref self: TContractState) -> ComponentState<TContractState>;
    fn get_contract(self: @ComponentState<TContractState>) -> @TContractState;
    fn get_contract_mut(ref self: ComponentState<TContractState>) -> TContractState;
    fn emit<S, impl IntoImp: core::traits::Into<S, Event>>(ref self: ComponentState<TContractState>, event: S);
}

#[starknet::embeddable]
pub impl I1I1<
            TContractState, impl X: HasComponent<TContractState>,
impl TContractStateDrop: Drop<TContractState>
> of super::Interface1<TContractState> {
    
    fn foo(ref self: TContractState) {
        let mut component = HasComponent::get_component_mut(ref self);
        Interface1_Implementation1::foo(ref component)
    }
}#[starknet::embeddable]
pub impl I1I2<
            TContractState, impl X: HasComponent<TContractState>,
impl TContractStateDrop: Drop<TContractState>
> of super::Interface1<TContractState> {
    
    fn foo(ref self: TContractState) {
        let mut component = HasComponent::get_component_mut(ref self);
        Interface1_Implementation2::foo(ref component)
    }
}#[starknet::embeddable]
pub impl I2I<
            TContractState, impl X: HasComponent<TContractState>,
impl TContractStateDrop: Drop<TContractState>
> of super::Interface2<TContractState> {
    
    fn foo(ref self: TContractState) {
        let mut component = HasComponent::get_component_mut(ref self);
        Interface2_Implementation::foo(ref component)
    }
}

lib.cairo:11:1
#[starknet::component]
^^^^^^^^^^^^^^^^^^^^^^
impls:

impl EventDrop<> of core::traits::Drop::<Event>;


lib.cairo:11:1
#[starknet::component]
^^^^^^^^^^^^^^^^^^^^^^
starknet_derive:

impl EventIsEvent of starknet::Event<Event> {
    fn append_keys_and_data(
        self: @Event, ref keys: Array<felt252>, ref data: Array<felt252>
    ) {
        match self {
        }
    }
    fn deserialize(
        ref keys: Span<felt252>, ref data: Span<felt252>,
    ) -> Option<Event> {
        let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?;
        Option::None
    }
}



lib.cairo:13:5
    #[storage]
    ^^^^^^^^^^
impls:

impl StorageStorageBaseDrop<> of core::traits::Drop::<StorageStorageBase>;
impl StorageStorageBaseCopy<> of core::traits::Copy::<StorageStorageBase>;


lib.cairo:13:5
    #[storage]
    ^^^^^^^^^^
impls:

impl StorageStorageBaseMutDrop<> of core::traits::Drop::<StorageStorageBaseMut>;
impl StorageStorageBaseMutCopy<> of core::traits::Copy::<StorageStorageBaseMut>;


lib.cairo:16:5
    #[embeddable_as(I1I1)]
    ^^^^^^^^^^^^^^^^^^^^^^
embeddable:

pub trait UnsafeNewContractStateTraitForI1I1<
    TContractState
> {
    fn unsafe_new_contract_state() -> TContractState;
}

#[doc(hidden)]
#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)]
fn __wrapper__I1I1__foo<TContractState, impl X: HasComponent<TContractState>,
impl TContractStateDrop: Drop<TContractState>, impl UnsafeNewContractState: UnsafeNewContractStateTraitForI1I1<TContractState>>(mut data: Span::<felt252>) -> Span::<felt252> {
    core::internal::require_implicit::<System>();
    core::internal::revoke_ap_tracking();
    core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas');
    
    assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments');
    core::option::OptionTraitImpl::expect(
        core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas',
    );
    let mut contract_state = UnsafeNewContractState::unsafe_new_contract_state();
    I1I1::<TContractState, X, TContractStateDrop>::foo(ref contract_state, );
    let mut arr = ArrayTrait::new();
    // References.
    // Result.
    core::array::ArrayTrait::span(@arr)
}



pub mod __external_I1I1 {
    pub use super::__wrapper__I1I1__foo as foo;
}

pub mod __l1_handler_I1I1 {
}

pub mod __constructor_I1I1 {
}


lib.cairo:23:5
    #[embeddable_as(I1I2)]
    ^^^^^^^^^^^^^^^^^^^^^^
embeddable:

pub trait UnsafeNewContractStateTraitForI1I2<
    TContractState
> {
    fn unsafe_new_contract_state() -> TContractState;
}

#[doc(hidden)]
#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)]
fn __wrapper__I1I2__foo<TContractState, impl X: HasComponent<TContractState>,
impl TContractStateDrop: Drop<TContractState>, impl UnsafeNewContractState: UnsafeNewContractStateTraitForI1I2<TContractState>>(mut data: Span::<felt252>) -> Span::<felt252> {
    core::internal::require_implicit::<System>();
    core::internal::revoke_ap_tracking();
    core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas');
    
    assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments');
    core::option::OptionTraitImpl::expect(
        core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas',
    );
    let mut contract_state = UnsafeNewContractState::unsafe_new_contract_state();
    I1I2::<TContractState, X, TContractStateDrop>::foo(ref contract_state, );
    let mut arr = ArrayTrait::new();
    // References.
    // Result.
    core::array::ArrayTrait::span(@arr)
}



pub mod __external_I1I2 {
    pub use super::__wrapper__I1I2__foo as foo;
}

pub mod __l1_handler_I1I2 {
}

pub mod __constructor_I1I2 {
}


lib.cairo:30:5
    #[embeddable_as(I2I)]
    ^^^^^^^^^^^^^^^^^^^^^
embeddable:

pub trait UnsafeNewContractStateTraitForI2I<
    TContractState
> {
    fn unsafe_new_contract_state() -> TContractState;
}

#[doc(hidden)]
#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)]
fn __wrapper__I2I__foo<TContractState, impl X: HasComponent<TContractState>,
impl TContractStateDrop: Drop<TContractState>, impl UnsafeNewContractState: UnsafeNewContractStateTraitForI2I<TContractState>>(mut data: Span::<felt252>) -> Span::<felt252> {
    core::internal::require_implicit::<System>();
    core::internal::revoke_ap_tracking();
    core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas');
    
    assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments');
    core::option::OptionTraitImpl::expect(
        core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas',
    );
    let mut contract_state = UnsafeNewContractState::unsafe_new_contract_state();
    I2I::<TContractState, X, TContractStateDrop>::foo(ref contract_state, );
    let mut arr = ArrayTrait::new();
    // References.
    // Result.
    core::array::ArrayTrait::span(@arr)
}



pub mod __external_I2I {
    pub use super::__wrapper__I2I__foo as foo;
}

pub mod __l1_handler_I2I {
}

pub mod __constructor_I2I {
}


lib.cairo:38:1
#[starknet::contract]
^^^^^^^^^^^^^^^^^^^^^
contract:



#[phantom]
pub struct Storage {
        #[substorage(v0)]
        pub comp_storage: super::comp::Storage,
}

#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct StorageStorageBase {
        #[substorage(v0)]
    pub comp_storage: starknet::storage::FlattenedStorage<super::comp::Storage>,
}
#[doc(hidden)]
impl StorageStorageImpl of starknet::storage::StorageTrait<Storage> {
    type BaseType = StorageStorageBase;
    fn storage(self: starknet::storage::FlattenedStorage<Storage>) -> StorageStorageBase {
        let __comp_storage_value__ = starknet::storage::FlattenedStorage {};
        StorageStorageBase {
           comp_storage: __comp_storage_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct StorageStorageBaseMut {
        #[substorage(v0)]
    pub comp_storage: starknet::storage::FlattenedStorage<starknet::storage::Mutable::<super::comp::Storage>>,
}
#[doc(hidden)]
impl StorageStorageMutImpl of starknet::storage::StorageTraitMut<Storage> {
    type BaseType = StorageStorageBaseMut;
    fn storage_mut(self: starknet::storage::FlattenedStorage<starknet::storage::Mutable::<Storage>>) -> StorageStorageBaseMut {
        let __comp_storage_value__ = starknet::storage::FlattenedStorage {};
        StorageStorageBaseMut {
           comp_storage: __comp_storage_value__,
        }
    }
}

pub struct ContractState {
        #[substorage(v0)]
        pub comp_storage: super::comp::ComponentState<ContractState>,
}

impl ContractStateDrop of Drop<ContractState> {}
 
impl ContractStateDeref of core::ops::Deref<@ContractState> {
    type Target = starknet::storage::FlattenedStorage<Storage>;
    fn deref(self: @ContractState) -> starknet::storage::FlattenedStorage<Storage> {
        starknet::storage::FlattenedStorage {}
    }
}
impl ContractStateDerefMut of core::ops::DerefMut<ContractState> {
    type Target = starknet::storage::FlattenedStorage<starknet::storage::Mutable<Storage>> ;
    fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage<starknet::storage::Mutable<Storage>> {
        starknet::storage::FlattenedStorage {}
    }
}
pub fn unsafe_new_contract_state() -> ContractState {
    ContractState {
            comp_storage: super::comp::unsafe_new_component_state::<ContractState>(),
    }
}
#[cfg(target: 'test')]
#[inline(always)]
pub fn contract_state_for_testing() -> ContractState {
    unsafe_new_contract_state()
}

// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one.
#[deprecated(
    feature: "deprecated_legacy_map",
    note: "Use `starknet::storage::Map` instead."
)]
#[allow(unused_imports)]
use starknet::storage::Map as LegacyMap;
#[cfg(target: 'test')]
pub const TEST_CLASS_HASH: starknet::ClassHash = 0x22aa9f2c832fb18ac0ec19b508b86f5fc9d78a62b4d7a72ee2a8c7c11a786b5.try_into().unwrap();

impl ContractStateI1I1 of
    super::comp::UnsafeNewContractStateTraitForI1I1<ContractState> {
    fn unsafe_new_contract_state() -> ContractState {
        unsafe_new_contract_state()
    }
}
impl ContractStateI1I2 of
    super::comp::UnsafeNewContractStateTraitForI1I2<ContractState> {
    fn unsafe_new_contract_state() -> ContractState {
        unsafe_new_contract_state()
    }
}
impl ContractStateI2I of
    super::comp::UnsafeNewContractStateTraitForI2I<ContractState> {
    fn unsafe_new_contract_state() -> ContractState {
        unsafe_new_contract_state()
    }
}
#[doc(hidden)]
#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)]
fn __wrapper__foo(mut data: Span::<felt252>) -> Span::<felt252> {
    core::internal::require_implicit::<System>();
    core::internal::revoke_ap_tracking();
    core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas');
    
    assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments');
    core::option::OptionTraitImpl::expect(
        core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas',
    );
    let mut contract_state = unsafe_new_contract_state();
    foo(@contract_state, );
    let mut arr = ArrayTrait::new();
    // References.
    // Result.
    core::array::ArrayTrait::span(@arr)
}


pub mod __external {
    pub use super::__wrapper__foo as foo;
}
pub mod __l1_handler {
}
pub mod __constructor {
}
    impl ContractStateEventEmitter of starknet::event::EventEmitter<
        ContractState, Event
    > {
        fn emit<S, impl IntoImp: core::traits::Into<S, Event>>(
            ref self: ContractState, event: S
        ) {
            let event: Event = core::traits::Into::into(event);
            let mut keys = Default::<core::array::Array>::default();
            let mut data = Default::<core::array::Array>::default();
            starknet::Event::append_keys_and_data(@event, ref keys, ref data);
            starknet::SyscallResultTrait::unwrap_syscall(
                starknet::syscalls::emit_event_syscall(
                    core::array::ArrayTrait::span(@keys),
                    core::array::ArrayTrait::span(@data),
                )
            )
        }
    }

impl HasComponentImpl_comp of super::comp::HasComponent<ContractState> {
    fn get_component(self: @ContractState) -> @super::comp::ComponentState<ContractState> {
                 @super::comp::unsafe_new_component_state::<ContractState>()
    }
    fn get_component_mut(ref self: ContractState) -> super::comp::ComponentState<ContractState> {
        super::comp::unsafe_new_component_state::<ContractState>()
    }
    fn get_contract(self: @super::comp::ComponentState<ContractState>) -> @ContractState {
        @unsafe_new_contract_state()
    }
    fn get_contract_mut(ref self: super::comp::ComponentState<ContractState>) -> ContractState {
        unsafe_new_contract_state()
    }
    fn emit<S, impl IntoImp: core::traits::Into<S, super::comp::Event>>(ref self: super::comp::ComponentState<ContractState>, event: S) {
        let event: super::comp::Event = core::traits::Into::into(event);
        let mut contract = super::comp::HasComponent::get_contract_mut(ref self);
        ContractStateEventEmitter::emit(ref contract, Event::CompEvent(event));
    }
}


lib.cairo:49:14
    #[derive(Drop, starknet::Event)]
             ^^^^
impls:

impl EventDrop<> of core::traits::Drop::<Event>;


lib.cairo:49:20
    #[derive(Drop, starknet::Event)]
                   ^^^^^^^^^^^^^^^
starknet_derive:

impl EventIsEvent of starknet::Event<Event> {
    fn append_keys_and_data(
        self: @Event, ref keys: Array<felt252>, ref data: Array<felt252>
    ) {
        match self {
            Event::CompEvent(val) => {
                core::array::ArrayTrait::append(ref keys, selector!("CompEvent"));
                starknet::Event::append_keys_and_data(
                    val, ref keys, ref data
                );
            },
        }
    }
    fn deserialize(
        ref keys: Span<felt252>, ref data: Span<felt252>,
    ) -> Option<Event> {
        let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?;
        if __selector__ == selector!("CompEvent") {
                let val = starknet::Event::deserialize(
                    ref keys, ref data
                )?;
                return Option::Some(Event::CompEvent(val));
        }
        Option::None
    }
}
impl EventCompEventIntoEvent of Into<super::comp::Event, Event> {
    fn into(self: super::comp::Event) -> Event {
        Event::CompEvent(self)
    }
}



lib.cairo:42:5
    #[storage]
    ^^^^^^^^^^
impls:

impl StorageStorageBaseDrop<> of core::traits::Drop::<StorageStorageBase>;
impl StorageStorageBaseCopy<> of core::traits::Copy::<StorageStorageBase>;


lib.cairo:42:5
    #[storage]
    ^^^^^^^^^^
impls:

impl StorageStorageBaseMutDrop<> of core::traits::Drop::<StorageStorageBaseMut>;
impl StorageStorageBaseMutCopy<> of core::traits::Copy::<StorageStorageBaseMut>;

//! > expected_diagnostics
warning: Plugin diagnostic: Failed to generate ABI: Duplicate entry point: 'foo'. This is not currently supported.
 --> lib.cairo:56:5-57:57
      #[abi(embed_v0)]
 _____^
|     impl EmbeddedI1I2 = super::comp::I1I2<ContractState>;
|_________________________________________________________^

warning: Plugin diagnostic: Failed to generate ABI: Duplicate entry point: 'foo'. This is not currently supported.
 --> lib.cairo:58:5-59:55
      #[abi(embed_v0)]
 _____^
|     impl EmbeddedI2I = super::comp::I2I<ContractState>;
|_______________________________________________________^

warning: Plugin diagnostic: Failed to generate ABI: Duplicate entry point: 'foo'. This is not currently supported.
 --> lib.cairo:61:5-62:35
      #[external(v0)]
 _____^
|     fn foo(self: @ContractState) {}
|___________________________________^
