//! > Test valid expansion of a dispatcher.

//! > test_runner_name
ExpandContractTestRunner(expect_diagnostics: false)

//! > cairo_code
#[starknet::interface]
trait IContract<T> {
    fn get_something(ref self: T, arg: felt252, num: felt252) -> felt252;

    fn empty(self: @T);
}

//! > generated_cairo_code
lib.cairo:

#[starknet::interface]
trait IContract<T> {
    fn get_something(ref self: T, arg: felt252, num: felt252) -> felt252;

    fn empty(self: @T);
}

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

#[doc(group: "dispatchers")]
trait IContractDispatcherTrait<T> {
    fn get_something(self: T, arg: felt252, num: felt252) -> felt252;

    fn empty(self: T);
}

#[doc(group: "dispatchers")]
#[derive(Copy, Drop, starknet::Store, Serde)]
struct IContractDispatcher {
    pub contract_address: starknet::ContractAddress,
}

#[doc(group: "dispatchers")]
impl IContractDispatcherImpl of IContractDispatcherTrait<IContractDispatcher> {
    fn get_something(self: IContractDispatcher, arg: felt252, num: felt252) -> felt252 {
        let mut __calldata__ = core::traits::Default::default();
        core::serde::Serde::<felt252>::serialize(@arg, ref __calldata__);
        core::serde::Serde::<felt252>::serialize(@num, ref __calldata__);

        let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall(
            self.contract_address,
            selector!("get_something"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__);
        core::option::OptionTrait::expect(
            core::serde::Serde::<felt252>::deserialize(ref __dispatcher_return_data__),
            'Returned data too short',
        )
    }

    fn empty(self: IContractDispatcher) {
        let mut __calldata__ = core::traits::Default::default();

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

}

#[doc(group: "dispatchers")]
#[derive(Copy, Drop, starknet::Store, Serde)]
struct IContractLibraryDispatcher {
    pub class_hash: starknet::ClassHash,
}

#[doc(group: "dispatchers")]
impl IContractLibraryDispatcherImpl of IContractDispatcherTrait<IContractLibraryDispatcher> {
    fn get_something(self: IContractLibraryDispatcher, arg: felt252, num: felt252) -> felt252 {
        let mut __calldata__ = core::traits::Default::default();
        core::serde::Serde::<felt252>::serialize(@arg, ref __calldata__);
        core::serde::Serde::<felt252>::serialize(@num, ref __calldata__);

        let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall(
            self.class_hash,
            selector!("get_something"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__);
        core::option::OptionTrait::expect(
            core::serde::Serde::<felt252>::deserialize(ref __dispatcher_return_data__),
            'Returned data too short',
        )
    }

    fn empty(self: IContractLibraryDispatcher) {
        let mut __calldata__ = core::traits::Default::default();

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

}

#[doc(group: "dispatchers")]
trait IContractSafeDispatcherTrait<T> {
    #[unstable(feature: "safe_dispatcher")]
    fn get_something(self: T, arg: felt252, num: felt252) -> starknet::SyscallResult<felt252>;
    #[unstable(feature: "safe_dispatcher")]

    fn empty(self: T) -> starknet::SyscallResult<()>;
}

#[doc(group: "dispatchers")]
#[derive(Copy, Drop, starknet::Store, Serde)]
struct IContractSafeLibraryDispatcher {
    pub class_hash: starknet::ClassHash,
}

#[doc(group: "dispatchers")]
impl IContractSafeLibraryDispatcherImpl of IContractSafeDispatcherTrait<IContractSafeLibraryDispatcher> {
    fn get_something(self: IContractSafeLibraryDispatcher, arg: felt252, num: felt252) -> starknet::SyscallResult<felt252> {
        let mut __calldata__ = core::traits::Default::default();
        core::serde::Serde::<felt252>::serialize(@arg, ref __calldata__);
        core::serde::Serde::<felt252>::serialize(@num, ref __calldata__);

        let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall(
            self.class_hash,
            selector!("get_something"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = __dispatcher_return_data__?;
        Result::Ok(
            core::option::OptionTrait::expect(
                core::serde::Serde::<felt252>::deserialize(ref __dispatcher_return_data__),
                'Returned data too short',
            )
        )
    }

    fn empty(self: IContractSafeLibraryDispatcher) -> starknet::SyscallResult<()> {
        let mut __calldata__ = core::traits::Default::default();

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

}


#[doc(group: "dispatchers")]
#[derive(Copy, Drop, starknet::Store, Serde)]
struct IContractSafeDispatcher {
    pub contract_address: starknet::ContractAddress,
}

#[doc(group: "dispatchers")]
impl IContractSafeDispatcherImpl of IContractSafeDispatcherTrait<IContractSafeDispatcher> {
    fn get_something(self: IContractSafeDispatcher, arg: felt252, num: felt252) -> starknet::SyscallResult<felt252> {
        let mut __calldata__ = core::traits::Default::default();
        core::serde::Serde::<felt252>::serialize(@arg, ref __calldata__);
        core::serde::Serde::<felt252>::serialize(@num, ref __calldata__);

        let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall(
            self.contract_address,
            selector!("get_something"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = __dispatcher_return_data__?;
        Result::Ok(
            core::option::OptionTrait::expect(
                core::serde::Serde::<felt252>::deserialize(ref __dispatcher_return_data__),
                'Returned data too short',
            )
        )
    }

    fn empty(self: IContractSafeDispatcher) -> starknet::SyscallResult<()> {
        let mut __calldata__ = core::traits::Default::default();

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

}


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

#[doc(group: "dispatchers")]
impl IContractDispatcherCopy<> of core::traits::Copy::<IContractDispatcher>;
#[doc(group: "dispatchers")]
impl IContractDispatcherDrop<> of core::traits::Drop::<IContractDispatcher>;
#[doc(group: "dispatchers")]
impl IContractDispatcherSerde<> of core::serde::Serde::<IContractDispatcher> {
    fn serialize(self: @IContractDispatcher, 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<IContractDispatcher> {
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: core::serde::Serde::<starknet::ContractAddress>::deserialize(ref serialized)? };
        core::option::Option::Some(IContractDispatcher {
            contract_address: contract_address.value,
        })
    }
}


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

impl IContractDispatcherStore<> of starknet::Store::<IContractDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<IContractDispatcher> {
        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(
            IContractDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IContractDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let IContractDispatcher {
            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<IContractDispatcher> {
        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(
            IContractDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IContractDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let IContractDispatcher {
            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 IContractDispatcherSubPointers {
    pub contract_address: starknet::storage::StoragePointer<starknet::ContractAddress>,
}
#[doc(hidden)]
impl IContractDispatcherSubPointersImpl of starknet::storage::SubPointers<IContractDispatcher> {
    type SubPointersType = IContractDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<IContractDispatcher>) -> IContractDispatcherSubPointers {
        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,
        };
                IContractDispatcherSubPointers {
           contract_address: __contract_address_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct IContractDispatcherSubPointersMut {
    pub contract_address: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ContractAddress>>,
}
#[doc(hidden)]
impl IContractDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<IContractDispatcher> {
    type SubPointersType = IContractDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<IContractDispatcher>>) -> IContractDispatcherSubPointersMut {
        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,
        };
                IContractDispatcherSubPointersMut {
           contract_address: __contract_address_value__,
        }
    }
}


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

#[doc(group: "dispatchers")]
impl IContractLibraryDispatcherCopy<> of core::traits::Copy::<IContractLibraryDispatcher>;
#[doc(group: "dispatchers")]
impl IContractLibraryDispatcherDrop<> of core::traits::Drop::<IContractLibraryDispatcher>;
#[doc(group: "dispatchers")]
impl IContractLibraryDispatcherSerde<> of core::serde::Serde::<IContractLibraryDispatcher> {
    fn serialize(self: @IContractLibraryDispatcher, 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<IContractLibraryDispatcher> {
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: core::serde::Serde::<starknet::ClassHash>::deserialize(ref serialized)? };
        core::option::Option::Some(IContractLibraryDispatcher {
            class_hash: class_hash.value,
        })
    }
}


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

impl IContractLibraryDispatcherStore<> of starknet::Store::<IContractLibraryDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<IContractLibraryDispatcher> {
        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(
            IContractLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IContractLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let IContractLibraryDispatcher {
            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<IContractLibraryDispatcher> {
        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(
            IContractLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IContractLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let IContractLibraryDispatcher {
            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 IContractLibraryDispatcherSubPointers {
    pub class_hash: starknet::storage::StoragePointer<starknet::ClassHash>,
}
#[doc(hidden)]
impl IContractLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers<IContractLibraryDispatcher> {
    type SubPointersType = IContractLibraryDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<IContractLibraryDispatcher>) -> IContractLibraryDispatcherSubPointers {
        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,
        };
                IContractLibraryDispatcherSubPointers {
           class_hash: __class_hash_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct IContractLibraryDispatcherSubPointersMut {
    pub class_hash: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ClassHash>>,
}
#[doc(hidden)]
impl IContractLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<IContractLibraryDispatcher> {
    type SubPointersType = IContractLibraryDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<IContractLibraryDispatcher>>) -> IContractLibraryDispatcherSubPointersMut {
        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,
        };
                IContractLibraryDispatcherSubPointersMut {
           class_hash: __class_hash_value__,
        }
    }
}


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

#[doc(group: "dispatchers")]
impl IContractSafeLibraryDispatcherCopy<> of core::traits::Copy::<IContractSafeLibraryDispatcher>;
#[doc(group: "dispatchers")]
impl IContractSafeLibraryDispatcherDrop<> of core::traits::Drop::<IContractSafeLibraryDispatcher>;
#[doc(group: "dispatchers")]
impl IContractSafeLibraryDispatcherSerde<> of core::serde::Serde::<IContractSafeLibraryDispatcher> {
    fn serialize(self: @IContractSafeLibraryDispatcher, 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<IContractSafeLibraryDispatcher> {
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: core::serde::Serde::<starknet::ClassHash>::deserialize(ref serialized)? };
        core::option::Option::Some(IContractSafeLibraryDispatcher {
            class_hash: class_hash.value,
        })
    }
}


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

impl IContractSafeLibraryDispatcherStore<> of starknet::Store::<IContractSafeLibraryDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<IContractSafeLibraryDispatcher> {
        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(
            IContractSafeLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IContractSafeLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let IContractSafeLibraryDispatcher {
            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<IContractSafeLibraryDispatcher> {
        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(
            IContractSafeLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IContractSafeLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let IContractSafeLibraryDispatcher {
            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 IContractSafeLibraryDispatcherSubPointers {
    pub class_hash: starknet::storage::StoragePointer<starknet::ClassHash>,
}
#[doc(hidden)]
impl IContractSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers<IContractSafeLibraryDispatcher> {
    type SubPointersType = IContractSafeLibraryDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<IContractSafeLibraryDispatcher>) -> IContractSafeLibraryDispatcherSubPointers {
        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,
        };
                IContractSafeLibraryDispatcherSubPointers {
           class_hash: __class_hash_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct IContractSafeLibraryDispatcherSubPointersMut {
    pub class_hash: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ClassHash>>,
}
#[doc(hidden)]
impl IContractSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<IContractSafeLibraryDispatcher> {
    type SubPointersType = IContractSafeLibraryDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<IContractSafeLibraryDispatcher>>) -> IContractSafeLibraryDispatcherSubPointersMut {
        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,
        };
                IContractSafeLibraryDispatcherSubPointersMut {
           class_hash: __class_hash_value__,
        }
    }
}


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

#[doc(group: "dispatchers")]
impl IContractSafeDispatcherCopy<> of core::traits::Copy::<IContractSafeDispatcher>;
#[doc(group: "dispatchers")]
impl IContractSafeDispatcherDrop<> of core::traits::Drop::<IContractSafeDispatcher>;
#[doc(group: "dispatchers")]
impl IContractSafeDispatcherSerde<> of core::serde::Serde::<IContractSafeDispatcher> {
    fn serialize(self: @IContractSafeDispatcher, 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<IContractSafeDispatcher> {
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: core::serde::Serde::<starknet::ContractAddress>::deserialize(ref serialized)? };
        core::option::Option::Some(IContractSafeDispatcher {
            contract_address: contract_address.value,
        })
    }
}


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

impl IContractSafeDispatcherStore<> of starknet::Store::<IContractSafeDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<IContractSafeDispatcher> {
        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(
            IContractSafeDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IContractSafeDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let IContractSafeDispatcher {
            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<IContractSafeDispatcher> {
        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(
            IContractSafeDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IContractSafeDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let IContractSafeDispatcher {
            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 IContractSafeDispatcherSubPointers {
    pub contract_address: starknet::storage::StoragePointer<starknet::ContractAddress>,
}
#[doc(hidden)]
impl IContractSafeDispatcherSubPointersImpl of starknet::storage::SubPointers<IContractSafeDispatcher> {
    type SubPointersType = IContractSafeDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<IContractSafeDispatcher>) -> IContractSafeDispatcherSubPointers {
        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,
        };
                IContractSafeDispatcherSubPointers {
           contract_address: __contract_address_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct IContractSafeDispatcherSubPointersMut {
    pub contract_address: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ContractAddress>>,
}
#[doc(hidden)]
impl IContractSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<IContractSafeDispatcher> {
    type SubPointersType = IContractSafeDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<IContractSafeDispatcher>>) -> IContractSafeDispatcherSubPointersMut {
        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,
        };
                IContractSafeDispatcherSubPointersMut {
           contract_address: __contract_address_value__,
        }
    }
}


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

#[doc(hidden)]
impl IContractDispatcherSubPointersDrop<> of core::traits::Drop::<IContractDispatcherSubPointers>;
#[doc(hidden)]
impl IContractDispatcherSubPointersCopy<> of core::traits::Copy::<IContractDispatcherSubPointers>;


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

#[doc(hidden)]
impl IContractDispatcherSubPointersMutDrop<> of core::traits::Drop::<IContractDispatcherSubPointersMut>;
#[doc(hidden)]
impl IContractDispatcherSubPointersMutCopy<> of core::traits::Copy::<IContractDispatcherSubPointersMut>;


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

#[doc(hidden)]
impl IContractLibraryDispatcherSubPointersDrop<> of core::traits::Drop::<IContractLibraryDispatcherSubPointers>;
#[doc(hidden)]
impl IContractLibraryDispatcherSubPointersCopy<> of core::traits::Copy::<IContractLibraryDispatcherSubPointers>;


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

#[doc(hidden)]
impl IContractLibraryDispatcherSubPointersMutDrop<> of core::traits::Drop::<IContractLibraryDispatcherSubPointersMut>;
#[doc(hidden)]
impl IContractLibraryDispatcherSubPointersMutCopy<> of core::traits::Copy::<IContractLibraryDispatcherSubPointersMut>;


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

#[doc(hidden)]
impl IContractSafeLibraryDispatcherSubPointersDrop<> of core::traits::Drop::<IContractSafeLibraryDispatcherSubPointers>;
#[doc(hidden)]
impl IContractSafeLibraryDispatcherSubPointersCopy<> of core::traits::Copy::<IContractSafeLibraryDispatcherSubPointers>;


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

#[doc(hidden)]
impl IContractSafeLibraryDispatcherSubPointersMutDrop<> of core::traits::Drop::<IContractSafeLibraryDispatcherSubPointersMut>;
#[doc(hidden)]
impl IContractSafeLibraryDispatcherSubPointersMutCopy<> of core::traits::Copy::<IContractSafeLibraryDispatcherSubPointersMut>;


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

#[doc(hidden)]
impl IContractSafeDispatcherSubPointersDrop<> of core::traits::Drop::<IContractSafeDispatcherSubPointers>;
#[doc(hidden)]
impl IContractSafeDispatcherSubPointersCopy<> of core::traits::Copy::<IContractSafeDispatcherSubPointers>;


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

#[doc(hidden)]
impl IContractSafeDispatcherSubPointersMutDrop<> of core::traits::Drop::<IContractSafeDispatcherSubPointersMut>;
#[doc(hidden)]
impl IContractSafeDispatcherSubPointersMutCopy<> of core::traits::Copy::<IContractSafeDispatcherSubPointersMut>;

//! > expected_diagnostics

//! > ==========================================================================

//! > Test erroneous expansion of a dispatcher.

//! > test_runner_name
ExpandContractTestRunner(expect_diagnostics: true)

//! > cairo_code
#[starknet::interface]
trait IContract<T> {
    fn bad_sig(ref self: T, ref arg1: felt252, ref arg2: felt252) -> felt252;

    fn bad_sig2(self: @T, __calldata__: felt252);
}

//! > generated_cairo_code
lib.cairo:

#[starknet::interface]
trait IContract<T> {
    fn bad_sig(ref self: T, ref arg1: felt252, ref arg2: felt252) -> felt252;

    fn bad_sig2(self: @T, __calldata__: felt252);
}

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

#[doc(group: "dispatchers")]
trait IContractDispatcherTrait<T> {
}

#[doc(group: "dispatchers")]
#[derive(Copy, Drop, starknet::Store, Serde)]
struct IContractDispatcher {
    pub contract_address: starknet::ContractAddress,
}

#[doc(group: "dispatchers")]
impl IContractDispatcherImpl of IContractDispatcherTrait<IContractDispatcher> {

}

#[doc(group: "dispatchers")]
#[derive(Copy, Drop, starknet::Store, Serde)]
struct IContractLibraryDispatcher {
    pub class_hash: starknet::ClassHash,
}

#[doc(group: "dispatchers")]
impl IContractLibraryDispatcherImpl of IContractDispatcherTrait<IContractLibraryDispatcher> {

}

#[doc(group: "dispatchers")]
trait IContractSafeDispatcherTrait<T> {
}

#[doc(group: "dispatchers")]
#[derive(Copy, Drop, starknet::Store, Serde)]
struct IContractSafeLibraryDispatcher {
    pub class_hash: starknet::ClassHash,
}

#[doc(group: "dispatchers")]
impl IContractSafeLibraryDispatcherImpl of IContractSafeDispatcherTrait<IContractSafeLibraryDispatcher> {

}


#[doc(group: "dispatchers")]
#[derive(Copy, Drop, starknet::Store, Serde)]
struct IContractSafeDispatcher {
    pub contract_address: starknet::ContractAddress,
}

#[doc(group: "dispatchers")]
impl IContractSafeDispatcherImpl of IContractSafeDispatcherTrait<IContractSafeDispatcher> {

}


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

#[doc(group: "dispatchers")]
impl IContractDispatcherCopy<> of core::traits::Copy::<IContractDispatcher>;
#[doc(group: "dispatchers")]
impl IContractDispatcherDrop<> of core::traits::Drop::<IContractDispatcher>;
#[doc(group: "dispatchers")]
impl IContractDispatcherSerde<> of core::serde::Serde::<IContractDispatcher> {
    fn serialize(self: @IContractDispatcher, 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<IContractDispatcher> {
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: core::serde::Serde::<starknet::ContractAddress>::deserialize(ref serialized)? };
        core::option::Option::Some(IContractDispatcher {
            contract_address: contract_address.value,
        })
    }
}


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

impl IContractDispatcherStore<> of starknet::Store::<IContractDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<IContractDispatcher> {
        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(
            IContractDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IContractDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let IContractDispatcher {
            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<IContractDispatcher> {
        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(
            IContractDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IContractDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let IContractDispatcher {
            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 IContractDispatcherSubPointers {
    pub contract_address: starknet::storage::StoragePointer<starknet::ContractAddress>,
}
#[doc(hidden)]
impl IContractDispatcherSubPointersImpl of starknet::storage::SubPointers<IContractDispatcher> {
    type SubPointersType = IContractDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<IContractDispatcher>) -> IContractDispatcherSubPointers {
        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,
        };
                IContractDispatcherSubPointers {
           contract_address: __contract_address_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct IContractDispatcherSubPointersMut {
    pub contract_address: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ContractAddress>>,
}
#[doc(hidden)]
impl IContractDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<IContractDispatcher> {
    type SubPointersType = IContractDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<IContractDispatcher>>) -> IContractDispatcherSubPointersMut {
        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,
        };
                IContractDispatcherSubPointersMut {
           contract_address: __contract_address_value__,
        }
    }
}


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

#[doc(group: "dispatchers")]
impl IContractLibraryDispatcherCopy<> of core::traits::Copy::<IContractLibraryDispatcher>;
#[doc(group: "dispatchers")]
impl IContractLibraryDispatcherDrop<> of core::traits::Drop::<IContractLibraryDispatcher>;
#[doc(group: "dispatchers")]
impl IContractLibraryDispatcherSerde<> of core::serde::Serde::<IContractLibraryDispatcher> {
    fn serialize(self: @IContractLibraryDispatcher, 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<IContractLibraryDispatcher> {
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: core::serde::Serde::<starknet::ClassHash>::deserialize(ref serialized)? };
        core::option::Option::Some(IContractLibraryDispatcher {
            class_hash: class_hash.value,
        })
    }
}


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

impl IContractLibraryDispatcherStore<> of starknet::Store::<IContractLibraryDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<IContractLibraryDispatcher> {
        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(
            IContractLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IContractLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let IContractLibraryDispatcher {
            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<IContractLibraryDispatcher> {
        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(
            IContractLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IContractLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let IContractLibraryDispatcher {
            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 IContractLibraryDispatcherSubPointers {
    pub class_hash: starknet::storage::StoragePointer<starknet::ClassHash>,
}
#[doc(hidden)]
impl IContractLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers<IContractLibraryDispatcher> {
    type SubPointersType = IContractLibraryDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<IContractLibraryDispatcher>) -> IContractLibraryDispatcherSubPointers {
        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,
        };
                IContractLibraryDispatcherSubPointers {
           class_hash: __class_hash_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct IContractLibraryDispatcherSubPointersMut {
    pub class_hash: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ClassHash>>,
}
#[doc(hidden)]
impl IContractLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<IContractLibraryDispatcher> {
    type SubPointersType = IContractLibraryDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<IContractLibraryDispatcher>>) -> IContractLibraryDispatcherSubPointersMut {
        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,
        };
                IContractLibraryDispatcherSubPointersMut {
           class_hash: __class_hash_value__,
        }
    }
}


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

#[doc(group: "dispatchers")]
impl IContractSafeLibraryDispatcherCopy<> of core::traits::Copy::<IContractSafeLibraryDispatcher>;
#[doc(group: "dispatchers")]
impl IContractSafeLibraryDispatcherDrop<> of core::traits::Drop::<IContractSafeLibraryDispatcher>;
#[doc(group: "dispatchers")]
impl IContractSafeLibraryDispatcherSerde<> of core::serde::Serde::<IContractSafeLibraryDispatcher> {
    fn serialize(self: @IContractSafeLibraryDispatcher, 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<IContractSafeLibraryDispatcher> {
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: core::serde::Serde::<starknet::ClassHash>::deserialize(ref serialized)? };
        core::option::Option::Some(IContractSafeLibraryDispatcher {
            class_hash: class_hash.value,
        })
    }
}


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

impl IContractSafeLibraryDispatcherStore<> of starknet::Store::<IContractSafeLibraryDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<IContractSafeLibraryDispatcher> {
        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(
            IContractSafeLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IContractSafeLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let IContractSafeLibraryDispatcher {
            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<IContractSafeLibraryDispatcher> {
        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(
            IContractSafeLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IContractSafeLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let IContractSafeLibraryDispatcher {
            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 IContractSafeLibraryDispatcherSubPointers {
    pub class_hash: starknet::storage::StoragePointer<starknet::ClassHash>,
}
#[doc(hidden)]
impl IContractSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers<IContractSafeLibraryDispatcher> {
    type SubPointersType = IContractSafeLibraryDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<IContractSafeLibraryDispatcher>) -> IContractSafeLibraryDispatcherSubPointers {
        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,
        };
                IContractSafeLibraryDispatcherSubPointers {
           class_hash: __class_hash_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct IContractSafeLibraryDispatcherSubPointersMut {
    pub class_hash: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ClassHash>>,
}
#[doc(hidden)]
impl IContractSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<IContractSafeLibraryDispatcher> {
    type SubPointersType = IContractSafeLibraryDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<IContractSafeLibraryDispatcher>>) -> IContractSafeLibraryDispatcherSubPointersMut {
        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,
        };
                IContractSafeLibraryDispatcherSubPointersMut {
           class_hash: __class_hash_value__,
        }
    }
}


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

#[doc(group: "dispatchers")]
impl IContractSafeDispatcherCopy<> of core::traits::Copy::<IContractSafeDispatcher>;
#[doc(group: "dispatchers")]
impl IContractSafeDispatcherDrop<> of core::traits::Drop::<IContractSafeDispatcher>;
#[doc(group: "dispatchers")]
impl IContractSafeDispatcherSerde<> of core::serde::Serde::<IContractSafeDispatcher> {
    fn serialize(self: @IContractSafeDispatcher, 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<IContractSafeDispatcher> {
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: core::serde::Serde::<starknet::ContractAddress>::deserialize(ref serialized)? };
        core::option::Option::Some(IContractSafeDispatcher {
            contract_address: contract_address.value,
        })
    }
}


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

impl IContractSafeDispatcherStore<> of starknet::Store::<IContractSafeDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<IContractSafeDispatcher> {
        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(
            IContractSafeDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IContractSafeDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let IContractSafeDispatcher {
            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<IContractSafeDispatcher> {
        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(
            IContractSafeDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IContractSafeDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let IContractSafeDispatcher {
            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 IContractSafeDispatcherSubPointers {
    pub contract_address: starknet::storage::StoragePointer<starknet::ContractAddress>,
}
#[doc(hidden)]
impl IContractSafeDispatcherSubPointersImpl of starknet::storage::SubPointers<IContractSafeDispatcher> {
    type SubPointersType = IContractSafeDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<IContractSafeDispatcher>) -> IContractSafeDispatcherSubPointers {
        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,
        };
                IContractSafeDispatcherSubPointers {
           contract_address: __contract_address_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct IContractSafeDispatcherSubPointersMut {
    pub contract_address: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ContractAddress>>,
}
#[doc(hidden)]
impl IContractSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<IContractSafeDispatcher> {
    type SubPointersType = IContractSafeDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<IContractSafeDispatcher>>) -> IContractSafeDispatcherSubPointersMut {
        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,
        };
                IContractSafeDispatcherSubPointersMut {
           contract_address: __contract_address_value__,
        }
    }
}


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

#[doc(hidden)]
impl IContractDispatcherSubPointersDrop<> of core::traits::Drop::<IContractDispatcherSubPointers>;
#[doc(hidden)]
impl IContractDispatcherSubPointersCopy<> of core::traits::Copy::<IContractDispatcherSubPointers>;


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

#[doc(hidden)]
impl IContractDispatcherSubPointersMutDrop<> of core::traits::Drop::<IContractDispatcherSubPointersMut>;
#[doc(hidden)]
impl IContractDispatcherSubPointersMutCopy<> of core::traits::Copy::<IContractDispatcherSubPointersMut>;


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

#[doc(hidden)]
impl IContractLibraryDispatcherSubPointersDrop<> of core::traits::Drop::<IContractLibraryDispatcherSubPointers>;
#[doc(hidden)]
impl IContractLibraryDispatcherSubPointersCopy<> of core::traits::Copy::<IContractLibraryDispatcherSubPointers>;


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

#[doc(hidden)]
impl IContractLibraryDispatcherSubPointersMutDrop<> of core::traits::Drop::<IContractLibraryDispatcherSubPointersMut>;
#[doc(hidden)]
impl IContractLibraryDispatcherSubPointersMutCopy<> of core::traits::Copy::<IContractLibraryDispatcherSubPointersMut>;


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

#[doc(hidden)]
impl IContractSafeLibraryDispatcherSubPointersDrop<> of core::traits::Drop::<IContractSafeLibraryDispatcherSubPointers>;
#[doc(hidden)]
impl IContractSafeLibraryDispatcherSubPointersCopy<> of core::traits::Copy::<IContractSafeLibraryDispatcherSubPointers>;


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

#[doc(hidden)]
impl IContractSafeLibraryDispatcherSubPointersMutDrop<> of core::traits::Drop::<IContractSafeLibraryDispatcherSubPointersMut>;
#[doc(hidden)]
impl IContractSafeLibraryDispatcherSubPointersMutCopy<> of core::traits::Copy::<IContractSafeLibraryDispatcherSubPointersMut>;


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

#[doc(hidden)]
impl IContractSafeDispatcherSubPointersDrop<> of core::traits::Drop::<IContractSafeDispatcherSubPointers>;
#[doc(hidden)]
impl IContractSafeDispatcherSubPointersCopy<> of core::traits::Copy::<IContractSafeDispatcherSubPointers>;


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

#[doc(hidden)]
impl IContractSafeDispatcherSubPointersMutDrop<> of core::traits::Drop::<IContractSafeDispatcherSubPointersMut>;
#[doc(hidden)]
impl IContractSafeDispatcherSubPointersMutCopy<> of core::traits::Copy::<IContractSafeDispatcherSubPointersMut>;

//! > expected_diagnostics
error: Plugin diagnostic: `starknet::interface` functions don't support `ref` parameters other than the first one.
 --> lib.cairo:3:29
    fn bad_sig(ref self: T, ref arg1: felt252, ref arg2: felt252) -> felt252;
                            ^^^

error: Plugin diagnostic: `starknet::interface` functions don't support `ref` parameters other than the first one.
 --> lib.cairo:3:48
    fn bad_sig(ref self: T, ref arg1: felt252, ref arg2: felt252) -> felt252;
                                               ^^^

error: Plugin diagnostic: Parameter name `__calldata__` cannot be used.
 --> lib.cairo:5:27
    fn bad_sig2(self: @T, __calldata__: felt252);
                          ^^^^^^^^^^^^

//! > ==========================================================================

//! > Test unsupported items in a starknet interface.

//! > test_runner_name
ExpandContractTestRunner(expect_diagnostics: true)

//! > cairo_code
#[starknet::interface]
trait IContract<T> {
    type X;
    const Y: usize;

    fn empty(self: @T);
}

//! > expected_diagnostics
error: Plugin diagnostic: `starknet::interface` does not yet support type items.
 --> lib.cairo:3:5
    type X;
    ^^^^

error: Plugin diagnostic: `starknet::interface` does not yet support constant items.
 --> lib.cairo:4:5
    const Y: usize;
    ^^^^^

//! > generated_cairo_code
lib.cairo:

#[starknet::interface]
trait IContract<T> {
    type X;
    const Y: usize;

    fn empty(self: @T);
}

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

#[doc(group: "dispatchers")]
trait IContractDispatcherTrait<T> {

    fn empty(self: T);
}

#[doc(group: "dispatchers")]
#[derive(Copy, Drop, starknet::Store, Serde)]
struct IContractDispatcher {
    pub contract_address: starknet::ContractAddress,
}

#[doc(group: "dispatchers")]
impl IContractDispatcherImpl of IContractDispatcherTrait<IContractDispatcher> {

    fn empty(self: IContractDispatcher) {
        let mut __calldata__ = core::traits::Default::default();

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

}

#[doc(group: "dispatchers")]
#[derive(Copy, Drop, starknet::Store, Serde)]
struct IContractLibraryDispatcher {
    pub class_hash: starknet::ClassHash,
}

#[doc(group: "dispatchers")]
impl IContractLibraryDispatcherImpl of IContractDispatcherTrait<IContractLibraryDispatcher> {

    fn empty(self: IContractLibraryDispatcher) {
        let mut __calldata__ = core::traits::Default::default();

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

}

#[doc(group: "dispatchers")]
trait IContractSafeDispatcherTrait<T> {
    #[unstable(feature: "safe_dispatcher")]

    fn empty(self: T) -> starknet::SyscallResult<()>;
}

#[doc(group: "dispatchers")]
#[derive(Copy, Drop, starknet::Store, Serde)]
struct IContractSafeLibraryDispatcher {
    pub class_hash: starknet::ClassHash,
}

#[doc(group: "dispatchers")]
impl IContractSafeLibraryDispatcherImpl of IContractSafeDispatcherTrait<IContractSafeLibraryDispatcher> {

    fn empty(self: IContractSafeLibraryDispatcher) -> starknet::SyscallResult<()> {
        let mut __calldata__ = core::traits::Default::default();

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

}


#[doc(group: "dispatchers")]
#[derive(Copy, Drop, starknet::Store, Serde)]
struct IContractSafeDispatcher {
    pub contract_address: starknet::ContractAddress,
}

#[doc(group: "dispatchers")]
impl IContractSafeDispatcherImpl of IContractSafeDispatcherTrait<IContractSafeDispatcher> {

    fn empty(self: IContractSafeDispatcher) -> starknet::SyscallResult<()> {
        let mut __calldata__ = core::traits::Default::default();

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

}


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

#[doc(group: "dispatchers")]
impl IContractDispatcherCopy<> of core::traits::Copy::<IContractDispatcher>;
#[doc(group: "dispatchers")]
impl IContractDispatcherDrop<> of core::traits::Drop::<IContractDispatcher>;
#[doc(group: "dispatchers")]
impl IContractDispatcherSerde<> of core::serde::Serde::<IContractDispatcher> {
    fn serialize(self: @IContractDispatcher, 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<IContractDispatcher> {
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: core::serde::Serde::<starknet::ContractAddress>::deserialize(ref serialized)? };
        core::option::Option::Some(IContractDispatcher {
            contract_address: contract_address.value,
        })
    }
}


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

impl IContractDispatcherStore<> of starknet::Store::<IContractDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<IContractDispatcher> {
        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(
            IContractDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IContractDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let IContractDispatcher {
            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<IContractDispatcher> {
        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(
            IContractDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IContractDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let IContractDispatcher {
            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 IContractDispatcherSubPointers {
    pub contract_address: starknet::storage::StoragePointer<starknet::ContractAddress>,
}
#[doc(hidden)]
impl IContractDispatcherSubPointersImpl of starknet::storage::SubPointers<IContractDispatcher> {
    type SubPointersType = IContractDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<IContractDispatcher>) -> IContractDispatcherSubPointers {
        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,
        };
                IContractDispatcherSubPointers {
           contract_address: __contract_address_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct IContractDispatcherSubPointersMut {
    pub contract_address: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ContractAddress>>,
}
#[doc(hidden)]
impl IContractDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<IContractDispatcher> {
    type SubPointersType = IContractDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<IContractDispatcher>>) -> IContractDispatcherSubPointersMut {
        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,
        };
                IContractDispatcherSubPointersMut {
           contract_address: __contract_address_value__,
        }
    }
}


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

#[doc(group: "dispatchers")]
impl IContractLibraryDispatcherCopy<> of core::traits::Copy::<IContractLibraryDispatcher>;
#[doc(group: "dispatchers")]
impl IContractLibraryDispatcherDrop<> of core::traits::Drop::<IContractLibraryDispatcher>;
#[doc(group: "dispatchers")]
impl IContractLibraryDispatcherSerde<> of core::serde::Serde::<IContractLibraryDispatcher> {
    fn serialize(self: @IContractLibraryDispatcher, 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<IContractLibraryDispatcher> {
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: core::serde::Serde::<starknet::ClassHash>::deserialize(ref serialized)? };
        core::option::Option::Some(IContractLibraryDispatcher {
            class_hash: class_hash.value,
        })
    }
}


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

impl IContractLibraryDispatcherStore<> of starknet::Store::<IContractLibraryDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<IContractLibraryDispatcher> {
        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(
            IContractLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IContractLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let IContractLibraryDispatcher {
            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<IContractLibraryDispatcher> {
        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(
            IContractLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IContractLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let IContractLibraryDispatcher {
            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 IContractLibraryDispatcherSubPointers {
    pub class_hash: starknet::storage::StoragePointer<starknet::ClassHash>,
}
#[doc(hidden)]
impl IContractLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers<IContractLibraryDispatcher> {
    type SubPointersType = IContractLibraryDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<IContractLibraryDispatcher>) -> IContractLibraryDispatcherSubPointers {
        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,
        };
                IContractLibraryDispatcherSubPointers {
           class_hash: __class_hash_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct IContractLibraryDispatcherSubPointersMut {
    pub class_hash: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ClassHash>>,
}
#[doc(hidden)]
impl IContractLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<IContractLibraryDispatcher> {
    type SubPointersType = IContractLibraryDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<IContractLibraryDispatcher>>) -> IContractLibraryDispatcherSubPointersMut {
        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,
        };
                IContractLibraryDispatcherSubPointersMut {
           class_hash: __class_hash_value__,
        }
    }
}


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

#[doc(group: "dispatchers")]
impl IContractSafeLibraryDispatcherCopy<> of core::traits::Copy::<IContractSafeLibraryDispatcher>;
#[doc(group: "dispatchers")]
impl IContractSafeLibraryDispatcherDrop<> of core::traits::Drop::<IContractSafeLibraryDispatcher>;
#[doc(group: "dispatchers")]
impl IContractSafeLibraryDispatcherSerde<> of core::serde::Serde::<IContractSafeLibraryDispatcher> {
    fn serialize(self: @IContractSafeLibraryDispatcher, 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<IContractSafeLibraryDispatcher> {
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: core::serde::Serde::<starknet::ClassHash>::deserialize(ref serialized)? };
        core::option::Option::Some(IContractSafeLibraryDispatcher {
            class_hash: class_hash.value,
        })
    }
}


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

impl IContractSafeLibraryDispatcherStore<> of starknet::Store::<IContractSafeLibraryDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<IContractSafeLibraryDispatcher> {
        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(
            IContractSafeLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IContractSafeLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let IContractSafeLibraryDispatcher {
            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<IContractSafeLibraryDispatcher> {
        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(
            IContractSafeLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IContractSafeLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let IContractSafeLibraryDispatcher {
            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 IContractSafeLibraryDispatcherSubPointers {
    pub class_hash: starknet::storage::StoragePointer<starknet::ClassHash>,
}
#[doc(hidden)]
impl IContractSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers<IContractSafeLibraryDispatcher> {
    type SubPointersType = IContractSafeLibraryDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<IContractSafeLibraryDispatcher>) -> IContractSafeLibraryDispatcherSubPointers {
        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,
        };
                IContractSafeLibraryDispatcherSubPointers {
           class_hash: __class_hash_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct IContractSafeLibraryDispatcherSubPointersMut {
    pub class_hash: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ClassHash>>,
}
#[doc(hidden)]
impl IContractSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<IContractSafeLibraryDispatcher> {
    type SubPointersType = IContractSafeLibraryDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<IContractSafeLibraryDispatcher>>) -> IContractSafeLibraryDispatcherSubPointersMut {
        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,
        };
                IContractSafeLibraryDispatcherSubPointersMut {
           class_hash: __class_hash_value__,
        }
    }
}


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

#[doc(group: "dispatchers")]
impl IContractSafeDispatcherCopy<> of core::traits::Copy::<IContractSafeDispatcher>;
#[doc(group: "dispatchers")]
impl IContractSafeDispatcherDrop<> of core::traits::Drop::<IContractSafeDispatcher>;
#[doc(group: "dispatchers")]
impl IContractSafeDispatcherSerde<> of core::serde::Serde::<IContractSafeDispatcher> {
    fn serialize(self: @IContractSafeDispatcher, 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<IContractSafeDispatcher> {
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: core::serde::Serde::<starknet::ContractAddress>::deserialize(ref serialized)? };
        core::option::Option::Some(IContractSafeDispatcher {
            contract_address: contract_address.value,
        })
    }
}


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

impl IContractSafeDispatcherStore<> of starknet::Store::<IContractSafeDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<IContractSafeDispatcher> {
        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(
            IContractSafeDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IContractSafeDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let IContractSafeDispatcher {
            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<IContractSafeDispatcher> {
        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(
            IContractSafeDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IContractSafeDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let IContractSafeDispatcher {
            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 IContractSafeDispatcherSubPointers {
    pub contract_address: starknet::storage::StoragePointer<starknet::ContractAddress>,
}
#[doc(hidden)]
impl IContractSafeDispatcherSubPointersImpl of starknet::storage::SubPointers<IContractSafeDispatcher> {
    type SubPointersType = IContractSafeDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<IContractSafeDispatcher>) -> IContractSafeDispatcherSubPointers {
        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,
        };
                IContractSafeDispatcherSubPointers {
           contract_address: __contract_address_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct IContractSafeDispatcherSubPointersMut {
    pub contract_address: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ContractAddress>>,
}
#[doc(hidden)]
impl IContractSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<IContractSafeDispatcher> {
    type SubPointersType = IContractSafeDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<IContractSafeDispatcher>>) -> IContractSafeDispatcherSubPointersMut {
        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,
        };
                IContractSafeDispatcherSubPointersMut {
           contract_address: __contract_address_value__,
        }
    }
}


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

#[doc(hidden)]
impl IContractDispatcherSubPointersDrop<> of core::traits::Drop::<IContractDispatcherSubPointers>;
#[doc(hidden)]
impl IContractDispatcherSubPointersCopy<> of core::traits::Copy::<IContractDispatcherSubPointers>;


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

#[doc(hidden)]
impl IContractDispatcherSubPointersMutDrop<> of core::traits::Drop::<IContractDispatcherSubPointersMut>;
#[doc(hidden)]
impl IContractDispatcherSubPointersMutCopy<> of core::traits::Copy::<IContractDispatcherSubPointersMut>;


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

#[doc(hidden)]
impl IContractLibraryDispatcherSubPointersDrop<> of core::traits::Drop::<IContractLibraryDispatcherSubPointers>;
#[doc(hidden)]
impl IContractLibraryDispatcherSubPointersCopy<> of core::traits::Copy::<IContractLibraryDispatcherSubPointers>;


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

#[doc(hidden)]
impl IContractLibraryDispatcherSubPointersMutDrop<> of core::traits::Drop::<IContractLibraryDispatcherSubPointersMut>;
#[doc(hidden)]
impl IContractLibraryDispatcherSubPointersMutCopy<> of core::traits::Copy::<IContractLibraryDispatcherSubPointersMut>;


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

#[doc(hidden)]
impl IContractSafeLibraryDispatcherSubPointersDrop<> of core::traits::Drop::<IContractSafeLibraryDispatcherSubPointers>;
#[doc(hidden)]
impl IContractSafeLibraryDispatcherSubPointersCopy<> of core::traits::Copy::<IContractSafeLibraryDispatcherSubPointers>;


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

#[doc(hidden)]
impl IContractSafeLibraryDispatcherSubPointersMutDrop<> of core::traits::Drop::<IContractSafeLibraryDispatcherSubPointersMut>;
#[doc(hidden)]
impl IContractSafeLibraryDispatcherSubPointersMutCopy<> of core::traits::Copy::<IContractSafeLibraryDispatcherSubPointersMut>;


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

#[doc(hidden)]
impl IContractSafeDispatcherSubPointersDrop<> of core::traits::Drop::<IContractSafeDispatcherSubPointers>;
#[doc(hidden)]
impl IContractSafeDispatcherSubPointersCopy<> of core::traits::Copy::<IContractSafeDispatcherSubPointers>;


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

#[doc(hidden)]
impl IContractSafeDispatcherSubPointersMutDrop<> of core::traits::Drop::<IContractSafeDispatcherSubPointersMut>;
#[doc(hidden)]
impl IContractSafeDispatcherSubPointersMutCopy<> of core::traits::Copy::<IContractSafeDispatcherSubPointersMut>;
