Trait WithAbiImpl 

pub trait WithAbiImpl<Abi: Abi, F: FnPtr = Self> {
    type F: FnPtr<Args = F::Args, Output = F::Output, Safety = F::Safety, Abi = Abi>;
}

Helper trait used by WithAbi (use it instead). This trait is required to allow FnPtr to be a subtrait of WithAbi, which eliminates the need for a type bound when using a fixed abi marker. Using WithAbi directly would result in a cyclic supertrait error.

Required Associated Types

type F: FnPtr<Args = F::Args, Output = F::Output, Safety = F::Safety, Abi = Abi>

The function pointer type with the requested abi (preserving all other properties).

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<Output, A, B, C, D, E, F> WithAbiImpl<C> for extern "C" fn(A, B, C, D, E, F) -> Output

type F = extern "C" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<C> for extern "C-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "C" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<C> for extern "efiapi" fn(A, B, C, D, E, F) -> Output

type F = extern "C" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<C> for extern "system" fn(A, B, C, D, E, F) -> Output

type F = extern "C" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<C> for extern "system-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "C" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<C> for extern "sysv64" fn(A, B, C, D, E, F) -> Output

type F = extern "C" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<C> for extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "C" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<C> for fn(A, B, C, D, E, F) -> Output

type F = extern "C" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<C> for unsafe extern "C" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "C" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<C> for unsafe extern "C-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "C" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<C> for unsafe extern "efiapi" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "C" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<C> for unsafe extern "system" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "C" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<C> for unsafe extern "system-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "C" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<C> for unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "C" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<C> for unsafe extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "C" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<C> for unsafe fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "C" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<CUnwind> for extern "C" fn(A, B, C, D, E, F) -> Output

type F = extern "C-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<CUnwind> for extern "C-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "C-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<CUnwind> for extern "efiapi" fn(A, B, C, D, E, F) -> Output

type F = extern "C-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<CUnwind> for extern "system" fn(A, B, C, D, E, F) -> Output

type F = extern "C-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<CUnwind> for extern "system-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "C-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<CUnwind> for extern "sysv64" fn(A, B, C, D, E, F) -> Output

type F = extern "C-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<CUnwind> for extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "C-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<CUnwind> for fn(A, B, C, D, E, F) -> Output

type F = extern "C-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<CUnwind> for unsafe extern "C" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<CUnwind> for unsafe extern "C-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<CUnwind> for unsafe extern "efiapi" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<CUnwind> for unsafe extern "system" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<CUnwind> for unsafe extern "system-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<CUnwind> for unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<CUnwind> for unsafe extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<CUnwind> for unsafe fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<EfiApi> for extern "C" fn(A, B, C, D, E, F) -> Output

type F = extern "efiapi" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<EfiApi> for extern "C-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "efiapi" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<EfiApi> for extern "efiapi" fn(A, B, C, D, E, F) -> Output

type F = extern "efiapi" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<EfiApi> for extern "system" fn(A, B, C, D, E, F) -> Output

type F = extern "efiapi" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<EfiApi> for extern "system-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "efiapi" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<EfiApi> for extern "sysv64" fn(A, B, C, D, E, F) -> Output

type F = extern "efiapi" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<EfiApi> for extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "efiapi" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<EfiApi> for fn(A, B, C, D, E, F) -> Output

type F = extern "efiapi" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<EfiApi> for unsafe extern "C" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<EfiApi> for unsafe extern "C-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<EfiApi> for unsafe extern "efiapi" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<EfiApi> for unsafe extern "system" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<EfiApi> for unsafe extern "system-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<EfiApi> for unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<EfiApi> for unsafe extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<EfiApi> for unsafe fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<Rust> for extern "C" fn(A, B, C, D, E, F) -> Output

type F = fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<Rust> for extern "C-unwind" fn(A, B, C, D, E, F) -> Output

type F = fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<Rust> for extern "efiapi" fn(A, B, C, D, E, F) -> Output

type F = fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<Rust> for extern "system" fn(A, B, C, D, E, F) -> Output

type F = fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<Rust> for extern "system-unwind" fn(A, B, C, D, E, F) -> Output

type F = fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<Rust> for extern "sysv64" fn(A, B, C, D, E, F) -> Output

type F = fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<Rust> for extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

type F = fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<Rust> for fn(A, B, C, D, E, F) -> Output

type F = fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<Rust> for unsafe extern "C" fn(A, B, C, D, E, F) -> Output

type F = unsafe fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<Rust> for unsafe extern "C-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<Rust> for unsafe extern "efiapi" fn(A, B, C, D, E, F) -> Output

type F = unsafe fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<Rust> for unsafe extern "system" fn(A, B, C, D, E, F) -> Output

type F = unsafe fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<Rust> for unsafe extern "system-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<Rust> for unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Output

type F = unsafe fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<Rust> for unsafe extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<Rust> for unsafe fn(A, B, C, D, E, F) -> Output

type F = unsafe fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64> for extern "C" fn(A, B, C, D, E, F) -> Output

type F = extern "sysv64" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64> for extern "C-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "sysv64" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64> for extern "efiapi" fn(A, B, C, D, E, F) -> Output

type F = extern "sysv64" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64> for extern "system" fn(A, B, C, D, E, F) -> Output

type F = extern "sysv64" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64> for extern "system-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "sysv64" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64> for extern "sysv64" fn(A, B, C, D, E, F) -> Output

type F = extern "sysv64" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64> for extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "sysv64" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64> for fn(A, B, C, D, E, F) -> Output

type F = extern "sysv64" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64> for unsafe extern "C" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64> for unsafe extern "C-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64> for unsafe extern "efiapi" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64> for unsafe extern "system" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64> for unsafe extern "system-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64> for unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64> for unsafe extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64> for unsafe fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64Unwind> for extern "C" fn(A, B, C, D, E, F) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64Unwind> for extern "C-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64Unwind> for extern "efiapi" fn(A, B, C, D, E, F) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64Unwind> for extern "system" fn(A, B, C, D, E, F) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64Unwind> for extern "system-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64Unwind> for extern "sysv64" fn(A, B, C, D, E, F) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64Unwind> for extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64Unwind> for fn(A, B, C, D, E, F) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64Unwind> for unsafe extern "C" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64Unwind> for unsafe extern "C-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64Unwind> for unsafe extern "efiapi" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64Unwind> for unsafe extern "system" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64Unwind> for unsafe extern "system-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64Unwind> for unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64Unwind> for unsafe extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SysV64Unwind> for unsafe fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<System> for extern "C" fn(A, B, C, D, E, F) -> Output

type F = extern "system" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<System> for extern "C-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "system" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<System> for extern "efiapi" fn(A, B, C, D, E, F) -> Output

type F = extern "system" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<System> for extern "system" fn(A, B, C, D, E, F) -> Output

type F = extern "system" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<System> for extern "system-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "system" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<System> for extern "sysv64" fn(A, B, C, D, E, F) -> Output

type F = extern "system" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<System> for extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "system" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<System> for fn(A, B, C, D, E, F) -> Output

type F = extern "system" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<System> for unsafe extern "C" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "system" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<System> for unsafe extern "C-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "system" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<System> for unsafe extern "efiapi" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "system" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<System> for unsafe extern "system" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "system" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<System> for unsafe extern "system-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "system" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<System> for unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "system" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<System> for unsafe extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "system" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<System> for unsafe fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "system" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SystemUnwind> for extern "C" fn(A, B, C, D, E, F) -> Output

type F = extern "system-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SystemUnwind> for extern "C-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "system-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SystemUnwind> for extern "efiapi" fn(A, B, C, D, E, F) -> Output

type F = extern "system-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SystemUnwind> for extern "system" fn(A, B, C, D, E, F) -> Output

type F = extern "system-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SystemUnwind> for extern "system-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "system-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SystemUnwind> for extern "sysv64" fn(A, B, C, D, E, F) -> Output

type F = extern "system-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SystemUnwind> for extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

type F = extern "system-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SystemUnwind> for fn(A, B, C, D, E, F) -> Output

type F = extern "system-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SystemUnwind> for unsafe extern "C" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SystemUnwind> for unsafe extern "C-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SystemUnwind> for unsafe extern "efiapi" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SystemUnwind> for unsafe extern "system" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SystemUnwind> for unsafe extern "system-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SystemUnwind> for unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SystemUnwind> for unsafe extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E, F> WithAbiImpl<SystemUnwind> for unsafe fn(A, B, C, D, E, F) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D, E, F) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<C> for extern "C" fn(A, B, C, D, E) -> Output

type F = extern "C" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<C> for extern "C-unwind" fn(A, B, C, D, E) -> Output

type F = extern "C" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<C> for extern "efiapi" fn(A, B, C, D, E) -> Output

type F = extern "C" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<C> for extern "system" fn(A, B, C, D, E) -> Output

type F = extern "C" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<C> for extern "system-unwind" fn(A, B, C, D, E) -> Output

type F = extern "C" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<C> for extern "sysv64" fn(A, B, C, D, E) -> Output

type F = extern "C" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<C> for extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

type F = extern "C" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<C> for fn(A, B, C, D, E) -> Output

type F = extern "C" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<C> for unsafe extern "C" fn(A, B, C, D, E) -> Output

type F = unsafe extern "C" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<C> for unsafe extern "C-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "C" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<C> for unsafe extern "efiapi" fn(A, B, C, D, E) -> Output

type F = unsafe extern "C" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<C> for unsafe extern "system" fn(A, B, C, D, E) -> Output

type F = unsafe extern "C" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<C> for unsafe extern "system-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "C" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<C> for unsafe extern "sysv64" fn(A, B, C, D, E) -> Output

type F = unsafe extern "C" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<C> for unsafe extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "C" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<C> for unsafe fn(A, B, C, D, E) -> Output

type F = unsafe extern "C" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<CUnwind> for extern "C" fn(A, B, C, D, E) -> Output

type F = extern "C-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<CUnwind> for extern "C-unwind" fn(A, B, C, D, E) -> Output

type F = extern "C-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<CUnwind> for extern "efiapi" fn(A, B, C, D, E) -> Output

type F = extern "C-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<CUnwind> for extern "system" fn(A, B, C, D, E) -> Output

type F = extern "C-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<CUnwind> for extern "system-unwind" fn(A, B, C, D, E) -> Output

type F = extern "C-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<CUnwind> for extern "sysv64" fn(A, B, C, D, E) -> Output

type F = extern "C-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<CUnwind> for extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

type F = extern "C-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<CUnwind> for fn(A, B, C, D, E) -> Output

type F = extern "C-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<CUnwind> for unsafe extern "C" fn(A, B, C, D, E) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<CUnwind> for unsafe extern "C-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<CUnwind> for unsafe extern "efiapi" fn(A, B, C, D, E) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<CUnwind> for unsafe extern "system" fn(A, B, C, D, E) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<CUnwind> for unsafe extern "system-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<CUnwind> for unsafe extern "sysv64" fn(A, B, C, D, E) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<CUnwind> for unsafe extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<CUnwind> for unsafe fn(A, B, C, D, E) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<EfiApi> for extern "C" fn(A, B, C, D, E) -> Output

type F = extern "efiapi" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<EfiApi> for extern "C-unwind" fn(A, B, C, D, E) -> Output

type F = extern "efiapi" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<EfiApi> for extern "efiapi" fn(A, B, C, D, E) -> Output

type F = extern "efiapi" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<EfiApi> for extern "system" fn(A, B, C, D, E) -> Output

type F = extern "efiapi" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<EfiApi> for extern "system-unwind" fn(A, B, C, D, E) -> Output

type F = extern "efiapi" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<EfiApi> for extern "sysv64" fn(A, B, C, D, E) -> Output

type F = extern "efiapi" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<EfiApi> for extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

type F = extern "efiapi" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<EfiApi> for fn(A, B, C, D, E) -> Output

type F = extern "efiapi" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<EfiApi> for unsafe extern "C" fn(A, B, C, D, E) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<EfiApi> for unsafe extern "C-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<EfiApi> for unsafe extern "efiapi" fn(A, B, C, D, E) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<EfiApi> for unsafe extern "system" fn(A, B, C, D, E) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<EfiApi> for unsafe extern "system-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<EfiApi> for unsafe extern "sysv64" fn(A, B, C, D, E) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<EfiApi> for unsafe extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<EfiApi> for unsafe fn(A, B, C, D, E) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<Rust> for extern "C" fn(A, B, C, D, E) -> Output

type F = fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<Rust> for extern "C-unwind" fn(A, B, C, D, E) -> Output

type F = fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<Rust> for extern "efiapi" fn(A, B, C, D, E) -> Output

type F = fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<Rust> for extern "system" fn(A, B, C, D, E) -> Output

type F = fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<Rust> for extern "system-unwind" fn(A, B, C, D, E) -> Output

type F = fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<Rust> for extern "sysv64" fn(A, B, C, D, E) -> Output

type F = fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<Rust> for extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

type F = fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<Rust> for fn(A, B, C, D, E) -> Output

type F = fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<Rust> for unsafe extern "C" fn(A, B, C, D, E) -> Output

type F = unsafe fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<Rust> for unsafe extern "C-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<Rust> for unsafe extern "efiapi" fn(A, B, C, D, E) -> Output

type F = unsafe fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<Rust> for unsafe extern "system" fn(A, B, C, D, E) -> Output

type F = unsafe fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<Rust> for unsafe extern "system-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<Rust> for unsafe extern "sysv64" fn(A, B, C, D, E) -> Output

type F = unsafe fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<Rust> for unsafe extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<Rust> for unsafe fn(A, B, C, D, E) -> Output

type F = unsafe fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64> for extern "C" fn(A, B, C, D, E) -> Output

type F = extern "sysv64" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64> for extern "C-unwind" fn(A, B, C, D, E) -> Output

type F = extern "sysv64" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64> for extern "efiapi" fn(A, B, C, D, E) -> Output

type F = extern "sysv64" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64> for extern "system" fn(A, B, C, D, E) -> Output

type F = extern "sysv64" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64> for extern "system-unwind" fn(A, B, C, D, E) -> Output

type F = extern "sysv64" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64> for extern "sysv64" fn(A, B, C, D, E) -> Output

type F = extern "sysv64" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64> for extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

type F = extern "sysv64" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64> for fn(A, B, C, D, E) -> Output

type F = extern "sysv64" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64> for unsafe extern "C" fn(A, B, C, D, E) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64> for unsafe extern "C-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64> for unsafe extern "efiapi" fn(A, B, C, D, E) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64> for unsafe extern "system" fn(A, B, C, D, E) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64> for unsafe extern "system-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64> for unsafe extern "sysv64" fn(A, B, C, D, E) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64> for unsafe extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64> for unsafe fn(A, B, C, D, E) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64Unwind> for extern "C" fn(A, B, C, D, E) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64Unwind> for extern "C-unwind" fn(A, B, C, D, E) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64Unwind> for extern "efiapi" fn(A, B, C, D, E) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64Unwind> for extern "system" fn(A, B, C, D, E) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64Unwind> for extern "system-unwind" fn(A, B, C, D, E) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64Unwind> for extern "sysv64" fn(A, B, C, D, E) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64Unwind> for extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64Unwind> for fn(A, B, C, D, E) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64Unwind> for unsafe extern "C" fn(A, B, C, D, E) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64Unwind> for unsafe extern "C-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64Unwind> for unsafe extern "efiapi" fn(A, B, C, D, E) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64Unwind> for unsafe extern "system" fn(A, B, C, D, E) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64Unwind> for unsafe extern "system-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64Unwind> for unsafe extern "sysv64" fn(A, B, C, D, E) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64Unwind> for unsafe extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SysV64Unwind> for unsafe fn(A, B, C, D, E) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<System> for extern "C" fn(A, B, C, D, E) -> Output

type F = extern "system" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<System> for extern "C-unwind" fn(A, B, C, D, E) -> Output

type F = extern "system" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<System> for extern "efiapi" fn(A, B, C, D, E) -> Output

type F = extern "system" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<System> for extern "system" fn(A, B, C, D, E) -> Output

type F = extern "system" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<System> for extern "system-unwind" fn(A, B, C, D, E) -> Output

type F = extern "system" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<System> for extern "sysv64" fn(A, B, C, D, E) -> Output

type F = extern "system" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<System> for extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

type F = extern "system" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<System> for fn(A, B, C, D, E) -> Output

type F = extern "system" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<System> for unsafe extern "C" fn(A, B, C, D, E) -> Output

type F = unsafe extern "system" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<System> for unsafe extern "C-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "system" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<System> for unsafe extern "efiapi" fn(A, B, C, D, E) -> Output

type F = unsafe extern "system" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<System> for unsafe extern "system" fn(A, B, C, D, E) -> Output

type F = unsafe extern "system" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<System> for unsafe extern "system-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "system" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<System> for unsafe extern "sysv64" fn(A, B, C, D, E) -> Output

type F = unsafe extern "system" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<System> for unsafe extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "system" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<System> for unsafe fn(A, B, C, D, E) -> Output

type F = unsafe extern "system" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SystemUnwind> for extern "C" fn(A, B, C, D, E) -> Output

type F = extern "system-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SystemUnwind> for extern "C-unwind" fn(A, B, C, D, E) -> Output

type F = extern "system-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SystemUnwind> for extern "efiapi" fn(A, B, C, D, E) -> Output

type F = extern "system-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SystemUnwind> for extern "system" fn(A, B, C, D, E) -> Output

type F = extern "system-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SystemUnwind> for extern "system-unwind" fn(A, B, C, D, E) -> Output

type F = extern "system-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SystemUnwind> for extern "sysv64" fn(A, B, C, D, E) -> Output

type F = extern "system-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SystemUnwind> for extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

type F = extern "system-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SystemUnwind> for fn(A, B, C, D, E) -> Output

type F = extern "system-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SystemUnwind> for unsafe extern "C" fn(A, B, C, D, E) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SystemUnwind> for unsafe extern "C-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SystemUnwind> for unsafe extern "efiapi" fn(A, B, C, D, E) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SystemUnwind> for unsafe extern "system" fn(A, B, C, D, E) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SystemUnwind> for unsafe extern "system-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SystemUnwind> for unsafe extern "sysv64" fn(A, B, C, D, E) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SystemUnwind> for unsafe extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D, E> WithAbiImpl<SystemUnwind> for unsafe fn(A, B, C, D, E) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D, E) -> Output

impl<Output, A, B, C, D> WithAbiImpl<C> for extern "C" fn(A, B, C, D) -> Output

type F = extern "C" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<C> for extern "C-unwind" fn(A, B, C, D) -> Output

type F = extern "C" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<C> for extern "efiapi" fn(A, B, C, D) -> Output

type F = extern "C" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<C> for extern "system" fn(A, B, C, D) -> Output

type F = extern "C" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<C> for extern "system-unwind" fn(A, B, C, D) -> Output

type F = extern "C" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<C> for extern "sysv64" fn(A, B, C, D) -> Output

type F = extern "C" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<C> for extern "sysv64-unwind" fn(A, B, C, D) -> Output

type F = extern "C" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<C> for fn(A, B, C, D) -> Output

type F = extern "C" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<C> for unsafe extern "C" fn(A, B, C, D) -> Output

type F = unsafe extern "C" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<C> for unsafe extern "C-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "C" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<C> for unsafe extern "efiapi" fn(A, B, C, D) -> Output

type F = unsafe extern "C" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<C> for unsafe extern "system" fn(A, B, C, D) -> Output

type F = unsafe extern "C" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<C> for unsafe extern "system-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "C" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<C> for unsafe extern "sysv64" fn(A, B, C, D) -> Output

type F = unsafe extern "C" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<C> for unsafe extern "sysv64-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "C" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<C> for unsafe fn(A, B, C, D) -> Output

type F = unsafe extern "C" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<CUnwind> for extern "C" fn(A, B, C, D) -> Output

type F = extern "C-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<CUnwind> for extern "C-unwind" fn(A, B, C, D) -> Output

type F = extern "C-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<CUnwind> for extern "efiapi" fn(A, B, C, D) -> Output

type F = extern "C-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<CUnwind> for extern "system" fn(A, B, C, D) -> Output

type F = extern "C-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<CUnwind> for extern "system-unwind" fn(A, B, C, D) -> Output

type F = extern "C-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<CUnwind> for extern "sysv64" fn(A, B, C, D) -> Output

type F = extern "C-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<CUnwind> for extern "sysv64-unwind" fn(A, B, C, D) -> Output

type F = extern "C-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<CUnwind> for fn(A, B, C, D) -> Output

type F = extern "C-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<CUnwind> for unsafe extern "C" fn(A, B, C, D) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<CUnwind> for unsafe extern "C-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<CUnwind> for unsafe extern "efiapi" fn(A, B, C, D) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<CUnwind> for unsafe extern "system" fn(A, B, C, D) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<CUnwind> for unsafe extern "system-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<CUnwind> for unsafe extern "sysv64" fn(A, B, C, D) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<CUnwind> for unsafe extern "sysv64-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<CUnwind> for unsafe fn(A, B, C, D) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<EfiApi> for extern "C" fn(A, B, C, D) -> Output

type F = extern "efiapi" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<EfiApi> for extern "C-unwind" fn(A, B, C, D) -> Output

type F = extern "efiapi" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<EfiApi> for extern "efiapi" fn(A, B, C, D) -> Output

type F = extern "efiapi" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<EfiApi> for extern "system" fn(A, B, C, D) -> Output

type F = extern "efiapi" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<EfiApi> for extern "system-unwind" fn(A, B, C, D) -> Output

type F = extern "efiapi" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<EfiApi> for extern "sysv64" fn(A, B, C, D) -> Output

type F = extern "efiapi" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<EfiApi> for extern "sysv64-unwind" fn(A, B, C, D) -> Output

type F = extern "efiapi" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<EfiApi> for fn(A, B, C, D) -> Output

type F = extern "efiapi" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<EfiApi> for unsafe extern "C" fn(A, B, C, D) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<EfiApi> for unsafe extern "C-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<EfiApi> for unsafe extern "efiapi" fn(A, B, C, D) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<EfiApi> for unsafe extern "system" fn(A, B, C, D) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<EfiApi> for unsafe extern "system-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<EfiApi> for unsafe extern "sysv64" fn(A, B, C, D) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<EfiApi> for unsafe extern "sysv64-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<EfiApi> for unsafe fn(A, B, C, D) -> Output

type F = unsafe extern "efiapi" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<Rust> for extern "C" fn(A, B, C, D) -> Output

type F = fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<Rust> for extern "C-unwind" fn(A, B, C, D) -> Output

type F = fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<Rust> for extern "efiapi" fn(A, B, C, D) -> Output

type F = fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<Rust> for extern "system" fn(A, B, C, D) -> Output

type F = fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<Rust> for extern "system-unwind" fn(A, B, C, D) -> Output

type F = fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<Rust> for extern "sysv64" fn(A, B, C, D) -> Output

type F = fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<Rust> for extern "sysv64-unwind" fn(A, B, C, D) -> Output

type F = fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<Rust> for fn(A, B, C, D) -> Output

type F = fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<Rust> for unsafe extern "C" fn(A, B, C, D) -> Output

type F = unsafe fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<Rust> for unsafe extern "C-unwind" fn(A, B, C, D) -> Output

type F = unsafe fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<Rust> for unsafe extern "efiapi" fn(A, B, C, D) -> Output

type F = unsafe fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<Rust> for unsafe extern "system" fn(A, B, C, D) -> Output

type F = unsafe fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<Rust> for unsafe extern "system-unwind" fn(A, B, C, D) -> Output

type F = unsafe fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<Rust> for unsafe extern "sysv64" fn(A, B, C, D) -> Output

type F = unsafe fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<Rust> for unsafe extern "sysv64-unwind" fn(A, B, C, D) -> Output

type F = unsafe fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<Rust> for unsafe fn(A, B, C, D) -> Output

type F = unsafe fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64> for extern "C" fn(A, B, C, D) -> Output

type F = extern "sysv64" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64> for extern "C-unwind" fn(A, B, C, D) -> Output

type F = extern "sysv64" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64> for extern "efiapi" fn(A, B, C, D) -> Output

type F = extern "sysv64" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64> for extern "system" fn(A, B, C, D) -> Output

type F = extern "sysv64" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64> for extern "system-unwind" fn(A, B, C, D) -> Output

type F = extern "sysv64" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64> for extern "sysv64" fn(A, B, C, D) -> Output

type F = extern "sysv64" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64> for extern "sysv64-unwind" fn(A, B, C, D) -> Output

type F = extern "sysv64" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64> for fn(A, B, C, D) -> Output

type F = extern "sysv64" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64> for unsafe extern "C" fn(A, B, C, D) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64> for unsafe extern "C-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64> for unsafe extern "efiapi" fn(A, B, C, D) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64> for unsafe extern "system" fn(A, B, C, D) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64> for unsafe extern "system-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64> for unsafe extern "sysv64" fn(A, B, C, D) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64> for unsafe extern "sysv64-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64> for unsafe fn(A, B, C, D) -> Output

type F = unsafe extern "sysv64" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64Unwind> for extern "C" fn(A, B, C, D) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64Unwind> for extern "C-unwind" fn(A, B, C, D) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64Unwind> for extern "efiapi" fn(A, B, C, D) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64Unwind> for extern "system" fn(A, B, C, D) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64Unwind> for extern "system-unwind" fn(A, B, C, D) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64Unwind> for extern "sysv64" fn(A, B, C, D) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64Unwind> for extern "sysv64-unwind" fn(A, B, C, D) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64Unwind> for fn(A, B, C, D) -> Output

type F = extern "sysv64-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64Unwind> for unsafe extern "C" fn(A, B, C, D) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64Unwind> for unsafe extern "C-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64Unwind> for unsafe extern "efiapi" fn(A, B, C, D) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64Unwind> for unsafe extern "system" fn(A, B, C, D) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64Unwind> for unsafe extern "system-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64Unwind> for unsafe extern "sysv64" fn(A, B, C, D) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64Unwind> for unsafe extern "sysv64-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SysV64Unwind> for unsafe fn(A, B, C, D) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<System> for extern "C" fn(A, B, C, D) -> Output

type F = extern "system" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<System> for extern "C-unwind" fn(A, B, C, D) -> Output

type F = extern "system" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<System> for extern "efiapi" fn(A, B, C, D) -> Output

type F = extern "system" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<System> for extern "system" fn(A, B, C, D) -> Output

type F = extern "system" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<System> for extern "system-unwind" fn(A, B, C, D) -> Output

type F = extern "system" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<System> for extern "sysv64" fn(A, B, C, D) -> Output

type F = extern "system" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<System> for extern "sysv64-unwind" fn(A, B, C, D) -> Output

type F = extern "system" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<System> for fn(A, B, C, D) -> Output

type F = extern "system" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<System> for unsafe extern "C" fn(A, B, C, D) -> Output

type F = unsafe extern "system" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<System> for unsafe extern "C-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "system" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<System> for unsafe extern "efiapi" fn(A, B, C, D) -> Output

type F = unsafe extern "system" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<System> for unsafe extern "system" fn(A, B, C, D) -> Output

type F = unsafe extern "system" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<System> for unsafe extern "system-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "system" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<System> for unsafe extern "sysv64" fn(A, B, C, D) -> Output

type F = unsafe extern "system" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<System> for unsafe extern "sysv64-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "system" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<System> for unsafe fn(A, B, C, D) -> Output

type F = unsafe extern "system" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SystemUnwind> for extern "C" fn(A, B, C, D) -> Output

type F = extern "system-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SystemUnwind> for extern "C-unwind" fn(A, B, C, D) -> Output

type F = extern "system-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SystemUnwind> for extern "efiapi" fn(A, B, C, D) -> Output

type F = extern "system-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SystemUnwind> for extern "system" fn(A, B, C, D) -> Output

type F = extern "system-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SystemUnwind> for extern "system-unwind" fn(A, B, C, D) -> Output

type F = extern "system-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SystemUnwind> for extern "sysv64" fn(A, B, C, D) -> Output

type F = extern "system-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SystemUnwind> for extern "sysv64-unwind" fn(A, B, C, D) -> Output

type F = extern "system-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SystemUnwind> for fn(A, B, C, D) -> Output

type F = extern "system-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SystemUnwind> for unsafe extern "C" fn(A, B, C, D) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SystemUnwind> for unsafe extern "C-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SystemUnwind> for unsafe extern "efiapi" fn(A, B, C, D) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SystemUnwind> for unsafe extern "system" fn(A, B, C, D) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SystemUnwind> for unsafe extern "system-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SystemUnwind> for unsafe extern "sysv64" fn(A, B, C, D) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SystemUnwind> for unsafe extern "sysv64-unwind" fn(A, B, C, D) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C, D> WithAbiImpl<SystemUnwind> for unsafe fn(A, B, C, D) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C, D) -> Output

impl<Output, A, B, C> WithAbiImpl<C> for extern "C" fn(A, B, C) -> Output

type F = extern "C" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<C> for extern "C-unwind" fn(A, B, C) -> Output

type F = extern "C" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<C> for extern "efiapi" fn(A, B, C) -> Output

type F = extern "C" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<C> for extern "system" fn(A, B, C) -> Output

type F = extern "C" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<C> for extern "system-unwind" fn(A, B, C) -> Output

type F = extern "C" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<C> for extern "sysv64" fn(A, B, C) -> Output

type F = extern "C" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<C> for extern "sysv64-unwind" fn(A, B, C) -> Output

type F = extern "C" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<C> for fn(A, B, C) -> Output

type F = extern "C" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<C> for unsafe extern "C" fn(A, B, C) -> Output

type F = unsafe extern "C" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<C> for unsafe extern "C-unwind" fn(A, B, C) -> Output

type F = unsafe extern "C" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<C> for unsafe extern "efiapi" fn(A, B, C) -> Output

type F = unsafe extern "C" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<C> for unsafe extern "system" fn(A, B, C) -> Output

type F = unsafe extern "C" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<C> for unsafe extern "system-unwind" fn(A, B, C) -> Output

type F = unsafe extern "C" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<C> for unsafe extern "sysv64" fn(A, B, C) -> Output

type F = unsafe extern "C" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<C> for unsafe extern "sysv64-unwind" fn(A, B, C) -> Output

type F = unsafe extern "C" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<C> for unsafe fn(A, B, C) -> Output

type F = unsafe extern "C" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<CUnwind> for extern "C" fn(A, B, C) -> Output

type F = extern "C-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<CUnwind> for extern "C-unwind" fn(A, B, C) -> Output

type F = extern "C-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<CUnwind> for extern "efiapi" fn(A, B, C) -> Output

type F = extern "C-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<CUnwind> for extern "system" fn(A, B, C) -> Output

type F = extern "C-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<CUnwind> for extern "system-unwind" fn(A, B, C) -> Output

type F = extern "C-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<CUnwind> for extern "sysv64" fn(A, B, C) -> Output

type F = extern "C-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<CUnwind> for extern "sysv64-unwind" fn(A, B, C) -> Output

type F = extern "C-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<CUnwind> for fn(A, B, C) -> Output

type F = extern "C-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<CUnwind> for unsafe extern "C" fn(A, B, C) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<CUnwind> for unsafe extern "C-unwind" fn(A, B, C) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<CUnwind> for unsafe extern "efiapi" fn(A, B, C) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<CUnwind> for unsafe extern "system" fn(A, B, C) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<CUnwind> for unsafe extern "system-unwind" fn(A, B, C) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<CUnwind> for unsafe extern "sysv64" fn(A, B, C) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<CUnwind> for unsafe extern "sysv64-unwind" fn(A, B, C) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<CUnwind> for unsafe fn(A, B, C) -> Output

type F = unsafe extern "C-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<EfiApi> for extern "C" fn(A, B, C) -> Output

type F = extern "efiapi" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<EfiApi> for extern "C-unwind" fn(A, B, C) -> Output

type F = extern "efiapi" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<EfiApi> for extern "efiapi" fn(A, B, C) -> Output

type F = extern "efiapi" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<EfiApi> for extern "system" fn(A, B, C) -> Output

type F = extern "efiapi" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<EfiApi> for extern "system-unwind" fn(A, B, C) -> Output

type F = extern "efiapi" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<EfiApi> for extern "sysv64" fn(A, B, C) -> Output

type F = extern "efiapi" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<EfiApi> for extern "sysv64-unwind" fn(A, B, C) -> Output

type F = extern "efiapi" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<EfiApi> for fn(A, B, C) -> Output

type F = extern "efiapi" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<EfiApi> for unsafe extern "C" fn(A, B, C) -> Output

type F = unsafe extern "efiapi" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<EfiApi> for unsafe extern "C-unwind" fn(A, B, C) -> Output

type F = unsafe extern "efiapi" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<EfiApi> for unsafe extern "efiapi" fn(A, B, C) -> Output

type F = unsafe extern "efiapi" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<EfiApi> for unsafe extern "system" fn(A, B, C) -> Output

type F = unsafe extern "efiapi" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<EfiApi> for unsafe extern "system-unwind" fn(A, B, C) -> Output

type F = unsafe extern "efiapi" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<EfiApi> for unsafe extern "sysv64" fn(A, B, C) -> Output

type F = unsafe extern "efiapi" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<EfiApi> for unsafe extern "sysv64-unwind" fn(A, B, C) -> Output

type F = unsafe extern "efiapi" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<EfiApi> for unsafe fn(A, B, C) -> Output

type F = unsafe extern "efiapi" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<Rust> for extern "C" fn(A, B, C) -> Output

type F = fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<Rust> for extern "C-unwind" fn(A, B, C) -> Output

type F = fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<Rust> for extern "efiapi" fn(A, B, C) -> Output

type F = fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<Rust> for extern "system" fn(A, B, C) -> Output

type F = fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<Rust> for extern "system-unwind" fn(A, B, C) -> Output

type F = fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<Rust> for extern "sysv64" fn(A, B, C) -> Output

type F = fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<Rust> for extern "sysv64-unwind" fn(A, B, C) -> Output

type F = fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<Rust> for fn(A, B, C) -> Output

type F = fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<Rust> for unsafe extern "C" fn(A, B, C) -> Output

type F = unsafe fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<Rust> for unsafe extern "C-unwind" fn(A, B, C) -> Output

type F = unsafe fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<Rust> for unsafe extern "efiapi" fn(A, B, C) -> Output

type F = unsafe fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<Rust> for unsafe extern "system" fn(A, B, C) -> Output

type F = unsafe fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<Rust> for unsafe extern "system-unwind" fn(A, B, C) -> Output

type F = unsafe fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<Rust> for unsafe extern "sysv64" fn(A, B, C) -> Output

type F = unsafe fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<Rust> for unsafe extern "sysv64-unwind" fn(A, B, C) -> Output

type F = unsafe fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<Rust> for unsafe fn(A, B, C) -> Output

type F = unsafe fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64> for extern "C" fn(A, B, C) -> Output

type F = extern "sysv64" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64> for extern "C-unwind" fn(A, B, C) -> Output

type F = extern "sysv64" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64> for extern "efiapi" fn(A, B, C) -> Output

type F = extern "sysv64" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64> for extern "system" fn(A, B, C) -> Output

type F = extern "sysv64" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64> for extern "system-unwind" fn(A, B, C) -> Output

type F = extern "sysv64" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64> for extern "sysv64" fn(A, B, C) -> Output

type F = extern "sysv64" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64> for extern "sysv64-unwind" fn(A, B, C) -> Output

type F = extern "sysv64" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64> for fn(A, B, C) -> Output

type F = extern "sysv64" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64> for unsafe extern "C" fn(A, B, C) -> Output

type F = unsafe extern "sysv64" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64> for unsafe extern "C-unwind" fn(A, B, C) -> Output

type F = unsafe extern "sysv64" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64> for unsafe extern "efiapi" fn(A, B, C) -> Output

type F = unsafe extern "sysv64" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64> for unsafe extern "system" fn(A, B, C) -> Output

type F = unsafe extern "sysv64" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64> for unsafe extern "system-unwind" fn(A, B, C) -> Output

type F = unsafe extern "sysv64" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64> for unsafe extern "sysv64" fn(A, B, C) -> Output

type F = unsafe extern "sysv64" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64> for unsafe extern "sysv64-unwind" fn(A, B, C) -> Output

type F = unsafe extern "sysv64" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64> for unsafe fn(A, B, C) -> Output

type F = unsafe extern "sysv64" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64Unwind> for extern "C" fn(A, B, C) -> Output

type F = extern "sysv64-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64Unwind> for extern "C-unwind" fn(A, B, C) -> Output

type F = extern "sysv64-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64Unwind> for extern "efiapi" fn(A, B, C) -> Output

type F = extern "sysv64-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64Unwind> for extern "system" fn(A, B, C) -> Output

type F = extern "sysv64-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64Unwind> for extern "system-unwind" fn(A, B, C) -> Output

type F = extern "sysv64-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64Unwind> for extern "sysv64" fn(A, B, C) -> Output

type F = extern "sysv64-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64Unwind> for extern "sysv64-unwind" fn(A, B, C) -> Output

type F = extern "sysv64-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64Unwind> for fn(A, B, C) -> Output

type F = extern "sysv64-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64Unwind> for unsafe extern "C" fn(A, B, C) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64Unwind> for unsafe extern "C-unwind" fn(A, B, C) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64Unwind> for unsafe extern "efiapi" fn(A, B, C) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64Unwind> for unsafe extern "system" fn(A, B, C) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64Unwind> for unsafe extern "system-unwind" fn(A, B, C) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64Unwind> for unsafe extern "sysv64" fn(A, B, C) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64Unwind> for unsafe extern "sysv64-unwind" fn(A, B, C) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SysV64Unwind> for unsafe fn(A, B, C) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<System> for extern "C" fn(A, B, C) -> Output

type F = extern "system" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<System> for extern "C-unwind" fn(A, B, C) -> Output

type F = extern "system" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<System> for extern "efiapi" fn(A, B, C) -> Output

type F = extern "system" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<System> for extern "system" fn(A, B, C) -> Output

type F = extern "system" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<System> for extern "system-unwind" fn(A, B, C) -> Output

type F = extern "system" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<System> for extern "sysv64" fn(A, B, C) -> Output

type F = extern "system" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<System> for extern "sysv64-unwind" fn(A, B, C) -> Output

type F = extern "system" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<System> for fn(A, B, C) -> Output

type F = extern "system" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<System> for unsafe extern "C" fn(A, B, C) -> Output

type F = unsafe extern "system" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<System> for unsafe extern "C-unwind" fn(A, B, C) -> Output

type F = unsafe extern "system" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<System> for unsafe extern "efiapi" fn(A, B, C) -> Output

type F = unsafe extern "system" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<System> for unsafe extern "system" fn(A, B, C) -> Output

type F = unsafe extern "system" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<System> for unsafe extern "system-unwind" fn(A, B, C) -> Output

type F = unsafe extern "system" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<System> for unsafe extern "sysv64" fn(A, B, C) -> Output

type F = unsafe extern "system" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<System> for unsafe extern "sysv64-unwind" fn(A, B, C) -> Output

type F = unsafe extern "system" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<System> for unsafe fn(A, B, C) -> Output

type F = unsafe extern "system" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SystemUnwind> for extern "C" fn(A, B, C) -> Output

type F = extern "system-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SystemUnwind> for extern "C-unwind" fn(A, B, C) -> Output

type F = extern "system-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SystemUnwind> for extern "efiapi" fn(A, B, C) -> Output

type F = extern "system-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SystemUnwind> for extern "system" fn(A, B, C) -> Output

type F = extern "system-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SystemUnwind> for extern "system-unwind" fn(A, B, C) -> Output

type F = extern "system-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SystemUnwind> for extern "sysv64" fn(A, B, C) -> Output

type F = extern "system-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SystemUnwind> for extern "sysv64-unwind" fn(A, B, C) -> Output

type F = extern "system-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SystemUnwind> for fn(A, B, C) -> Output

type F = extern "system-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SystemUnwind> for unsafe extern "C" fn(A, B, C) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SystemUnwind> for unsafe extern "C-unwind" fn(A, B, C) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SystemUnwind> for unsafe extern "efiapi" fn(A, B, C) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SystemUnwind> for unsafe extern "system" fn(A, B, C) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SystemUnwind> for unsafe extern "system-unwind" fn(A, B, C) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SystemUnwind> for unsafe extern "sysv64" fn(A, B, C) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SystemUnwind> for unsafe extern "sysv64-unwind" fn(A, B, C) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C) -> Output

impl<Output, A, B, C> WithAbiImpl<SystemUnwind> for unsafe fn(A, B, C) -> Output

type F = unsafe extern "system-unwind" fn(A, B, C) -> Output

impl<Output, A, B> WithAbiImpl<C> for extern "C" fn(A, B) -> Output

type F = extern "C" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<C> for extern "C-unwind" fn(A, B) -> Output

type F = extern "C" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<C> for extern "efiapi" fn(A, B) -> Output

type F = extern "C" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<C> for extern "system" fn(A, B) -> Output

type F = extern "C" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<C> for extern "system-unwind" fn(A, B) -> Output

type F = extern "C" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<C> for extern "sysv64" fn(A, B) -> Output

type F = extern "C" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<C> for extern "sysv64-unwind" fn(A, B) -> Output

type F = extern "C" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<C> for fn(A, B) -> Output

type F = extern "C" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<C> for unsafe extern "C" fn(A, B) -> Output

type F = unsafe extern "C" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<C> for unsafe extern "C-unwind" fn(A, B) -> Output

type F = unsafe extern "C" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<C> for unsafe extern "efiapi" fn(A, B) -> Output

type F = unsafe extern "C" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<C> for unsafe extern "system" fn(A, B) -> Output

type F = unsafe extern "C" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<C> for unsafe extern "system-unwind" fn(A, B) -> Output

type F = unsafe extern "C" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<C> for unsafe extern "sysv64" fn(A, B) -> Output

type F = unsafe extern "C" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<C> for unsafe extern "sysv64-unwind" fn(A, B) -> Output

type F = unsafe extern "C" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<C> for unsafe fn(A, B) -> Output

type F = unsafe extern "C" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<CUnwind> for extern "C" fn(A, B) -> Output

type F = extern "C-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<CUnwind> for extern "C-unwind" fn(A, B) -> Output

type F = extern "C-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<CUnwind> for extern "efiapi" fn(A, B) -> Output

type F = extern "C-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<CUnwind> for extern "system" fn(A, B) -> Output

type F = extern "C-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<CUnwind> for extern "system-unwind" fn(A, B) -> Output

type F = extern "C-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<CUnwind> for extern "sysv64" fn(A, B) -> Output

type F = extern "C-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<CUnwind> for extern "sysv64-unwind" fn(A, B) -> Output

type F = extern "C-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<CUnwind> for fn(A, B) -> Output

type F = extern "C-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<CUnwind> for unsafe extern "C" fn(A, B) -> Output

type F = unsafe extern "C-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<CUnwind> for unsafe extern "C-unwind" fn(A, B) -> Output

type F = unsafe extern "C-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<CUnwind> for unsafe extern "efiapi" fn(A, B) -> Output

type F = unsafe extern "C-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<CUnwind> for unsafe extern "system" fn(A, B) -> Output

type F = unsafe extern "C-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<CUnwind> for unsafe extern "system-unwind" fn(A, B) -> Output

type F = unsafe extern "C-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<CUnwind> for unsafe extern "sysv64" fn(A, B) -> Output

type F = unsafe extern "C-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<CUnwind> for unsafe extern "sysv64-unwind" fn(A, B) -> Output

type F = unsafe extern "C-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<CUnwind> for unsafe fn(A, B) -> Output

type F = unsafe extern "C-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<EfiApi> for extern "C" fn(A, B) -> Output

type F = extern "efiapi" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<EfiApi> for extern "C-unwind" fn(A, B) -> Output

type F = extern "efiapi" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<EfiApi> for extern "efiapi" fn(A, B) -> Output

type F = extern "efiapi" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<EfiApi> for extern "system" fn(A, B) -> Output

type F = extern "efiapi" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<EfiApi> for extern "system-unwind" fn(A, B) -> Output

type F = extern "efiapi" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<EfiApi> for extern "sysv64" fn(A, B) -> Output

type F = extern "efiapi" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<EfiApi> for extern "sysv64-unwind" fn(A, B) -> Output

type F = extern "efiapi" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<EfiApi> for fn(A, B) -> Output

type F = extern "efiapi" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<EfiApi> for unsafe extern "C" fn(A, B) -> Output

type F = unsafe extern "efiapi" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<EfiApi> for unsafe extern "C-unwind" fn(A, B) -> Output

type F = unsafe extern "efiapi" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<EfiApi> for unsafe extern "efiapi" fn(A, B) -> Output

type F = unsafe extern "efiapi" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<EfiApi> for unsafe extern "system" fn(A, B) -> Output

type F = unsafe extern "efiapi" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<EfiApi> for unsafe extern "system-unwind" fn(A, B) -> Output

type F = unsafe extern "efiapi" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<EfiApi> for unsafe extern "sysv64" fn(A, B) -> Output

type F = unsafe extern "efiapi" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<EfiApi> for unsafe extern "sysv64-unwind" fn(A, B) -> Output

type F = unsafe extern "efiapi" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<EfiApi> for unsafe fn(A, B) -> Output

type F = unsafe extern "efiapi" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<Rust> for extern "C" fn(A, B) -> Output

type F = fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<Rust> for extern "C-unwind" fn(A, B) -> Output

type F = fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<Rust> for extern "efiapi" fn(A, B) -> Output

type F = fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<Rust> for extern "system" fn(A, B) -> Output

type F = fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<Rust> for extern "system-unwind" fn(A, B) -> Output

type F = fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<Rust> for extern "sysv64" fn(A, B) -> Output

type F = fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<Rust> for extern "sysv64-unwind" fn(A, B) -> Output

type F = fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<Rust> for fn(A, B) -> Output

type F = fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<Rust> for unsafe extern "C" fn(A, B) -> Output

type F = unsafe fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<Rust> for unsafe extern "C-unwind" fn(A, B) -> Output

type F = unsafe fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<Rust> for unsafe extern "efiapi" fn(A, B) -> Output

type F = unsafe fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<Rust> for unsafe extern "system" fn(A, B) -> Output

type F = unsafe fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<Rust> for unsafe extern "system-unwind" fn(A, B) -> Output

type F = unsafe fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<Rust> for unsafe extern "sysv64" fn(A, B) -> Output

type F = unsafe fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<Rust> for unsafe extern "sysv64-unwind" fn(A, B) -> Output

type F = unsafe fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<Rust> for unsafe fn(A, B) -> Output

type F = unsafe fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64> for extern "C" fn(A, B) -> Output

type F = extern "sysv64" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64> for extern "C-unwind" fn(A, B) -> Output

type F = extern "sysv64" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64> for extern "efiapi" fn(A, B) -> Output

type F = extern "sysv64" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64> for extern "system" fn(A, B) -> Output

type F = extern "sysv64" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64> for extern "system-unwind" fn(A, B) -> Output

type F = extern "sysv64" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64> for extern "sysv64" fn(A, B) -> Output

type F = extern "sysv64" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64> for extern "sysv64-unwind" fn(A, B) -> Output

type F = extern "sysv64" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64> for fn(A, B) -> Output

type F = extern "sysv64" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64> for unsafe extern "C" fn(A, B) -> Output

type F = unsafe extern "sysv64" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64> for unsafe extern "C-unwind" fn(A, B) -> Output

type F = unsafe extern "sysv64" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64> for unsafe extern "efiapi" fn(A, B) -> Output

type F = unsafe extern "sysv64" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64> for unsafe extern "system" fn(A, B) -> Output

type F = unsafe extern "sysv64" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64> for unsafe extern "system-unwind" fn(A, B) -> Output

type F = unsafe extern "sysv64" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64> for unsafe extern "sysv64" fn(A, B) -> Output

type F = unsafe extern "sysv64" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64> for unsafe extern "sysv64-unwind" fn(A, B) -> Output

type F = unsafe extern "sysv64" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64> for unsafe fn(A, B) -> Output

type F = unsafe extern "sysv64" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64Unwind> for extern "C" fn(A, B) -> Output

type F = extern "sysv64-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64Unwind> for extern "C-unwind" fn(A, B) -> Output

type F = extern "sysv64-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64Unwind> for extern "efiapi" fn(A, B) -> Output

type F = extern "sysv64-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64Unwind> for extern "system" fn(A, B) -> Output

type F = extern "sysv64-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64Unwind> for extern "system-unwind" fn(A, B) -> Output

type F = extern "sysv64-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64Unwind> for extern "sysv64" fn(A, B) -> Output

type F = extern "sysv64-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64Unwind> for extern "sysv64-unwind" fn(A, B) -> Output

type F = extern "sysv64-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64Unwind> for fn(A, B) -> Output

type F = extern "sysv64-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64Unwind> for unsafe extern "C" fn(A, B) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64Unwind> for unsafe extern "C-unwind" fn(A, B) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64Unwind> for unsafe extern "efiapi" fn(A, B) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64Unwind> for unsafe extern "system" fn(A, B) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64Unwind> for unsafe extern "system-unwind" fn(A, B) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64Unwind> for unsafe extern "sysv64" fn(A, B) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64Unwind> for unsafe extern "sysv64-unwind" fn(A, B) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SysV64Unwind> for unsafe fn(A, B) -> Output

type F = unsafe extern "sysv64-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<System> for extern "C" fn(A, B) -> Output

type F = extern "system" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<System> for extern "C-unwind" fn(A, B) -> Output

type F = extern "system" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<System> for extern "efiapi" fn(A, B) -> Output

type F = extern "system" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<System> for extern "system" fn(A, B) -> Output

type F = extern "system" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<System> for extern "system-unwind" fn(A, B) -> Output

type F = extern "system" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<System> for extern "sysv64" fn(A, B) -> Output

type F = extern "system" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<System> for extern "sysv64-unwind" fn(A, B) -> Output

type F = extern "system" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<System> for fn(A, B) -> Output

type F = extern "system" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<System> for unsafe extern "C" fn(A, B) -> Output

type F = unsafe extern "system" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<System> for unsafe extern "C-unwind" fn(A, B) -> Output

type F = unsafe extern "system" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<System> for unsafe extern "efiapi" fn(A, B) -> Output

type F = unsafe extern "system" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<System> for unsafe extern "system" fn(A, B) -> Output

type F = unsafe extern "system" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<System> for unsafe extern "system-unwind" fn(A, B) -> Output

type F = unsafe extern "system" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<System> for unsafe extern "sysv64" fn(A, B) -> Output

type F = unsafe extern "system" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<System> for unsafe extern "sysv64-unwind" fn(A, B) -> Output

type F = unsafe extern "system" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<System> for unsafe fn(A, B) -> Output

type F = unsafe extern "system" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SystemUnwind> for extern "C" fn(A, B) -> Output

type F = extern "system-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SystemUnwind> for extern "C-unwind" fn(A, B) -> Output

type F = extern "system-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SystemUnwind> for extern "efiapi" fn(A, B) -> Output

type F = extern "system-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SystemUnwind> for extern "system" fn(A, B) -> Output

type F = extern "system-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SystemUnwind> for extern "system-unwind" fn(A, B) -> Output

type F = extern "system-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SystemUnwind> for extern "sysv64" fn(A, B) -> Output

type F = extern "system-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SystemUnwind> for extern "sysv64-unwind" fn(A, B) -> Output

type F = extern "system-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SystemUnwind> for fn(A, B) -> Output

type F = extern "system-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SystemUnwind> for unsafe extern "C" fn(A, B) -> Output

type F = unsafe extern "system-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SystemUnwind> for unsafe extern "C-unwind" fn(A, B) -> Output

type F = unsafe extern "system-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SystemUnwind> for unsafe extern "efiapi" fn(A, B) -> Output

type F = unsafe extern "system-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SystemUnwind> for unsafe extern "system" fn(A, B) -> Output

type F = unsafe extern "system-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SystemUnwind> for unsafe extern "system-unwind" fn(A, B) -> Output

type F = unsafe extern "system-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SystemUnwind> for unsafe extern "sysv64" fn(A, B) -> Output

type F = unsafe extern "system-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SystemUnwind> for unsafe extern "sysv64-unwind" fn(A, B) -> Output

type F = unsafe extern "system-unwind" fn(A, B) -> Output

impl<Output, A, B> WithAbiImpl<SystemUnwind> for unsafe fn(A, B) -> Output

type F = unsafe extern "system-unwind" fn(A, B) -> Output

impl<Output, A> WithAbiImpl<C> for extern "C" fn(A) -> Output

type F = extern "C" fn(A) -> Output

impl<Output, A> WithAbiImpl<C> for extern "C-unwind" fn(A) -> Output

type F = extern "C" fn(A) -> Output

impl<Output, A> WithAbiImpl<C> for extern "efiapi" fn(A) -> Output

type F = extern "C" fn(A) -> Output

impl<Output, A> WithAbiImpl<C> for extern "system" fn(A) -> Output

type F = extern "C" fn(A) -> Output

impl<Output, A> WithAbiImpl<C> for extern "system-unwind" fn(A) -> Output

type F = extern "C" fn(A) -> Output

impl<Output, A> WithAbiImpl<C> for extern "sysv64" fn(A) -> Output

type F = extern "C" fn(A) -> Output

impl<Output, A> WithAbiImpl<C> for extern "sysv64-unwind" fn(A) -> Output

type F = extern "C" fn(A) -> Output

impl<Output, A> WithAbiImpl<C> for fn(A) -> Output

type F = extern "C" fn(A) -> Output

impl<Output, A> WithAbiImpl<C> for unsafe extern "C" fn(A) -> Output

type F = unsafe extern "C" fn(A) -> Output

impl<Output, A> WithAbiImpl<C> for unsafe extern "C-unwind" fn(A) -> Output

type F = unsafe extern "C" fn(A) -> Output

impl<Output, A> WithAbiImpl<C> for unsafe extern "efiapi" fn(A) -> Output

type F = unsafe extern "C" fn(A) -> Output

impl<Output, A> WithAbiImpl<C> for unsafe extern "system" fn(A) -> Output

type F = unsafe extern "C" fn(A) -> Output

impl<Output, A> WithAbiImpl<C> for unsafe extern "system-unwind" fn(A) -> Output

type F = unsafe extern "C" fn(A) -> Output

impl<Output, A> WithAbiImpl<C> for unsafe extern "sysv64" fn(A) -> Output

type F = unsafe extern "C" fn(A) -> Output

impl<Output, A> WithAbiImpl<C> for unsafe extern "sysv64-unwind" fn(A) -> Output

type F = unsafe extern "C" fn(A) -> Output

impl<Output, A> WithAbiImpl<C> for unsafe fn(A) -> Output

type F = unsafe extern "C" fn(A) -> Output

impl<Output, A> WithAbiImpl<CUnwind> for extern "C" fn(A) -> Output

type F = extern "C-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<CUnwind> for extern "C-unwind" fn(A) -> Output

type F = extern "C-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<CUnwind> for extern "efiapi" fn(A) -> Output

type F = extern "C-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<CUnwind> for extern "system" fn(A) -> Output

type F = extern "C-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<CUnwind> for extern "system-unwind" fn(A) -> Output

type F = extern "C-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<CUnwind> for extern "sysv64" fn(A) -> Output

type F = extern "C-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<CUnwind> for extern "sysv64-unwind" fn(A) -> Output

type F = extern "C-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<CUnwind> for fn(A) -> Output

type F = extern "C-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<CUnwind> for unsafe extern "C" fn(A) -> Output

type F = unsafe extern "C-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<CUnwind> for unsafe extern "C-unwind" fn(A) -> Output

type F = unsafe extern "C-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<CUnwind> for unsafe extern "efiapi" fn(A) -> Output

type F = unsafe extern "C-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<CUnwind> for unsafe extern "system" fn(A) -> Output

type F = unsafe extern "C-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<CUnwind> for unsafe extern "system-unwind" fn(A) -> Output

type F = unsafe extern "C-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<CUnwind> for unsafe extern "sysv64" fn(A) -> Output

type F = unsafe extern "C-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<CUnwind> for unsafe extern "sysv64-unwind" fn(A) -> Output

type F = unsafe extern "C-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<CUnwind> for unsafe fn(A) -> Output

type F = unsafe extern "C-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<EfiApi> for extern "C" fn(A) -> Output

type F = extern "efiapi" fn(A) -> Output

impl<Output, A> WithAbiImpl<EfiApi> for extern "C-unwind" fn(A) -> Output

type F = extern "efiapi" fn(A) -> Output

impl<Output, A> WithAbiImpl<EfiApi> for extern "efiapi" fn(A) -> Output

type F = extern "efiapi" fn(A) -> Output

impl<Output, A> WithAbiImpl<EfiApi> for extern "system" fn(A) -> Output

type F = extern "efiapi" fn(A) -> Output

impl<Output, A> WithAbiImpl<EfiApi> for extern "system-unwind" fn(A) -> Output

type F = extern "efiapi" fn(A) -> Output

impl<Output, A> WithAbiImpl<EfiApi> for extern "sysv64" fn(A) -> Output

type F = extern "efiapi" fn(A) -> Output

impl<Output, A> WithAbiImpl<EfiApi> for extern "sysv64-unwind" fn(A) -> Output

type F = extern "efiapi" fn(A) -> Output

impl<Output, A> WithAbiImpl<EfiApi> for fn(A) -> Output

type F = extern "efiapi" fn(A) -> Output

impl<Output, A> WithAbiImpl<EfiApi> for unsafe extern "C" fn(A) -> Output

type F = unsafe extern "efiapi" fn(A) -> Output

impl<Output, A> WithAbiImpl<EfiApi> for unsafe extern "C-unwind" fn(A) -> Output

type F = unsafe extern "efiapi" fn(A) -> Output

impl<Output, A> WithAbiImpl<EfiApi> for unsafe extern "efiapi" fn(A) -> Output

type F = unsafe extern "efiapi" fn(A) -> Output

impl<Output, A> WithAbiImpl<EfiApi> for unsafe extern "system" fn(A) -> Output

type F = unsafe extern "efiapi" fn(A) -> Output

impl<Output, A> WithAbiImpl<EfiApi> for unsafe extern "system-unwind" fn(A) -> Output

type F = unsafe extern "efiapi" fn(A) -> Output

impl<Output, A> WithAbiImpl<EfiApi> for unsafe extern "sysv64" fn(A) -> Output

type F = unsafe extern "efiapi" fn(A) -> Output

impl<Output, A> WithAbiImpl<EfiApi> for unsafe extern "sysv64-unwind" fn(A) -> Output

type F = unsafe extern "efiapi" fn(A) -> Output

impl<Output, A> WithAbiImpl<EfiApi> for unsafe fn(A) -> Output

type F = unsafe extern "efiapi" fn(A) -> Output

impl<Output, A> WithAbiImpl<Rust> for extern "C" fn(A) -> Output

type F = fn(A) -> Output

impl<Output, A> WithAbiImpl<Rust> for extern "C-unwind" fn(A) -> Output

type F = fn(A) -> Output

impl<Output, A> WithAbiImpl<Rust> for extern "efiapi" fn(A) -> Output

type F = fn(A) -> Output

impl<Output, A> WithAbiImpl<Rust> for extern "system" fn(A) -> Output

type F = fn(A) -> Output

impl<Output, A> WithAbiImpl<Rust> for extern "system-unwind" fn(A) -> Output

type F = fn(A) -> Output

impl<Output, A> WithAbiImpl<Rust> for extern "sysv64" fn(A) -> Output

type F = fn(A) -> Output

impl<Output, A> WithAbiImpl<Rust> for extern "sysv64-unwind" fn(A) -> Output

type F = fn(A) -> Output

impl<Output, A> WithAbiImpl<Rust> for fn(A) -> Output

type F = fn(A) -> Output

impl<Output, A> WithAbiImpl<Rust> for unsafe extern "C" fn(A) -> Output

type F = unsafe fn(A) -> Output

impl<Output, A> WithAbiImpl<Rust> for unsafe extern "C-unwind" fn(A) -> Output

type F = unsafe fn(A) -> Output

impl<Output, A> WithAbiImpl<Rust> for unsafe extern "efiapi" fn(A) -> Output

type F = unsafe fn(A) -> Output

impl<Output, A> WithAbiImpl<Rust> for unsafe extern "system" fn(A) -> Output

type F = unsafe fn(A) -> Output

impl<Output, A> WithAbiImpl<Rust> for unsafe extern "system-unwind" fn(A) -> Output

type F = unsafe fn(A) -> Output

impl<Output, A> WithAbiImpl<Rust> for unsafe extern "sysv64" fn(A) -> Output

type F = unsafe fn(A) -> Output

impl<Output, A> WithAbiImpl<Rust> for unsafe extern "sysv64-unwind" fn(A) -> Output

type F = unsafe fn(A) -> Output

impl<Output, A> WithAbiImpl<Rust> for unsafe fn(A) -> Output

type F = unsafe fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64> for extern "C" fn(A) -> Output

type F = extern "sysv64" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64> for extern "C-unwind" fn(A) -> Output

type F = extern "sysv64" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64> for extern "efiapi" fn(A) -> Output

type F = extern "sysv64" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64> for extern "system" fn(A) -> Output

type F = extern "sysv64" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64> for extern "system-unwind" fn(A) -> Output

type F = extern "sysv64" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64> for extern "sysv64" fn(A) -> Output

type F = extern "sysv64" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64> for extern "sysv64-unwind" fn(A) -> Output

type F = extern "sysv64" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64> for fn(A) -> Output

type F = extern "sysv64" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64> for unsafe extern "C" fn(A) -> Output

type F = unsafe extern "sysv64" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64> for unsafe extern "C-unwind" fn(A) -> Output

type F = unsafe extern "sysv64" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64> for unsafe extern "efiapi" fn(A) -> Output

type F = unsafe extern "sysv64" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64> for unsafe extern "system" fn(A) -> Output

type F = unsafe extern "sysv64" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64> for unsafe extern "system-unwind" fn(A) -> Output

type F = unsafe extern "sysv64" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64> for unsafe extern "sysv64" fn(A) -> Output

type F = unsafe extern "sysv64" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64> for unsafe extern "sysv64-unwind" fn(A) -> Output

type F = unsafe extern "sysv64" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64> for unsafe fn(A) -> Output

type F = unsafe extern "sysv64" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64Unwind> for extern "C" fn(A) -> Output

type F = extern "sysv64-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64Unwind> for extern "C-unwind" fn(A) -> Output

type F = extern "sysv64-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64Unwind> for extern "efiapi" fn(A) -> Output

type F = extern "sysv64-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64Unwind> for extern "system" fn(A) -> Output

type F = extern "sysv64-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64Unwind> for extern "system-unwind" fn(A) -> Output

type F = extern "sysv64-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64Unwind> for extern "sysv64" fn(A) -> Output

type F = extern "sysv64-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64Unwind> for extern "sysv64-unwind" fn(A) -> Output

type F = extern "sysv64-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64Unwind> for fn(A) -> Output

type F = extern "sysv64-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64Unwind> for unsafe extern "C" fn(A) -> Output

type F = unsafe extern "sysv64-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64Unwind> for unsafe extern "C-unwind" fn(A) -> Output

type F = unsafe extern "sysv64-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64Unwind> for unsafe extern "efiapi" fn(A) -> Output

type F = unsafe extern "sysv64-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64Unwind> for unsafe extern "system" fn(A) -> Output

type F = unsafe extern "sysv64-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64Unwind> for unsafe extern "system-unwind" fn(A) -> Output

type F = unsafe extern "sysv64-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64Unwind> for unsafe extern "sysv64" fn(A) -> Output

type F = unsafe extern "sysv64-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64Unwind> for unsafe extern "sysv64-unwind" fn(A) -> Output

type F = unsafe extern "sysv64-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SysV64Unwind> for unsafe fn(A) -> Output

type F = unsafe extern "sysv64-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<System> for extern "C" fn(A) -> Output

type F = extern "system" fn(A) -> Output

impl<Output, A> WithAbiImpl<System> for extern "C-unwind" fn(A) -> Output

type F = extern "system" fn(A) -> Output

impl<Output, A> WithAbiImpl<System> for extern "efiapi" fn(A) -> Output

type F = extern "system" fn(A) -> Output

impl<Output, A> WithAbiImpl<System> for extern "system" fn(A) -> Output

type F = extern "system" fn(A) -> Output

impl<Output, A> WithAbiImpl<System> for extern "system-unwind" fn(A) -> Output

type F = extern "system" fn(A) -> Output

impl<Output, A> WithAbiImpl<System> for extern "sysv64" fn(A) -> Output

type F = extern "system" fn(A) -> Output

impl<Output, A> WithAbiImpl<System> for extern "sysv64-unwind" fn(A) -> Output

type F = extern "system" fn(A) -> Output

impl<Output, A> WithAbiImpl<System> for fn(A) -> Output

type F = extern "system" fn(A) -> Output

impl<Output, A> WithAbiImpl<System> for unsafe extern "C" fn(A) -> Output

type F = unsafe extern "system" fn(A) -> Output

impl<Output, A> WithAbiImpl<System> for unsafe extern "C-unwind" fn(A) -> Output

type F = unsafe extern "system" fn(A) -> Output

impl<Output, A> WithAbiImpl<System> for unsafe extern "efiapi" fn(A) -> Output

type F = unsafe extern "system" fn(A) -> Output

impl<Output, A> WithAbiImpl<System> for unsafe extern "system" fn(A) -> Output

type F = unsafe extern "system" fn(A) -> Output

impl<Output, A> WithAbiImpl<System> for unsafe extern "system-unwind" fn(A) -> Output

type F = unsafe extern "system" fn(A) -> Output

impl<Output, A> WithAbiImpl<System> for unsafe extern "sysv64" fn(A) -> Output

type F = unsafe extern "system" fn(A) -> Output

impl<Output, A> WithAbiImpl<System> for unsafe extern "sysv64-unwind" fn(A) -> Output

type F = unsafe extern "system" fn(A) -> Output

impl<Output, A> WithAbiImpl<System> for unsafe fn(A) -> Output

type F = unsafe extern "system" fn(A) -> Output

impl<Output, A> WithAbiImpl<SystemUnwind> for extern "C" fn(A) -> Output

type F = extern "system-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SystemUnwind> for extern "C-unwind" fn(A) -> Output

type F = extern "system-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SystemUnwind> for extern "efiapi" fn(A) -> Output

type F = extern "system-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SystemUnwind> for extern "system" fn(A) -> Output

type F = extern "system-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SystemUnwind> for extern "system-unwind" fn(A) -> Output

type F = extern "system-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SystemUnwind> for extern "sysv64" fn(A) -> Output

type F = extern "system-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SystemUnwind> for extern "sysv64-unwind" fn(A) -> Output

type F = extern "system-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SystemUnwind> for fn(A) -> Output

type F = extern "system-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SystemUnwind> for unsafe extern "C" fn(A) -> Output

type F = unsafe extern "system-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SystemUnwind> for unsafe extern "C-unwind" fn(A) -> Output

type F = unsafe extern "system-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SystemUnwind> for unsafe extern "efiapi" fn(A) -> Output

type F = unsafe extern "system-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SystemUnwind> for unsafe extern "system" fn(A) -> Output

type F = unsafe extern "system-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SystemUnwind> for unsafe extern "system-unwind" fn(A) -> Output

type F = unsafe extern "system-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SystemUnwind> for unsafe extern "sysv64" fn(A) -> Output

type F = unsafe extern "system-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SystemUnwind> for unsafe extern "sysv64-unwind" fn(A) -> Output

type F = unsafe extern "system-unwind" fn(A) -> Output

impl<Output, A> WithAbiImpl<SystemUnwind> for unsafe fn(A) -> Output

type F = unsafe extern "system-unwind" fn(A) -> Output

impl<Output> WithAbiImpl<C> for extern "C" fn() -> Output

type F = extern "C" fn() -> Output

impl<Output> WithAbiImpl<C> for extern "C-unwind" fn() -> Output

type F = extern "C" fn() -> Output

impl<Output> WithAbiImpl<C> for extern "efiapi" fn() -> Output

type F = extern "C" fn() -> Output

impl<Output> WithAbiImpl<C> for extern "system" fn() -> Output

type F = extern "C" fn() -> Output

impl<Output> WithAbiImpl<C> for extern "system-unwind" fn() -> Output

type F = extern "C" fn() -> Output

impl<Output> WithAbiImpl<C> for extern "sysv64" fn() -> Output

type F = extern "C" fn() -> Output

impl<Output> WithAbiImpl<C> for extern "sysv64-unwind" fn() -> Output

type F = extern "C" fn() -> Output

impl<Output> WithAbiImpl<C> for fn() -> Output

type F = extern "C" fn() -> Output

impl<Output> WithAbiImpl<C> for unsafe extern "C" fn() -> Output

type F = unsafe extern "C" fn() -> Output

impl<Output> WithAbiImpl<C> for unsafe extern "C-unwind" fn() -> Output

type F = unsafe extern "C" fn() -> Output

impl<Output> WithAbiImpl<C> for unsafe extern "efiapi" fn() -> Output

type F = unsafe extern "C" fn() -> Output

impl<Output> WithAbiImpl<C> for unsafe extern "system" fn() -> Output

type F = unsafe extern "C" fn() -> Output

impl<Output> WithAbiImpl<C> for unsafe extern "system-unwind" fn() -> Output

type F = unsafe extern "C" fn() -> Output

impl<Output> WithAbiImpl<C> for unsafe extern "sysv64" fn() -> Output

type F = unsafe extern "C" fn() -> Output

impl<Output> WithAbiImpl<C> for unsafe extern "sysv64-unwind" fn() -> Output

type F = unsafe extern "C" fn() -> Output

impl<Output> WithAbiImpl<C> for unsafe fn() -> Output

type F = unsafe extern "C" fn() -> Output

impl<Output> WithAbiImpl<CUnwind> for extern "C" fn() -> Output

type F = extern "C-unwind" fn() -> Output

impl<Output> WithAbiImpl<CUnwind> for extern "C-unwind" fn() -> Output

type F = extern "C-unwind" fn() -> Output

impl<Output> WithAbiImpl<CUnwind> for extern "efiapi" fn() -> Output

type F = extern "C-unwind" fn() -> Output

impl<Output> WithAbiImpl<CUnwind> for extern "system" fn() -> Output

type F = extern "C-unwind" fn() -> Output

impl<Output> WithAbiImpl<CUnwind> for extern "system-unwind" fn() -> Output

type F = extern "C-unwind" fn() -> Output

impl<Output> WithAbiImpl<CUnwind> for extern "sysv64" fn() -> Output

type F = extern "C-unwind" fn() -> Output

impl<Output> WithAbiImpl<CUnwind> for extern "sysv64-unwind" fn() -> Output

type F = extern "C-unwind" fn() -> Output

impl<Output> WithAbiImpl<CUnwind> for fn() -> Output

type F = extern "C-unwind" fn() -> Output

impl<Output> WithAbiImpl<CUnwind> for unsafe extern "C" fn() -> Output

type F = unsafe extern "C-unwind" fn() -> Output

impl<Output> WithAbiImpl<CUnwind> for unsafe extern "C-unwind" fn() -> Output

type F = unsafe extern "C-unwind" fn() -> Output

impl<Output> WithAbiImpl<CUnwind> for unsafe extern "efiapi" fn() -> Output

type F = unsafe extern "C-unwind" fn() -> Output

impl<Output> WithAbiImpl<CUnwind> for unsafe extern "system" fn() -> Output

type F = unsafe extern "C-unwind" fn() -> Output

impl<Output> WithAbiImpl<CUnwind> for unsafe extern "system-unwind" fn() -> Output

type F = unsafe extern "C-unwind" fn() -> Output

impl<Output> WithAbiImpl<CUnwind> for unsafe extern "sysv64" fn() -> Output

type F = unsafe extern "C-unwind" fn() -> Output

impl<Output> WithAbiImpl<CUnwind> for unsafe extern "sysv64-unwind" fn() -> Output

type F = unsafe extern "C-unwind" fn() -> Output

impl<Output> WithAbiImpl<CUnwind> for unsafe fn() -> Output

type F = unsafe extern "C-unwind" fn() -> Output

impl<Output> WithAbiImpl<EfiApi> for extern "C" fn() -> Output

type F = extern "efiapi" fn() -> Output

impl<Output> WithAbiImpl<EfiApi> for extern "C-unwind" fn() -> Output

type F = extern "efiapi" fn() -> Output

impl<Output> WithAbiImpl<EfiApi> for extern "efiapi" fn() -> Output

type F = extern "efiapi" fn() -> Output

impl<Output> WithAbiImpl<EfiApi> for extern "system" fn() -> Output

type F = extern "efiapi" fn() -> Output

impl<Output> WithAbiImpl<EfiApi> for extern "system-unwind" fn() -> Output

type F = extern "efiapi" fn() -> Output

impl<Output> WithAbiImpl<EfiApi> for extern "sysv64" fn() -> Output

type F = extern "efiapi" fn() -> Output

impl<Output> WithAbiImpl<EfiApi> for extern "sysv64-unwind" fn() -> Output

type F = extern "efiapi" fn() -> Output

impl<Output> WithAbiImpl<EfiApi> for fn() -> Output

type F = extern "efiapi" fn() -> Output

impl<Output> WithAbiImpl<EfiApi> for unsafe extern "C" fn() -> Output

type F = unsafe extern "efiapi" fn() -> Output

impl<Output> WithAbiImpl<EfiApi> for unsafe extern "C-unwind" fn() -> Output

type F = unsafe extern "efiapi" fn() -> Output

impl<Output> WithAbiImpl<EfiApi> for unsafe extern "efiapi" fn() -> Output

type F = unsafe extern "efiapi" fn() -> Output

impl<Output> WithAbiImpl<EfiApi> for unsafe extern "system" fn() -> Output

type F = unsafe extern "efiapi" fn() -> Output

impl<Output> WithAbiImpl<EfiApi> for unsafe extern "system-unwind" fn() -> Output

type F = unsafe extern "efiapi" fn() -> Output

impl<Output> WithAbiImpl<EfiApi> for unsafe extern "sysv64" fn() -> Output

type F = unsafe extern "efiapi" fn() -> Output

impl<Output> WithAbiImpl<EfiApi> for unsafe extern "sysv64-unwind" fn() -> Output

type F = unsafe extern "efiapi" fn() -> Output

impl<Output> WithAbiImpl<EfiApi> for unsafe fn() -> Output

type F = unsafe extern "efiapi" fn() -> Output

impl<Output> WithAbiImpl<Rust> for extern "C" fn() -> Output

type F = fn() -> Output

impl<Output> WithAbiImpl<Rust> for extern "C-unwind" fn() -> Output

type F = fn() -> Output

impl<Output> WithAbiImpl<Rust> for extern "efiapi" fn() -> Output

type F = fn() -> Output

impl<Output> WithAbiImpl<Rust> for extern "system" fn() -> Output

type F = fn() -> Output

impl<Output> WithAbiImpl<Rust> for extern "system-unwind" fn() -> Output

type F = fn() -> Output

impl<Output> WithAbiImpl<Rust> for extern "sysv64" fn() -> Output

type F = fn() -> Output

impl<Output> WithAbiImpl<Rust> for extern "sysv64-unwind" fn() -> Output

type F = fn() -> Output

impl<Output> WithAbiImpl<Rust> for fn() -> Output

type F = fn() -> Output

impl<Output> WithAbiImpl<Rust> for unsafe extern "C" fn() -> Output

type F = unsafe fn() -> Output

impl<Output> WithAbiImpl<Rust> for unsafe extern "C-unwind" fn() -> Output

type F = unsafe fn() -> Output

impl<Output> WithAbiImpl<Rust> for unsafe extern "efiapi" fn() -> Output

type F = unsafe fn() -> Output

impl<Output> WithAbiImpl<Rust> for unsafe extern "system" fn() -> Output

type F = unsafe fn() -> Output

impl<Output> WithAbiImpl<Rust> for unsafe extern "system-unwind" fn() -> Output

type F = unsafe fn() -> Output

impl<Output> WithAbiImpl<Rust> for unsafe extern "sysv64" fn() -> Output

type F = unsafe fn() -> Output

impl<Output> WithAbiImpl<Rust> for unsafe extern "sysv64-unwind" fn() -> Output

type F = unsafe fn() -> Output

impl<Output> WithAbiImpl<Rust> for unsafe fn() -> Output

type F = unsafe fn() -> Output

impl<Output> WithAbiImpl<SysV64> for extern "C" fn() -> Output

type F = extern "sysv64" fn() -> Output

impl<Output> WithAbiImpl<SysV64> for extern "C-unwind" fn() -> Output

type F = extern "sysv64" fn() -> Output

impl<Output> WithAbiImpl<SysV64> for extern "efiapi" fn() -> Output

type F = extern "sysv64" fn() -> Output

impl<Output> WithAbiImpl<SysV64> for extern "system" fn() -> Output

type F = extern "sysv64" fn() -> Output

impl<Output> WithAbiImpl<SysV64> for extern "system-unwind" fn() -> Output

type F = extern "sysv64" fn() -> Output

impl<Output> WithAbiImpl<SysV64> for extern "sysv64" fn() -> Output

type F = extern "sysv64" fn() -> Output

impl<Output> WithAbiImpl<SysV64> for extern "sysv64-unwind" fn() -> Output

type F = extern "sysv64" fn() -> Output

impl<Output> WithAbiImpl<SysV64> for fn() -> Output

type F = extern "sysv64" fn() -> Output

impl<Output> WithAbiImpl<SysV64> for unsafe extern "C" fn() -> Output

type F = unsafe extern "sysv64" fn() -> Output

impl<Output> WithAbiImpl<SysV64> for unsafe extern "C-unwind" fn() -> Output

type F = unsafe extern "sysv64" fn() -> Output

impl<Output> WithAbiImpl<SysV64> for unsafe extern "efiapi" fn() -> Output

type F = unsafe extern "sysv64" fn() -> Output

impl<Output> WithAbiImpl<SysV64> for unsafe extern "system" fn() -> Output

type F = unsafe extern "sysv64" fn() -> Output

impl<Output> WithAbiImpl<SysV64> for unsafe extern "system-unwind" fn() -> Output

type F = unsafe extern "sysv64" fn() -> Output

impl<Output> WithAbiImpl<SysV64> for unsafe extern "sysv64" fn() -> Output

type F = unsafe extern "sysv64" fn() -> Output

impl<Output> WithAbiImpl<SysV64> for unsafe extern "sysv64-unwind" fn() -> Output

type F = unsafe extern "sysv64" fn() -> Output

impl<Output> WithAbiImpl<SysV64> for unsafe fn() -> Output

type F = unsafe extern "sysv64" fn() -> Output

impl<Output> WithAbiImpl<SysV64Unwind> for extern "C" fn() -> Output

type F = extern "sysv64-unwind" fn() -> Output

impl<Output> WithAbiImpl<SysV64Unwind> for extern "C-unwind" fn() -> Output

type F = extern "sysv64-unwind" fn() -> Output

impl<Output> WithAbiImpl<SysV64Unwind> for extern "efiapi" fn() -> Output

type F = extern "sysv64-unwind" fn() -> Output

impl<Output> WithAbiImpl<SysV64Unwind> for extern "system" fn() -> Output

type F = extern "sysv64-unwind" fn() -> Output

impl<Output> WithAbiImpl<SysV64Unwind> for extern "system-unwind" fn() -> Output

type F = extern "sysv64-unwind" fn() -> Output

impl<Output> WithAbiImpl<SysV64Unwind> for extern "sysv64" fn() -> Output

type F = extern "sysv64-unwind" fn() -> Output

impl<Output> WithAbiImpl<SysV64Unwind> for extern "sysv64-unwind" fn() -> Output

type F = extern "sysv64-unwind" fn() -> Output

impl<Output> WithAbiImpl<SysV64Unwind> for fn() -> Output

type F = extern "sysv64-unwind" fn() -> Output

impl<Output> WithAbiImpl<SysV64Unwind> for unsafe extern "C" fn() -> Output

type F = unsafe extern "sysv64-unwind" fn() -> Output

impl<Output> WithAbiImpl<SysV64Unwind> for unsafe extern "C-unwind" fn() -> Output

type F = unsafe extern "sysv64-unwind" fn() -> Output

impl<Output> WithAbiImpl<SysV64Unwind> for unsafe extern "efiapi" fn() -> Output

type F = unsafe extern "sysv64-unwind" fn() -> Output

impl<Output> WithAbiImpl<SysV64Unwind> for unsafe extern "system" fn() -> Output

type F = unsafe extern "sysv64-unwind" fn() -> Output

impl<Output> WithAbiImpl<SysV64Unwind> for unsafe extern "system-unwind" fn() -> Output

type F = unsafe extern "sysv64-unwind" fn() -> Output

impl<Output> WithAbiImpl<SysV64Unwind> for unsafe extern "sysv64" fn() -> Output

type F = unsafe extern "sysv64-unwind" fn() -> Output

impl<Output> WithAbiImpl<SysV64Unwind> for unsafe extern "sysv64-unwind" fn() -> Output

type F = unsafe extern "sysv64-unwind" fn() -> Output

impl<Output> WithAbiImpl<SysV64Unwind> for unsafe fn() -> Output

type F = unsafe extern "sysv64-unwind" fn() -> Output

impl<Output> WithAbiImpl<System> for extern "C" fn() -> Output

type F = extern "system" fn() -> Output

impl<Output> WithAbiImpl<System> for extern "C-unwind" fn() -> Output

type F = extern "system" fn() -> Output

impl<Output> WithAbiImpl<System> for extern "efiapi" fn() -> Output

type F = extern "system" fn() -> Output

impl<Output> WithAbiImpl<System> for extern "system" fn() -> Output

type F = extern "system" fn() -> Output

impl<Output> WithAbiImpl<System> for extern "system-unwind" fn() -> Output

type F = extern "system" fn() -> Output

impl<Output> WithAbiImpl<System> for extern "sysv64" fn() -> Output

type F = extern "system" fn() -> Output

impl<Output> WithAbiImpl<System> for extern "sysv64-unwind" fn() -> Output

type F = extern "system" fn() -> Output

impl<Output> WithAbiImpl<System> for fn() -> Output

type F = extern "system" fn() -> Output

impl<Output> WithAbiImpl<System> for unsafe extern "C" fn() -> Output

type F = unsafe extern "system" fn() -> Output

impl<Output> WithAbiImpl<System> for unsafe extern "C-unwind" fn() -> Output

type F = unsafe extern "system" fn() -> Output

impl<Output> WithAbiImpl<System> for unsafe extern "efiapi" fn() -> Output

type F = unsafe extern "system" fn() -> Output

impl<Output> WithAbiImpl<System> for unsafe extern "system" fn() -> Output

type F = unsafe extern "system" fn() -> Output

impl<Output> WithAbiImpl<System> for unsafe extern "system-unwind" fn() -> Output

type F = unsafe extern "system" fn() -> Output

impl<Output> WithAbiImpl<System> for unsafe extern "sysv64" fn() -> Output

type F = unsafe extern "system" fn() -> Output

impl<Output> WithAbiImpl<System> for unsafe extern "sysv64-unwind" fn() -> Output

type F = unsafe extern "system" fn() -> Output

impl<Output> WithAbiImpl<System> for unsafe fn() -> Output

type F = unsafe extern "system" fn() -> Output

impl<Output> WithAbiImpl<SystemUnwind> for extern "C" fn() -> Output

type F = extern "system-unwind" fn() -> Output

impl<Output> WithAbiImpl<SystemUnwind> for extern "C-unwind" fn() -> Output

type F = extern "system-unwind" fn() -> Output

impl<Output> WithAbiImpl<SystemUnwind> for extern "efiapi" fn() -> Output

type F = extern "system-unwind" fn() -> Output

impl<Output> WithAbiImpl<SystemUnwind> for extern "system" fn() -> Output

type F = extern "system-unwind" fn() -> Output

impl<Output> WithAbiImpl<SystemUnwind> for extern "system-unwind" fn() -> Output

type F = extern "system-unwind" fn() -> Output

impl<Output> WithAbiImpl<SystemUnwind> for extern "sysv64" fn() -> Output

type F = extern "system-unwind" fn() -> Output

impl<Output> WithAbiImpl<SystemUnwind> for extern "sysv64-unwind" fn() -> Output

type F = extern "system-unwind" fn() -> Output

impl<Output> WithAbiImpl<SystemUnwind> for fn() -> Output

type F = extern "system-unwind" fn() -> Output

impl<Output> WithAbiImpl<SystemUnwind> for unsafe extern "C" fn() -> Output

type F = unsafe extern "system-unwind" fn() -> Output

impl<Output> WithAbiImpl<SystemUnwind> for unsafe extern "C-unwind" fn() -> Output

type F = unsafe extern "system-unwind" fn() -> Output

impl<Output> WithAbiImpl<SystemUnwind> for unsafe extern "efiapi" fn() -> Output

type F = unsafe extern "system-unwind" fn() -> Output

impl<Output> WithAbiImpl<SystemUnwind> for unsafe extern "system" fn() -> Output

type F = unsafe extern "system-unwind" fn() -> Output

impl<Output> WithAbiImpl<SystemUnwind> for unsafe extern "system-unwind" fn() -> Output

type F = unsafe extern "system-unwind" fn() -> Output

impl<Output> WithAbiImpl<SystemUnwind> for unsafe extern "sysv64" fn() -> Output

type F = unsafe extern "system-unwind" fn() -> Output

impl<Output> WithAbiImpl<SystemUnwind> for unsafe extern "sysv64-unwind" fn() -> Output

type F = unsafe extern "system-unwind" fn() -> Output

impl<Output> WithAbiImpl<SystemUnwind> for unsafe fn() -> Output

type F = unsafe extern "system-unwind" fn() -> Output

Implementors