Classes
struct	_CONTEXT

struct	_KPCR

Macros
#define	PASSIVE_LEVEL 0

#define	LOW_LEVEL 0

#define	APC_LEVEL 1

#define	DISPATCH_LEVEL 2

#define	CLOCK_LEVEL 13

#define	IPI_LEVEL 14

#define	DRS_LEVEL 14

#define	POWER_LEVEL 14

#define	PROFILE_LEVEL 15

#define	HIGH_LEVEL 15

#define	KIP0PCRADDRESS 0xFFDFF000

#define	KI_USER_SHARED_DATA 0xFFFF9000

#define	SharedUserData ((KUSER_SHARED_DATA * const)KI_USER_SHARED_DATA)

#define	PAGE_SIZE 0x1000

#define	PAGE_SHIFT 12L

#define	MemoryBarrier() __dmb(_ARM_BARRIER_SY)

#define	PreFetchCacheLine(l, a) __prefetch((const void *) (a))

#define	PrefetchForWrite(p) __prefetch((const void *) (p))

#define	ReadForWriteAccess(p) (*(p))

#define	KeMemoryBarrierWithoutFence() _ReadWriteBarrier()

#define	KeLowerIrql(a) KfLowerIrql(a)

#define	KeRaiseIrql(a, b) *(b) = KfRaiseIrql(a)

#define	KeAcquireSpinLock(a, b) *(b) = KfAcquireSpinLock(a)

#define	KeReleaseSpinLock(a, b) KfReleaseSpinLock(a,b)

#define	KeAcquireSpinLockAtDpcLevel(SpinLock) KefAcquireSpinLockAtDpcLevel(SpinLock)

#define	KeReleaseSpinLockFromDpcLevel(SpinLock) KefReleaseSpinLockFromDpcLevel(SpinLock)

#define	DbgRaiseAssertionFailure() __emit(0xdefc)

#define	KeQueryTickCount(CurrentCount) _KeQueryTickCount(CurrentCount)

#define	CP15_PMSELR 15, 0, 9, 12, 5 /* Event Counter Selection Register */

#define	CP15_PMXEVCNTR 15, 0, 9, 13, 2 /* Event Count Register */

#define	CP15_TPIDRURW 15, 0, 13, 0, 2 /* Software Thread ID Register, UsRW */

#define	CP15_TPIDRURO 15, 0, 13, 0, 3 /* Software Thread ID Register, UsRO */

#define	CP15_TPIDRPRW 15, 0, 13, 0, 4 /* Software Thread ID Register, Kernel */

#define	PAUSE_PROCESSOR __yield();

#define	KERNEL_STACK_SIZE 0x3000

#define	KERNEL_LARGE_STACK_SIZE 0xF000

#define	KERNEL_LARGE_STACK_COMMIT KERNEL_STACK_SIZE

#define	KERNEL_MCA_EXCEPTION_STACK_SIZE 0x2000

#define	EXCEPTION_READ_FAULT 0

#define	EXCEPTION_WRITE_FAULT 1

#define	EXCEPTION_EXECUTE_FAULT 8

#define	CONTEXT_ARM 0x200000L

#define	CONTEXT_CONTROL (CONTEXT_ARM \| 0x00000001L)

#define	CONTEXT_INTEGER (CONTEXT_ARM \| 0x00000002L)

#define	CONTEXT_FLOATING_POINT (CONTEXT_ARM \| 0x00000004L)

#define	CONTEXT_DEBUG_REGISTERS (CONTEXT_ARM \| 0x00000008L)

#define	CONTEXT_FULL (CONTEXT_CONTROL \| CONTEXT_INTEGER \| CONTEXT_FLOATING_POINT)

#define	ARM_MAX_BREAKPOINTS 8

#define	ARM_MAX_WATCHPOINTS 1

#define	PCR_MINOR_VERSION 1

#define	PCR_MAJOR_VERSION 1

#define	CP15_PCR_RESERVED_MASK 0xFFF

Typedefs
typedef struct _CONTEXT	CONTEXT

typedef struct _KPCR	KPCR

typedef struct _KPCR *	PKPCR

Functions
	$if (_WDMDDK_) typedef struct _KFLOATING_SAVE

FORCEINLINE VOID	YieldProcessor (VOID)

FORCEINLINE VOID	KeMemoryBarrier (VOID)

	_IRQL_requires_max_ (HIGH_LEVEL) _IRQL_saves_ NTHALAPI KIRQL NTAPI KeGetCurrentIrql(VOID)

	_IRQL_requires_max_ (DISPATCH_LEVEL) _IRQL_saves_ _IRQL_raises_(DISPATCH_LEVEL) NTHALAPI KIRQL NTAPI KeRaiseIrqlToDpcLevel(VOID)

NTHALAPI KIRQL NTAPI	KeRaiseIrqlToSynchLevel (VOID)

_Requires_lock_held_ SpinLock _Releases_lock_ SpinLock	_IRQL_requires_ (DISPATCH_LEVEL) NTHALAPI VOID FASTCALL KfReleaseSpinLock(_Inout_ PKSPIN_LOCK SpinLock

_Requires_lock_not_held_ SpinLock _Acquires_lock_ SpinLock	_IRQL_requires_min_ (DISPATCH_LEVEL) NTKERNELAPI VOID FASTCALL KefAcquireSpinLockAtDpcLevel(_Inout_ PKSPIN_LOCK SpinLock)

NTSYSAPI PKTHREAD NTAPI	KeGetCurrentThread (VOID)

	_Always_ (_Post_satisfies_(return<=0)) _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) _Kernel_float_saved_ _At_(*FloatSave

	_Kernel_requires_resource_not_held_ (FloatState) _Kernel_acquires_resource_(FloatState)) FORCEINLINE NTSTATUS KeSaveFloatingPointState(_Out_ PKFLOATING_SAVE FloatSave)

	_Success_ (1) _Kernel_float_restored_ _At_(*FloatSave

	_Kernel_requires_resource_held_ (FloatState) _Kernel_releases_resource_(FloatState)) FORCEINLINE NTSTATUS KeRestoreFloatingPointState(_In_ PKFLOATING_SAVE FloatSave)

VOID	KeFlushIoBuffers (_In_ PMDL Mdl, _In_ BOOLEAN ReadOperation, _In_ BOOLEAN DmaOperation)

FORCEINLINE VOID	_KeQueryTickCount (OUT PLARGE_INTEGER CurrentCount)

	$endif (_WDMDDK_) $if(_NTDDK_) typedef struct _NEON128 == *HashTable

FORCEINLINE PKPCR	KeGetPcr (VOID)

FORCEINLINE ULONG	KeGetCurrentProcessorNumber (VOID)

Variables
	KFLOATING_SAVE

*	PKFLOATING_SAVE

NTKERNELAPI volatile KSYSTEM_TIME	KeTickCount

_Requires_lock_held_ SpinLock _Releases_lock_ SpinLock _In_ _IRQL_restores_ KIRQL	NewIrql

	NEON128

*	PNEON128

Macro Definition Documentation

◆ APC_LEVEL

#define APC_LEVEL 1

◆ ARM_MAX_BREAKPOINTS

#define ARM_MAX_BREAKPOINTS 8

Definition at line 231 of file ke.h.

◆ ARM_MAX_WATCHPOINTS

#define ARM_MAX_WATCHPOINTS 1

Definition at line 232 of file ke.h.

◆ CLOCK_LEVEL

#define CLOCK_LEVEL 13

◆ CONTEXT_ARM

#define CONTEXT_ARM 0x200000L

◆ CONTEXT_CONTROL

#define CONTEXT_CONTROL (CONTEXT_ARM | 0x00000001L)

◆ CONTEXT_DEBUG_REGISTERS

#define CONTEXT_DEBUG_REGISTERS (CONTEXT_ARM | 0x00000008L)

◆ CONTEXT_FLOATING_POINT

#define CONTEXT_FLOATING_POINT (CONTEXT_ARM | 0x00000004L)

◆ CONTEXT_FULL

#define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT)

◆ CONTEXT_INTEGER

#define CONTEXT_INTEGER (CONTEXT_ARM | 0x00000002L)

◆ CP15_PCR_RESERVED_MASK

#define CP15_PCR_RESERVED_MASK 0xFFF

Definition at line 336 of file ke.h.

◆ CP15_PMSELR

#define CP15_PMSELR 15, 0, 9, 12, 5 /* Event Counter Selection Register */

Definition at line 196 of file ke.h.

◆ CP15_PMXEVCNTR

#define CP15_PMXEVCNTR 15, 0, 9, 13, 2 /* Event Count Register */

Definition at line 197 of file ke.h.

◆ CP15_TPIDRPRW

#define CP15_TPIDRPRW 15, 0, 13, 0, 4 /* Software Thread ID Register, Kernel */

Definition at line 200 of file ke.h.

◆ CP15_TPIDRURO

#define CP15_TPIDRURO 15, 0, 13, 0, 3 /* Software Thread ID Register, UsRO */

Definition at line 199 of file ke.h.

◆ CP15_TPIDRURW

#define CP15_TPIDRURW 15, 0, 13, 0, 2 /* Software Thread ID Register, UsRW */

Definition at line 198 of file ke.h.

◆ DbgRaiseAssertionFailure

#define DbgRaiseAssertionFailure ( ) __emit(0xdefc)

Definition at line 174 of file ke.h.

◆ DISPATCH_LEVEL

#define DISPATCH_LEVEL 2

◆ DRS_LEVEL

#define DRS_LEVEL 14

◆ EXCEPTION_EXECUTE_FAULT

#define EXCEPTION_EXECUTE_FAULT 8

◆ EXCEPTION_READ_FAULT

#define EXCEPTION_READ_FAULT 0

◆ EXCEPTION_WRITE_FAULT

#define EXCEPTION_WRITE_FAULT 1

◆ HIGH_LEVEL

#define HIGH_LEVEL 15

◆ IPI_LEVEL

#define IPI_LEVEL 14

◆ KeAcquireSpinLock

#define KeAcquireSpinLock	(	a,
		b
	)	*(b) = KfAcquireSpinLock(a)

Definition at line 104 of file ke.h.

◆ KeAcquireSpinLockAtDpcLevel

#define KeAcquireSpinLockAtDpcLevel ( SpinLock ) KefAcquireSpinLockAtDpcLevel(SpinLock)

Definition at line 125 of file ke.h.

◆ KeLowerIrql

#define KeLowerIrql ( a ) KfLowerIrql(a)

Definition at line 69 of file ke.h.

◆ KeMemoryBarrierWithoutFence

#define KeMemoryBarrierWithoutFence ( ) _ReadWriteBarrier()

Definition at line 53 of file ke.h.

◆ KeQueryTickCount

#define KeQueryTickCount ( CurrentCount ) _KeQueryTickCount(CurrentCount)

Definition at line 194 of file ke.h.

◆ KeRaiseIrql

#define KeRaiseIrql	(	a,
		b
	)	*(b) = KfRaiseIrql(a)

Definition at line 79 of file ke.h.

◆ KeReleaseSpinLock

#define KeReleaseSpinLock	(	a,
		b
	)	KfReleaseSpinLock(a,b)

Definition at line 115 of file ke.h.

◆ KeReleaseSpinLockFromDpcLevel

#define KeReleaseSpinLockFromDpcLevel ( SpinLock ) KefReleaseSpinLockFromDpcLevel(SpinLock)

Definition at line 135 of file ke.h.

◆ KERNEL_LARGE_STACK_COMMIT

#define KERNEL_LARGE_STACK_COMMIT KERNEL_STACK_SIZE

◆ KERNEL_LARGE_STACK_SIZE

#define KERNEL_LARGE_STACK_SIZE 0xF000

◆ KERNEL_MCA_EXCEPTION_STACK_SIZE

#define KERNEL_MCA_EXCEPTION_STACK_SIZE 0x2000

◆ KERNEL_STACK_SIZE

#define KERNEL_STACK_SIZE 0x3000

◆ KI_USER_SHARED_DATA

#define KI_USER_SHARED_DATA 0xFFFF9000

◆ KIP0PCRADDRESS

#define KIP0PCRADDRESS 0xFFDFF000

◆ LOW_LEVEL

#define LOW_LEVEL 0

◆ MemoryBarrier

#define MemoryBarrier ( ) __dmb(_ARM_BARRIER_SY)

Definition at line 39 of file ke.h.

◆ PAGE_SHIFT

#define PAGE_SHIFT 12L

◆ PAGE_SIZE

#define PAGE_SIZE 0x1000

◆ PASSIVE_LEVEL

#define PASSIVE_LEVEL 0

◆ PAUSE_PROCESSOR

#define PAUSE_PROCESSOR __yield();

◆ PCR_MAJOR_VERSION

#define PCR_MAJOR_VERSION 1

Definition at line 294 of file ke.h.

◆ PCR_MINOR_VERSION

#define PCR_MINOR_VERSION 1

Definition at line 293 of file ke.h.

◆ POWER_LEVEL

#define POWER_LEVEL 14

◆ PreFetchCacheLine

#define PreFetchCacheLine	(	l,
		a
	)	__prefetch((const void *) (a))

Definition at line 40 of file ke.h.

◆ PrefetchForWrite

#define PrefetchForWrite ( p ) __prefetch((const void *) (p))

Definition at line 41 of file ke.h.

◆ PROFILE_LEVEL

#define PROFILE_LEVEL 15

◆ ReadForWriteAccess

#define ReadForWriteAccess ( p ) (*(p))

Definition at line 42 of file ke.h.

◆ SharedUserData

#define SharedUserData ((KUSER_SHARED_DATA * const)KI_USER_SHARED_DATA)

Typedef Documentation

◆ CONTEXT

typedef struct _CONTEXT CONTEXT

◆ KPCR

typedef struct _KPCR KPCR

◆ PKPCR

typedef struct _KPCR * PKPCR

Function Documentation

◆ $endif()

$endif ( _WDMDDK_ ) == *HashTable

Definition at line 202 of file ke.h.

{
    ULONGLONG Low;
    LONGLONG High;
} NEON128, *PNEON128;

◆ $if()

$if ( _WDMDDK_ )

Kernel definitions for ARM

Definition at line 1 of file ke.h.

{
    ULONG Reserved;
} KFLOATING_SAVE, *PKFLOATING_SAVE;

◆ _Always_()

_Always_ ( _Post_satisfies_(return<=0) )

◆ _IRQL_requires_()

_Requires_lock_held_ SpinLock _Releases_lock_ SpinLock _IRQL_requires_ ( DISPATCH_LEVEL )

Definition at line 394 of file expool.c.

{
    SIZE_T OldSize = PoolBigPageTableSize;
    SIZE_T NewSize, NewSizeInBytes;
    PPOOL_TRACKER_BIG_PAGES NewTable;
    PPOOL_TRACKER_BIG_PAGES OldTable;
    ULONG i;
    ULONG PagesFreed;
    ULONG Hash;
    ULONG HashMask;
 
    /* Must be holding ExpLargePoolTableLock */
    ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
 
    /* Make sure we don't overflow */
    if (Shrink)
    {
        NewSize = OldSize / 2;
 
        /* Make sure we don't shrink too much. */
        ASSERT(NewSize >= ExpPoolBigEntriesInUse);
 
        NewSize = ALIGN_UP_BY(NewSize, PAGE_SIZE / sizeof(POOL_TRACKER_BIG_PAGES));
        ASSERT(NewSize <= OldSize);
 
        /* If there is only one page left, then keep it around. Not a failure either. */
        if (NewSize == OldSize)
        {
            ASSERT(NewSize == (PAGE_SIZE / sizeof(POOL_TRACKER_BIG_PAGES)));
            KeReleaseSpinLock(&ExpLargePoolTableLock, OldIrql);
            return TRUE;
        }
    }
    else
    {
        if (!NT_SUCCESS(RtlSIZETMult(2, OldSize, &NewSize)))
        {
            DPRINT1("Overflow expanding big page table. Size=%lu\n", OldSize);
            KeReleaseSpinLock(&ExpLargePoolTableLock, OldIrql);
            return FALSE;
        }
 
        /* Make sure we don't stupidly waste pages */
        NewSize = ALIGN_DOWN_BY(NewSize, PAGE_SIZE / sizeof(POOL_TRACKER_BIG_PAGES));
        ASSERT(NewSize > OldSize);
    }
 
    if (!NT_SUCCESS(RtlSIZETMult(sizeof(POOL_TRACKER_BIG_PAGES), NewSize, &NewSizeInBytes)))
    {
        DPRINT1("Overflow while calculating big page table size. Size=%lu\n", OldSize);
        KeReleaseSpinLock(&ExpLargePoolTableLock, OldIrql);
        return FALSE;
    }
 
    NewTable = MiAllocatePoolPages(NonPagedPool, NewSizeInBytes);
    if (NewTable == NULL)
    {
        DPRINT("Could not allocate %lu bytes for new big page table\n", NewSizeInBytes);
        KeReleaseSpinLock(&ExpLargePoolTableLock, OldIrql);
        return FALSE;
    }
 
    DPRINT("%s big pool tracker table to %lu entries\n", Shrink ? "Shrinking" : "Expanding", NewSize);
 
    /* Initialize the new table */
    RtlZeroMemory(NewTable, NewSizeInBytes);
    for (i = 0; i < NewSize; i++)
    {
        NewTable[i].Va = (PVOID)POOL_BIG_TABLE_ENTRY_FREE;
    }
 
    /* Copy over all items */
    OldTable = PoolBigPageTable;
    HashMask = NewSize - 1;
    for (i = 0; i < OldSize; i++)
    {
        /* Skip over empty items */
        if ((ULONG_PTR)OldTable[i].Va & POOL_BIG_TABLE_ENTRY_FREE)
        {
            continue;
        }
 
        /* Recalculate the hash due to the new table size */
        Hash = ExpComputePartialHashForAddress(OldTable[i].Va) % HashMask;
 
        /* Find the location in the new table */
        while (!((ULONG_PTR)NewTable[Hash].Va & POOL_BIG_TABLE_ENTRY_FREE))
        {
            if (++Hash == NewSize)
                Hash = 0;
        }
 
        /* We must have space */
        ASSERT((ULONG_PTR)NewTable[Hash].Va & POOL_BIG_TABLE_ENTRY_FREE);
 
        /* Finally, copy the item */
        NewTable[Hash] = OldTable[i];
    }
 
    /* Activate the new table */
    PoolBigPageTable = NewTable;
    PoolBigPageTableSize = NewSize;
    PoolBigPageTableHash = PoolBigPageTableSize - 1;
 
    /* Release the lock, we're done changing global state */
    KeReleaseSpinLock(&ExpLargePoolTableLock, OldIrql);
 
    /* Free the old table and update our tracker */
    PagesFreed = MiFreePoolPages(OldTable);
    ExpRemovePoolTracker('looP', PagesFreed << PAGE_SHIFT, 0);
    ExpInsertPoolTracker('looP', ALIGN_UP_BY(NewSizeInBytes, PAGE_SIZE), 0);
 
    return TRUE;
}

◆ _IRQL_requires_max_() [1/2]

_IRQL_requires_max_ ( DISPATCH_LEVEL )

Definition at line 1705 of file hardware.c.

{
    SendKey();
    Wake(LogicalDevice->CSN);
}

◆ _IRQL_requires_max_() [2/2]

_IRQL_requires_max_ ( HIGH_LEVEL )

Definition at line 134 of file wdfdpc.h.

{
    return ((PFN_WDFDPCENQUEUE) WdfFunctions[WdfDpcEnqueueTableIndex])(WdfDriverGlobals, Dpc);
}

◆ _IRQL_requires_min_()

_Requires_lock_not_held_ SpinLock _Acquires_lock_ SpinLock _IRQL_requires_min_ ( DISPATCH_LEVEL )

Definition at line 1015 of file mm.h.

{
    PKSPIN_LOCK_QUEUE LockQueue;
 
    ASSERT(KeGetCurrentIrql() >= DISPATCH_LEVEL);
    LockQueue = &KeGetCurrentPrcb()->LockQueue[LockQueuePfnLock];
    KeAcquireQueuedSpinLockAtDpcLevel(LockQueue);
}

◆ _KeQueryTickCount()

FORCEINLINE VOID _KeQueryTickCount ( OUT PLARGE_INTEGER CurrentCount )

Definition at line 178 of file ke.h.

{
  for (;;) {
#ifdef NONAMELESSUNION
    CurrentCount->s.HighPart = KeTickCount.High1Time;
    CurrentCount->s.LowPart = KeTickCount.LowPart;
    if (CurrentCount->s.HighPart == KeTickCount.High2Time) break;
#else
    CurrentCount->HighPart = KeTickCount.High1Time;
    CurrentCount->LowPart = KeTickCount.LowPart;
    if (CurrentCount->HighPart == KeTickCount.High2Time) break;
#endif
    YieldProcessor();
  }
}

◆ _Kernel_requires_resource_held_()

_Kernel_requires_resource_held_ ( FloatState )

Definition at line 158 of file ke.h.

{
    UNREFERENCED_PARAMETER(FloatSave);
    return STATUS_SUCCESS;
}

◆ _Kernel_requires_resource_not_held_()

_Kernel_requires_resource_not_held_ ( FloatState )

Definition at line 146 of file ke.h.

{
    UNREFERENCED_PARAMETER(FloatSave);
    return STATUS_SUCCESS;
}

◆ _Success_()

_Success_ ( 1 )

◆ KeFlushIoBuffers()

VOID KeFlushIoBuffers	(	_In_ PMDL	Mdl,
		_In_ BOOLEAN	ReadOperation,
		_In_ BOOLEAN	DmaOperation
	)

Definition at line 191 of file cpu.c.

{
    DbgBreakPoint();
}

◆ KeGetCurrentProcessorNumber()

FORCEINLINE ULONG KeGetCurrentProcessorNumber ( VOID )

Definition at line 350 of file ke.h.

{
    return *((PUCHAR)KeGetPcr() + 0x580);
}

◆ KeGetCurrentThread()

NTSYSAPI PKTHREAD NTAPI KeGetCurrentThread ( VOID )

Definition at line 355 of file ke.h.

{
    /* Return the current thread */
    return ((PKIPCR)KeGetPcr())->PrcbData.CurrentThread;
}

◆ KeGetPcr()

FORCEINLINE PKPCR KeGetPcr ( VOID )

Definition at line 341 of file ke.h.

{
    return (PKPCR)(_MoveFromCoprocessor(CP15_TPIDRPRW) & ~CP15_PCR_RESERVED_MASK);
}

◆ KeMemoryBarrier()

FORCEINLINE VOID KeMemoryBarrier ( VOID )

Definition at line 46 of file ke.h.

{
    _ReadWriteBarrier();
    MemoryBarrier();
}

◆ KeRaiseIrqlToSynchLevel()

NTHALAPI KIRQL NTAPI KeRaiseIrqlToSynchLevel ( VOID )

Definition at line 156 of file pic.c.

{
    PKPCR Pcr = KeGetPcr();
    KIRQL CurrentIrql;
 
    /* Save and update IRQL */
    CurrentIrql = Pcr->Irql;
    Pcr->Irql = SYNCH_LEVEL;
 
#ifdef IRQL_DEBUG
    /* Validate correct raise */
    if (CurrentIrql > SYNCH_LEVEL)
    {
        /* Crash system */
        KeBugCheckEx(IRQL_NOT_GREATER_OR_EQUAL,
                     CurrentIrql,
                     SYNCH_LEVEL,
                     0,
                     1);
    }
#endif
 
    /* Return the previous value */
    return CurrentIrql;
}

◆ YieldProcessor()

FORCEINLINE VOID YieldProcessor ( VOID )

Definition at line 32 of file ke.h.

{
    __dmb(_ARM_BARRIER_ISHST);
    __yield();
}

Variable Documentation

◆ KeTickCount

NTKERNELAPI volatile KSYSTEM_TIME KeTickCount

extern

Definition at line 19 of file clock.c.

◆ KFLOATING_SAVE

KFLOATING_SAVE

Definition at line 26 of file ke.h.

◆ NEON128

NEON128

Definition at line 229 of file ke.h.

◆ NewIrql

_Requires_lock_held_ SpinLock _Releases_lock_ SpinLock _In_ _IRQL_restores_ KIRQL NewIrql

Definition at line 114 of file ke.h.

Referenced by __drv_maxIRQL(), _Releases_lock_(), HalpLowerIrql(), KeLowerIrql(), KeRaiseIrql(), KeReleaseSpinLock(), KeSetCurrentIrql(), KfLowerIrql(), KfRaiseIrql(), KmtSetIrql(), KxLowerIrql(), KxRaiseIrql(), and VideoPortReleaseSpinLock().

◆ PKFLOATING_SAVE

* PKFLOATING_SAVE