//! > Test expansion of a basic component.

//! > test_runner_name
ExpandContractTestRunner(expect_diagnostics: false)

//! > cairo_code
#[derive(Drop, starknet::Store)]
struct MyType {
    x: u32,
}

#[starknet::component]
mod component {
    use starknet::ContractAddress;
    use super::MyTrait;

    #[storage]
    struct Storage {
        data: u32,
        #[feature("deprecated_legacy_map")]
        map: LegacyMap<u32, u32>,
        my_type_var: super::MyType,
    }

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

    #[embeddable_as(MyImpl)]
    impl MyInnerImpl<
        TContractState, impl X: HasComponent<TContractState>,
    > of MyTrait<ComponentState<TContractState>> {
        fn get(self: @ComponentState<TContractState>, addr: ContractAddress) -> u32 {
            self.data.read() + self.map.read(10)
        }
        fn set(ref self: ComponentState<TContractState>, addr: ContractAddress, value: u32) {
            self.map.write(10, value);
            self.data.write(value);
            self.emit(Log {});
        }
    }
}
use starknet::ContractAddress;
#[starknet::interface]
trait MyTrait<T> {
    fn get(self: @T, addr: ContractAddress) -> u32;
    fn set(ref self: T, addr: ContractAddress, value: u32);
}

//! > generated_cairo_code
lib.cairo:

#[derive(Drop, starknet::Store)]
struct MyType {
    x: u32,
}

#[starknet::component]
mod component {
    use starknet::ContractAddress;
    use super::MyTrait;

    #[storage]
    struct Storage {
        data: u32,
        #[feature("deprecated_legacy_map")]
        map: LegacyMap<u32, u32>,
        my_type_var: super::MyType,
    }

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

    #[embeddable_as(MyImpl)]
    impl MyInnerImpl<
        TContractState, impl X: HasComponent<TContractState>,
    > of MyTrait<ComponentState<TContractState>> {
        fn get(self: @ComponentState<TContractState>, addr: ContractAddress) -> u32 {
            self.data.read() + self.map.read(10)
        }
        fn set(ref self: ComponentState<TContractState>, addr: ContractAddress, value: u32) {
            self.map.write(10, value);
            self.data.write(value);
            self.emit(Log {});
        }
    }
}
use starknet::ContractAddress;
#[starknet::interface]
trait MyTrait<T> {
    fn get(self: @T, addr: ContractAddress) -> u32;
    fn set(ref self: T, addr: ContractAddress, value: u32);
}

lib.cairo:1:10
#[derive(Drop, starknet::Store)]
         ^^^^
impls:

impl MyTypeDrop<> of core::traits::Drop::<MyType>;


lib.cairo:1:16
#[derive(Drop, starknet::Store)]
               ^^^^^^^^^^^^^^^
starknet_derive:

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

#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct MyTypeSubPointers {
    pub x: starknet::storage::StoragePointer<u32>,
}
#[doc(hidden)]
impl MyTypeSubPointersImpl of starknet::storage::SubPointers<MyType> {
    type SubPointersType = MyTypeSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<MyType>) -> MyTypeSubPointers {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __x_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                MyTypeSubPointers {
           x: __x_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct MyTypeSubPointersMut {
    pub x: starknet::storage::StoragePointer<starknet::storage::Mutable::<u32>>,
}
#[doc(hidden)]
impl MyTypeSubPointersMutImpl of starknet::storage::SubPointersMut<MyType> {
    type SubPointersType = MyTypeSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<MyType>>) -> MyTypeSubPointersMut {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __x_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                MyTypeSubPointersMut {
           x: __x_value__,
        }
    }
}


lib.cairo:42:1
#[starknet::interface]
^^^^^^^^^^^^^^^^^^^^^^
MyTraitDispatcherTrait:

trait MyTraitDispatcherTrait<T> {
    fn get(self: T, addr: ContractAddress) -> u32;
    fn set(self: T, addr: ContractAddress, value: u32);
}

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

impl MyTraitDispatcherImpl of MyTraitDispatcherTrait<MyTraitDispatcher> {
    fn get(self: MyTraitDispatcher, addr: ContractAddress) -> u32 {
        let mut __calldata__ = core::traits::Default::default();
        core::serde::Serde::<ContractAddress>::serialize(@addr, ref __calldata__);

        let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall(
            self.contract_address,
            selector!("get"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__);
        core::option::OptionTrait::expect(
            core::serde::Serde::<u32>::deserialize(ref __dispatcher_return_data__),
            'Returned data too short',
        )
    }
    fn set(self: MyTraitDispatcher, addr: ContractAddress, value: u32) {
        let mut __calldata__ = core::traits::Default::default();
        core::serde::Serde::<ContractAddress>::serialize(@addr, ref __calldata__);
        core::serde::Serde::<u32>::serialize(@value, ref __calldata__);

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

}

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

impl MyTraitLibraryDispatcherImpl of MyTraitDispatcherTrait<MyTraitLibraryDispatcher> {
    fn get(self: MyTraitLibraryDispatcher, addr: ContractAddress) -> u32 {
        let mut __calldata__ = core::traits::Default::default();
        core::serde::Serde::<ContractAddress>::serialize(@addr, ref __calldata__);

        let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall(
            self.class_hash,
            selector!("get"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__);
        core::option::OptionTrait::expect(
            core::serde::Serde::<u32>::deserialize(ref __dispatcher_return_data__),
            'Returned data too short',
        )
    }
    fn set(self: MyTraitLibraryDispatcher, addr: ContractAddress, value: u32) {
        let mut __calldata__ = core::traits::Default::default();
        core::serde::Serde::<ContractAddress>::serialize(@addr, ref __calldata__);
        core::serde::Serde::<u32>::serialize(@value, ref __calldata__);

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

}

trait MyTraitSafeDispatcherTrait<T> {
    #[unstable(feature: "safe_dispatcher")]
    fn get(self: T, addr: ContractAddress) -> starknet::SyscallResult<u32>;
    #[unstable(feature: "safe_dispatcher")]
    fn set(self: T, addr: ContractAddress, value: u32) -> starknet::SyscallResult<()>;
}

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

impl MyTraitSafeLibraryDispatcherImpl of MyTraitSafeDispatcherTrait<MyTraitSafeLibraryDispatcher> {
    fn get(self: MyTraitSafeLibraryDispatcher, addr: ContractAddress) -> starknet::SyscallResult<u32> {
        let mut __calldata__ = core::traits::Default::default();
        core::serde::Serde::<ContractAddress>::serialize(@addr, ref __calldata__);

        let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall(
            self.class_hash,
            selector!("get"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = __dispatcher_return_data__?;
        Result::Ok(
            core::option::OptionTrait::expect(
                core::serde::Serde::<u32>::deserialize(ref __dispatcher_return_data__),
                'Returned data too short',
            )
        )
    }
    fn set(self: MyTraitSafeLibraryDispatcher, addr: ContractAddress, value: u32) -> starknet::SyscallResult<()> {
        let mut __calldata__ = core::traits::Default::default();
        core::serde::Serde::<ContractAddress>::serialize(@addr, ref __calldata__);
        core::serde::Serde::<u32>::serialize(@value, ref __calldata__);

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

}


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

impl MyTraitSafeDispatcherImpl of MyTraitSafeDispatcherTrait<MyTraitSafeDispatcher> {
    fn get(self: MyTraitSafeDispatcher, addr: ContractAddress) -> starknet::SyscallResult<u32> {
        let mut __calldata__ = core::traits::Default::default();
        core::serde::Serde::<ContractAddress>::serialize(@addr, ref __calldata__);

        let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall(
            self.contract_address,
            selector!("get"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = __dispatcher_return_data__?;
        Result::Ok(
            core::option::OptionTrait::expect(
                core::serde::Serde::<u32>::deserialize(ref __dispatcher_return_data__),
                'Returned data too short',
            )
        )
    }
    fn set(self: MyTraitSafeDispatcher, addr: ContractAddress, value: u32) -> starknet::SyscallResult<()> {
        let mut __calldata__ = core::traits::Default::default();
        core::serde::Serde::<ContractAddress>::serialize(@addr, ref __calldata__);
        core::serde::Serde::<u32>::serialize(@value, ref __calldata__);

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

}


lib.cairo:1:16
#[derive(Drop, starknet::Store)]
               ^^^^^^^^^^^^^^^
impls:

impl MyTypeSubPointersDrop<> of core::traits::Drop::<MyTypeSubPointers>;
impl MyTypeSubPointersCopy<> of core::traits::Copy::<MyTypeSubPointers>;


lib.cairo:1:16
#[derive(Drop, starknet::Store)]
               ^^^^^^^^^^^^^^^
impls:

impl MyTypeSubPointersMutDrop<> of core::traits::Drop::<MyTypeSubPointersMut>;
impl MyTypeSubPointersMutCopy<> of core::traits::Copy::<MyTypeSubPointersMut>;


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

impl MyTraitDispatcherCopy<> of core::traits::Copy::<MyTraitDispatcher>;
impl MyTraitDispatcherDrop<> of core::traits::Drop::<MyTraitDispatcher>;
impl MyTraitDispatcherSerde<> of core::serde::Serde::<MyTraitDispatcher> {
    fn serialize(self: @MyTraitDispatcher, 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<MyTraitDispatcher> {
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: core::serde::Serde::<starknet::ContractAddress>::deserialize(ref serialized)? };
        core::option::Option::Some(MyTraitDispatcher {
            contract_address: contract_address.value,
        })
    }
}


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

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


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

impl MyTraitLibraryDispatcherCopy<> of core::traits::Copy::<MyTraitLibraryDispatcher>;
impl MyTraitLibraryDispatcherDrop<> of core::traits::Drop::<MyTraitLibraryDispatcher>;
impl MyTraitLibraryDispatcherSerde<> of core::serde::Serde::<MyTraitLibraryDispatcher> {
    fn serialize(self: @MyTraitLibraryDispatcher, 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<MyTraitLibraryDispatcher> {
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: core::serde::Serde::<starknet::ClassHash>::deserialize(ref serialized)? };
        core::option::Option::Some(MyTraitLibraryDispatcher {
            class_hash: class_hash.value,
        })
    }
}


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

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


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

impl MyTraitSafeLibraryDispatcherCopy<> of core::traits::Copy::<MyTraitSafeLibraryDispatcher>;
impl MyTraitSafeLibraryDispatcherDrop<> of core::traits::Drop::<MyTraitSafeLibraryDispatcher>;
impl MyTraitSafeLibraryDispatcherSerde<> of core::serde::Serde::<MyTraitSafeLibraryDispatcher> {
    fn serialize(self: @MyTraitSafeLibraryDispatcher, 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<MyTraitSafeLibraryDispatcher> {
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: core::serde::Serde::<starknet::ClassHash>::deserialize(ref serialized)? };
        core::option::Option::Some(MyTraitSafeLibraryDispatcher {
            class_hash: class_hash.value,
        })
    }
}


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

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


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

impl MyTraitSafeDispatcherCopy<> of core::traits::Copy::<MyTraitSafeDispatcher>;
impl MyTraitSafeDispatcherDrop<> of core::traits::Drop::<MyTraitSafeDispatcher>;
impl MyTraitSafeDispatcherSerde<> of core::serde::Serde::<MyTraitSafeDispatcher> {
    fn serialize(self: @MyTraitSafeDispatcher, 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<MyTraitSafeDispatcher> {
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: core::serde::Serde::<starknet::ContractAddress>::deserialize(ref serialized)? };
        core::option::Option::Some(MyTraitSafeDispatcher {
            contract_address: contract_address.value,
        })
    }
}


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

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


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

impl MyTraitDispatcherSubPointersDrop<> of core::traits::Drop::<MyTraitDispatcherSubPointers>;
impl MyTraitDispatcherSubPointersCopy<> of core::traits::Copy::<MyTraitDispatcherSubPointers>;


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

impl MyTraitDispatcherSubPointersMutDrop<> of core::traits::Drop::<MyTraitDispatcherSubPointersMut>;
impl MyTraitDispatcherSubPointersMutCopy<> of core::traits::Copy::<MyTraitDispatcherSubPointersMut>;


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

impl MyTraitLibraryDispatcherSubPointersDrop<> of core::traits::Drop::<MyTraitLibraryDispatcherSubPointers>;
impl MyTraitLibraryDispatcherSubPointersCopy<> of core::traits::Copy::<MyTraitLibraryDispatcherSubPointers>;


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

impl MyTraitLibraryDispatcherSubPointersMutDrop<> of core::traits::Drop::<MyTraitLibraryDispatcherSubPointersMut>;
impl MyTraitLibraryDispatcherSubPointersMutCopy<> of core::traits::Copy::<MyTraitLibraryDispatcherSubPointersMut>;


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

impl MyTraitSafeLibraryDispatcherSubPointersDrop<> of core::traits::Drop::<MyTraitSafeLibraryDispatcherSubPointers>;
impl MyTraitSafeLibraryDispatcherSubPointersCopy<> of core::traits::Copy::<MyTraitSafeLibraryDispatcherSubPointers>;


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

impl MyTraitSafeLibraryDispatcherSubPointersMutDrop<> of core::traits::Drop::<MyTraitSafeLibraryDispatcherSubPointersMut>;
impl MyTraitSafeLibraryDispatcherSubPointersMutCopy<> of core::traits::Copy::<MyTraitSafeLibraryDispatcherSubPointersMut>;


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

impl MyTraitSafeDispatcherSubPointersDrop<> of core::traits::Drop::<MyTraitSafeDispatcherSubPointers>;
impl MyTraitSafeDispatcherSubPointersCopy<> of core::traits::Copy::<MyTraitSafeDispatcherSubPointers>;


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

impl MyTraitSafeDispatcherSubPointersMutDrop<> of core::traits::Drop::<MyTraitSafeDispatcherSubPointersMut>;
impl MyTraitSafeDispatcherSubPointersMutCopy<> of core::traits::Copy::<MyTraitSafeDispatcherSubPointersMut>;


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



#[phantom]
pub struct Storage {
        pub data: u32,
        #[feature("deprecated_legacy_map")]
        pub map: LegacyMap<u32, u32>,
        pub my_type_var: super::MyType,
}

#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct StorageStorageBase {
    pub data: starknet::storage::StorageBase<u32>,
        #[feature("deprecated_legacy_map")]
    pub map: starknet::storage::StorageBase<LegacyMap<u32, u32>>,
    pub my_type_var: starknet::storage::StorageBase<super::MyType>,
}
#[doc(hidden)]
impl StorageStorageImpl of starknet::storage::StorageTrait<Storage> {
    type BaseType = StorageStorageBase;
    fn storage(self: starknet::storage::FlattenedStorage<Storage>) -> StorageStorageBase {
        let __data_value__ = starknet::storage::StorageBase {__base_address__: selector!("data")};
        let __map_value__ = starknet::storage::StorageBase {__base_address__: selector!("map")};
        let __my_type_var_value__ = starknet::storage::StorageBase {__base_address__: selector!("my_type_var")};
        StorageStorageBase {
           data: __data_value__,
           map: __map_value__,
           my_type_var: __my_type_var_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct StorageStorageBaseMut {
    pub data: starknet::storage::StorageBase<starknet::storage::Mutable::<u32>>,
        #[feature("deprecated_legacy_map")]
    pub map: starknet::storage::StorageBase<starknet::storage::Mutable::<LegacyMap<u32, u32>>>,
    pub my_type_var: starknet::storage::StorageBase<starknet::storage::Mutable::<super::MyType>>,
}
#[doc(hidden)]
impl StorageStorageMutImpl of starknet::storage::StorageTraitMut<Storage> {
    type BaseType = StorageStorageBaseMut;
    fn storage_mut(self: starknet::storage::FlattenedStorage<starknet::storage::Mutable::<Storage>>) -> StorageStorageBaseMut {
        let __data_value__ = starknet::storage::StorageBase {__base_address__: selector!("data")};
        let __map_value__ = starknet::storage::StorageBase {__base_address__: selector!("map")};
        let __my_type_var_value__ = starknet::storage::StorageBase {__base_address__: selector!("my_type_var")};
        StorageStorageBaseMut {
           data: __data_value__,
           map: __map_value__,
           my_type_var: __my_type_var_value__,
        }
    }
}

pub struct ComponentState<TContractState> {
}

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


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

#[starknet::embeddable]
pub impl MyImpl<
            TContractState, impl X: HasComponent<TContractState>,
impl TContractStateDrop: Drop<TContractState>
> of MyTrait<TContractState> {
    
    fn get(self: @TContractState, addr: ContractAddress) -> u32 {
        let component = HasComponent::get_component(self);
        MyInnerImpl::get(component, addr)
    }
    
    fn set(ref self: TContractState, addr: ContractAddress, value: u32) {
        let mut component = HasComponent::get_component_mut(ref self);
        MyInnerImpl::set(ref component, addr, value)
    }
}

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

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


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

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



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

impl LogDrop<> of core::traits::Drop::<Log>;


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

impl LogIsEvent of starknet::Event<Log> {
    fn append_keys_and_data(
        self: @Log, ref keys: Array<felt252>, ref data: Array<felt252>
    ) {
    }
    fn deserialize(
        ref keys: Span<felt252>, ref data: Span<felt252>,
    ) -> Option<Log> {
        Option::Some(Log {})
    }
}


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

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


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

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


lib.cairo:27:5
    #[embeddable_as(MyImpl)]
    ^^^^^^^^^^^^^^^^^^^^^^^^
embeddable:

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

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

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



pub mod __external_MyImpl {
    pub use super::__wrapper__MyImpl__get as get;
    pub use super::__wrapper__MyImpl__set as set;
}

pub mod __l1_handler_MyImpl {
}

pub mod __constructor_MyImpl {
}

//! > expected_diagnostics
