#![feature(prelude_import)]
#![no_std]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std;
extern crate intercom;
use intercom::*;

pub trait Foo {
    fn static_method(a: u16, b: i16);

    fn simple_method(&self);

    fn arg_method(&self, a: u16);

    fn simple_result_method(&self) -> u16;
    fn com_result_method(&self) -> ComResult<u16>;
    fn rust_result_method(&self) -> Result<u16, i32>;

    fn complete_method(&mut self, a: u16, b: i16) -> ComResult<bool>;

    fn string_method(&self, msg: String) -> String;
    fn comitf_method(&self, itf: ComItf<dyn Foo>) -> ComResult<ComItf<dyn IUnknown>>;

    // Should be VARIANT_BOOL in Automation interface.
    fn bool_method(&self, input: bool) -> ComResult<bool>;

    fn variant_method(&self, input: Variant) -> ComResult<Variant>;
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_simple_method_Automation<I, S>(
    self_vtable: intercom::raw::RawComPtr,
) -> ()
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::AutomationTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::AutomationTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"simple_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let self_struct = &**self_combox;
    let __result = self_struct.simple_method();
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::", ", OK"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"simple_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_arg_method_Automation<I, S>(
    self_vtable: intercom::raw::RawComPtr,
    a:
                                                             <u16 as
                                                             intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
) -> ()
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::AutomationTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::AutomationTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"arg_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let self_struct = &**self_combox;
    let __result = self_struct.arg_method(<u16 as intercom::type_system::InfallibleExternInput<
        intercom::type_system::AutomationTypeSystem,
    >>::from_foreign_parameter(a));
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::", ", OK"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"arg_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_simple_result_method_Automation<I,
                                                                S>(self_vtable:
                                                                       intercom::raw::RawComPtr)
 ->
     <u16 as
     intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
 where I: ?Sized,
 S: intercom::attributes::ComClassInterface<I,
                                            intercom::type_system::AutomationTypeSystem> +
intercom::attributes::ComClass + Foo{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::AutomationTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"simple_result_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let self_struct = &**self_combox;
    let __result = self_struct.simple_result_method();
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::", ", OK"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"simple_result_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    <u16 as intercom::type_system::InfallibleExternOutput<
        intercom::type_system::AutomationTypeSystem,
    >>::into_foreign_output(__result)
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_com_result_method_Automation<I, S>(
    self_vtable: intercom::raw::RawComPtr,
    __out: *mut <u16 as intercom::type_system::ExternType<
        intercom::type_system::AutomationTypeSystem,
    >>::ForeignType,
) -> <intercom::raw::HRESULT as intercom::type_system::ExternType<
    intercom::type_system::AutomationTypeSystem,
>>::ForeignType
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::AutomationTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::AutomationTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"com_result_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let result: Result<
        <intercom::raw::HRESULT as intercom::type_system::ExternType<
            intercom::type_system::AutomationTypeSystem,
        >>::ForeignType,
        intercom::ComError,
    > = (|| {
        let self_struct = &**self_combox;
        let __result = self_struct.com_result_method();
        Ok({
            match __result.and_then(|v1| {
                let ____out_guard =
                    intercom::type_system::OutputGuard::<
                        intercom::type_system::AutomationTypeSystem,
                        u16,
                    >::wrap(<u16 as intercom::type_system::ExternOutput<
                        intercom::type_system::AutomationTypeSystem,
                    >>::into_foreign_output(v1)?);
                *__out = ____out_guard.consume();
                Ok(intercom::raw::S_OK)
            }) {
                Ok(s) => s,
                Err(e) => {
                    *__out = intercom::type_system::ExternDefault::extern_default();
                    intercom::store_error(e).hresult
                }
            }
        })
    })();
    match result {
        Ok(v) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", OK"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"com_result_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            v
        }
        Err(err) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", ERROR"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"com_result_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            <<intercom::raw::HRESULT as intercom::type_system::ExternType<
                intercom::type_system::AutomationTypeSystem,
            >>::ForeignType as intercom::ErrorValue>::from_error(intercom::store_error(
                err,
            ))
        }
    }
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_rust_result_method_Automation<I, S>(
    self_vtable: intercom::raw::RawComPtr,
    __out: *mut <u16 as intercom::type_system::ExternType<
        intercom::type_system::AutomationTypeSystem,
    >>::ForeignType,
) -> <intercom::raw::HRESULT as intercom::type_system::ExternType<
    intercom::type_system::AutomationTypeSystem,
>>::ForeignType
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::AutomationTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::AutomationTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"rust_result_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let result: Result<
        <intercom::raw::HRESULT as intercom::type_system::ExternType<
            intercom::type_system::AutomationTypeSystem,
        >>::ForeignType,
        intercom::ComError,
    > = (|| {
        let self_struct = &**self_combox;
        let __result = self_struct.rust_result_method();
        Ok({
            match __result.and_then(|v1| {
                let ____out_guard =
                    intercom::type_system::OutputGuard::<
                        intercom::type_system::AutomationTypeSystem,
                        u16,
                    >::wrap(<u16 as intercom::type_system::ExternOutput<
                        intercom::type_system::AutomationTypeSystem,
                    >>::into_foreign_output(v1)?);
                *__out = ____out_guard.consume();
                Ok(intercom::raw::S_OK)
            }) {
                Ok(s) => s,
                Err(e) => {
                    *__out = intercom::type_system::ExternDefault::extern_default();
                    intercom::store_error(e).hresult
                }
            }
        })
    })();
    match result {
        Ok(v) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", OK"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"rust_result_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            v
        }
        Err(err) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", ERROR"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"rust_result_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            <<intercom::raw::HRESULT as intercom::type_system::ExternType<
                intercom::type_system::AutomationTypeSystem,
            >>::ForeignType as intercom::ErrorValue>::from_error(intercom::store_error(
                err,
            ))
        }
    }
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_complete_method_Automation<I, S>(
    self_vtable: intercom::raw::RawComPtr,
    a:
                                                                  <u16 as
                                                                  intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
    b:
                                                                  <i16 as
                                                                  intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
    __out: *mut <bool as intercom::type_system::ExternType<
        intercom::type_system::AutomationTypeSystem,
    >>::ForeignType,
) -> <intercom::raw::HRESULT as intercom::type_system::ExternType<
    intercom::type_system::AutomationTypeSystem,
>>::ForeignType
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::AutomationTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::AutomationTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"complete_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let result: Result<
        <intercom::raw::HRESULT as intercom::type_system::ExternType<
            intercom::type_system::AutomationTypeSystem,
        >>::ForeignType,
        intercom::ComError,
    > = (|| {
        let self_struct = &mut **self_combox;
        let __result = self_struct.complete_method(
            <u16 as intercom::type_system::ExternInput<
                intercom::type_system::AutomationTypeSystem,
            >>::from_foreign_parameter(a)?,
            <i16 as intercom::type_system::ExternInput<
                intercom::type_system::AutomationTypeSystem,
            >>::from_foreign_parameter(b)?,
        );
        Ok({
            match __result.and_then(|v1| {
                let ____out_guard =
                    intercom::type_system::OutputGuard::<
                        intercom::type_system::AutomationTypeSystem,
                        bool,
                    >::wrap(<bool as intercom::type_system::ExternOutput<
                        intercom::type_system::AutomationTypeSystem,
                    >>::into_foreign_output(v1)?);
                *__out = ____out_guard.consume();
                Ok(intercom::raw::S_OK)
            }) {
                Ok(s) => s,
                Err(e) => {
                    *__out = intercom::type_system::ExternDefault::extern_default();
                    intercom::store_error(e).hresult
                }
            }
        })
    })();
    match result {
        Ok(v) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", OK"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"complete_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            v
        }
        Err(err) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", ERROR"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"complete_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            <<intercom::raw::HRESULT as intercom::type_system::ExternType<
                intercom::type_system::AutomationTypeSystem,
            >>::ForeignType as intercom::ErrorValue>::from_error(intercom::store_error(
                err,
            ))
        }
    }
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_string_method_Automation<I,
                                                         S>(self_vtable:
                                                                intercom::raw::RawComPtr,
                                                            msg:
                                                                <String as
                                                                intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType)
 ->
     <String as
     intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
 where I: ?Sized,
 S: intercom::attributes::ComClassInterface<I,
                                            intercom::type_system::AutomationTypeSystem> +
intercom::attributes::ComClass + Foo{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::AutomationTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"string_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let self_struct = &**self_combox;
    let __result =
        self_struct.string_method(<String as intercom::type_system::InfallibleExternInput<
            intercom::type_system::AutomationTypeSystem,
        >>::from_foreign_parameter(msg));
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::", ", OK"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"string_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    <String as intercom::type_system::InfallibleExternOutput<
        intercom::type_system::AutomationTypeSystem,
    >>::into_foreign_output(__result)
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_comitf_method_Automation<I, S>(
    self_vtable: intercom::raw::RawComPtr,
    itf: <ComItf<dyn Foo> as intercom::type_system::ExternType<
        intercom::type_system::AutomationTypeSystem,
    >>::ForeignType,
    __out: *mut <ComItf<dyn IUnknown> as intercom::type_system::ExternType<
        intercom::type_system::AutomationTypeSystem,
    >>::ForeignType,
) -> <intercom::raw::HRESULT as intercom::type_system::ExternType<
    intercom::type_system::AutomationTypeSystem,
>>::ForeignType
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::AutomationTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::AutomationTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"comitf_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let result: Result<
        <intercom::raw::HRESULT as intercom::type_system::ExternType<
            intercom::type_system::AutomationTypeSystem,
        >>::ForeignType,
        intercom::ComError,
    > = (|| {
        let self_struct = &**self_combox;
        let __result =
            self_struct.comitf_method(<ComItf<dyn Foo> as intercom::type_system::ExternInput<
                intercom::type_system::AutomationTypeSystem,
            >>::from_foreign_parameter(itf)?);
        Ok({
            match __result.and_then(|v1| {
                let ____out_guard = intercom::type_system::OutputGuard::<
                    intercom::type_system::AutomationTypeSystem,
                    ComItf<dyn IUnknown>,
                >::wrap(
                    <ComItf<dyn IUnknown> as intercom::type_system::ExternOutput<
                        intercom::type_system::AutomationTypeSystem,
                    >>::into_foreign_output(v1)?,
                );
                *__out = ____out_guard.consume();
                Ok(intercom::raw::S_OK)
            }) {
                Ok(s) => s,
                Err(e) => {
                    *__out = intercom::type_system::ExternDefault::extern_default();
                    intercom::store_error(e).hresult
                }
            }
        })
    })();
    match result {
        Ok(v) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", OK"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"comitf_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            v
        }
        Err(err) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", ERROR"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"comitf_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            <<intercom::raw::HRESULT as intercom::type_system::ExternType<
                intercom::type_system::AutomationTypeSystem,
            >>::ForeignType as intercom::ErrorValue>::from_error(intercom::store_error(
                err,
            ))
        }
    }
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_bool_method_Automation<I, S>(
    self_vtable: intercom::raw::RawComPtr,
    input: <bool as intercom::type_system::ExternType<
        intercom::type_system::AutomationTypeSystem,
    >>::ForeignType,
    __out: *mut <bool as intercom::type_system::ExternType<
        intercom::type_system::AutomationTypeSystem,
    >>::ForeignType,
) -> <intercom::raw::HRESULT as intercom::type_system::ExternType<
    intercom::type_system::AutomationTypeSystem,
>>::ForeignType
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::AutomationTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::AutomationTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"bool_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let result: Result<
        <intercom::raw::HRESULT as intercom::type_system::ExternType<
            intercom::type_system::AutomationTypeSystem,
        >>::ForeignType,
        intercom::ComError,
    > = (|| {
        let self_struct = &**self_combox;
        let __result = self_struct.bool_method(<bool as intercom::type_system::ExternInput<
            intercom::type_system::AutomationTypeSystem,
        >>::from_foreign_parameter(input)?);
        Ok({
            match __result.and_then(|v1| {
                let ____out_guard =
                    intercom::type_system::OutputGuard::<
                        intercom::type_system::AutomationTypeSystem,
                        bool,
                    >::wrap(<bool as intercom::type_system::ExternOutput<
                        intercom::type_system::AutomationTypeSystem,
                    >>::into_foreign_output(v1)?);
                *__out = ____out_guard.consume();
                Ok(intercom::raw::S_OK)
            }) {
                Ok(s) => s,
                Err(e) => {
                    *__out = intercom::type_system::ExternDefault::extern_default();
                    intercom::store_error(e).hresult
                }
            }
        })
    })();
    match result {
        Ok(v) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", OK"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"bool_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            v
        }
        Err(err) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", ERROR"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"bool_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            <<intercom::raw::HRESULT as intercom::type_system::ExternType<
                intercom::type_system::AutomationTypeSystem,
            >>::ForeignType as intercom::ErrorValue>::from_error(intercom::store_error(
                err,
            ))
        }
    }
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_variant_method_Automation<I, S>(
    self_vtable: intercom::raw::RawComPtr,
    input: <Variant as intercom::type_system::ExternType<
        intercom::type_system::AutomationTypeSystem,
    >>::ForeignType,
    __out: *mut <Variant as intercom::type_system::ExternType<
        intercom::type_system::AutomationTypeSystem,
    >>::ForeignType,
) -> <intercom::raw::HRESULT as intercom::type_system::ExternType<
    intercom::type_system::AutomationTypeSystem,
>>::ForeignType
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::AutomationTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::AutomationTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"variant_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let result: Result<
        <intercom::raw::HRESULT as intercom::type_system::ExternType<
            intercom::type_system::AutomationTypeSystem,
        >>::ForeignType,
        intercom::ComError,
    > = (|| {
        let self_struct = &**self_combox;
        let __result =
            self_struct.variant_method(<Variant as intercom::type_system::ExternInput<
                intercom::type_system::AutomationTypeSystem,
            >>::from_foreign_parameter(input)?);
        Ok({
            match __result.and_then(|v1| {
                let ____out_guard = intercom::type_system::OutputGuard::<
                    intercom::type_system::AutomationTypeSystem,
                    Variant,
                >::wrap(
                    <Variant as intercom::type_system::ExternOutput<
                        intercom::type_system::AutomationTypeSystem,
                    >>::into_foreign_output(v1)?,
                );
                *__out = ____out_guard.consume();
                Ok(intercom::raw::S_OK)
            }) {
                Ok(s) => s,
                Err(e) => {
                    *__out = intercom::type_system::ExternDefault::extern_default();
                    intercom::store_error(e).hresult
                }
            }
        })
    })();
    match result {
        Ok(v) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", OK"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"variant_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            v
        }
        Err(err) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", ERROR"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"variant_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            <<intercom::raw::HRESULT as intercom::type_system::ExternType<
                intercom::type_system::AutomationTypeSystem,
            >>::ForeignType as intercom::ErrorValue>::from_error(intercom::store_error(
                err,
            ))
        }
    }
}
#[allow(non_camel_case_types)]
#[allow(non_snake_case)]
#[allow(clippy::all)]
#[repr(C)]
#[doc(hidden)]
pub struct __FooAutomationVTable {
    pub __base: <dyn intercom::IUnknown as
                intercom::attributes::ComInterfaceVariant<intercom::type_system::AutomationTypeSystem>>::VTable,
    pub simple_method: unsafe extern "system" fn(self_vtable:
                                                     intercom::raw::RawComPtr)
                           -> (),
    pub arg_method: unsafe extern "system" fn(self_vtable:
                                                  intercom::raw::RawComPtr,
                                              a:
                                                  <u16 as
                                                  intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType)
                        -> (),
    pub simple_result_method: unsafe extern "system" fn(self_vtable:
                                                            intercom::raw::RawComPtr)
                                  ->
                                      <u16 as
                                      intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
    pub com_result_method: unsafe extern "system" fn(self_vtable:
                                                         intercom::raw::RawComPtr,
                                                     __out:
                                                         *mut <u16 as
                                                              intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType)
                               ->
                                   <intercom::raw::HRESULT as
                                   intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
    pub rust_result_method: unsafe extern "system" fn(self_vtable:
                                                          intercom::raw::RawComPtr,
                                                      __out:
                                                          *mut <u16 as
                                                               intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType)
                                ->
                                    <intercom::raw::HRESULT as
                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
    pub complete_method: unsafe extern "system" fn(self_vtable:
                                                       intercom::raw::RawComPtr,
                                                   a:
                                                       <u16 as
                                                       intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
                                                   b:
                                                       <i16 as
                                                       intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
                                                   __out:
                                                       *mut <bool as
                                                            intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType)
                             ->
                                 <intercom::raw::HRESULT as
                                 intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
    pub string_method: unsafe extern "system" fn(self_vtable:
                                                     intercom::raw::RawComPtr,
                                                 msg:
                                                     <String as
                                                     intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType)
                           ->
                               <String as
                               intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
    pub comitf_method: unsafe extern "system" fn(self_vtable:
                                                     intercom::raw::RawComPtr,
                                                 itf:
                                                     <ComItf<dyn Foo> as
                                                     intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
                                                 __out:
                                                     *mut <ComItf<dyn IUnknown>
                                                          as
                                                          intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType)
                           ->
                               <intercom::raw::HRESULT as
                               intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
    pub bool_method: unsafe extern "system" fn(self_vtable:
                                                   intercom::raw::RawComPtr,
                                               input:
                                                   <bool as
                                                   intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
                                               __out:
                                                   *mut <bool as
                                                        intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType)
                         ->
                             <intercom::raw::HRESULT as
                             intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
    pub variant_method: unsafe extern "system" fn(self_vtable:
                                                      intercom::raw::RawComPtr,
                                                  input:
                                                      <Variant as
                                                      intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
                                                  __out:
                                                      *mut <Variant as
                                                           intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType)
                            ->
                                <intercom::raw::HRESULT as
                                intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types)]
#[allow(non_snake_case)]
#[allow(clippy::all)]
impl ::core::clone::Clone for __FooAutomationVTable {
    #[inline]
    fn clone(&self) -> __FooAutomationVTable {
        {
            let _: ::core::clone::AssertParamIsClone<
                <dyn intercom::IUnknown as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::AutomationTypeSystem,
                >>::VTable,
            >;
            let _: ::core::clone::AssertParamIsClone<
                unsafe extern "system" fn(self_vtable: intercom::raw::RawComPtr) -> (),
            >;
            let _: ::core::clone::AssertParamIsClone<
                unsafe extern "system" fn(
                    self_vtable: intercom::raw::RawComPtr,
                    a: <u16 as intercom::type_system::ExternType<
                        intercom::type_system::AutomationTypeSystem,
                    >>::ForeignType,
                ) -> (),
            >;
            let _: ::core::clone::AssertParamIsClone<
                unsafe extern "system" fn(
                    self_vtable: intercom::raw::RawComPtr,
                )
                    -> <u16 as intercom::type_system::ExternType<
                    intercom::type_system::AutomationTypeSystem,
                >>::ForeignType,
            >;
            let _:
                    ::core::clone::AssertParamIsClone<unsafe extern "system" fn(self_vtable:
                                                                                    intercom::raw::RawComPtr,
                                                                                __out:
                                                                                    *mut <u16
                                                                                         as
                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType)
                                                          ->
                                                              <intercom::raw::HRESULT
                                                              as
                                                              intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType>;
            let _:
                    ::core::clone::AssertParamIsClone<unsafe extern "system" fn(self_vtable:
                                                                                    intercom::raw::RawComPtr,
                                                                                __out:
                                                                                    *mut <u16
                                                                                         as
                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType)
                                                          ->
                                                              <intercom::raw::HRESULT
                                                              as
                                                              intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType>;
            let _:
                    ::core::clone::AssertParamIsClone<unsafe extern "system" fn(self_vtable:
                                                                                    intercom::raw::RawComPtr,
                                                                                a:
                                                                                    <u16
                                                                                    as
                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
                                                                                b:
                                                                                    <i16
                                                                                    as
                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
                                                                                __out:
                                                                                    *mut <bool
                                                                                         as
                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType)
                                                          ->
                                                              <intercom::raw::HRESULT
                                                              as
                                                              intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType>;
            let _: ::core::clone::AssertParamIsClone<
                unsafe extern "system" fn(
                    self_vtable: intercom::raw::RawComPtr,
                    msg: <String as intercom::type_system::ExternType<
                        intercom::type_system::AutomationTypeSystem,
                    >>::ForeignType,
                )
                    -> <String as intercom::type_system::ExternType<
                    intercom::type_system::AutomationTypeSystem,
                >>::ForeignType,
            >;
            let _:
                    ::core::clone::AssertParamIsClone<unsafe extern "system" fn(self_vtable:
                                                                                    intercom::raw::RawComPtr,
                                                                                itf:
                                                                                    <ComItf<dyn Foo>
                                                                                    as
                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
                                                                                __out:
                                                                                    *mut <ComItf<dyn IUnknown>
                                                                                         as
                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType)
                                                          ->
                                                              <intercom::raw::HRESULT
                                                              as
                                                              intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType>;
            let _:
                    ::core::clone::AssertParamIsClone<unsafe extern "system" fn(self_vtable:
                                                                                    intercom::raw::RawComPtr,
                                                                                input:
                                                                                    <bool
                                                                                    as
                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
                                                                                __out:
                                                                                    *mut <bool
                                                                                         as
                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType)
                                                          ->
                                                              <intercom::raw::HRESULT
                                                              as
                                                              intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType>;
            let _:
                    ::core::clone::AssertParamIsClone<unsafe extern "system" fn(self_vtable:
                                                                                    intercom::raw::RawComPtr,
                                                                                input:
                                                                                    <Variant
                                                                                    as
                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType,
                                                                                __out:
                                                                                    *mut <Variant
                                                                                         as
                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType)
                                                          ->
                                                              <intercom::raw::HRESULT
                                                              as
                                                              intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType>;
            *self
        }
    }
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types)]
#[allow(non_snake_case)]
#[allow(clippy::all)]
impl ::core::marker::Copy for __FooAutomationVTable {}
#[allow(unused)]
impl<I, S>
    intercom::attributes::ComInterfaceVTableFor<I, S, intercom::type_system::AutomationTypeSystem>
    for dyn Foo
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::AutomationTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    const VTABLE: __FooAutomationVTable = __FooAutomationVTable {
        __base: <dyn intercom::IUnknown as intercom::attributes::ComInterfaceVTableFor<
            I,
            S,
            intercom::type_system::AutomationTypeSystem,
        >>::VTABLE,
        simple_method: __Foo_simple_method_Automation::<I, S>,
        arg_method: __Foo_arg_method_Automation::<I, S>,
        simple_result_method: __Foo_simple_result_method_Automation::<I, S>,
        com_result_method: __Foo_com_result_method_Automation::<I, S>,
        rust_result_method: __Foo_rust_result_method_Automation::<I, S>,
        complete_method: __Foo_complete_method_Automation::<I, S>,
        string_method: __Foo_string_method_Automation::<I, S>,
        comitf_method: __Foo_comitf_method_Automation::<I, S>,
        bool_method: __Foo_bool_method_Automation::<I, S>,
        variant_method: __Foo_variant_method_Automation::<I, S>,
    };
}
#[allow(non_camel_case_types)]
#[allow(non_snake_case)]
#[allow(clippy::all)]
#[doc(hidden)]
impl intercom::attributes::ComInterfaceVariant<intercom::type_system::AutomationTypeSystem>
    for dyn Foo
{
    type VTable = __FooAutomationVTable;
    fn iid() -> &'static intercom::IID {
        &intercom::GUID {
            data1: 0u32,
            data2: 0u16,
            data3: 0u16,
            data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
        }
    }
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_simple_method_Raw<I, S>(self_vtable: intercom::raw::RawComPtr) -> ()
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::RawTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::RawTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"simple_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let self_struct = &**self_combox;
    let __result = self_struct.simple_method();
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::", ", OK"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"simple_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_arg_method_Raw<I, S>(
    self_vtable: intercom::raw::RawComPtr,
    a:
                                                      <u16 as
                                                      intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
) -> ()
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::RawTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::RawTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"arg_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let self_struct = &**self_combox;
    let __result = self_struct.arg_method(<u16 as intercom::type_system::InfallibleExternInput<
        intercom::type_system::RawTypeSystem,
    >>::from_foreign_parameter(a));
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::", ", OK"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"arg_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_simple_result_method_Raw<I, S>(
    self_vtable: intercom::raw::RawComPtr,
) -> <u16 as intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::RawTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::RawTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"simple_result_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let self_struct = &**self_combox;
    let __result = self_struct.simple_result_method();
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::", ", OK"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"simple_result_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    <u16 as
        intercom::type_system::InfallibleExternOutput<intercom::type_system::RawTypeSystem>>::into_foreign_output(__result)
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_com_result_method_Raw<I, S>(
    self_vtable: intercom::raw::RawComPtr,
    __out:
                                                             *mut <u16 as
                                                                  intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
) -> <intercom::raw::HRESULT as intercom::type_system::ExternType<
    intercom::type_system::RawTypeSystem,
>>::ForeignType
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::RawTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::RawTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"com_result_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let result: Result<
        <intercom::raw::HRESULT as intercom::type_system::ExternType<
            intercom::type_system::RawTypeSystem,
        >>::ForeignType,
        intercom::ComError,
    > = (|| {
        let self_struct = &**self_combox;
        let __result = self_struct.com_result_method();
        Ok({
            match __result.and_then(|v1| {
                let ____out_guard = intercom::type_system::OutputGuard::<
                    intercom::type_system::RawTypeSystem,
                    u16,
                >::wrap(
                    <u16 as intercom::type_system::ExternOutput<
                        intercom::type_system::RawTypeSystem,
                    >>::into_foreign_output(v1)?,
                );
                *__out = ____out_guard.consume();
                Ok(intercom::raw::S_OK)
            }) {
                Ok(s) => s,
                Err(e) => {
                    *__out = intercom::type_system::ExternDefault::extern_default();
                    intercom::store_error(e).hresult
                }
            }
        })
    })();
    match result {
        Ok(v) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", OK"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"com_result_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            v
        }
        Err(err) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", ERROR"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"com_result_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            <<intercom::raw::HRESULT as intercom::type_system::ExternType<
                intercom::type_system::RawTypeSystem,
            >>::ForeignType as intercom::ErrorValue>::from_error(intercom::store_error(
                err,
            ))
        }
    }
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_rust_result_method_Raw<I, S>(
    self_vtable: intercom::raw::RawComPtr,
    __out:
                                                              *mut <u16 as
                                                                   intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
) -> <intercom::raw::HRESULT as intercom::type_system::ExternType<
    intercom::type_system::RawTypeSystem,
>>::ForeignType
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::RawTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::RawTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"rust_result_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let result: Result<
        <intercom::raw::HRESULT as intercom::type_system::ExternType<
            intercom::type_system::RawTypeSystem,
        >>::ForeignType,
        intercom::ComError,
    > = (|| {
        let self_struct = &**self_combox;
        let __result = self_struct.rust_result_method();
        Ok({
            match __result.and_then(|v1| {
                let ____out_guard = intercom::type_system::OutputGuard::<
                    intercom::type_system::RawTypeSystem,
                    u16,
                >::wrap(
                    <u16 as intercom::type_system::ExternOutput<
                        intercom::type_system::RawTypeSystem,
                    >>::into_foreign_output(v1)?,
                );
                *__out = ____out_guard.consume();
                Ok(intercom::raw::S_OK)
            }) {
                Ok(s) => s,
                Err(e) => {
                    *__out = intercom::type_system::ExternDefault::extern_default();
                    intercom::store_error(e).hresult
                }
            }
        })
    })();
    match result {
        Ok(v) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", OK"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"rust_result_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            v
        }
        Err(err) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", ERROR"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"rust_result_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            <<intercom::raw::HRESULT as intercom::type_system::ExternType<
                intercom::type_system::RawTypeSystem,
            >>::ForeignType as intercom::ErrorValue>::from_error(intercom::store_error(
                err,
            ))
        }
    }
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_complete_method_Raw<I, S>(
    self_vtable: intercom::raw::RawComPtr,
    a:
                                                           <u16 as
                                                           intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
    b:
                                                           <i16 as
                                                           intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
    __out:
                                                           *mut <bool as
                                                                intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
) -> <intercom::raw::HRESULT as intercom::type_system::ExternType<
    intercom::type_system::RawTypeSystem,
>>::ForeignType
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::RawTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::RawTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"complete_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let result: Result<
        <intercom::raw::HRESULT as intercom::type_system::ExternType<
            intercom::type_system::RawTypeSystem,
        >>::ForeignType,
        intercom::ComError,
    > = (|| {
        let self_struct = &mut **self_combox;
        let __result =
            self_struct.complete_method(
                <u16 as intercom::type_system::ExternInput<
                    intercom::type_system::RawTypeSystem,
                >>::from_foreign_parameter(a)?,
                <i16 as intercom::type_system::ExternInput<
                    intercom::type_system::RawTypeSystem,
                >>::from_foreign_parameter(b)?,
            );
        Ok({
            match __result.and_then(|v1| {
                let ____out_guard = intercom::type_system::OutputGuard::<
                    intercom::type_system::RawTypeSystem,
                    bool,
                >::wrap(
                    <bool as intercom::type_system::ExternOutput<
                        intercom::type_system::RawTypeSystem,
                    >>::into_foreign_output(v1)?,
                );
                *__out = ____out_guard.consume();
                Ok(intercom::raw::S_OK)
            }) {
                Ok(s) => s,
                Err(e) => {
                    *__out = intercom::type_system::ExternDefault::extern_default();
                    intercom::store_error(e).hresult
                }
            }
        })
    })();
    match result {
        Ok(v) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", OK"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"complete_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            v
        }
        Err(err) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", ERROR"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"complete_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            <<intercom::raw::HRESULT as intercom::type_system::ExternType<
                intercom::type_system::RawTypeSystem,
            >>::ForeignType as intercom::ErrorValue>::from_error(intercom::store_error(
                err,
            ))
        }
    }
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_string_method_Raw<I, S>(
    self_vtable: intercom::raw::RawComPtr,
    msg:
                                                         <String as
                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
) -> <String as intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::RawTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::RawTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"string_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let self_struct = &**self_combox;
    let __result =
        self_struct.string_method(<String as intercom::type_system::InfallibleExternInput<
            intercom::type_system::RawTypeSystem,
        >>::from_foreign_parameter(msg));
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::", ", OK"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"string_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    <String as intercom::type_system::InfallibleExternOutput<
        intercom::type_system::RawTypeSystem,
    >>::into_foreign_output(__result)
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_comitf_method_Raw<I, S>(
    self_vtable: intercom::raw::RawComPtr,
    itf: <ComItf<dyn Foo> as intercom::type_system::ExternType<
        intercom::type_system::RawTypeSystem,
    >>::ForeignType,
    __out: *mut <ComItf<dyn IUnknown> as intercom::type_system::ExternType<
        intercom::type_system::RawTypeSystem,
    >>::ForeignType,
) -> <intercom::raw::HRESULT as intercom::type_system::ExternType<
    intercom::type_system::RawTypeSystem,
>>::ForeignType
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::RawTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::RawTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"comitf_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let result: Result<
        <intercom::raw::HRESULT as intercom::type_system::ExternType<
            intercom::type_system::RawTypeSystem,
        >>::ForeignType,
        intercom::ComError,
    > = (|| {
        let self_struct = &**self_combox;
        let __result =
            self_struct.comitf_method(<ComItf<dyn Foo> as intercom::type_system::ExternInput<
                intercom::type_system::RawTypeSystem,
            >>::from_foreign_parameter(itf)?);
        Ok({
            match __result.and_then(|v1| {
                let ____out_guard = intercom::type_system::OutputGuard::<
                    intercom::type_system::RawTypeSystem,
                    ComItf<dyn IUnknown>,
                >::wrap(
                    <ComItf<dyn IUnknown> as intercom::type_system::ExternOutput<
                        intercom::type_system::RawTypeSystem,
                    >>::into_foreign_output(v1)?,
                );
                *__out = ____out_guard.consume();
                Ok(intercom::raw::S_OK)
            }) {
                Ok(s) => s,
                Err(e) => {
                    *__out = intercom::type_system::ExternDefault::extern_default();
                    intercom::store_error(e).hresult
                }
            }
        })
    })();
    match result {
        Ok(v) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", OK"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"comitf_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            v
        }
        Err(err) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", ERROR"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"comitf_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            <<intercom::raw::HRESULT as intercom::type_system::ExternType<
                intercom::type_system::RawTypeSystem,
            >>::ForeignType as intercom::ErrorValue>::from_error(intercom::store_error(
                err,
            ))
        }
    }
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_bool_method_Raw<I, S>(
    self_vtable: intercom::raw::RawComPtr,
    input:
                                                       <bool as
                                                       intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
    __out:
                                                       *mut <bool as
                                                            intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
) -> <intercom::raw::HRESULT as intercom::type_system::ExternType<
    intercom::type_system::RawTypeSystem,
>>::ForeignType
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::RawTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::RawTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"bool_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let result: Result<
        <intercom::raw::HRESULT as intercom::type_system::ExternType<
            intercom::type_system::RawTypeSystem,
        >>::ForeignType,
        intercom::ComError,
    > = (|| {
        let self_struct = &**self_combox;
        let __result = self_struct.bool_method(<bool as intercom::type_system::ExternInput<
            intercom::type_system::RawTypeSystem,
        >>::from_foreign_parameter(input)?);
        Ok({
            match __result.and_then(|v1| {
                let ____out_guard = intercom::type_system::OutputGuard::<
                    intercom::type_system::RawTypeSystem,
                    bool,
                >::wrap(
                    <bool as intercom::type_system::ExternOutput<
                        intercom::type_system::RawTypeSystem,
                    >>::into_foreign_output(v1)?,
                );
                *__out = ____out_guard.consume();
                Ok(intercom::raw::S_OK)
            }) {
                Ok(s) => s,
                Err(e) => {
                    *__out = intercom::type_system::ExternDefault::extern_default();
                    intercom::store_error(e).hresult
                }
            }
        })
    })();
    match result {
        Ok(v) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", OK"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"bool_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            v
        }
        Err(err) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", ERROR"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"bool_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            <<intercom::raw::HRESULT as intercom::type_system::ExternType<
                intercom::type_system::RawTypeSystem,
            >>::ForeignType as intercom::ErrorValue>::from_error(intercom::store_error(
                err,
            ))
        }
    }
}
#[allow(non_snake_case)]
#[allow(dead_code)]
#[doc(hidden)]
unsafe extern "system" fn __Foo_variant_method_Raw<I, S>(
    self_vtable: intercom::raw::RawComPtr,
    input:
                                                          <Variant as
                                                          intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
    __out: *mut <Variant as intercom::type_system::ExternType<
        intercom::type_system::RawTypeSystem,
    >>::ForeignType,
) -> <intercom::raw::HRESULT as intercom::type_system::ExternType<
    intercom::type_system::RawTypeSystem,
>>::ForeignType
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::RawTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    let offset = <S as intercom::attributes::ComClassInterface<
        I,
        intercom::type_system::RawTypeSystem,
    >>::offset();
    let self_combox = (self_vtable as usize - offset) as *mut intercom::ComBoxData<S>;
    intercom::logging::trace(|l| {
        l(
            "testcrate",
            ::core::fmt::Arguments::new_v1(
                &["[", ", through ", "] Serving ", "::"],
                &match (
                    &self_combox,
                    &self_vtable,
                    &std::any::type_name::<S>(),
                    &"variant_method",
                ) {
                    (arg0, arg1, arg2, arg3) => [
                        ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                        ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                    ],
                },
            ),
        )
    });
    let result: Result<
        <intercom::raw::HRESULT as intercom::type_system::ExternType<
            intercom::type_system::RawTypeSystem,
        >>::ForeignType,
        intercom::ComError,
    > = (|| {
        let self_struct = &**self_combox;
        let __result =
            self_struct.variant_method(<Variant as intercom::type_system::ExternInput<
                intercom::type_system::RawTypeSystem,
            >>::from_foreign_parameter(input)?);
        Ok({
            match __result.and_then(|v1| {
                let ____out_guard = intercom::type_system::OutputGuard::<
                    intercom::type_system::RawTypeSystem,
                    Variant,
                >::wrap(
                    <Variant as intercom::type_system::ExternOutput<
                        intercom::type_system::RawTypeSystem,
                    >>::into_foreign_output(v1)?,
                );
                *__out = ____out_guard.consume();
                Ok(intercom::raw::S_OK)
            }) {
                Ok(s) => s,
                Err(e) => {
                    *__out = intercom::type_system::ExternDefault::extern_default();
                    intercom::store_error(e).hresult
                }
            }
        })
    })();
    match result {
        Ok(v) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", OK"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"variant_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            v
        }
        Err(err) => {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", through ", "] Serving ", "::", ", ERROR"],
                        &match (
                            &self_combox,
                            &self_vtable,
                            &std::any::type_name::<S>(),
                            &"variant_method",
                        ) {
                            (arg0, arg1, arg2, arg3) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            <<intercom::raw::HRESULT as intercom::type_system::ExternType<
                intercom::type_system::RawTypeSystem,
            >>::ForeignType as intercom::ErrorValue>::from_error(intercom::store_error(
                err,
            ))
        }
    }
}
#[allow(non_camel_case_types)]
#[allow(non_snake_case)]
#[allow(clippy::all)]
#[repr(C)]
#[doc(hidden)]
pub struct __FooRawVTable {
    pub __base: <dyn intercom::IUnknown as
                intercom::attributes::ComInterfaceVariant<intercom::type_system::RawTypeSystem>>::VTable,
    pub simple_method: unsafe extern "system" fn(self_vtable:
                                                     intercom::raw::RawComPtr)
                           -> (),
    pub arg_method: unsafe extern "system" fn(self_vtable:
                                                  intercom::raw::RawComPtr,
                                              a:
                                                  <u16 as
                                                  intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType)
                        -> (),
    pub simple_result_method: unsafe extern "system" fn(self_vtable:
                                                            intercom::raw::RawComPtr)
                                  ->
                                      <u16 as
                                      intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
    pub com_result_method: unsafe extern "system" fn(self_vtable:
                                                         intercom::raw::RawComPtr,
                                                     __out:
                                                         *mut <u16 as
                                                              intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType)
                               ->
                                   <intercom::raw::HRESULT as
                                   intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
    pub rust_result_method: unsafe extern "system" fn(self_vtable:
                                                          intercom::raw::RawComPtr,
                                                      __out:
                                                          *mut <u16 as
                                                               intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType)
                                ->
                                    <intercom::raw::HRESULT as
                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
    pub complete_method: unsafe extern "system" fn(self_vtable:
                                                       intercom::raw::RawComPtr,
                                                   a:
                                                       <u16 as
                                                       intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
                                                   b:
                                                       <i16 as
                                                       intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
                                                   __out:
                                                       *mut <bool as
                                                            intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType)
                             ->
                                 <intercom::raw::HRESULT as
                                 intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
    pub string_method: unsafe extern "system" fn(self_vtable:
                                                     intercom::raw::RawComPtr,
                                                 msg:
                                                     <String as
                                                     intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType)
                           ->
                               <String as
                               intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
    pub comitf_method: unsafe extern "system" fn(self_vtable:
                                                     intercom::raw::RawComPtr,
                                                 itf:
                                                     <ComItf<dyn Foo> as
                                                     intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
                                                 __out:
                                                     *mut <ComItf<dyn IUnknown>
                                                          as
                                                          intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType)
                           ->
                               <intercom::raw::HRESULT as
                               intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
    pub bool_method: unsafe extern "system" fn(self_vtable:
                                                   intercom::raw::RawComPtr,
                                               input:
                                                   <bool as
                                                   intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
                                               __out:
                                                   *mut <bool as
                                                        intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType)
                         ->
                             <intercom::raw::HRESULT as
                             intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
    pub variant_method: unsafe extern "system" fn(self_vtable:
                                                      intercom::raw::RawComPtr,
                                                  input:
                                                      <Variant as
                                                      intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
                                                  __out:
                                                      *mut <Variant as
                                                           intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType)
                            ->
                                <intercom::raw::HRESULT as
                                intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types)]
#[allow(non_snake_case)]
#[allow(clippy::all)]
impl ::core::clone::Clone for __FooRawVTable {
    #[inline]
    fn clone(&self) -> __FooRawVTable {
        {
            let _: ::core::clone::AssertParamIsClone<
                <dyn intercom::IUnknown as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::RawTypeSystem,
                >>::VTable,
            >;
            let _: ::core::clone::AssertParamIsClone<
                unsafe extern "system" fn(self_vtable: intercom::raw::RawComPtr) -> (),
            >;
            let _: ::core::clone::AssertParamIsClone<
                unsafe extern "system" fn(
                    self_vtable: intercom::raw::RawComPtr,
                    a: <u16 as intercom::type_system::ExternType<
                        intercom::type_system::RawTypeSystem,
                    >>::ForeignType,
                ) -> (),
            >;
            let _: ::core::clone::AssertParamIsClone<
                unsafe extern "system" fn(
                    self_vtable: intercom::raw::RawComPtr,
                )
                    -> <u16 as intercom::type_system::ExternType<
                    intercom::type_system::RawTypeSystem,
                >>::ForeignType,
            >;
            let _:
                    ::core::clone::AssertParamIsClone<unsafe extern "system" fn(self_vtable:
                                                                                    intercom::raw::RawComPtr,
                                                                                __out:
                                                                                    *mut <u16
                                                                                         as
                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType)
                                                          ->
                                                              <intercom::raw::HRESULT
                                                              as
                                                              intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType>;
            let _:
                    ::core::clone::AssertParamIsClone<unsafe extern "system" fn(self_vtable:
                                                                                    intercom::raw::RawComPtr,
                                                                                __out:
                                                                                    *mut <u16
                                                                                         as
                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType)
                                                          ->
                                                              <intercom::raw::HRESULT
                                                              as
                                                              intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType>;
            let _:
                    ::core::clone::AssertParamIsClone<unsafe extern "system" fn(self_vtable:
                                                                                    intercom::raw::RawComPtr,
                                                                                a:
                                                                                    <u16
                                                                                    as
                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
                                                                                b:
                                                                                    <i16
                                                                                    as
                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
                                                                                __out:
                                                                                    *mut <bool
                                                                                         as
                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType)
                                                          ->
                                                              <intercom::raw::HRESULT
                                                              as
                                                              intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType>;
            let _: ::core::clone::AssertParamIsClone<
                unsafe extern "system" fn(
                    self_vtable: intercom::raw::RawComPtr,
                    msg: <String as intercom::type_system::ExternType<
                        intercom::type_system::RawTypeSystem,
                    >>::ForeignType,
                )
                    -> <String as intercom::type_system::ExternType<
                    intercom::type_system::RawTypeSystem,
                >>::ForeignType,
            >;
            let _:
                    ::core::clone::AssertParamIsClone<unsafe extern "system" fn(self_vtable:
                                                                                    intercom::raw::RawComPtr,
                                                                                itf:
                                                                                    <ComItf<dyn Foo>
                                                                                    as
                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
                                                                                __out:
                                                                                    *mut <ComItf<dyn IUnknown>
                                                                                         as
                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType)
                                                          ->
                                                              <intercom::raw::HRESULT
                                                              as
                                                              intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType>;
            let _:
                    ::core::clone::AssertParamIsClone<unsafe extern "system" fn(self_vtable:
                                                                                    intercom::raw::RawComPtr,
                                                                                input:
                                                                                    <bool
                                                                                    as
                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
                                                                                __out:
                                                                                    *mut <bool
                                                                                         as
                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType)
                                                          ->
                                                              <intercom::raw::HRESULT
                                                              as
                                                              intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType>;
            let _:
                    ::core::clone::AssertParamIsClone<unsafe extern "system" fn(self_vtable:
                                                                                    intercom::raw::RawComPtr,
                                                                                input:
                                                                                    <Variant
                                                                                    as
                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType,
                                                                                __out:
                                                                                    *mut <Variant
                                                                                         as
                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType)
                                                          ->
                                                              <intercom::raw::HRESULT
                                                              as
                                                              intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType>;
            *self
        }
    }
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types)]
#[allow(non_snake_case)]
#[allow(clippy::all)]
impl ::core::marker::Copy for __FooRawVTable {}
#[allow(unused)]
impl<I, S> intercom::attributes::ComInterfaceVTableFor<I, S, intercom::type_system::RawTypeSystem>
    for dyn Foo
where
    I: ?Sized,
    S: intercom::attributes::ComClassInterface<I, intercom::type_system::RawTypeSystem>
        + intercom::attributes::ComClass
        + Foo,
{
    const VTABLE: __FooRawVTable = __FooRawVTable {
        __base: <dyn intercom::IUnknown as intercom::attributes::ComInterfaceVTableFor<
            I,
            S,
            intercom::type_system::RawTypeSystem,
        >>::VTABLE,
        simple_method: __Foo_simple_method_Raw::<I, S>,
        arg_method: __Foo_arg_method_Raw::<I, S>,
        simple_result_method: __Foo_simple_result_method_Raw::<I, S>,
        com_result_method: __Foo_com_result_method_Raw::<I, S>,
        rust_result_method: __Foo_rust_result_method_Raw::<I, S>,
        complete_method: __Foo_complete_method_Raw::<I, S>,
        string_method: __Foo_string_method_Raw::<I, S>,
        comitf_method: __Foo_comitf_method_Raw::<I, S>,
        bool_method: __Foo_bool_method_Raw::<I, S>,
        variant_method: __Foo_variant_method_Raw::<I, S>,
    };
}
#[allow(non_camel_case_types)]
#[allow(non_snake_case)]
#[allow(clippy::all)]
#[doc(hidden)]
impl intercom::attributes::ComInterfaceVariant<intercom::type_system::RawTypeSystem> for dyn Foo {
    type VTable = __FooRawVTable;
    fn iid() -> &'static intercom::IID {
        &intercom::GUID {
            data1: 0u32,
            data2: 0u16,
            data3: 0u16,
            data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8],
        }
    }
}
#[allow(clippy::all)]
#[allow(unused_braces)]
impl<I: intercom::attributes::ComInterface + Foo + ?Sized> Foo for intercom::ComItf<I> {
    fn arg_method(&self, a: u16) -> () {
        intercom::logging::trace(|l| {
            l(
                "testcrate",
                ::core::fmt::Arguments::new_v1(
                    &["[", "] Calling ", "::"],
                    &match (&self, &"Foo", &"arg_method") {
                        (arg0, arg1, arg2) => [
                            ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                            ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
                            ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ],
                    },
                ),
            )
        });
        #[allow(unused_imports)]
        use intercom::ErrorValue;
        if let Some(comptr) =
            intercom::ComItf::ptr::<intercom::type_system::AutomationTypeSystem>(self)
        {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (&self, &comptr.ptr, &"Foo", &"arg_method", &"Automation") {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::AutomationTypeSystem,
                >>::VTable;

            #[allow(unused_unsafe)]
            unsafe {
                let __result = ((**vtbl).arg_method)(
                    comptr.ptr.as_ptr(),
                    <u16 as intercom::type_system::InfallibleExternInput<
                        intercom::type_system::AutomationTypeSystem,
                    >>::into_foreign_parameter(a)
                    .0,
                );
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
                };

                #[allow(unused_braces)]
                return {};
            }
        }
        if let Some(comptr) = intercom::ComItf::ptr::<intercom::type_system::RawTypeSystem>(self) {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (&self, &comptr.ptr, &"Foo", &"arg_method", &"Raw") {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::RawTypeSystem,
                >>::VTable;

            #[allow(unused_unsafe)]
            unsafe {
                let __result = ((**vtbl).arg_method)(
                    comptr.ptr.as_ptr(),
                    <u16 as intercom::type_system::InfallibleExternInput<
                        intercom::type_system::RawTypeSystem,
                    >>::into_foreign_parameter(a)
                    .0,
                );
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8],
                };

                #[allow(unused_braces)]
                return {};
            }
        }
        {
            ::core::panicking::panic("internal error: entered unreachable code")
        };
    }
    fn bool_method(&self, input: bool) -> ComResult<bool> {
        intercom::logging::trace(|l| {
            l(
                "testcrate",
                ::core::fmt::Arguments::new_v1(
                    &["[", "] Calling ", "::"],
                    &match (&self, &"Foo", &"bool_method") {
                        (arg0, arg1, arg2) => [
                            ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                            ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
                            ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ],
                    },
                ),
            )
        });
        #[allow(unused_imports)]
        use intercom::ErrorValue;
        if let Some(comptr) =
            intercom::ComItf::ptr::<intercom::type_system::AutomationTypeSystem>(self)
        {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (&self, &comptr.ptr, &"Foo", &"bool_method", &"Automation") {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::AutomationTypeSystem,
                >>::VTable;
            #[allow(unused_unsafe)]
            let __intercom_result: Result<ComResult<bool>, intercom::ComError> = (|| unsafe {
                let mut __out: <bool as intercom::type_system::ExternType<
                    intercom::type_system::AutomationTypeSystem,
                >>::ForeignType = intercom::type_system::ExternDefault::extern_default();
                let __result = ((**vtbl).bool_method)(
                    comptr.ptr.as_ptr(),
                    <bool as intercom::type_system::ExternInput<
                        intercom::type_system::AutomationTypeSystem,
                    >>::into_foreign_parameter(input)?
                    .0,
                    &mut __out,
                );
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
                };

                #[allow(unused_braces)]
                Ok({
                    if __result == intercom::raw::S_OK || __result == intercom::raw::S_FALSE {
                        let ____out_guard = <bool as intercom::type_system::ExternOutput<
                            intercom::type_system::AutomationTypeSystem,
                        >>::from_foreign_output(__out);
                        Ok(____out_guard?)
                    } else {
                        return Err(intercom::load_error(self, &__intercom_iid, __result));
                    }
                })
            })();
            return match __intercom_result {
                Ok(v) => v,
                Err(err) => <ComResult<bool> as intercom::ErrorValue>::from_error(err),
            };
        }
        if let Some(comptr) = intercom::ComItf::ptr::<intercom::type_system::RawTypeSystem>(self) {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (&self, &comptr.ptr, &"Foo", &"bool_method", &"Raw") {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::RawTypeSystem,
                >>::VTable;
            #[allow(unused_unsafe)]
            let __intercom_result: Result<ComResult<bool>, intercom::ComError> = (|| unsafe {
                let mut __out: <bool as intercom::type_system::ExternType<
                    intercom::type_system::RawTypeSystem,
                >>::ForeignType = intercom::type_system::ExternDefault::extern_default();
                let __result = ((**vtbl).bool_method)(
                    comptr.ptr.as_ptr(),
                    <bool as intercom::type_system::ExternInput<
                        intercom::type_system::RawTypeSystem,
                    >>::into_foreign_parameter(input)?
                    .0,
                    &mut __out,
                );
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8],
                };

                #[allow(unused_braces)]
                Ok({
                    if __result == intercom::raw::S_OK || __result == intercom::raw::S_FALSE {
                        let ____out_guard = <bool as intercom::type_system::ExternOutput<
                            intercom::type_system::RawTypeSystem,
                        >>::from_foreign_output(__out);
                        Ok(____out_guard?)
                    } else {
                        return Err(intercom::load_error(self, &__intercom_iid, __result));
                    }
                })
            })();
            return match __intercom_result {
                Ok(v) => v,
                Err(err) => <ComResult<bool> as intercom::ErrorValue>::from_error(err),
            };
        }
        {
            ::core::panicking::panic("internal error: entered unreachable code")
        };
    }
    fn com_result_method(&self) -> ComResult<u16> {
        intercom::logging::trace(|l| {
            l(
                "testcrate",
                ::core::fmt::Arguments::new_v1(
                    &["[", "] Calling ", "::"],
                    &match (&self, &"Foo", &"com_result_method") {
                        (arg0, arg1, arg2) => [
                            ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                            ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
                            ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ],
                    },
                ),
            )
        });
        #[allow(unused_imports)]
        use intercom::ErrorValue;
        if let Some(comptr) =
            intercom::ComItf::ptr::<intercom::type_system::AutomationTypeSystem>(self)
        {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (
                            &self,
                            &comptr.ptr,
                            &"Foo",
                            &"com_result_method",
                            &"Automation",
                        ) {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::AutomationTypeSystem,
                >>::VTable;
            #[allow(unused_unsafe)]
            let __intercom_result: Result<ComResult<u16>, intercom::ComError> = (|| unsafe {
                let mut __out: <u16 as intercom::type_system::ExternType<
                    intercom::type_system::AutomationTypeSystem,
                >>::ForeignType = intercom::type_system::ExternDefault::extern_default();
                let __result = ((**vtbl).com_result_method)(comptr.ptr.as_ptr(), &mut __out);
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
                };

                #[allow(unused_braces)]
                Ok({
                    if __result == intercom::raw::S_OK || __result == intercom::raw::S_FALSE {
                        let ____out_guard = <u16 as intercom::type_system::ExternOutput<
                            intercom::type_system::AutomationTypeSystem,
                        >>::from_foreign_output(__out);
                        Ok(____out_guard?)
                    } else {
                        return Err(intercom::load_error(self, &__intercom_iid, __result));
                    }
                })
            })();
            return match __intercom_result {
                Ok(v) => v,
                Err(err) => <ComResult<u16> as intercom::ErrorValue>::from_error(err),
            };
        }
        if let Some(comptr) = intercom::ComItf::ptr::<intercom::type_system::RawTypeSystem>(self) {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (&self, &comptr.ptr, &"Foo", &"com_result_method", &"Raw") {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::RawTypeSystem,
                >>::VTable;
            #[allow(unused_unsafe)]
            let __intercom_result: Result<ComResult<u16>, intercom::ComError> = (|| unsafe {
                let mut __out: <u16 as intercom::type_system::ExternType<
                    intercom::type_system::RawTypeSystem,
                >>::ForeignType = intercom::type_system::ExternDefault::extern_default();
                let __result = ((**vtbl).com_result_method)(comptr.ptr.as_ptr(), &mut __out);
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8],
                };

                #[allow(unused_braces)]
                Ok({
                    if __result == intercom::raw::S_OK || __result == intercom::raw::S_FALSE {
                        let ____out_guard = <u16 as intercom::type_system::ExternOutput<
                            intercom::type_system::RawTypeSystem,
                        >>::from_foreign_output(__out);
                        Ok(____out_guard?)
                    } else {
                        return Err(intercom::load_error(self, &__intercom_iid, __result));
                    }
                })
            })();
            return match __intercom_result {
                Ok(v) => v,
                Err(err) => <ComResult<u16> as intercom::ErrorValue>::from_error(err),
            };
        }
        {
            ::core::panicking::panic("internal error: entered unreachable code")
        };
    }
    fn comitf_method(&self, itf: ComItf<dyn Foo>) -> ComResult<ComItf<dyn IUnknown>> {
        intercom::logging::trace(|l| {
            l(
                "testcrate",
                ::core::fmt::Arguments::new_v1(
                    &["[", "] Calling ", "::"],
                    &match (&self, &"Foo", &"comitf_method") {
                        (arg0, arg1, arg2) => [
                            ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                            ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
                            ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ],
                    },
                ),
            )
        });
        #[allow(unused_imports)]
        use intercom::ErrorValue;
        if let Some(comptr) =
            intercom::ComItf::ptr::<intercom::type_system::AutomationTypeSystem>(self)
        {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (&self, &comptr.ptr, &"Foo", &"comitf_method", &"Automation") {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::AutomationTypeSystem,
                >>::VTable;
            #[allow(unused_unsafe)]
            let __intercom_result: Result<
                ComResult<ComItf<dyn IUnknown>>,
                intercom::ComError,
            > = (|| unsafe {
                let mut __out: <ComItf<dyn IUnknown> as intercom::type_system::ExternType<
                    intercom::type_system::AutomationTypeSystem,
                >>::ForeignType = intercom::type_system::ExternDefault::extern_default();
                let __result = ((**vtbl).comitf_method)(
                    comptr.ptr.as_ptr(),
                    <ComItf<dyn Foo> as intercom::type_system::ExternInput<
                        intercom::type_system::AutomationTypeSystem,
                    >>::into_foreign_parameter(itf)?
                    .0,
                    &mut __out,
                );
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
                };

                #[allow(unused_braces)]
                Ok({
                    if __result == intercom::raw::S_OK || __result == intercom::raw::S_FALSE {
                        let ____out_guard =
                            <ComItf<dyn IUnknown> as intercom::type_system::ExternOutput<
                                intercom::type_system::AutomationTypeSystem,
                            >>::from_foreign_output(__out);
                        Ok(____out_guard?)
                    } else {
                        return Err(intercom::load_error(self, &__intercom_iid, __result));
                    }
                })
            })();
            return match __intercom_result {
                Ok(v) => v,
                Err(err) => {
                    <ComResult<ComItf<dyn IUnknown>> as intercom::ErrorValue>::from_error(err)
                }
            };
        }
        if let Some(comptr) = intercom::ComItf::ptr::<intercom::type_system::RawTypeSystem>(self) {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (&self, &comptr.ptr, &"Foo", &"comitf_method", &"Raw") {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::RawTypeSystem,
                >>::VTable;
            #[allow(unused_unsafe)]
            let __intercom_result: Result<
                ComResult<ComItf<dyn IUnknown>>,
                intercom::ComError,
            > = (|| unsafe {
                let mut __out: <ComItf<dyn IUnknown> as intercom::type_system::ExternType<
                    intercom::type_system::RawTypeSystem,
                >>::ForeignType = intercom::type_system::ExternDefault::extern_default();
                let __result = ((**vtbl).comitf_method)(
                    comptr.ptr.as_ptr(),
                    <ComItf<dyn Foo> as intercom::type_system::ExternInput<
                        intercom::type_system::RawTypeSystem,
                    >>::into_foreign_parameter(itf)?
                    .0,
                    &mut __out,
                );
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8],
                };

                #[allow(unused_braces)]
                Ok({
                    if __result == intercom::raw::S_OK || __result == intercom::raw::S_FALSE {
                        let ____out_guard =
                            <ComItf<dyn IUnknown> as intercom::type_system::ExternOutput<
                                intercom::type_system::RawTypeSystem,
                            >>::from_foreign_output(__out);
                        Ok(____out_guard?)
                    } else {
                        return Err(intercom::load_error(self, &__intercom_iid, __result));
                    }
                })
            })();
            return match __intercom_result {
                Ok(v) => v,
                Err(err) => {
                    <ComResult<ComItf<dyn IUnknown>> as intercom::ErrorValue>::from_error(err)
                }
            };
        }
        {
            ::core::panicking::panic("internal error: entered unreachable code")
        };
    }
    fn complete_method(&mut self, a: u16, b: i16) -> ComResult<bool> {
        intercom::logging::trace(|l| {
            l(
                "testcrate",
                ::core::fmt::Arguments::new_v1(
                    &["[", "] Calling ", "::"],
                    &match (&self, &"Foo", &"complete_method") {
                        (arg0, arg1, arg2) => [
                            ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                            ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
                            ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ],
                    },
                ),
            )
        });
        #[allow(unused_imports)]
        use intercom::ErrorValue;
        if let Some(comptr) =
            intercom::ComItf::ptr::<intercom::type_system::AutomationTypeSystem>(self)
        {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (
                            &self,
                            &comptr.ptr,
                            &"Foo",
                            &"complete_method",
                            &"Automation",
                        ) {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::AutomationTypeSystem,
                >>::VTable;
            #[allow(unused_unsafe)]
            let __intercom_result: Result<ComResult<bool>, intercom::ComError> = (|| unsafe {
                let mut __out: <bool as intercom::type_system::ExternType<
                    intercom::type_system::AutomationTypeSystem,
                >>::ForeignType = intercom::type_system::ExternDefault::extern_default();
                let __result = ((**vtbl).complete_method)(
                    comptr.ptr.as_ptr(),
                    <u16 as intercom::type_system::ExternInput<
                        intercom::type_system::AutomationTypeSystem,
                    >>::into_foreign_parameter(a)?
                    .0,
                    <i16 as intercom::type_system::ExternInput<
                        intercom::type_system::AutomationTypeSystem,
                    >>::into_foreign_parameter(b)?
                    .0,
                    &mut __out,
                );
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
                };

                #[allow(unused_braces)]
                Ok({
                    if __result == intercom::raw::S_OK || __result == intercom::raw::S_FALSE {
                        let ____out_guard = <bool as intercom::type_system::ExternOutput<
                            intercom::type_system::AutomationTypeSystem,
                        >>::from_foreign_output(__out);
                        Ok(____out_guard?)
                    } else {
                        return Err(intercom::load_error(self, &__intercom_iid, __result));
                    }
                })
            })();
            return match __intercom_result {
                Ok(v) => v,
                Err(err) => <ComResult<bool> as intercom::ErrorValue>::from_error(err),
            };
        }
        if let Some(comptr) = intercom::ComItf::ptr::<intercom::type_system::RawTypeSystem>(self) {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (&self, &comptr.ptr, &"Foo", &"complete_method", &"Raw") {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::RawTypeSystem,
                >>::VTable;
            #[allow(unused_unsafe)]
            let __intercom_result: Result<ComResult<bool>, intercom::ComError> = (|| unsafe {
                let mut __out: <bool as intercom::type_system::ExternType<
                    intercom::type_system::RawTypeSystem,
                >>::ForeignType = intercom::type_system::ExternDefault::extern_default();
                let __result = ((**vtbl).complete_method)(
                    comptr.ptr.as_ptr(),
                    <u16 as intercom::type_system::ExternInput<
                        intercom::type_system::RawTypeSystem,
                    >>::into_foreign_parameter(a)?
                    .0,
                    <i16 as intercom::type_system::ExternInput<
                        intercom::type_system::RawTypeSystem,
                    >>::into_foreign_parameter(b)?
                    .0,
                    &mut __out,
                );
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8],
                };

                #[allow(unused_braces)]
                Ok({
                    if __result == intercom::raw::S_OK || __result == intercom::raw::S_FALSE {
                        let ____out_guard = <bool as intercom::type_system::ExternOutput<
                            intercom::type_system::RawTypeSystem,
                        >>::from_foreign_output(__out);
                        Ok(____out_guard?)
                    } else {
                        return Err(intercom::load_error(self, &__intercom_iid, __result));
                    }
                })
            })();
            return match __intercom_result {
                Ok(v) => v,
                Err(err) => <ComResult<bool> as intercom::ErrorValue>::from_error(err),
            };
        }
        {
            ::core::panicking::panic("internal error: entered unreachable code")
        };
    }
    fn rust_result_method(&self) -> Result<u16, i32> {
        intercom::logging::trace(|l| {
            l(
                "testcrate",
                ::core::fmt::Arguments::new_v1(
                    &["[", "] Calling ", "::"],
                    &match (&self, &"Foo", &"rust_result_method") {
                        (arg0, arg1, arg2) => [
                            ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                            ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
                            ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ],
                    },
                ),
            )
        });
        #[allow(unused_imports)]
        use intercom::ErrorValue;
        if let Some(comptr) =
            intercom::ComItf::ptr::<intercom::type_system::AutomationTypeSystem>(self)
        {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (
                            &self,
                            &comptr.ptr,
                            &"Foo",
                            &"rust_result_method",
                            &"Automation",
                        ) {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::AutomationTypeSystem,
                >>::VTable;
            #[allow(unused_unsafe)]
            let __intercom_result: Result<Result<u16, i32>, intercom::ComError> = (|| unsafe {
                let mut __out: <u16 as intercom::type_system::ExternType<
                    intercom::type_system::AutomationTypeSystem,
                >>::ForeignType = intercom::type_system::ExternDefault::extern_default();
                let __result = ((**vtbl).rust_result_method)(comptr.ptr.as_ptr(), &mut __out);
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
                };

                #[allow(unused_braces)]
                Ok({
                    if __result == intercom::raw::S_OK || __result == intercom::raw::S_FALSE {
                        let ____out_guard = <u16 as intercom::type_system::ExternOutput<
                            intercom::type_system::AutomationTypeSystem,
                        >>::from_foreign_output(__out);
                        Ok(____out_guard?)
                    } else {
                        return Err(intercom::load_error(self, &__intercom_iid, __result));
                    }
                })
            })();
            return match __intercom_result {
                Ok(v) => v,
                Err(err) => <Result<u16, i32> as intercom::ErrorValue>::from_error(err),
            };
        }
        if let Some(comptr) = intercom::ComItf::ptr::<intercom::type_system::RawTypeSystem>(self) {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (&self, &comptr.ptr, &"Foo", &"rust_result_method", &"Raw") {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::RawTypeSystem,
                >>::VTable;
            #[allow(unused_unsafe)]
            let __intercom_result: Result<Result<u16, i32>, intercom::ComError> = (|| unsafe {
                let mut __out: <u16 as intercom::type_system::ExternType<
                    intercom::type_system::RawTypeSystem,
                >>::ForeignType = intercom::type_system::ExternDefault::extern_default();
                let __result = ((**vtbl).rust_result_method)(comptr.ptr.as_ptr(), &mut __out);
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8],
                };

                #[allow(unused_braces)]
                Ok({
                    if __result == intercom::raw::S_OK || __result == intercom::raw::S_FALSE {
                        let ____out_guard = <u16 as intercom::type_system::ExternOutput<
                            intercom::type_system::RawTypeSystem,
                        >>::from_foreign_output(__out);
                        Ok(____out_guard?)
                    } else {
                        return Err(intercom::load_error(self, &__intercom_iid, __result));
                    }
                })
            })();
            return match __intercom_result {
                Ok(v) => v,
                Err(err) => <Result<u16, i32> as intercom::ErrorValue>::from_error(err),
            };
        }
        {
            ::core::panicking::panic("internal error: entered unreachable code")
        };
    }
    fn simple_method(&self) -> () {
        intercom::logging::trace(|l| {
            l(
                "testcrate",
                ::core::fmt::Arguments::new_v1(
                    &["[", "] Calling ", "::"],
                    &match (&self, &"Foo", &"simple_method") {
                        (arg0, arg1, arg2) => [
                            ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                            ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
                            ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ],
                    },
                ),
            )
        });
        #[allow(unused_imports)]
        use intercom::ErrorValue;
        if let Some(comptr) =
            intercom::ComItf::ptr::<intercom::type_system::AutomationTypeSystem>(self)
        {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (&self, &comptr.ptr, &"Foo", &"simple_method", &"Automation") {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::AutomationTypeSystem,
                >>::VTable;

            #[allow(unused_unsafe)]
            unsafe {
                let __result = ((**vtbl).simple_method)(comptr.ptr.as_ptr());
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
                };

                #[allow(unused_braces)]
                return {};
            }
        }
        if let Some(comptr) = intercom::ComItf::ptr::<intercom::type_system::RawTypeSystem>(self) {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (&self, &comptr.ptr, &"Foo", &"simple_method", &"Raw") {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::RawTypeSystem,
                >>::VTable;

            #[allow(unused_unsafe)]
            unsafe {
                let __result = ((**vtbl).simple_method)(comptr.ptr.as_ptr());
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8],
                };

                #[allow(unused_braces)]
                return {};
            }
        }
        {
            ::core::panicking::panic("internal error: entered unreachable code")
        };
    }
    fn simple_result_method(&self) -> u16 {
        intercom::logging::trace(|l| {
            l(
                "testcrate",
                ::core::fmt::Arguments::new_v1(
                    &["[", "] Calling ", "::"],
                    &match (&self, &"Foo", &"simple_result_method") {
                        (arg0, arg1, arg2) => [
                            ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                            ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
                            ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ],
                    },
                ),
            )
        });
        #[allow(unused_imports)]
        use intercom::ErrorValue;
        if let Some(comptr) =
            intercom::ComItf::ptr::<intercom::type_system::AutomationTypeSystem>(self)
        {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (
                            &self,
                            &comptr.ptr,
                            &"Foo",
                            &"simple_result_method",
                            &"Automation",
                        ) {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::AutomationTypeSystem,
                >>::VTable;

            #[allow(unused_unsafe)]
            unsafe {
                let __result = ((**vtbl).simple_result_method)(comptr.ptr.as_ptr());
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
                };

                #[allow(unused_braces)]
                return {
                    <u16 as intercom::type_system::InfallibleExternOutput<
                        intercom::type_system::AutomationTypeSystem,
                    >>::from_foreign_output(__result)
                };
            }
        }
        if let Some(comptr) = intercom::ComItf::ptr::<intercom::type_system::RawTypeSystem>(self) {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (&self, &comptr.ptr, &"Foo", &"simple_result_method", &"Raw") {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::RawTypeSystem,
                >>::VTable;

            #[allow(unused_unsafe)]
            unsafe {
                let __result = ((**vtbl).simple_result_method)(comptr.ptr.as_ptr());
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8],
                };

                #[allow(unused_braces)]
                return {
                    <u16 as intercom::type_system::InfallibleExternOutput<
                        intercom::type_system::RawTypeSystem,
                    >>::from_foreign_output(__result)
                };
            }
        }
        {
            ::core::panicking::panic("internal error: entered unreachable code")
        };
    }
    fn string_method(&self, msg: String) -> String {
        intercom::logging::trace(|l| {
            l(
                "testcrate",
                ::core::fmt::Arguments::new_v1(
                    &["[", "] Calling ", "::"],
                    &match (&self, &"Foo", &"string_method") {
                        (arg0, arg1, arg2) => [
                            ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                            ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
                            ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ],
                    },
                ),
            )
        });
        #[allow(unused_imports)]
        use intercom::ErrorValue;
        if let Some(comptr) =
            intercom::ComItf::ptr::<intercom::type_system::AutomationTypeSystem>(self)
        {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (&self, &comptr.ptr, &"Foo", &"string_method", &"Automation") {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::AutomationTypeSystem,
                >>::VTable;

            #[allow(unused_unsafe)]
            unsafe {
                let __result = ((**vtbl).string_method)(
                    comptr.ptr.as_ptr(),
                    <String as intercom::type_system::InfallibleExternInput<
                        intercom::type_system::AutomationTypeSystem,
                    >>::into_foreign_parameter(msg)
                    .0,
                );
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
                };

                #[allow(unused_braces)]
                return {
                    <String as intercom::type_system::InfallibleExternOutput<
                        intercom::type_system::AutomationTypeSystem,
                    >>::from_foreign_output(__result)
                };
            }
        }
        if let Some(comptr) = intercom::ComItf::ptr::<intercom::type_system::RawTypeSystem>(self) {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (&self, &comptr.ptr, &"Foo", &"string_method", &"Raw") {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::RawTypeSystem,
                >>::VTable;

            #[allow(unused_unsafe)]
            unsafe {
                let __result = ((**vtbl).string_method)(
                    comptr.ptr.as_ptr(),
                    <String as intercom::type_system::InfallibleExternInput<
                        intercom::type_system::RawTypeSystem,
                    >>::into_foreign_parameter(msg)
                    .0,
                );
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8],
                };

                #[allow(unused_braces)]
                return {
                    <String as intercom::type_system::InfallibleExternOutput<
                        intercom::type_system::RawTypeSystem,
                    >>::from_foreign_output(__result)
                };
            }
        }
        {
            ::core::panicking::panic("internal error: entered unreachable code")
        };
    }
    fn variant_method(&self, input: Variant) -> ComResult<Variant> {
        intercom::logging::trace(|l| {
            l(
                "testcrate",
                ::core::fmt::Arguments::new_v1(
                    &["[", "] Calling ", "::"],
                    &match (&self, &"Foo", &"variant_method") {
                        (arg0, arg1, arg2) => [
                            ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                            ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
                            ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ],
                    },
                ),
            )
        });
        #[allow(unused_imports)]
        use intercom::ErrorValue;
        if let Some(comptr) =
            intercom::ComItf::ptr::<intercom::type_system::AutomationTypeSystem>(self)
        {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (&self, &comptr.ptr, &"Foo", &"variant_method", &"Automation") {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::AutomationTypeSystem,
                >>::VTable;
            #[allow(unused_unsafe)]
            let __intercom_result: Result<ComResult<Variant>, intercom::ComError> = (|| unsafe {
                let mut __out: <Variant as intercom::type_system::ExternType<
                    intercom::type_system::AutomationTypeSystem,
                >>::ForeignType = intercom::type_system::ExternDefault::extern_default();
                let __result = ((**vtbl).variant_method)(
                    comptr.ptr.as_ptr(),
                    <Variant as intercom::type_system::ExternInput<
                        intercom::type_system::AutomationTypeSystem,
                    >>::into_foreign_parameter(input)?
                    .0,
                    &mut __out,
                );
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
                };

                #[allow(unused_braces)]
                Ok({
                    if __result == intercom::raw::S_OK || __result == intercom::raw::S_FALSE {
                        let ____out_guard = <Variant as intercom::type_system::ExternOutput<
                            intercom::type_system::AutomationTypeSystem,
                        >>::from_foreign_output(__out);
                        Ok(____out_guard?)
                    } else {
                        return Err(intercom::load_error(self, &__intercom_iid, __result));
                    }
                })
            })(
            );
            return match __intercom_result {
                Ok(v) => v,
                Err(err) => <ComResult<Variant> as intercom::ErrorValue>::from_error(err),
            };
        }
        if let Some(comptr) = intercom::ComItf::ptr::<intercom::type_system::RawTypeSystem>(self) {
            intercom::logging::trace(|l| {
                l(
                    "testcrate",
                    ::core::fmt::Arguments::new_v1(
                        &["[", ", with ", "] Calling ", "::", ", type system: "],
                        &match (&self, &comptr.ptr, &"Foo", &"variant_method", &"Raw") {
                            (arg0, arg1, arg2, arg3, arg4) => [
                                ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Pointer::fmt),
                                ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
                                ::core::fmt::ArgumentV1::new(arg4, ::core::fmt::Display::fmt),
                            ],
                        },
                    ),
                )
            });
            #[allow(unused_imports)]
            let vtbl = comptr.ptr.as_ptr()
                as *const *const <dyn Foo as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::RawTypeSystem,
                >>::VTable;
            #[allow(unused_unsafe)]
            let __intercom_result: Result<ComResult<Variant>, intercom::ComError> = (|| unsafe {
                let mut __out: <Variant as intercom::type_system::ExternType<
                    intercom::type_system::RawTypeSystem,
                >>::ForeignType = intercom::type_system::ExternDefault::extern_default();
                let __result = ((**vtbl).variant_method)(
                    comptr.ptr.as_ptr(),
                    <Variant as intercom::type_system::ExternInput<
                        intercom::type_system::RawTypeSystem,
                    >>::into_foreign_parameter(input)?
                    .0,
                    &mut __out,
                );
                let __intercom_iid = intercom::GUID {
                    data1: 0u32,
                    data2: 0u16,
                    data3: 0u16,
                    data4: [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8],
                };

                #[allow(unused_braces)]
                Ok({
                    if __result == intercom::raw::S_OK || __result == intercom::raw::S_FALSE {
                        let ____out_guard = <Variant as intercom::type_system::ExternOutput<
                            intercom::type_system::RawTypeSystem,
                        >>::from_foreign_output(__out);
                        Ok(____out_guard?)
                    } else {
                        return Err(intercom::load_error(self, &__intercom_iid, __result));
                    }
                })
            })(
            );
            return match __intercom_result {
                Ok(v) => v,
                Err(err) => <ComResult<Variant> as intercom::ErrorValue>::from_error(err),
            };
        }
        {
            ::core::panicking::panic("internal error: entered unreachable code")
        };
    }
}
impl intercom::attributes::ComInterface for dyn Foo {
    type TSelf = dyn Foo;
    #[doc = "Returns the IID of the requested interface."]
    fn iid_ts<TS: intercom::type_system::TypeSystem>() -> &'static intercom::IID
    where
        Self: intercom::attributes::ComInterfaceVariant<TS>,
    {
        <Self as intercom::attributes::ComInterfaceVariant<TS>>::iid()
    }
    fn iid(ts: intercom::type_system::TypeSystemName) -> Option<&'static intercom::IID> {
        match ts {
            intercom::type_system::TypeSystemName::Automation => {
                Some(<Self as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::AutomationTypeSystem,
                >>::iid())
            }
            intercom::type_system::TypeSystemName::Raw => {
                Some(<Self as intercom::attributes::ComInterfaceVariant<
                    intercom::type_system::RawTypeSystem,
                >>::iid())
            }
        }
    }
    fn deref(com_itf: &intercom::ComItf<dyn Foo>) -> &(dyn Foo + 'static) {
        com_itf
    }
}
impl intercom::type_system::ForeignType for dyn Foo {
    #[doc = r" The name of the type."]
    fn type_name() -> &'static str {
        "Foo"
    }
}
#[allow(non_snake_case)]
#[allow(dead_code)]
impl intercom::attributes::ComInterfaceTypeInfo for dyn Foo {
    fn gather_type_info() -> Vec<intercom::typelib::TypeInfo> {
        let variants =
            <[_]>::into_vec(box
                                [intercom::ComBox::new(intercom::typelib::InterfaceVariant{ts:
                                                                                               intercom::type_system::TypeSystemName::Automation,
                                                                                           iid:
                                                                                               intercom::GUID{data1:
                                                                                                                  0u32,
                                                                                                              data2:
                                                                                                                  0u16,
                                                                                                              data3:
                                                                                                                  0u16,
                                                                                                              data4:
                                                                                                                  [0u8,
                                                                                                                   0u8,
                                                                                                                   0u8,
                                                                                                                   0u8,
                                                                                                                   0u8,
                                                                                                                   0u8,
                                                                                                                   0u8,
                                                                                                                   0u8],},
                                                                                           methods:
                                                                                               <[_]>::into_vec(box
                                                                                                                   [intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "simple_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   "void".into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   0,
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        ::alloc::vec::Vec::new(),}),
                                                                                                                    intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "arg_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   "void".into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   0,
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        <[_]>::into_vec(box
                                                                                                                                                                                            [intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "a".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<u16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<u16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::In,}]),}),
                                                                                                                    intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "simple_result_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   <<u16
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   <<u16
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        ::alloc::vec::Vec::new(),}),
                                                                                                                    intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "com_result_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        <[_]>::into_vec(box
                                                                                                                                                                                            [intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "__out".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<u16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<u16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::Retval,}]),}),
                                                                                                                    intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "rust_result_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   <<i32
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   <<i32
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        <[_]>::into_vec(box
                                                                                                                                                                                            [intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "__out".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<u16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<u16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::Retval,}]),}),
                                                                                                                    intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "complete_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        <[_]>::into_vec(box
                                                                                                                                                                                            [intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "a".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<u16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<u16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::In,},
                                                                                                                                                                                             intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "b".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<i16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<i16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::In,},
                                                                                                                                                                                             intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "__out".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<bool
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<bool
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::Retval,}]),}),
                                                                                                                    intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "string_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   <<String
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   <<String
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        <[_]>::into_vec(box
                                                                                                                                                                                            [intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "msg".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<String
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<String
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::In,}]),}),
                                                                                                                    intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "comitf_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        <[_]>::into_vec(box
                                                                                                                                                                                            [intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "itf".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<ComItf<dyn Foo>
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<ComItf<dyn Foo>
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::In,},
                                                                                                                                                                                             intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "__out".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<ComItf<dyn IUnknown>
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<ComItf<dyn IUnknown>
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::Retval,}]),}),
                                                                                                                    intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "bool_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        <[_]>::into_vec(box
                                                                                                                                                                                            [intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "input".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<bool
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<bool
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::In,},
                                                                                                                                                                                             intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "__out".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<bool
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<bool
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::Retval,}]),}),
                                                                                                                    intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "variant_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        <[_]>::into_vec(box
                                                                                                                                                                                            [intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "input".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<Variant
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<Variant
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::In,},
                                                                                                                                                                                             intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "__out".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<Variant
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<Variant
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::AutomationTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::Retval,}]),})]),}),
                                 intercom::ComBox::new(intercom::typelib::InterfaceVariant{ts:
                                                                                               intercom::type_system::TypeSystemName::Raw,
                                                                                           iid:
                                                                                               intercom::GUID{data1:
                                                                                                                  0u32,
                                                                                                              data2:
                                                                                                                  0u16,
                                                                                                              data3:
                                                                                                                  0u16,
                                                                                                              data4:
                                                                                                                  [0u8,
                                                                                                                   0u8,
                                                                                                                   0u8,
                                                                                                                   0u8,
                                                                                                                   0u8,
                                                                                                                   0u8,
                                                                                                                   0u8,
                                                                                                                   1u8],},
                                                                                           methods:
                                                                                               <[_]>::into_vec(box
                                                                                                                   [intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "simple_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   "void".into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   0,
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        ::alloc::vec::Vec::new(),}),
                                                                                                                    intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "arg_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   "void".into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   0,
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        <[_]>::into_vec(box
                                                                                                                                                                                            [intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "a".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<u16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<u16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::In,}]),}),
                                                                                                                    intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "simple_result_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   <<u16
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   <<u16
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        ::alloc::vec::Vec::new(),}),
                                                                                                                    intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "com_result_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        <[_]>::into_vec(box
                                                                                                                                                                                            [intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "__out".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<u16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<u16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::Retval,}]),}),
                                                                                                                    intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "rust_result_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   <<i32
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   <<i32
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        <[_]>::into_vec(box
                                                                                                                                                                                            [intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "__out".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<u16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<u16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::Retval,}]),}),
                                                                                                                    intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "complete_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        <[_]>::into_vec(box
                                                                                                                                                                                            [intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "a".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<u16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<u16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::In,},
                                                                                                                                                                                             intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "b".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<i16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<i16
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::In,},
                                                                                                                                                                                             intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "__out".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<bool
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<bool
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::Retval,}]),}),
                                                                                                                    intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "string_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   <<String
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   <<String
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        <[_]>::into_vec(box
                                                                                                                                                                                            [intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "msg".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<String
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<String
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::In,}]),}),
                                                                                                                    intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "comitf_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        <[_]>::into_vec(box
                                                                                                                                                                                            [intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "itf".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<ComItf<dyn Foo>
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<ComItf<dyn Foo>
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::In,},
                                                                                                                                                                                             intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "__out".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<ComItf<dyn IUnknown>
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<ComItf<dyn IUnknown>
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::Retval,}]),}),
                                                                                                                    intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "bool_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        <[_]>::into_vec(box
                                                                                                                                                                                            [intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "input".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<bool
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<bool
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::In,},
                                                                                                                                                                                             intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "__out".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<bool
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<bool
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::Retval,}]),}),
                                                                                                                    intercom::ComBox::new(intercom::typelib::Method{name:
                                                                                                                                                                        "variant_method".into(),
                                                                                                                                                                    return_type:
                                                                                                                                                                        intercom::typelib::Arg{name:
                                                                                                                                                                                                   "".into(),
                                                                                                                                                                                               ty:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                               indirection_level:
                                                                                                                                                                                                   <<intercom::raw::HRESULT
                                                                                                                                                                                                    as
                                                                                                                                                                                                    intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                       as
                                                                                                                                                                                                       intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                               direction:
                                                                                                                                                                                                   intercom::typelib::Direction::Return,},
                                                                                                                                                                    parameters:
                                                                                                                                                                        <[_]>::into_vec(box
                                                                                                                                                                                            [intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "input".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<Variant
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<Variant
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::In,},
                                                                                                                                                                                             intercom::typelib::Arg{name:
                                                                                                                                                                                                                        "__out".into(),
                                                                                                                                                                                                                    ty:
                                                                                                                                                                                                                        <<Variant
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::type_name().into(),
                                                                                                                                                                                                                    indirection_level:
                                                                                                                                                                                                                        <<Variant
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         intercom::type_system::ExternType<intercom::type_system::RawTypeSystem>>::ForeignType
                                                                                                                                                                                                                            as
                                                                                                                                                                                                                            intercom::type_system::ForeignType>::indirection_level(),
                                                                                                                                                                                                                    direction:
                                                                                                                                                                                                                        intercom::typelib::Direction::Retval,}]),})]),})]);
        <[_]>::into_vec(box [intercom::typelib::TypeInfo::Interface(
            intercom::ComBox::new(intercom::typelib::Interface {
                name: "Foo".into(),
                variants,
                options: intercom::typelib::InterfaceOptions {
                    class_impl_interface: false,
                    ..Default::default()
                },
            }),
        )])
    }
}