clretwallmain.h

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

/******************************************************************

DO NOT MODIFY. AUTOGENERATED FILE.
This file is generated using the logic from <root>/src/scripts/genEventing.py

******************************************************************/

#include "clrxplatevents.h"
#include "clreventpipewriteevents.h"

inline BOOL EventEnabledGCStart() {return EventPipeEventEnabledGCStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCStart());}

inline ULONG FireEtwGCStart(
    const unsigned int  Count,
    const unsigned int  Reason
)
{
    ULONG status = EventPipeWriteEventGCStart(Count,Reason);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCStart(Count,Reason);
    }
    return status;
}

inline BOOL EventEnabledGCStart_V1() {return EventPipeEventEnabledGCStart_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCStart_V1());}

inline ULONG FireEtwGCStart_V1(
    const unsigned int  Count,
    const unsigned int  Depth,
    const unsigned int  Reason,
    const unsigned int  Type,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCStart_V1(Count,Depth,Reason,Type,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCStart_V1(Count,Depth,Reason,Type,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCStart_V2() {return EventPipeEventEnabledGCStart_V2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCStart_V2());}

inline ULONG FireEtwGCStart_V2(
    const unsigned int  Count,
    const unsigned int  Depth,
    const unsigned int  Reason,
    const unsigned int  Type,
    const unsigned short  ClrInstanceID,
    const unsigned __int64  ClientSequenceNumber
)
{
    ULONG status = EventPipeWriteEventGCStart_V2(Count,Depth,Reason,Type,ClrInstanceID,ClientSequenceNumber);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCStart_V2(Count,Depth,Reason,Type,ClrInstanceID,ClientSequenceNumber);
    }
    return status;
}

inline BOOL EventEnabledGCEnd() {return EventPipeEventEnabledGCEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCEnd());}

inline ULONG FireEtwGCEnd(
    const unsigned int  Count,
    const unsigned short  Depth
)
{
    ULONG status = EventPipeWriteEventGCEnd(Count,Depth);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCEnd(Count,Depth);
    }
    return status;
}

inline BOOL EventEnabledGCEnd_V1() {return EventPipeEventEnabledGCEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCEnd_V1());}

inline ULONG FireEtwGCEnd_V1(
    const unsigned int  Count,
    const unsigned int  Depth,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCEnd_V1(Count,Depth,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCEnd_V1(Count,Depth,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCRestartEEEnd() {return EventPipeEventEnabledGCRestartEEEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCRestartEEEnd());}

inline ULONG FireEtwGCRestartEEEnd(

)
{
    ULONG status = EventPipeWriteEventGCRestartEEEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCRestartEEEnd();
    }
    return status;
}

inline BOOL EventEnabledGCRestartEEEnd_V1() {return EventPipeEventEnabledGCRestartEEEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCRestartEEEnd_V1());}

inline ULONG FireEtwGCRestartEEEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCRestartEEEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCRestartEEEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCHeapStats() {return EventPipeEventEnabledGCHeapStats() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCHeapStats());}

inline ULONG FireEtwGCHeapStats(
    const unsigned __int64  GenerationSize0,
    const unsigned __int64  TotalPromotedSize0,
    const unsigned __int64  GenerationSize1,
    const unsigned __int64  TotalPromotedSize1,
    const unsigned __int64  GenerationSize2,
    const unsigned __int64  TotalPromotedSize2,
    const unsigned __int64  GenerationSize3,
    const unsigned __int64  TotalPromotedSize3,
    const unsigned __int64  FinalizationPromotedSize,
    const unsigned __int64  FinalizationPromotedCount,
    const unsigned int  PinnedObjectCount,
    const unsigned int  SinkBlockCount,
    const unsigned int  GCHandleCount
)
{
    ULONG status = EventPipeWriteEventGCHeapStats(GenerationSize0,TotalPromotedSize0,GenerationSize1,TotalPromotedSize1,GenerationSize2,TotalPromotedSize2,GenerationSize3,TotalPromotedSize3,FinalizationPromotedSize,FinalizationPromotedCount,PinnedObjectCount,SinkBlockCount,GCHandleCount);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCHeapStats(GenerationSize0,TotalPromotedSize0,GenerationSize1,TotalPromotedSize1,GenerationSize2,TotalPromotedSize2,GenerationSize3,TotalPromotedSize3,FinalizationPromotedSize,FinalizationPromotedCount,PinnedObjectCount,SinkBlockCount,GCHandleCount);
    }
    return status;
}

inline BOOL EventEnabledGCHeapStats_V1() {return EventPipeEventEnabledGCHeapStats_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCHeapStats_V1());}

inline ULONG FireEtwGCHeapStats_V1(
    const unsigned __int64  GenerationSize0,
    const unsigned __int64  TotalPromotedSize0,
    const unsigned __int64  GenerationSize1,
    const unsigned __int64  TotalPromotedSize1,
    const unsigned __int64  GenerationSize2,
    const unsigned __int64  TotalPromotedSize2,
    const unsigned __int64  GenerationSize3,
    const unsigned __int64  TotalPromotedSize3,
    const unsigned __int64  FinalizationPromotedSize,
    const unsigned __int64  FinalizationPromotedCount,
    const unsigned int  PinnedObjectCount,
    const unsigned int  SinkBlockCount,
    const unsigned int  GCHandleCount,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCHeapStats_V1(GenerationSize0,TotalPromotedSize0,GenerationSize1,TotalPromotedSize1,GenerationSize2,TotalPromotedSize2,GenerationSize3,TotalPromotedSize3,FinalizationPromotedSize,FinalizationPromotedCount,PinnedObjectCount,SinkBlockCount,GCHandleCount,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCHeapStats_V1(GenerationSize0,TotalPromotedSize0,GenerationSize1,TotalPromotedSize1,GenerationSize2,TotalPromotedSize2,GenerationSize3,TotalPromotedSize3,FinalizationPromotedSize,FinalizationPromotedCount,PinnedObjectCount,SinkBlockCount,GCHandleCount,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCCreateSegment() {return EventPipeEventEnabledGCCreateSegment() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCCreateSegment());}

inline ULONG FireEtwGCCreateSegment(
    const unsigned __int64  Address,
    const unsigned __int64  Size,
    const unsigned int  Type
)
{
    ULONG status = EventPipeWriteEventGCCreateSegment(Address,Size,Type);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCCreateSegment(Address,Size,Type);
    }
    return status;
}

inline BOOL EventEnabledGCCreateSegment_V1() {return EventPipeEventEnabledGCCreateSegment_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCCreateSegment_V1());}

inline ULONG FireEtwGCCreateSegment_V1(
    const unsigned __int64  Address,
    const unsigned __int64  Size,
    const unsigned int  Type,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCCreateSegment_V1(Address,Size,Type,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCCreateSegment_V1(Address,Size,Type,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCFreeSegment() {return EventPipeEventEnabledGCFreeSegment() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCFreeSegment());}

inline ULONG FireEtwGCFreeSegment(
    const unsigned __int64  Address
)
{
    ULONG status = EventPipeWriteEventGCFreeSegment(Address);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCFreeSegment(Address);
    }
    return status;
}

inline BOOL EventEnabledGCFreeSegment_V1() {return EventPipeEventEnabledGCFreeSegment_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCFreeSegment_V1());}

inline ULONG FireEtwGCFreeSegment_V1(
    const unsigned __int64  Address,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCFreeSegment_V1(Address,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCFreeSegment_V1(Address,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCRestartEEBegin() {return EventPipeEventEnabledGCRestartEEBegin() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCRestartEEBegin());}

inline ULONG FireEtwGCRestartEEBegin(

)
{
    ULONG status = EventPipeWriteEventGCRestartEEBegin();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCRestartEEBegin();
    }
    return status;
}

inline BOOL EventEnabledGCRestartEEBegin_V1() {return EventPipeEventEnabledGCRestartEEBegin_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCRestartEEBegin_V1());}

inline ULONG FireEtwGCRestartEEBegin_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCRestartEEBegin_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCRestartEEBegin_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCSuspendEEEnd() {return EventPipeEventEnabledGCSuspendEEEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCSuspendEEEnd());}

inline ULONG FireEtwGCSuspendEEEnd(

)
{
    ULONG status = EventPipeWriteEventGCSuspendEEEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCSuspendEEEnd();
    }
    return status;
}

inline BOOL EventEnabledGCSuspendEEEnd_V1() {return EventPipeEventEnabledGCSuspendEEEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCSuspendEEEnd_V1());}

inline ULONG FireEtwGCSuspendEEEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCSuspendEEEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCSuspendEEEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCSuspendEEBegin() {return EventPipeEventEnabledGCSuspendEEBegin() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCSuspendEEBegin());}

inline ULONG FireEtwGCSuspendEEBegin(
    const unsigned short  Reason
)
{
    ULONG status = EventPipeWriteEventGCSuspendEEBegin(Reason);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCSuspendEEBegin(Reason);
    }
    return status;
}

inline BOOL EventEnabledGCSuspendEEBegin_V1() {return EventPipeEventEnabledGCSuspendEEBegin_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCSuspendEEBegin_V1());}

inline ULONG FireEtwGCSuspendEEBegin_V1(
    const unsigned int  Reason,
    const unsigned int  Count,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCSuspendEEBegin_V1(Reason,Count,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCSuspendEEBegin_V1(Reason,Count,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCAllocationTick() {return EventPipeEventEnabledGCAllocationTick() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCAllocationTick());}

inline ULONG FireEtwGCAllocationTick(
    const unsigned int  AllocationAmount,
    const unsigned int  AllocationKind
)
{
    ULONG status = EventPipeWriteEventGCAllocationTick(AllocationAmount,AllocationKind);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCAllocationTick(AllocationAmount,AllocationKind);
    }
    return status;
}

inline BOOL EventEnabledGCAllocationTick_V1() {return EventPipeEventEnabledGCAllocationTick_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCAllocationTick_V1());}

inline ULONG FireEtwGCAllocationTick_V1(
    const unsigned int  AllocationAmount,
    const unsigned int  AllocationKind,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCAllocationTick_V1(AllocationAmount,AllocationKind,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCAllocationTick_V1(AllocationAmount,AllocationKind,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCAllocationTick_V2() {return EventPipeEventEnabledGCAllocationTick_V2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCAllocationTick_V2());}

inline ULONG FireEtwGCAllocationTick_V2(
    const unsigned int  AllocationAmount,
    const unsigned int  AllocationKind,
    const unsigned short  ClrInstanceID,
    const unsigned __int64  AllocationAmount64,
    const void*  TypeID,
    PCWSTR  TypeName,
    const unsigned int  HeapIndex
)
{
    ULONG status = EventPipeWriteEventGCAllocationTick_V2(AllocationAmount,AllocationKind,ClrInstanceID,AllocationAmount64,TypeID,TypeName,HeapIndex);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCAllocationTick_V2(AllocationAmount,AllocationKind,ClrInstanceID,AllocationAmount64,TypeID,TypeName,HeapIndex);
    }
    return status;
}

inline BOOL EventEnabledGCAllocationTick_V3() {return EventPipeEventEnabledGCAllocationTick_V3() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCAllocationTick_V3());}

inline ULONG FireEtwGCAllocationTick_V3(
    const unsigned int  AllocationAmount,
    const unsigned int  AllocationKind,
    const unsigned short  ClrInstanceID,
    const unsigned __int64  AllocationAmount64,
    const void*  TypeID,
    PCWSTR  TypeName,
    const unsigned int  HeapIndex,
    const void*  Address
)
{
    ULONG status = EventPipeWriteEventGCAllocationTick_V3(AllocationAmount,AllocationKind,ClrInstanceID,AllocationAmount64,TypeID,TypeName,HeapIndex,Address);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCAllocationTick_V3(AllocationAmount,AllocationKind,ClrInstanceID,AllocationAmount64,TypeID,TypeName,HeapIndex,Address);
    }
    return status;
}

inline BOOL EventEnabledGCCreateConcurrentThread() {return EventPipeEventEnabledGCCreateConcurrentThread() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCCreateConcurrentThread());}

inline ULONG FireEtwGCCreateConcurrentThread(

)
{
    ULONG status = EventPipeWriteEventGCCreateConcurrentThread();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCCreateConcurrentThread();
    }
    return status;
}

inline BOOL EventEnabledGCCreateConcurrentThread_V1() {return EventPipeEventEnabledGCCreateConcurrentThread_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCCreateConcurrentThread_V1());}

inline ULONG FireEtwGCCreateConcurrentThread_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCCreateConcurrentThread_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCCreateConcurrentThread_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCTerminateConcurrentThread() {return EventPipeEventEnabledGCTerminateConcurrentThread() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCTerminateConcurrentThread());}

inline ULONG FireEtwGCTerminateConcurrentThread(

)
{
    ULONG status = EventPipeWriteEventGCTerminateConcurrentThread();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCTerminateConcurrentThread();
    }
    return status;
}

inline BOOL EventEnabledGCTerminateConcurrentThread_V1() {return EventPipeEventEnabledGCTerminateConcurrentThread_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCTerminateConcurrentThread_V1());}

inline ULONG FireEtwGCTerminateConcurrentThread_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCTerminateConcurrentThread_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCTerminateConcurrentThread_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCFinalizersEnd() {return EventPipeEventEnabledGCFinalizersEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCFinalizersEnd());}

inline ULONG FireEtwGCFinalizersEnd(
    const unsigned int  Count
)
{
    ULONG status = EventPipeWriteEventGCFinalizersEnd(Count);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCFinalizersEnd(Count);
    }
    return status;
}

inline BOOL EventEnabledGCFinalizersEnd_V1() {return EventPipeEventEnabledGCFinalizersEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCFinalizersEnd_V1());}

inline ULONG FireEtwGCFinalizersEnd_V1(
    const unsigned int  Count,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCFinalizersEnd_V1(Count,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCFinalizersEnd_V1(Count,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCFinalizersBegin() {return EventPipeEventEnabledGCFinalizersBegin() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCFinalizersBegin());}

inline ULONG FireEtwGCFinalizersBegin(

)
{
    ULONG status = EventPipeWriteEventGCFinalizersBegin();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCFinalizersBegin();
    }
    return status;
}

inline BOOL EventEnabledGCFinalizersBegin_V1() {return EventPipeEventEnabledGCFinalizersBegin_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCFinalizersBegin_V1());}

inline ULONG FireEtwGCFinalizersBegin_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCFinalizersBegin_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCFinalizersBegin_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBulkType() {return EventPipeEventEnabledBulkType() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBulkType());}

inline ULONG FireEtwBulkType(
    const unsigned int  Count,
    const unsigned short  ClrInstanceID,
    int Values_ElementSize,
    const void* Values
)
{
    ULONG status = EventPipeWriteEventBulkType(Count,ClrInstanceID,Values_ElementSize, Values);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBulkType(Count,ClrInstanceID,Values_ElementSize, Values);
    }
    return status;
}

inline BOOL EventEnabledGCBulkRootEdge() {return EventPipeEventEnabledGCBulkRootEdge() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCBulkRootEdge());}

inline ULONG FireEtwGCBulkRootEdge(
    const unsigned int  Index,
    const unsigned int  Count,
    const unsigned short  ClrInstanceID,
    int Values_ElementSize,
    const void* Values
)
{
    ULONG status = EventPipeWriteEventGCBulkRootEdge(Index,Count,ClrInstanceID,Values_ElementSize, Values);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCBulkRootEdge(Index,Count,ClrInstanceID,Values_ElementSize, Values);
    }
    return status;
}

inline BOOL EventEnabledGCBulkRootConditionalWeakTableElementEdge() {return EventPipeEventEnabledGCBulkRootConditionalWeakTableElementEdge() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCBulkRootConditionalWeakTableElementEdge());}

inline ULONG FireEtwGCBulkRootConditionalWeakTableElementEdge(
    const unsigned int  Index,
    const unsigned int  Count,
    const unsigned short  ClrInstanceID,
    int Values_ElementSize,
    const void* Values
)
{
    ULONG status = EventPipeWriteEventGCBulkRootConditionalWeakTableElementEdge(Index,Count,ClrInstanceID,Values_ElementSize, Values);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCBulkRootConditionalWeakTableElementEdge(Index,Count,ClrInstanceID,Values_ElementSize, Values);
    }
    return status;
}

inline BOOL EventEnabledGCBulkNode() {return EventPipeEventEnabledGCBulkNode() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCBulkNode());}

inline ULONG FireEtwGCBulkNode(
    const unsigned int  Index,
    const unsigned int  Count,
    const unsigned short  ClrInstanceID,
    int Values_ElementSize,
    const void* Values
)
{
    ULONG status = EventPipeWriteEventGCBulkNode(Index,Count,ClrInstanceID,Values_ElementSize, Values);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCBulkNode(Index,Count,ClrInstanceID,Values_ElementSize, Values);
    }
    return status;
}

inline BOOL EventEnabledGCBulkEdge() {return EventPipeEventEnabledGCBulkEdge() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCBulkEdge());}

inline ULONG FireEtwGCBulkEdge(
    const unsigned int  Index,
    const unsigned int  Count,
    const unsigned short  ClrInstanceID,
    int Values_ElementSize,
    const void* Values
)
{
    ULONG status = EventPipeWriteEventGCBulkEdge(Index,Count,ClrInstanceID,Values_ElementSize, Values);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCBulkEdge(Index,Count,ClrInstanceID,Values_ElementSize, Values);
    }
    return status;
}

inline BOOL EventEnabledGCSampledObjectAllocationHigh() {return EventPipeEventEnabledGCSampledObjectAllocationHigh() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCSampledObjectAllocationHigh());}

inline ULONG FireEtwGCSampledObjectAllocationHigh(
    const void*  Address,
    const void*  TypeID,
    const unsigned int  ObjectCountForTypeSample,
    const unsigned __int64  TotalSizeForTypeSample,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCSampledObjectAllocationHigh(Address,TypeID,ObjectCountForTypeSample,TotalSizeForTypeSample,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCSampledObjectAllocationHigh(Address,TypeID,ObjectCountForTypeSample,TotalSizeForTypeSample,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCBulkSurvivingObjectRanges() {return EventPipeEventEnabledGCBulkSurvivingObjectRanges() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCBulkSurvivingObjectRanges());}

inline ULONG FireEtwGCBulkSurvivingObjectRanges(
    const unsigned int  Index,
    const unsigned int  Count,
    const unsigned short  ClrInstanceID,
    int Values_ElementSize,
    const void* Values
)
{
    ULONG status = EventPipeWriteEventGCBulkSurvivingObjectRanges(Index,Count,ClrInstanceID,Values_ElementSize, Values);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCBulkSurvivingObjectRanges(Index,Count,ClrInstanceID,Values_ElementSize, Values);
    }
    return status;
}

inline BOOL EventEnabledGCBulkMovedObjectRanges() {return EventPipeEventEnabledGCBulkMovedObjectRanges() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCBulkMovedObjectRanges());}

inline ULONG FireEtwGCBulkMovedObjectRanges(
    const unsigned int  Index,
    const unsigned int  Count,
    const unsigned short  ClrInstanceID,
    int Values_ElementSize,
    const void* Values
)
{
    ULONG status = EventPipeWriteEventGCBulkMovedObjectRanges(Index,Count,ClrInstanceID,Values_ElementSize, Values);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCBulkMovedObjectRanges(Index,Count,ClrInstanceID,Values_ElementSize, Values);
    }
    return status;
}

inline BOOL EventEnabledGCGenerationRange() {return EventPipeEventEnabledGCGenerationRange() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCGenerationRange());}

inline ULONG FireEtwGCGenerationRange(
    const unsigned char  Generation,
    const void*  RangeStart,
    const unsigned __int64  RangeUsedLength,
    const unsigned __int64  RangeReservedLength,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCGenerationRange(Generation,RangeStart,RangeUsedLength,RangeReservedLength,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCGenerationRange(Generation,RangeStart,RangeUsedLength,RangeReservedLength,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCMarkStackRoots() {return EventPipeEventEnabledGCMarkStackRoots() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCMarkStackRoots());}

inline ULONG FireEtwGCMarkStackRoots(
    const unsigned int  HeapNum,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCMarkStackRoots(HeapNum,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCMarkStackRoots(HeapNum,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCMarkFinalizeQueueRoots() {return EventPipeEventEnabledGCMarkFinalizeQueueRoots() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCMarkFinalizeQueueRoots());}

inline ULONG FireEtwGCMarkFinalizeQueueRoots(
    const unsigned int  HeapNum,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCMarkFinalizeQueueRoots(HeapNum,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCMarkFinalizeQueueRoots(HeapNum,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCMarkHandles() {return EventPipeEventEnabledGCMarkHandles() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCMarkHandles());}

inline ULONG FireEtwGCMarkHandles(
    const unsigned int  HeapNum,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCMarkHandles(HeapNum,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCMarkHandles(HeapNum,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCMarkOlderGenerationRoots() {return EventPipeEventEnabledGCMarkOlderGenerationRoots() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCMarkOlderGenerationRoots());}

inline ULONG FireEtwGCMarkOlderGenerationRoots(
    const unsigned int  HeapNum,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCMarkOlderGenerationRoots(HeapNum,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCMarkOlderGenerationRoots(HeapNum,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledFinalizeObject() {return EventPipeEventEnabledFinalizeObject() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFinalizeObject());}

inline ULONG FireEtwFinalizeObject(
    const void*  TypeID,
    const void*  ObjectID,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventFinalizeObject(TypeID,ObjectID,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFinalizeObject(TypeID,ObjectID,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledSetGCHandle() {return EventPipeEventEnabledSetGCHandle() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledSetGCHandle());}

inline ULONG FireEtwSetGCHandle(
    const void*  HandleID,
    const void*  ObjectID,
    const unsigned int  Kind,
    const unsigned int  Generation,
    const unsigned __int64  AppDomainID,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventSetGCHandle(HandleID,ObjectID,Kind,Generation,AppDomainID,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatSetGCHandle(HandleID,ObjectID,Kind,Generation,AppDomainID,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledDestroyGCHandle() {return EventPipeEventEnabledDestroyGCHandle() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDestroyGCHandle());}

inline ULONG FireEtwDestroyGCHandle(
    const void*  HandleID,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventDestroyGCHandle(HandleID,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDestroyGCHandle(HandleID,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCSampledObjectAllocationLow() {return EventPipeEventEnabledGCSampledObjectAllocationLow() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCSampledObjectAllocationLow());}

inline ULONG FireEtwGCSampledObjectAllocationLow(
    const void*  Address,
    const void*  TypeID,
    const unsigned int  ObjectCountForTypeSample,
    const unsigned __int64  TotalSizeForTypeSample,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCSampledObjectAllocationLow(Address,TypeID,ObjectCountForTypeSample,TotalSizeForTypeSample,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCSampledObjectAllocationLow(Address,TypeID,ObjectCountForTypeSample,TotalSizeForTypeSample,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledPinObjectAtGCTime() {return EventPipeEventEnabledPinObjectAtGCTime() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledPinObjectAtGCTime());}

inline ULONG FireEtwPinObjectAtGCTime(
    const void*  HandleID,
    const void*  ObjectID,
    const unsigned __int64  ObjectSize,
    PCWSTR  TypeName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventPinObjectAtGCTime(HandleID,ObjectID,ObjectSize,TypeName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatPinObjectAtGCTime(HandleID,ObjectID,ObjectSize,TypeName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCTriggered() {return EventPipeEventEnabledGCTriggered() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCTriggered());}

inline ULONG FireEtwGCTriggered(
    const unsigned int  Reason,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCTriggered(Reason,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCTriggered(Reason,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCBulkRootCCW() {return EventPipeEventEnabledGCBulkRootCCW() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCBulkRootCCW());}

inline ULONG FireEtwGCBulkRootCCW(
    const unsigned int  Count,
    const unsigned short  ClrInstanceID,
    int Values_ElementSize,
    const void* Values
)
{
    ULONG status = EventPipeWriteEventGCBulkRootCCW(Count,ClrInstanceID,Values_ElementSize, Values);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCBulkRootCCW(Count,ClrInstanceID,Values_ElementSize, Values);
    }
    return status;
}

inline BOOL EventEnabledGCBulkRCW() {return EventPipeEventEnabledGCBulkRCW() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCBulkRCW());}

inline ULONG FireEtwGCBulkRCW(
    const unsigned int  Count,
    const unsigned short  ClrInstanceID,
    int Values_ElementSize,
    const void* Values
)
{
    ULONG status = EventPipeWriteEventGCBulkRCW(Count,ClrInstanceID,Values_ElementSize, Values);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCBulkRCW(Count,ClrInstanceID,Values_ElementSize, Values);
    }
    return status;
}

inline BOOL EventEnabledGCBulkRootStaticVar() {return EventPipeEventEnabledGCBulkRootStaticVar() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCBulkRootStaticVar());}

inline ULONG FireEtwGCBulkRootStaticVar(
    const unsigned int  Count,
    const unsigned __int64  AppDomainID,
    const unsigned short  ClrInstanceID,
    int Values_ElementSize,
    const void* Values
)
{
    ULONG status = EventPipeWriteEventGCBulkRootStaticVar(Count,AppDomainID,ClrInstanceID,Values_ElementSize, Values);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCBulkRootStaticVar(Count,AppDomainID,ClrInstanceID,Values_ElementSize, Values);
    }
    return status;
}

inline BOOL EventEnabledWorkerThreadCreate() {return EventPipeEventEnabledWorkerThreadCreate() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledWorkerThreadCreate());}

inline ULONG FireEtwWorkerThreadCreate(
    const unsigned int  WorkerThreadCount,
    const unsigned int  RetiredWorkerThreads
)
{
    ULONG status = EventPipeWriteEventWorkerThreadCreate(WorkerThreadCount,RetiredWorkerThreads);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatWorkerThreadCreate(WorkerThreadCount,RetiredWorkerThreads);
    }
    return status;
}

inline BOOL EventEnabledWorkerThreadTerminate() {return EventPipeEventEnabledWorkerThreadTerminate() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledWorkerThreadTerminate());}

inline ULONG FireEtwWorkerThreadTerminate(
    const unsigned int  WorkerThreadCount,
    const unsigned int  RetiredWorkerThreads
)
{
    ULONG status = EventPipeWriteEventWorkerThreadTerminate(WorkerThreadCount,RetiredWorkerThreads);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatWorkerThreadTerminate(WorkerThreadCount,RetiredWorkerThreads);
    }
    return status;
}

inline BOOL EventEnabledWorkerThreadRetire() {return EventPipeEventEnabledWorkerThreadRetire() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledWorkerThreadRetire());}

inline ULONG FireEtwWorkerThreadRetire(
    const unsigned int  WorkerThreadCount,
    const unsigned int  RetiredWorkerThreads
)
{
    ULONG status = EventPipeWriteEventWorkerThreadRetire(WorkerThreadCount,RetiredWorkerThreads);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatWorkerThreadRetire(WorkerThreadCount,RetiredWorkerThreads);
    }
    return status;
}

inline BOOL EventEnabledWorkerThreadUnretire() {return EventPipeEventEnabledWorkerThreadUnretire() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledWorkerThreadUnretire());}

inline ULONG FireEtwWorkerThreadUnretire(
    const unsigned int  WorkerThreadCount,
    const unsigned int  RetiredWorkerThreads
)
{
    ULONG status = EventPipeWriteEventWorkerThreadUnretire(WorkerThreadCount,RetiredWorkerThreads);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatWorkerThreadUnretire(WorkerThreadCount,RetiredWorkerThreads);
    }
    return status;
}

inline BOOL EventEnabledIOThreadCreate() {return EventPipeEventEnabledIOThreadCreate() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledIOThreadCreate());}

inline ULONG FireEtwIOThreadCreate(
    const unsigned int  IOThreadCount,
    const unsigned int  RetiredIOThreads
)
{
    ULONG status = EventPipeWriteEventIOThreadCreate(IOThreadCount,RetiredIOThreads);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatIOThreadCreate(IOThreadCount,RetiredIOThreads);
    }
    return status;
}

inline BOOL EventEnabledIOThreadCreate_V1() {return EventPipeEventEnabledIOThreadCreate_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledIOThreadCreate_V1());}

inline ULONG FireEtwIOThreadCreate_V1(
    const unsigned int  IOThreadCount,
    const unsigned int  RetiredIOThreads,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventIOThreadCreate_V1(IOThreadCount,RetiredIOThreads,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatIOThreadCreate_V1(IOThreadCount,RetiredIOThreads,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledIOThreadTerminate() {return EventPipeEventEnabledIOThreadTerminate() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledIOThreadTerminate());}

inline ULONG FireEtwIOThreadTerminate(
    const unsigned int  IOThreadCount,
    const unsigned int  RetiredIOThreads
)
{
    ULONG status = EventPipeWriteEventIOThreadTerminate(IOThreadCount,RetiredIOThreads);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatIOThreadTerminate(IOThreadCount,RetiredIOThreads);
    }
    return status;
}

inline BOOL EventEnabledIOThreadTerminate_V1() {return EventPipeEventEnabledIOThreadTerminate_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledIOThreadTerminate_V1());}

inline ULONG FireEtwIOThreadTerminate_V1(
    const unsigned int  IOThreadCount,
    const unsigned int  RetiredIOThreads,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventIOThreadTerminate_V1(IOThreadCount,RetiredIOThreads,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatIOThreadTerminate_V1(IOThreadCount,RetiredIOThreads,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledIOThreadRetire() {return EventPipeEventEnabledIOThreadRetire() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledIOThreadRetire());}

inline ULONG FireEtwIOThreadRetire(
    const unsigned int  IOThreadCount,
    const unsigned int  RetiredIOThreads
)
{
    ULONG status = EventPipeWriteEventIOThreadRetire(IOThreadCount,RetiredIOThreads);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatIOThreadRetire(IOThreadCount,RetiredIOThreads);
    }
    return status;
}

inline BOOL EventEnabledIOThreadRetire_V1() {return EventPipeEventEnabledIOThreadRetire_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledIOThreadRetire_V1());}

inline ULONG FireEtwIOThreadRetire_V1(
    const unsigned int  IOThreadCount,
    const unsigned int  RetiredIOThreads,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventIOThreadRetire_V1(IOThreadCount,RetiredIOThreads,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatIOThreadRetire_V1(IOThreadCount,RetiredIOThreads,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledIOThreadUnretire() {return EventPipeEventEnabledIOThreadUnretire() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledIOThreadUnretire());}

inline ULONG FireEtwIOThreadUnretire(
    const unsigned int  IOThreadCount,
    const unsigned int  RetiredIOThreads
)
{
    ULONG status = EventPipeWriteEventIOThreadUnretire(IOThreadCount,RetiredIOThreads);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatIOThreadUnretire(IOThreadCount,RetiredIOThreads);
    }
    return status;
}

inline BOOL EventEnabledIOThreadUnretire_V1() {return EventPipeEventEnabledIOThreadUnretire_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledIOThreadUnretire_V1());}

inline ULONG FireEtwIOThreadUnretire_V1(
    const unsigned int  IOThreadCount,
    const unsigned int  RetiredIOThreads,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventIOThreadUnretire_V1(IOThreadCount,RetiredIOThreads,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatIOThreadUnretire_V1(IOThreadCount,RetiredIOThreads,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadpoolSuspensionSuspendThread() {return EventPipeEventEnabledThreadpoolSuspensionSuspendThread() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadpoolSuspensionSuspendThread());}

inline ULONG FireEtwThreadpoolSuspensionSuspendThread(
    const unsigned int  ClrThreadID,
    const unsigned int  CpuUtilization
)
{
    ULONG status = EventPipeWriteEventThreadpoolSuspensionSuspendThread(ClrThreadID,CpuUtilization);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadpoolSuspensionSuspendThread(ClrThreadID,CpuUtilization);
    }
    return status;
}

inline BOOL EventEnabledThreadpoolSuspensionResumeThread() {return EventPipeEventEnabledThreadpoolSuspensionResumeThread() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadpoolSuspensionResumeThread());}

inline ULONG FireEtwThreadpoolSuspensionResumeThread(
    const unsigned int  ClrThreadID,
    const unsigned int  CpuUtilization
)
{
    ULONG status = EventPipeWriteEventThreadpoolSuspensionResumeThread(ClrThreadID,CpuUtilization);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadpoolSuspensionResumeThread(ClrThreadID,CpuUtilization);
    }
    return status;
}

inline BOOL EventEnabledThreadPoolWorkerThreadStart() {return EventPipeEventEnabledThreadPoolWorkerThreadStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadPoolWorkerThreadStart());}

inline ULONG FireEtwThreadPoolWorkerThreadStart(
    const unsigned int  ActiveWorkerThreadCount,
    const unsigned int  RetiredWorkerThreadCount,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadPoolWorkerThreadStart(ActiveWorkerThreadCount,RetiredWorkerThreadCount,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadPoolWorkerThreadStart(ActiveWorkerThreadCount,RetiredWorkerThreadCount,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadPoolWorkerThreadStop() {return EventPipeEventEnabledThreadPoolWorkerThreadStop() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadPoolWorkerThreadStop());}

inline ULONG FireEtwThreadPoolWorkerThreadStop(
    const unsigned int  ActiveWorkerThreadCount,
    const unsigned int  RetiredWorkerThreadCount,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadPoolWorkerThreadStop(ActiveWorkerThreadCount,RetiredWorkerThreadCount,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadPoolWorkerThreadStop(ActiveWorkerThreadCount,RetiredWorkerThreadCount,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadPoolWorkerThreadRetirementStart() {return EventPipeEventEnabledThreadPoolWorkerThreadRetirementStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadPoolWorkerThreadRetirementStart());}

inline ULONG FireEtwThreadPoolWorkerThreadRetirementStart(
    const unsigned int  ActiveWorkerThreadCount,
    const unsigned int  RetiredWorkerThreadCount,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadPoolWorkerThreadRetirementStart(ActiveWorkerThreadCount,RetiredWorkerThreadCount,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadPoolWorkerThreadRetirementStart(ActiveWorkerThreadCount,RetiredWorkerThreadCount,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadPoolWorkerThreadRetirementStop() {return EventPipeEventEnabledThreadPoolWorkerThreadRetirementStop() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadPoolWorkerThreadRetirementStop());}

inline ULONG FireEtwThreadPoolWorkerThreadRetirementStop(
    const unsigned int  ActiveWorkerThreadCount,
    const unsigned int  RetiredWorkerThreadCount,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadPoolWorkerThreadRetirementStop(ActiveWorkerThreadCount,RetiredWorkerThreadCount,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadPoolWorkerThreadRetirementStop(ActiveWorkerThreadCount,RetiredWorkerThreadCount,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadPoolWorkerThreadAdjustmentSample() {return EventPipeEventEnabledThreadPoolWorkerThreadAdjustmentSample() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadPoolWorkerThreadAdjustmentSample());}

inline ULONG FireEtwThreadPoolWorkerThreadAdjustmentSample(
    const double  Throughput,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadPoolWorkerThreadAdjustmentSample(Throughput,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadPoolWorkerThreadAdjustmentSample(Throughput,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadPoolWorkerThreadAdjustmentAdjustment() {return EventPipeEventEnabledThreadPoolWorkerThreadAdjustmentAdjustment() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadPoolWorkerThreadAdjustmentAdjustment());}

inline ULONG FireEtwThreadPoolWorkerThreadAdjustmentAdjustment(
    const double  AverageThroughput,
    const unsigned int  NewWorkerThreadCount,
    const unsigned int  Reason,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadPoolWorkerThreadAdjustmentAdjustment(AverageThroughput,NewWorkerThreadCount,Reason,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadPoolWorkerThreadAdjustmentAdjustment(AverageThroughput,NewWorkerThreadCount,Reason,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadPoolWorkerThreadAdjustmentStats() {return EventPipeEventEnabledThreadPoolWorkerThreadAdjustmentStats() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadPoolWorkerThreadAdjustmentStats());}

inline ULONG FireEtwThreadPoolWorkerThreadAdjustmentStats(
    const double  Duration,
    const double  Throughput,
    const double  ThreadWave,
    const double  ThroughputWave,
    const double  ThroughputErrorEstimate,
    const double  AverageThroughputErrorEstimate,
    const double  ThroughputRatio,
    const double  Confidence,
    const double  NewControlSetting,
    const unsigned short  NewThreadWaveMagnitude,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadPoolWorkerThreadAdjustmentStats(Duration,Throughput,ThreadWave,ThroughputWave,ThroughputErrorEstimate,AverageThroughputErrorEstimate,ThroughputRatio,Confidence,NewControlSetting,NewThreadWaveMagnitude,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadPoolWorkerThreadAdjustmentStats(Duration,Throughput,ThreadWave,ThroughputWave,ThroughputErrorEstimate,AverageThroughputErrorEstimate,ThroughputRatio,Confidence,NewControlSetting,NewThreadWaveMagnitude,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadPoolWorkerThreadWait() {return EventPipeEventEnabledThreadPoolWorkerThreadWait() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadPoolWorkerThreadWait());}

inline ULONG FireEtwThreadPoolWorkerThreadWait(
    const unsigned int  ActiveWorkerThreadCount,
    const unsigned int  RetiredWorkerThreadCount,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadPoolWorkerThreadWait(ActiveWorkerThreadCount,RetiredWorkerThreadCount,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadPoolWorkerThreadWait(ActiveWorkerThreadCount,RetiredWorkerThreadCount,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadPoolWorkingThreadCount() {return EventPipeEventEnabledThreadPoolWorkingThreadCount() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadPoolWorkingThreadCount());}

inline ULONG FireEtwThreadPoolWorkingThreadCount(
    const unsigned int  Count,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadPoolWorkingThreadCount(Count,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadPoolWorkingThreadCount(Count,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadPoolEnqueue() {return EventPipeEventEnabledThreadPoolEnqueue() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadPoolEnqueue());}

inline ULONG FireEtwThreadPoolEnqueue(
    const void*  WorkID,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadPoolEnqueue(WorkID,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadPoolEnqueue(WorkID,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadPoolDequeue() {return EventPipeEventEnabledThreadPoolDequeue() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadPoolDequeue());}

inline ULONG FireEtwThreadPoolDequeue(
    const void*  WorkID,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadPoolDequeue(WorkID,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadPoolDequeue(WorkID,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadPoolIOEnqueue() {return EventPipeEventEnabledThreadPoolIOEnqueue() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadPoolIOEnqueue());}

inline ULONG FireEtwThreadPoolIOEnqueue(
    const void*  NativeOverlapped,
    const void*  Overlapped,
    const BOOL  MultiDequeues,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadPoolIOEnqueue(NativeOverlapped,Overlapped,MultiDequeues,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadPoolIOEnqueue(NativeOverlapped,Overlapped,MultiDequeues,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadPoolIODequeue() {return EventPipeEventEnabledThreadPoolIODequeue() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadPoolIODequeue());}

inline ULONG FireEtwThreadPoolIODequeue(
    const void*  NativeOverlapped,
    const void*  Overlapped,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadPoolIODequeue(NativeOverlapped,Overlapped,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadPoolIODequeue(NativeOverlapped,Overlapped,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadPoolIOPack() {return EventPipeEventEnabledThreadPoolIOPack() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadPoolIOPack());}

inline ULONG FireEtwThreadPoolIOPack(
    const void*  NativeOverlapped,
    const void*  Overlapped,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadPoolIOPack(NativeOverlapped,Overlapped,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadPoolIOPack(NativeOverlapped,Overlapped,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadCreating() {return EventPipeEventEnabledThreadCreating() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadCreating());}

inline ULONG FireEtwThreadCreating(
    const void*  ID,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadCreating(ID,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadCreating(ID,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadRunning() {return EventPipeEventEnabledThreadRunning() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadRunning());}

inline ULONG FireEtwThreadRunning(
    const void*  ID,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadRunning(ID,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadRunning(ID,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledExceptionThrown() {return EventPipeEventEnabledExceptionThrown() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledExceptionThrown());}

inline ULONG FireEtwExceptionThrown(

)
{
    ULONG status = EventPipeWriteEventExceptionThrown();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatExceptionThrown();
    }
    return status;
}

inline BOOL EventEnabledExceptionThrown_V1() {return EventPipeEventEnabledExceptionThrown_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledExceptionThrown_V1());}

inline ULONG FireEtwExceptionThrown_V1(
    PCWSTR  ExceptionType,
    PCWSTR  ExceptionMessage,
    const void*  ExceptionEIP,
    const unsigned int  ExceptionHRESULT,
    const unsigned short  ExceptionFlags,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventExceptionThrown_V1(ExceptionType,ExceptionMessage,ExceptionEIP,ExceptionHRESULT,ExceptionFlags,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatExceptionThrown_V1(ExceptionType,ExceptionMessage,ExceptionEIP,ExceptionHRESULT,ExceptionFlags,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledExceptionCatchStart() {return EventPipeEventEnabledExceptionCatchStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledExceptionCatchStart());}

inline ULONG FireEtwExceptionCatchStart(
    const unsigned __int64  EntryEIP,
    const unsigned __int64  MethodID,
    PCWSTR  MethodName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventExceptionCatchStart(EntryEIP,MethodID,MethodName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatExceptionCatchStart(EntryEIP,MethodID,MethodName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledExceptionCatchStop() {return EventPipeEventEnabledExceptionCatchStop() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledExceptionCatchStop());}

inline ULONG FireEtwExceptionCatchStop(

)
{
    ULONG status = EventPipeWriteEventExceptionCatchStop();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatExceptionCatchStop();
    }
    return status;
}

inline BOOL EventEnabledExceptionFinallyStart() {return EventPipeEventEnabledExceptionFinallyStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledExceptionFinallyStart());}

inline ULONG FireEtwExceptionFinallyStart(
    const unsigned __int64  EntryEIP,
    const unsigned __int64  MethodID,
    PCWSTR  MethodName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventExceptionFinallyStart(EntryEIP,MethodID,MethodName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatExceptionFinallyStart(EntryEIP,MethodID,MethodName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledExceptionFinallyStop() {return EventPipeEventEnabledExceptionFinallyStop() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledExceptionFinallyStop());}

inline ULONG FireEtwExceptionFinallyStop(

)
{
    ULONG status = EventPipeWriteEventExceptionFinallyStop();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatExceptionFinallyStop();
    }
    return status;
}

inline BOOL EventEnabledExceptionFilterStart() {return EventPipeEventEnabledExceptionFilterStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledExceptionFilterStart());}

inline ULONG FireEtwExceptionFilterStart(
    const unsigned __int64  EntryEIP,
    const unsigned __int64  MethodID,
    PCWSTR  MethodName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventExceptionFilterStart(EntryEIP,MethodID,MethodName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatExceptionFilterStart(EntryEIP,MethodID,MethodName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledExceptionFilterStop() {return EventPipeEventEnabledExceptionFilterStop() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledExceptionFilterStop());}

inline ULONG FireEtwExceptionFilterStop(

)
{
    ULONG status = EventPipeWriteEventExceptionFilterStop();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatExceptionFilterStop();
    }
    return status;
}

inline BOOL EventEnabledExceptionThrownStop() {return EventPipeEventEnabledExceptionThrownStop() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledExceptionThrownStop());}

inline ULONG FireEtwExceptionThrownStop(

)
{
    ULONG status = EventPipeWriteEventExceptionThrownStop();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatExceptionThrownStop();
    }
    return status;
}

inline BOOL EventEnabledContention() {return EventPipeEventEnabledContention() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledContention());}

inline ULONG FireEtwContention(

)
{
    ULONG status = EventPipeWriteEventContention();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatContention();
    }
    return status;
}

inline BOOL EventEnabledContentionStart_V1() {return EventPipeEventEnabledContentionStart_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledContentionStart_V1());}

inline ULONG FireEtwContentionStart_V1(
    const unsigned char  ContentionFlags,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventContentionStart_V1(ContentionFlags,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatContentionStart_V1(ContentionFlags,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledContentionStop() {return EventPipeEventEnabledContentionStop() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledContentionStop());}

inline ULONG FireEtwContentionStop(
    const unsigned char  ContentionFlags,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventContentionStop(ContentionFlags,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatContentionStop(ContentionFlags,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledCLRStackWalk() {return EventPipeEventEnabledCLRStackWalk() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledCLRStackWalk());}

inline ULONG FireEtwCLRStackWalk(
    const unsigned short  ClrInstanceID,
    const unsigned char  Reserved1,
    const unsigned char  Reserved2,
    const unsigned int  FrameCount,
    const void** Stack
)
{
    ULONG status = EventPipeWriteEventCLRStackWalk(ClrInstanceID,Reserved1,Reserved2,FrameCount,Stack);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatCLRStackWalk(ClrInstanceID,Reserved1,Reserved2,FrameCount,Stack);
    }
    return status;
}

inline BOOL EventEnabledAppDomainMemAllocated() {return EventPipeEventEnabledAppDomainMemAllocated() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAppDomainMemAllocated());}

inline ULONG FireEtwAppDomainMemAllocated(
    const unsigned __int64  AppDomainID,
    const unsigned __int64  Allocated,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventAppDomainMemAllocated(AppDomainID,Allocated,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAppDomainMemAllocated(AppDomainID,Allocated,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledAppDomainMemSurvived() {return EventPipeEventEnabledAppDomainMemSurvived() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAppDomainMemSurvived());}

inline ULONG FireEtwAppDomainMemSurvived(
    const unsigned __int64  AppDomainID,
    const unsigned __int64  Survived,
    const unsigned __int64  ProcessSurvived,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventAppDomainMemSurvived(AppDomainID,Survived,ProcessSurvived,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAppDomainMemSurvived(AppDomainID,Survived,ProcessSurvived,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadCreated() {return EventPipeEventEnabledThreadCreated() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadCreated());}

inline ULONG FireEtwThreadCreated(
    const unsigned __int64  ManagedThreadID,
    const unsigned __int64  AppDomainID,
    const unsigned int  Flags,
    const unsigned int  ManagedThreadIndex,
    const unsigned int  OSThreadID,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadCreated(ManagedThreadID,AppDomainID,Flags,ManagedThreadIndex,OSThreadID,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadCreated(ManagedThreadID,AppDomainID,Flags,ManagedThreadIndex,OSThreadID,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadTerminated() {return EventPipeEventEnabledThreadTerminated() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadTerminated());}

inline ULONG FireEtwThreadTerminated(
    const unsigned __int64  ManagedThreadID,
    const unsigned __int64  AppDomainID,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadTerminated(ManagedThreadID,AppDomainID,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadTerminated(ManagedThreadID,AppDomainID,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadDomainEnter() {return EventPipeEventEnabledThreadDomainEnter() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadDomainEnter());}

inline ULONG FireEtwThreadDomainEnter(
    const unsigned __int64  ManagedThreadID,
    const unsigned __int64  AppDomainID,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadDomainEnter(ManagedThreadID,AppDomainID,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadDomainEnter(ManagedThreadID,AppDomainID,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledILStubGenerated() {return EventPipeEventEnabledILStubGenerated() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledILStubGenerated());}

inline ULONG FireEtwILStubGenerated(
    const unsigned short  ClrInstanceID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  StubMethodID,
    const unsigned int  StubFlags,
    const unsigned int  ManagedInteropMethodToken,
    PCWSTR  ManagedInteropMethodNamespace,
    PCWSTR  ManagedInteropMethodName,
    PCWSTR  ManagedInteropMethodSignature,
    PCWSTR  NativeMethodSignature,
    PCWSTR  StubMethodSignature,
    PCWSTR  StubMethodILCode
)
{
    ULONG status = EventPipeWriteEventILStubGenerated(ClrInstanceID,ModuleID,StubMethodID,StubFlags,ManagedInteropMethodToken,ManagedInteropMethodNamespace,ManagedInteropMethodName,ManagedInteropMethodSignature,NativeMethodSignature,StubMethodSignature,StubMethodILCode);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatILStubGenerated(ClrInstanceID,ModuleID,StubMethodID,StubFlags,ManagedInteropMethodToken,ManagedInteropMethodNamespace,ManagedInteropMethodName,ManagedInteropMethodSignature,NativeMethodSignature,StubMethodSignature,StubMethodILCode);
    }
    return status;
}

inline BOOL EventEnabledILStubCacheHit() {return EventPipeEventEnabledILStubCacheHit() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledILStubCacheHit());}

inline ULONG FireEtwILStubCacheHit(
    const unsigned short  ClrInstanceID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  StubMethodID,
    const unsigned int  ManagedInteropMethodToken,
    PCWSTR  ManagedInteropMethodNamespace,
    PCWSTR  ManagedInteropMethodName,
    PCWSTR  ManagedInteropMethodSignature
)
{
    ULONG status = EventPipeWriteEventILStubCacheHit(ClrInstanceID,ModuleID,StubMethodID,ManagedInteropMethodToken,ManagedInteropMethodNamespace,ManagedInteropMethodName,ManagedInteropMethodSignature);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatILStubCacheHit(ClrInstanceID,ModuleID,StubMethodID,ManagedInteropMethodToken,ManagedInteropMethodNamespace,ManagedInteropMethodName,ManagedInteropMethodSignature);
    }
    return status;
}

inline BOOL EventEnabledDCStartCompleteV2() {return EventPipeEventEnabledDCStartCompleteV2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDCStartCompleteV2());}

inline ULONG FireEtwDCStartCompleteV2(

)
{
    ULONG status = EventPipeWriteEventDCStartCompleteV2();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDCStartCompleteV2();
    }
    return status;
}

inline BOOL EventEnabledDCEndCompleteV2() {return EventPipeEventEnabledDCEndCompleteV2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDCEndCompleteV2());}

inline ULONG FireEtwDCEndCompleteV2(

)
{
    ULONG status = EventPipeWriteEventDCEndCompleteV2();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDCEndCompleteV2();
    }
    return status;
}

inline BOOL EventEnabledMethodDCStartV2() {return EventPipeEventEnabledMethodDCStartV2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodDCStartV2());}

inline ULONG FireEtwMethodDCStartV2(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags
)
{
    ULONG status = EventPipeWriteEventMethodDCStartV2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodDCStartV2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags);
    }
    return status;
}

inline BOOL EventEnabledMethodDCEndV2() {return EventPipeEventEnabledMethodDCEndV2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodDCEndV2());}

inline ULONG FireEtwMethodDCEndV2(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags
)
{
    ULONG status = EventPipeWriteEventMethodDCEndV2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodDCEndV2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags);
    }
    return status;
}

inline BOOL EventEnabledMethodDCStartVerboseV2() {return EventPipeEventEnabledMethodDCStartVerboseV2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodDCStartVerboseV2());}

inline ULONG FireEtwMethodDCStartVerboseV2(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    PCWSTR  MethodNamespace,
    PCWSTR  MethodName,
    PCWSTR  MethodSignature
)
{
    ULONG status = EventPipeWriteEventMethodDCStartVerboseV2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodDCStartVerboseV2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature);
    }
    return status;
}

inline BOOL EventEnabledMethodDCEndVerboseV2() {return EventPipeEventEnabledMethodDCEndVerboseV2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodDCEndVerboseV2());}

inline ULONG FireEtwMethodDCEndVerboseV2(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    PCWSTR  MethodNamespace,
    PCWSTR  MethodName,
    PCWSTR  MethodSignature
)
{
    ULONG status = EventPipeWriteEventMethodDCEndVerboseV2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodDCEndVerboseV2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature);
    }
    return status;
}

inline BOOL EventEnabledMethodLoad() {return EventPipeEventEnabledMethodLoad() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodLoad());}

inline ULONG FireEtwMethodLoad(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags
)
{
    ULONG status = EventPipeWriteEventMethodLoad(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodLoad(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags);
    }
    return status;
}

inline BOOL EventEnabledMethodLoad_V1() {return EventPipeEventEnabledMethodLoad_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodLoad_V1());}

inline ULONG FireEtwMethodLoad_V1(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMethodLoad_V1(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodLoad_V1(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMethodLoad_V2() {return EventPipeEventEnabledMethodLoad_V2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodLoad_V2());}

inline ULONG FireEtwMethodLoad_V2(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    const unsigned short  ClrInstanceID,
    const unsigned __int64  ReJITID
)
{
    ULONG status = EventPipeWriteEventMethodLoad_V2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,ClrInstanceID,ReJITID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodLoad_V2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,ClrInstanceID,ReJITID);
    }
    return status;
}

inline BOOL EventEnabledMethodUnload() {return EventPipeEventEnabledMethodUnload() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodUnload());}

inline ULONG FireEtwMethodUnload(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags
)
{
    ULONG status = EventPipeWriteEventMethodUnload(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodUnload(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags);
    }
    return status;
}

inline BOOL EventEnabledMethodUnload_V1() {return EventPipeEventEnabledMethodUnload_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodUnload_V1());}

inline ULONG FireEtwMethodUnload_V1(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMethodUnload_V1(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodUnload_V1(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMethodUnload_V2() {return EventPipeEventEnabledMethodUnload_V2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodUnload_V2());}

inline ULONG FireEtwMethodUnload_V2(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    const unsigned short  ClrInstanceID,
    const unsigned __int64  ReJITID
)
{
    ULONG status = EventPipeWriteEventMethodUnload_V2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,ClrInstanceID,ReJITID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodUnload_V2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,ClrInstanceID,ReJITID);
    }
    return status;
}

inline BOOL EventEnabledMethodLoadVerbose() {return EventPipeEventEnabledMethodLoadVerbose() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodLoadVerbose());}

inline ULONG FireEtwMethodLoadVerbose(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    PCWSTR  MethodNamespace,
    PCWSTR  MethodName,
    PCWSTR  MethodSignature
)
{
    ULONG status = EventPipeWriteEventMethodLoadVerbose(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodLoadVerbose(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature);
    }
    return status;
}

inline BOOL EventEnabledMethodLoadVerbose_V1() {return EventPipeEventEnabledMethodLoadVerbose_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodLoadVerbose_V1());}

inline ULONG FireEtwMethodLoadVerbose_V1(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    PCWSTR  MethodNamespace,
    PCWSTR  MethodName,
    PCWSTR  MethodSignature,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMethodLoadVerbose_V1(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodLoadVerbose_V1(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMethodLoadVerbose_V2() {return EventPipeEventEnabledMethodLoadVerbose_V2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodLoadVerbose_V2());}

inline ULONG FireEtwMethodLoadVerbose_V2(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    PCWSTR  MethodNamespace,
    PCWSTR  MethodName,
    PCWSTR  MethodSignature,
    const unsigned short  ClrInstanceID,
    const unsigned __int64  ReJITID
)
{
    ULONG status = EventPipeWriteEventMethodLoadVerbose_V2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature,ClrInstanceID,ReJITID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodLoadVerbose_V2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature,ClrInstanceID,ReJITID);
    }
    return status;
}

inline BOOL EventEnabledMethodUnloadVerbose() {return EventPipeEventEnabledMethodUnloadVerbose() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodUnloadVerbose());}

inline ULONG FireEtwMethodUnloadVerbose(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    PCWSTR  MethodNamespace,
    PCWSTR  MethodName,
    PCWSTR  MethodSignature
)
{
    ULONG status = EventPipeWriteEventMethodUnloadVerbose(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodUnloadVerbose(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature);
    }
    return status;
}

inline BOOL EventEnabledMethodUnloadVerbose_V1() {return EventPipeEventEnabledMethodUnloadVerbose_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodUnloadVerbose_V1());}

inline ULONG FireEtwMethodUnloadVerbose_V1(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    PCWSTR  MethodNamespace,
    PCWSTR  MethodName,
    PCWSTR  MethodSignature,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMethodUnloadVerbose_V1(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodUnloadVerbose_V1(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMethodUnloadVerbose_V2() {return EventPipeEventEnabledMethodUnloadVerbose_V2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodUnloadVerbose_V2());}

inline ULONG FireEtwMethodUnloadVerbose_V2(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    PCWSTR  MethodNamespace,
    PCWSTR  MethodName,
    PCWSTR  MethodSignature,
    const unsigned short  ClrInstanceID,
    const unsigned __int64  ReJITID
)
{
    ULONG status = EventPipeWriteEventMethodUnloadVerbose_V2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature,ClrInstanceID,ReJITID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodUnloadVerbose_V2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature,ClrInstanceID,ReJITID);
    }
    return status;
}

inline BOOL EventEnabledMethodJittingStarted() {return EventPipeEventEnabledMethodJittingStarted() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodJittingStarted());}

inline ULONG FireEtwMethodJittingStarted(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned int  MethodToken,
    const unsigned int  MethodILSize,
    PCWSTR  MethodNamespace,
    PCWSTR  MethodName,
    PCWSTR  MethodSignature
)
{
    ULONG status = EventPipeWriteEventMethodJittingStarted(MethodID,ModuleID,MethodToken,MethodILSize,MethodNamespace,MethodName,MethodSignature);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodJittingStarted(MethodID,ModuleID,MethodToken,MethodILSize,MethodNamespace,MethodName,MethodSignature);
    }
    return status;
}

inline BOOL EventEnabledMethodJittingStarted_V1() {return EventPipeEventEnabledMethodJittingStarted_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodJittingStarted_V1());}

inline ULONG FireEtwMethodJittingStarted_V1(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned int  MethodToken,
    const unsigned int  MethodILSize,
    PCWSTR  MethodNamespace,
    PCWSTR  MethodName,
    PCWSTR  MethodSignature,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMethodJittingStarted_V1(MethodID,ModuleID,MethodToken,MethodILSize,MethodNamespace,MethodName,MethodSignature,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodJittingStarted_V1(MethodID,ModuleID,MethodToken,MethodILSize,MethodNamespace,MethodName,MethodSignature,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMethodJitInliningSucceeded() {return EventPipeEventEnabledMethodJitInliningSucceeded() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodJitInliningSucceeded());}

inline ULONG FireEtwMethodJitInliningSucceeded(
    PCWSTR  MethodBeingCompiledNamespace,
    PCWSTR  MethodBeingCompiledName,
    PCWSTR  MethodBeingCompiledNameSignature,
    PCWSTR  InlinerNamespace,
    PCWSTR  InlinerName,
    PCWSTR  InlinerNameSignature,
    PCWSTR  InlineeNamespace,
    PCWSTR  InlineeName,
    PCWSTR  InlineeNameSignature,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMethodJitInliningSucceeded(MethodBeingCompiledNamespace,MethodBeingCompiledName,MethodBeingCompiledNameSignature,InlinerNamespace,InlinerName,InlinerNameSignature,InlineeNamespace,InlineeName,InlineeNameSignature,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodJitInliningSucceeded(MethodBeingCompiledNamespace,MethodBeingCompiledName,MethodBeingCompiledNameSignature,InlinerNamespace,InlinerName,InlinerNameSignature,InlineeNamespace,InlineeName,InlineeNameSignature,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMethodJitInliningFailed() {return EventPipeEventEnabledMethodJitInliningFailed() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodJitInliningFailed());}

inline ULONG FireEtwMethodJitInliningFailed(
    PCWSTR  MethodBeingCompiledNamespace,
    PCWSTR  MethodBeingCompiledName,
    PCWSTR  MethodBeingCompiledNameSignature,
    PCWSTR  InlinerNamespace,
    PCWSTR  InlinerName,
    PCWSTR  InlinerNameSignature,
    PCWSTR  InlineeNamespace,
    PCWSTR  InlineeName,
    PCWSTR  InlineeNameSignature,
    const BOOL  FailAlways,
    LPCSTR  FailReason,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMethodJitInliningFailed(MethodBeingCompiledNamespace,MethodBeingCompiledName,MethodBeingCompiledNameSignature,InlinerNamespace,InlinerName,InlinerNameSignature,InlineeNamespace,InlineeName,InlineeNameSignature,FailAlways,FailReason,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodJitInliningFailed(MethodBeingCompiledNamespace,MethodBeingCompiledName,MethodBeingCompiledNameSignature,InlinerNamespace,InlinerName,InlinerNameSignature,InlineeNamespace,InlineeName,InlineeNameSignature,FailAlways,FailReason,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMethodJitTailCallSucceeded() {return EventPipeEventEnabledMethodJitTailCallSucceeded() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodJitTailCallSucceeded());}

inline ULONG FireEtwMethodJitTailCallSucceeded(
    PCWSTR  MethodBeingCompiledNamespace,
    PCWSTR  MethodBeingCompiledName,
    PCWSTR  MethodBeingCompiledNameSignature,
    PCWSTR  CallerNamespace,
    PCWSTR  CallerName,
    PCWSTR  CallerNameSignature,
    PCWSTR  CalleeNamespace,
    PCWSTR  CalleeName,
    PCWSTR  CalleeNameSignature,
    const BOOL  TailPrefix,
    const unsigned int  TailCallType,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMethodJitTailCallSucceeded(MethodBeingCompiledNamespace,MethodBeingCompiledName,MethodBeingCompiledNameSignature,CallerNamespace,CallerName,CallerNameSignature,CalleeNamespace,CalleeName,CalleeNameSignature,TailPrefix,TailCallType,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodJitTailCallSucceeded(MethodBeingCompiledNamespace,MethodBeingCompiledName,MethodBeingCompiledNameSignature,CallerNamespace,CallerName,CallerNameSignature,CalleeNamespace,CalleeName,CalleeNameSignature,TailPrefix,TailCallType,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMethodJitTailCallFailed() {return EventPipeEventEnabledMethodJitTailCallFailed() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodJitTailCallFailed());}

inline ULONG FireEtwMethodJitTailCallFailed(
    PCWSTR  MethodBeingCompiledNamespace,
    PCWSTR  MethodBeingCompiledName,
    PCWSTR  MethodBeingCompiledNameSignature,
    PCWSTR  CallerNamespace,
    PCWSTR  CallerName,
    PCWSTR  CallerNameSignature,
    PCWSTR  CalleeNamespace,
    PCWSTR  CalleeName,
    PCWSTR  CalleeNameSignature,
    const BOOL  TailPrefix,
    LPCSTR  FailReason,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMethodJitTailCallFailed(MethodBeingCompiledNamespace,MethodBeingCompiledName,MethodBeingCompiledNameSignature,CallerNamespace,CallerName,CallerNameSignature,CalleeNamespace,CalleeName,CalleeNameSignature,TailPrefix,FailReason,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodJitTailCallFailed(MethodBeingCompiledNamespace,MethodBeingCompiledName,MethodBeingCompiledNameSignature,CallerNamespace,CallerName,CallerNameSignature,CalleeNamespace,CalleeName,CalleeNameSignature,TailPrefix,FailReason,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMethodILToNativeMap() {return EventPipeEventEnabledMethodILToNativeMap() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodILToNativeMap());}

inline ULONG FireEtwMethodILToNativeMap(
    const unsigned __int64  MethodID,
    const unsigned __int64  ReJITID,
    const unsigned char  MethodExtent,
    const unsigned short  CountOfMapEntries,
    const unsigned int* ILOffsets,
    const unsigned int* NativeOffsets,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMethodILToNativeMap(MethodID,ReJITID,MethodExtent,CountOfMapEntries,ILOffsets,NativeOffsets,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodILToNativeMap(MethodID,ReJITID,MethodExtent,CountOfMapEntries,ILOffsets,NativeOffsets,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledModuleDCStartV2() {return EventPipeEventEnabledModuleDCStartV2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleDCStartV2());}

inline ULONG FireEtwModuleDCStartV2(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath
)
{
    ULONG status = EventPipeWriteEventModuleDCStartV2(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleDCStartV2(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath);
    }
    return status;
}

inline BOOL EventEnabledModuleDCEndV2() {return EventPipeEventEnabledModuleDCEndV2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleDCEndV2());}

inline ULONG FireEtwModuleDCEndV2(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath
)
{
    ULONG status = EventPipeWriteEventModuleDCEndV2(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleDCEndV2(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath);
    }
    return status;
}

inline BOOL EventEnabledDomainModuleLoad() {return EventPipeEventEnabledDomainModuleLoad() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDomainModuleLoad());}

inline ULONG FireEtwDomainModuleLoad(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned __int64  AppDomainID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath
)
{
    ULONG status = EventPipeWriteEventDomainModuleLoad(ModuleID,AssemblyID,AppDomainID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDomainModuleLoad(ModuleID,AssemblyID,AppDomainID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath);
    }
    return status;
}

inline BOOL EventEnabledDomainModuleLoad_V1() {return EventPipeEventEnabledDomainModuleLoad_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDomainModuleLoad_V1());}

inline ULONG FireEtwDomainModuleLoad_V1(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned __int64  AppDomainID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventDomainModuleLoad_V1(ModuleID,AssemblyID,AppDomainID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDomainModuleLoad_V1(ModuleID,AssemblyID,AppDomainID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledModuleLoad() {return EventPipeEventEnabledModuleLoad() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleLoad());}

inline ULONG FireEtwModuleLoad(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath
)
{
    ULONG status = EventPipeWriteEventModuleLoad(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleLoad(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath);
    }
    return status;
}

inline BOOL EventEnabledModuleLoad_V1() {return EventPipeEventEnabledModuleLoad_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleLoad_V1());}

inline ULONG FireEtwModuleLoad_V1(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventModuleLoad_V1(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleLoad_V1(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledModuleLoad_V2() {return EventPipeEventEnabledModuleLoad_V2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleLoad_V2());}

inline ULONG FireEtwModuleLoad_V2(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath,
    const unsigned short  ClrInstanceID,
    const GUID* ManagedPdbSignature,
    const unsigned int  ManagedPdbAge,
    PCWSTR  ManagedPdbBuildPath,
    const GUID* NativePdbSignature,
    const unsigned int  NativePdbAge,
    PCWSTR  NativePdbBuildPath
)
{
    ULONG status = EventPipeWriteEventModuleLoad_V2(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID,ManagedPdbSignature,ManagedPdbAge,ManagedPdbBuildPath,NativePdbSignature,NativePdbAge,NativePdbBuildPath);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleLoad_V2(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID,ManagedPdbSignature,ManagedPdbAge,ManagedPdbBuildPath,NativePdbSignature,NativePdbAge,NativePdbBuildPath);
    }
    return status;
}

inline BOOL EventEnabledModuleUnload() {return EventPipeEventEnabledModuleUnload() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleUnload());}

inline ULONG FireEtwModuleUnload(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath
)
{
    ULONG status = EventPipeWriteEventModuleUnload(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleUnload(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath);
    }
    return status;
}

inline BOOL EventEnabledModuleUnload_V1() {return EventPipeEventEnabledModuleUnload_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleUnload_V1());}

inline ULONG FireEtwModuleUnload_V1(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventModuleUnload_V1(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleUnload_V1(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledModuleUnload_V2() {return EventPipeEventEnabledModuleUnload_V2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleUnload_V2());}

inline ULONG FireEtwModuleUnload_V2(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath,
    const unsigned short  ClrInstanceID,
    const GUID* ManagedPdbSignature,
    const unsigned int  ManagedPdbAge,
    PCWSTR  ManagedPdbBuildPath,
    const GUID* NativePdbSignature,
    const unsigned int  NativePdbAge,
    PCWSTR  NativePdbBuildPath
)
{
    ULONG status = EventPipeWriteEventModuleUnload_V2(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID,ManagedPdbSignature,ManagedPdbAge,ManagedPdbBuildPath,NativePdbSignature,NativePdbAge,NativePdbBuildPath);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleUnload_V2(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID,ManagedPdbSignature,ManagedPdbAge,ManagedPdbBuildPath,NativePdbSignature,NativePdbAge,NativePdbBuildPath);
    }
    return status;
}

inline BOOL EventEnabledAssemblyLoad() {return EventPipeEventEnabledAssemblyLoad() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAssemblyLoad());}

inline ULONG FireEtwAssemblyLoad(
    const unsigned __int64  AssemblyID,
    const unsigned __int64  AppDomainID,
    const unsigned int  AssemblyFlags,
    PCWSTR  FullyQualifiedAssemblyName
)
{
    ULONG status = EventPipeWriteEventAssemblyLoad(AssemblyID,AppDomainID,AssemblyFlags,FullyQualifiedAssemblyName);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAssemblyLoad(AssemblyID,AppDomainID,AssemblyFlags,FullyQualifiedAssemblyName);
    }
    return status;
}

inline BOOL EventEnabledAssemblyLoad_V1() {return EventPipeEventEnabledAssemblyLoad_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAssemblyLoad_V1());}

inline ULONG FireEtwAssemblyLoad_V1(
    const unsigned __int64  AssemblyID,
    const unsigned __int64  AppDomainID,
    const unsigned __int64  BindingID,
    const unsigned int  AssemblyFlags,
    PCWSTR  FullyQualifiedAssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventAssemblyLoad_V1(AssemblyID,AppDomainID,BindingID,AssemblyFlags,FullyQualifiedAssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAssemblyLoad_V1(AssemblyID,AppDomainID,BindingID,AssemblyFlags,FullyQualifiedAssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledAssemblyUnload() {return EventPipeEventEnabledAssemblyUnload() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAssemblyUnload());}

inline ULONG FireEtwAssemblyUnload(
    const unsigned __int64  AssemblyID,
    const unsigned __int64  AppDomainID,
    const unsigned int  AssemblyFlags,
    PCWSTR  FullyQualifiedAssemblyName
)
{
    ULONG status = EventPipeWriteEventAssemblyUnload(AssemblyID,AppDomainID,AssemblyFlags,FullyQualifiedAssemblyName);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAssemblyUnload(AssemblyID,AppDomainID,AssemblyFlags,FullyQualifiedAssemblyName);
    }
    return status;
}

inline BOOL EventEnabledAssemblyUnload_V1() {return EventPipeEventEnabledAssemblyUnload_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAssemblyUnload_V1());}

inline ULONG FireEtwAssemblyUnload_V1(
    const unsigned __int64  AssemblyID,
    const unsigned __int64  AppDomainID,
    const unsigned __int64  BindingID,
    const unsigned int  AssemblyFlags,
    PCWSTR  FullyQualifiedAssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventAssemblyUnload_V1(AssemblyID,AppDomainID,BindingID,AssemblyFlags,FullyQualifiedAssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAssemblyUnload_V1(AssemblyID,AppDomainID,BindingID,AssemblyFlags,FullyQualifiedAssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledAppDomainLoad() {return EventPipeEventEnabledAppDomainLoad() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAppDomainLoad());}

inline ULONG FireEtwAppDomainLoad(
    const unsigned __int64  AppDomainID,
    const unsigned int  AppDomainFlags,
    PCWSTR  AppDomainName
)
{
    ULONG status = EventPipeWriteEventAppDomainLoad(AppDomainID,AppDomainFlags,AppDomainName);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAppDomainLoad(AppDomainID,AppDomainFlags,AppDomainName);
    }
    return status;
}

inline BOOL EventEnabledAppDomainLoad_V1() {return EventPipeEventEnabledAppDomainLoad_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAppDomainLoad_V1());}

inline ULONG FireEtwAppDomainLoad_V1(
    const unsigned __int64  AppDomainID,
    const unsigned int  AppDomainFlags,
    PCWSTR  AppDomainName,
    const unsigned int  AppDomainIndex,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventAppDomainLoad_V1(AppDomainID,AppDomainFlags,AppDomainName,AppDomainIndex,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAppDomainLoad_V1(AppDomainID,AppDomainFlags,AppDomainName,AppDomainIndex,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledAppDomainUnload() {return EventPipeEventEnabledAppDomainUnload() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAppDomainUnload());}

inline ULONG FireEtwAppDomainUnload(
    const unsigned __int64  AppDomainID,
    const unsigned int  AppDomainFlags,
    PCWSTR  AppDomainName
)
{
    ULONG status = EventPipeWriteEventAppDomainUnload(AppDomainID,AppDomainFlags,AppDomainName);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAppDomainUnload(AppDomainID,AppDomainFlags,AppDomainName);
    }
    return status;
}

inline BOOL EventEnabledAppDomainUnload_V1() {return EventPipeEventEnabledAppDomainUnload_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAppDomainUnload_V1());}

inline ULONG FireEtwAppDomainUnload_V1(
    const unsigned __int64  AppDomainID,
    const unsigned int  AppDomainFlags,
    PCWSTR  AppDomainName,
    const unsigned int  AppDomainIndex,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventAppDomainUnload_V1(AppDomainID,AppDomainFlags,AppDomainName,AppDomainIndex,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAppDomainUnload_V1(AppDomainID,AppDomainFlags,AppDomainName,AppDomainIndex,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledModuleRangeLoad() {return EventPipeEventEnabledModuleRangeLoad() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleRangeLoad());}

inline ULONG FireEtwModuleRangeLoad(
    const unsigned short  ClrInstanceID,
    const unsigned __int64  ModuleID,
    const unsigned int  RangeBegin,
    const unsigned int  RangeSize,
    const unsigned char  RangeType
)
{
    ULONG status = EventPipeWriteEventModuleRangeLoad(ClrInstanceID,ModuleID,RangeBegin,RangeSize,RangeType);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleRangeLoad(ClrInstanceID,ModuleID,RangeBegin,RangeSize,RangeType);
    }
    return status;
}

inline BOOL EventEnabledStrongNameVerificationStart() {return EventPipeEventEnabledStrongNameVerificationStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledStrongNameVerificationStart());}

inline ULONG FireEtwStrongNameVerificationStart(
    const unsigned int  VerificationFlags,
    const unsigned int  ErrorCode,
    PCWSTR  FullyQualifiedAssemblyName
)
{
    ULONG status = EventPipeWriteEventStrongNameVerificationStart(VerificationFlags,ErrorCode,FullyQualifiedAssemblyName);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatStrongNameVerificationStart(VerificationFlags,ErrorCode,FullyQualifiedAssemblyName);
    }
    return status;
}

inline BOOL EventEnabledStrongNameVerificationStart_V1() {return EventPipeEventEnabledStrongNameVerificationStart_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledStrongNameVerificationStart_V1());}

inline ULONG FireEtwStrongNameVerificationStart_V1(
    const unsigned int  VerificationFlags,
    const unsigned int  ErrorCode,
    PCWSTR  FullyQualifiedAssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventStrongNameVerificationStart_V1(VerificationFlags,ErrorCode,FullyQualifiedAssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatStrongNameVerificationStart_V1(VerificationFlags,ErrorCode,FullyQualifiedAssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledStrongNameVerificationStop() {return EventPipeEventEnabledStrongNameVerificationStop() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledStrongNameVerificationStop());}

inline ULONG FireEtwStrongNameVerificationStop(
    const unsigned int  VerificationFlags,
    const unsigned int  ErrorCode,
    PCWSTR  FullyQualifiedAssemblyName
)
{
    ULONG status = EventPipeWriteEventStrongNameVerificationStop(VerificationFlags,ErrorCode,FullyQualifiedAssemblyName);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatStrongNameVerificationStop(VerificationFlags,ErrorCode,FullyQualifiedAssemblyName);
    }
    return status;
}

inline BOOL EventEnabledStrongNameVerificationStop_V1() {return EventPipeEventEnabledStrongNameVerificationStop_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledStrongNameVerificationStop_V1());}

inline ULONG FireEtwStrongNameVerificationStop_V1(
    const unsigned int  VerificationFlags,
    const unsigned int  ErrorCode,
    PCWSTR  FullyQualifiedAssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventStrongNameVerificationStop_V1(VerificationFlags,ErrorCode,FullyQualifiedAssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatStrongNameVerificationStop_V1(VerificationFlags,ErrorCode,FullyQualifiedAssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledAuthenticodeVerificationStart() {return EventPipeEventEnabledAuthenticodeVerificationStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAuthenticodeVerificationStart());}

inline ULONG FireEtwAuthenticodeVerificationStart(
    const unsigned int  VerificationFlags,
    const unsigned int  ErrorCode,
    PCWSTR  ModulePath
)
{
    ULONG status = EventPipeWriteEventAuthenticodeVerificationStart(VerificationFlags,ErrorCode,ModulePath);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAuthenticodeVerificationStart(VerificationFlags,ErrorCode,ModulePath);
    }
    return status;
}

inline BOOL EventEnabledAuthenticodeVerificationStart_V1() {return EventPipeEventEnabledAuthenticodeVerificationStart_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAuthenticodeVerificationStart_V1());}

inline ULONG FireEtwAuthenticodeVerificationStart_V1(
    const unsigned int  VerificationFlags,
    const unsigned int  ErrorCode,
    PCWSTR  ModulePath,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventAuthenticodeVerificationStart_V1(VerificationFlags,ErrorCode,ModulePath,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAuthenticodeVerificationStart_V1(VerificationFlags,ErrorCode,ModulePath,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledAuthenticodeVerificationStop() {return EventPipeEventEnabledAuthenticodeVerificationStop() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAuthenticodeVerificationStop());}

inline ULONG FireEtwAuthenticodeVerificationStop(
    const unsigned int  VerificationFlags,
    const unsigned int  ErrorCode,
    PCWSTR  ModulePath
)
{
    ULONG status = EventPipeWriteEventAuthenticodeVerificationStop(VerificationFlags,ErrorCode,ModulePath);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAuthenticodeVerificationStop(VerificationFlags,ErrorCode,ModulePath);
    }
    return status;
}

inline BOOL EventEnabledAuthenticodeVerificationStop_V1() {return EventPipeEventEnabledAuthenticodeVerificationStop_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAuthenticodeVerificationStop_V1());}

inline ULONG FireEtwAuthenticodeVerificationStop_V1(
    const unsigned int  VerificationFlags,
    const unsigned int  ErrorCode,
    PCWSTR  ModulePath,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventAuthenticodeVerificationStop_V1(VerificationFlags,ErrorCode,ModulePath,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAuthenticodeVerificationStop_V1(VerificationFlags,ErrorCode,ModulePath,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledRuntimeInformationStart() {return EventPipeEventEnabledRuntimeInformationStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledRuntimeInformationStart());}

inline ULONG FireEtwRuntimeInformationStart(
    const unsigned short  ClrInstanceID,
    const unsigned short  Sku,
    const unsigned short  BclMajorVersion,
    const unsigned short  BclMinorVersion,
    const unsigned short  BclBuildNumber,
    const unsigned short  BclQfeNumber,
    const unsigned short  VMMajorVersion,
    const unsigned short  VMMinorVersion,
    const unsigned short  VMBuildNumber,
    const unsigned short  VMQfeNumber,
    const unsigned int  StartupFlags,
    const unsigned char  StartupMode,
    PCWSTR  CommandLine,
    const GUID* ComObjectGuid,
    PCWSTR  RuntimeDllPath
)
{
    ULONG status = EventPipeWriteEventRuntimeInformationStart(ClrInstanceID,Sku,BclMajorVersion,BclMinorVersion,BclBuildNumber,BclQfeNumber,VMMajorVersion,VMMinorVersion,VMBuildNumber,VMQfeNumber,StartupFlags,StartupMode,CommandLine,ComObjectGuid,RuntimeDllPath);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatRuntimeInformationStart(ClrInstanceID,Sku,BclMajorVersion,BclMinorVersion,BclBuildNumber,BclQfeNumber,VMMajorVersion,VMMinorVersion,VMBuildNumber,VMQfeNumber,StartupFlags,StartupMode,CommandLine,ComObjectGuid,RuntimeDllPath);
    }
    return status;
}

inline BOOL EventEnabledIncreaseMemoryPressure() {return EventPipeEventEnabledIncreaseMemoryPressure() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledIncreaseMemoryPressure());}

inline ULONG FireEtwIncreaseMemoryPressure(
    const unsigned __int64  BytesAllocated,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventIncreaseMemoryPressure(BytesAllocated,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatIncreaseMemoryPressure(BytesAllocated,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledDecreaseMemoryPressure() {return EventPipeEventEnabledDecreaseMemoryPressure() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDecreaseMemoryPressure());}

inline ULONG FireEtwDecreaseMemoryPressure(
    const unsigned __int64  BytesFreed,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventDecreaseMemoryPressure(BytesFreed,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDecreaseMemoryPressure(BytesFreed,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCMarkWithType() {return EventPipeEventEnabledGCMarkWithType() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCMarkWithType());}

inline ULONG FireEtwGCMarkWithType(
    const unsigned int  HeapNum,
    const unsigned short  ClrInstanceID,
    const unsigned int  Type,
    const unsigned __int64  Bytes
)
{
    ULONG status = EventPipeWriteEventGCMarkWithType(HeapNum,ClrInstanceID,Type,Bytes);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCMarkWithType(HeapNum,ClrInstanceID,Type,Bytes);
    }
    return status;
}

inline BOOL EventEnabledGCJoin_V2() {return EventPipeEventEnabledGCJoin_V2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCJoin_V2());}

inline ULONG FireEtwGCJoin_V2(
    const unsigned int  Heap,
    const unsigned int  JoinTime,
    const unsigned int  JoinType,
    const unsigned short  ClrInstanceID,
    const unsigned int  JoinID
)
{
    ULONG status = EventPipeWriteEventGCJoin_V2(Heap,JoinTime,JoinType,ClrInstanceID,JoinID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCJoin_V2(Heap,JoinTime,JoinType,ClrInstanceID,JoinID);
    }
    return status;
}

inline BOOL EventEnabledGCPerHeapHistory_V3() {return EventPipeEventEnabledGCPerHeapHistory_V3() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCPerHeapHistory_V3());}

inline ULONG FireEtwGCPerHeapHistory_V3(
    const unsigned short  ClrInstanceID,
    const void*  FreeListAllocated,
    const void*  FreeListRejected,
    const void*  EndOfSegAllocated,
    const void*  CondemnedAllocated,
    const void*  PinnedAllocated,
    const void*  PinnedAllocatedAdvance,
    const unsigned int  RunningFreeListEfficiency,
    const unsigned int  CondemnReasons0,
    const unsigned int  CondemnReasons1,
    const unsigned int  CompactMechanisms,
    const unsigned int  ExpandMechanisms,
    const unsigned int  HeapIndex,
    const void*  ExtraGen0Commit,
    const unsigned int  Count,
    int Values_ElementSize,
    const void* Values
)
{
    ULONG status = EventPipeWriteEventGCPerHeapHistory_V3(ClrInstanceID,FreeListAllocated,FreeListRejected,EndOfSegAllocated,CondemnedAllocated,PinnedAllocated,PinnedAllocatedAdvance,RunningFreeListEfficiency,CondemnReasons0,CondemnReasons1,CompactMechanisms,ExpandMechanisms,HeapIndex,ExtraGen0Commit,Count,Values_ElementSize, Values);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCPerHeapHistory_V3(ClrInstanceID,FreeListAllocated,FreeListRejected,EndOfSegAllocated,CondemnedAllocated,PinnedAllocated,PinnedAllocatedAdvance,RunningFreeListEfficiency,CondemnReasons0,CondemnReasons1,CompactMechanisms,ExpandMechanisms,HeapIndex,ExtraGen0Commit,Count,Values_ElementSize, Values);
    }
    return status;
}

inline BOOL EventEnabledGCGlobalHeapHistory_V2() {return EventPipeEventEnabledGCGlobalHeapHistory_V2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCGlobalHeapHistory_V2());}

inline ULONG FireEtwGCGlobalHeapHistory_V2(
    const unsigned __int64  FinalYoungestDesired,
    const signed int  NumHeaps,
    const unsigned int  CondemnedGeneration,
    const unsigned int  Gen0ReductionCount,
    const unsigned int  Reason,
    const unsigned int  GlobalMechanisms,
    const unsigned short  ClrInstanceID,
    const unsigned int  PauseMode,
    const unsigned int  MemoryPressure
)
{
    ULONG status = EventPipeWriteEventGCGlobalHeapHistory_V2(FinalYoungestDesired,NumHeaps,CondemnedGeneration,Gen0ReductionCount,Reason,GlobalMechanisms,ClrInstanceID,PauseMode,MemoryPressure);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCGlobalHeapHistory_V2(FinalYoungestDesired,NumHeaps,CondemnedGeneration,Gen0ReductionCount,Reason,GlobalMechanisms,ClrInstanceID,PauseMode,MemoryPressure);
    }
    return status;
}

inline BOOL EventEnabledDebugIPCEventStart() {return EventPipeEventEnabledDebugIPCEventStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDebugIPCEventStart());}

inline ULONG FireEtwDebugIPCEventStart(

)
{
    ULONG status = EventPipeWriteEventDebugIPCEventStart();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDebugIPCEventStart();
    }
    return status;
}

inline BOOL EventEnabledDebugIPCEventEnd() {return EventPipeEventEnabledDebugIPCEventEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDebugIPCEventEnd());}

inline ULONG FireEtwDebugIPCEventEnd(

)
{
    ULONG status = EventPipeWriteEventDebugIPCEventEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDebugIPCEventEnd();
    }
    return status;
}

inline BOOL EventEnabledDebugExceptionProcessingStart() {return EventPipeEventEnabledDebugExceptionProcessingStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDebugExceptionProcessingStart());}

inline ULONG FireEtwDebugExceptionProcessingStart(

)
{
    ULONG status = EventPipeWriteEventDebugExceptionProcessingStart();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDebugExceptionProcessingStart();
    }
    return status;
}

inline BOOL EventEnabledDebugExceptionProcessingEnd() {return EventPipeEventEnabledDebugExceptionProcessingEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDebugExceptionProcessingEnd());}

inline ULONG FireEtwDebugExceptionProcessingEnd(

)
{
    ULONG status = EventPipeWriteEventDebugExceptionProcessingEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDebugExceptionProcessingEnd();
    }
    return status;
}

inline BOOL EventEnabledCodeSymbols() {return EventPipeEventEnabledCodeSymbols() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledCodeSymbols());}

inline ULONG FireEtwCodeSymbols(
    const unsigned __int64  ModuleId,
    const unsigned short  TotalChunks,
    const unsigned short  ChunkNumber,
    const unsigned int  ChunkLength,
    const BYTE* Chunk,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventCodeSymbols(ModuleId,TotalChunks,ChunkNumber,ChunkLength,Chunk,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatCodeSymbols(ModuleId,TotalChunks,ChunkNumber,ChunkLength,Chunk,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledEventSource() {return EventPipeEventEnabledEventSource() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledEventSource());}

inline ULONG FireEtwEventSource(
    const signed int  EventID,
    PCWSTR  EventName,
    PCWSTR  EventSourceName,
    PCWSTR  Payload
)
{
    ULONG status = EventPipeWriteEventEventSource(EventID,EventName,EventSourceName,Payload);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatEventSource(EventID,EventName,EventSourceName,Payload);
    }
    return status;
}


inline BOOL EventEnabledCLRStackWalkDCStart() {return EventPipeEventEnabledCLRStackWalkDCStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledCLRStackWalkDCStart());}

inline ULONG FireEtwCLRStackWalkDCStart(
    const unsigned short  ClrInstanceID,
    const unsigned char  Reserved1,
    const unsigned char  Reserved2,
    const unsigned int  FrameCount,
    const void** Stack
)
{
    ULONG status = EventPipeWriteEventCLRStackWalkDCStart(ClrInstanceID,Reserved1,Reserved2,FrameCount,Stack);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatCLRStackWalkDCStart(ClrInstanceID,Reserved1,Reserved2,FrameCount,Stack);
    }
    return status;
}

inline BOOL EventEnabledMethodDCStart() {return EventPipeEventEnabledMethodDCStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodDCStart());}

inline ULONG FireEtwMethodDCStart(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags
)
{
    ULONG status = EventPipeWriteEventMethodDCStart(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodDCStart(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags);
    }
    return status;
}

inline BOOL EventEnabledMethodDCStart_V1() {return EventPipeEventEnabledMethodDCStart_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodDCStart_V1());}

inline ULONG FireEtwMethodDCStart_V1(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMethodDCStart_V1(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodDCStart_V1(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMethodDCStart_V2() {return EventPipeEventEnabledMethodDCStart_V2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodDCStart_V2());}

inline ULONG FireEtwMethodDCStart_V2(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    const unsigned short  ClrInstanceID,
    const unsigned __int64  ReJITID
)
{
    ULONG status = EventPipeWriteEventMethodDCStart_V2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,ClrInstanceID,ReJITID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodDCStart_V2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,ClrInstanceID,ReJITID);
    }
    return status;
}

inline BOOL EventEnabledMethodDCEnd() {return EventPipeEventEnabledMethodDCEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodDCEnd());}

inline ULONG FireEtwMethodDCEnd(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags
)
{
    ULONG status = EventPipeWriteEventMethodDCEnd(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodDCEnd(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags);
    }
    return status;
}

inline BOOL EventEnabledMethodDCEnd_V1() {return EventPipeEventEnabledMethodDCEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodDCEnd_V1());}

inline ULONG FireEtwMethodDCEnd_V1(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMethodDCEnd_V1(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodDCEnd_V1(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMethodDCEnd_V2() {return EventPipeEventEnabledMethodDCEnd_V2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodDCEnd_V2());}

inline ULONG FireEtwMethodDCEnd_V2(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    const unsigned short  ClrInstanceID,
    const unsigned __int64  ReJITID
)
{
    ULONG status = EventPipeWriteEventMethodDCEnd_V2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,ClrInstanceID,ReJITID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodDCEnd_V2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,ClrInstanceID,ReJITID);
    }
    return status;
}

inline BOOL EventEnabledMethodDCStartVerbose() {return EventPipeEventEnabledMethodDCStartVerbose() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodDCStartVerbose());}

inline ULONG FireEtwMethodDCStartVerbose(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    PCWSTR  MethodNamespace,
    PCWSTR  MethodName,
    PCWSTR  MethodSignature
)
{
    ULONG status = EventPipeWriteEventMethodDCStartVerbose(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodDCStartVerbose(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature);
    }
    return status;
}

inline BOOL EventEnabledMethodDCStartVerbose_V1() {return EventPipeEventEnabledMethodDCStartVerbose_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodDCStartVerbose_V1());}

inline ULONG FireEtwMethodDCStartVerbose_V1(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    PCWSTR  MethodNamespace,
    PCWSTR  MethodName,
    PCWSTR  MethodSignature,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMethodDCStartVerbose_V1(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodDCStartVerbose_V1(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMethodDCStartVerbose_V2() {return EventPipeEventEnabledMethodDCStartVerbose_V2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodDCStartVerbose_V2());}

inline ULONG FireEtwMethodDCStartVerbose_V2(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    PCWSTR  MethodNamespace,
    PCWSTR  MethodName,
    PCWSTR  MethodSignature,
    const unsigned short  ClrInstanceID,
    const unsigned __int64  ReJITID
)
{
    ULONG status = EventPipeWriteEventMethodDCStartVerbose_V2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature,ClrInstanceID,ReJITID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodDCStartVerbose_V2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature,ClrInstanceID,ReJITID);
    }
    return status;
}

inline BOOL EventEnabledMethodDCEndVerbose() {return EventPipeEventEnabledMethodDCEndVerbose() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodDCEndVerbose());}

inline ULONG FireEtwMethodDCEndVerbose(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    PCWSTR  MethodNamespace,
    PCWSTR  MethodName,
    PCWSTR  MethodSignature
)
{
    ULONG status = EventPipeWriteEventMethodDCEndVerbose(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodDCEndVerbose(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature);
    }
    return status;
}

inline BOOL EventEnabledMethodDCEndVerbose_V1() {return EventPipeEventEnabledMethodDCEndVerbose_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodDCEndVerbose_V1());}

inline ULONG FireEtwMethodDCEndVerbose_V1(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    PCWSTR  MethodNamespace,
    PCWSTR  MethodName,
    PCWSTR  MethodSignature,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMethodDCEndVerbose_V1(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodDCEndVerbose_V1(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMethodDCEndVerbose_V2() {return EventPipeEventEnabledMethodDCEndVerbose_V2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodDCEndVerbose_V2());}

inline ULONG FireEtwMethodDCEndVerbose_V2(
    const unsigned __int64  MethodID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodStartAddress,
    const unsigned int  MethodSize,
    const unsigned int  MethodToken,
    const unsigned int  MethodFlags,
    PCWSTR  MethodNamespace,
    PCWSTR  MethodName,
    PCWSTR  MethodSignature,
    const unsigned short  ClrInstanceID,
    const unsigned __int64  ReJITID
)
{
    ULONG status = EventPipeWriteEventMethodDCEndVerbose_V2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature,ClrInstanceID,ReJITID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodDCEndVerbose_V2(MethodID,ModuleID,MethodStartAddress,MethodSize,MethodToken,MethodFlags,MethodNamespace,MethodName,MethodSignature,ClrInstanceID,ReJITID);
    }
    return status;
}

inline BOOL EventEnabledDCStartComplete() {return EventPipeEventEnabledDCStartComplete() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDCStartComplete());}

inline ULONG FireEtwDCStartComplete(

)
{
    ULONG status = EventPipeWriteEventDCStartComplete();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDCStartComplete();
    }
    return status;
}

inline BOOL EventEnabledDCStartComplete_V1() {return EventPipeEventEnabledDCStartComplete_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDCStartComplete_V1());}

inline ULONG FireEtwDCStartComplete_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventDCStartComplete_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDCStartComplete_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledDCEndComplete() {return EventPipeEventEnabledDCEndComplete() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDCEndComplete());}

inline ULONG FireEtwDCEndComplete(

)
{
    ULONG status = EventPipeWriteEventDCEndComplete();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDCEndComplete();
    }
    return status;
}

inline BOOL EventEnabledDCEndComplete_V1() {return EventPipeEventEnabledDCEndComplete_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDCEndComplete_V1());}

inline ULONG FireEtwDCEndComplete_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventDCEndComplete_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDCEndComplete_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledDCStartInit() {return EventPipeEventEnabledDCStartInit() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDCStartInit());}

inline ULONG FireEtwDCStartInit(

)
{
    ULONG status = EventPipeWriteEventDCStartInit();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDCStartInit();
    }
    return status;
}

inline BOOL EventEnabledDCStartInit_V1() {return EventPipeEventEnabledDCStartInit_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDCStartInit_V1());}

inline ULONG FireEtwDCStartInit_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventDCStartInit_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDCStartInit_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledDCEndInit() {return EventPipeEventEnabledDCEndInit() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDCEndInit());}

inline ULONG FireEtwDCEndInit(

)
{
    ULONG status = EventPipeWriteEventDCEndInit();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDCEndInit();
    }
    return status;
}

inline BOOL EventEnabledDCEndInit_V1() {return EventPipeEventEnabledDCEndInit_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDCEndInit_V1());}

inline ULONG FireEtwDCEndInit_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventDCEndInit_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDCEndInit_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMethodDCStartILToNativeMap() {return EventPipeEventEnabledMethodDCStartILToNativeMap() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodDCStartILToNativeMap());}

inline ULONG FireEtwMethodDCStartILToNativeMap(
    const unsigned __int64  MethodID,
    const unsigned __int64  ReJITID,
    const unsigned char  MethodExtent,
    const unsigned short  CountOfMapEntries,
    const unsigned int* ILOffsets,
    const unsigned int* NativeOffsets,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMethodDCStartILToNativeMap(MethodID,ReJITID,MethodExtent,CountOfMapEntries,ILOffsets,NativeOffsets,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodDCStartILToNativeMap(MethodID,ReJITID,MethodExtent,CountOfMapEntries,ILOffsets,NativeOffsets,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMethodDCEndILToNativeMap() {return EventPipeEventEnabledMethodDCEndILToNativeMap() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodDCEndILToNativeMap());}

inline ULONG FireEtwMethodDCEndILToNativeMap(
    const unsigned __int64  MethodID,
    const unsigned __int64  ReJITID,
    const unsigned char  MethodExtent,
    const unsigned short  CountOfMapEntries,
    const unsigned int* ILOffsets,
    const unsigned int* NativeOffsets,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMethodDCEndILToNativeMap(MethodID,ReJITID,MethodExtent,CountOfMapEntries,ILOffsets,NativeOffsets,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodDCEndILToNativeMap(MethodID,ReJITID,MethodExtent,CountOfMapEntries,ILOffsets,NativeOffsets,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledDomainModuleDCStart() {return EventPipeEventEnabledDomainModuleDCStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDomainModuleDCStart());}

inline ULONG FireEtwDomainModuleDCStart(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned __int64  AppDomainID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath
)
{
    ULONG status = EventPipeWriteEventDomainModuleDCStart(ModuleID,AssemblyID,AppDomainID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDomainModuleDCStart(ModuleID,AssemblyID,AppDomainID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath);
    }
    return status;
}

inline BOOL EventEnabledDomainModuleDCStart_V1() {return EventPipeEventEnabledDomainModuleDCStart_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDomainModuleDCStart_V1());}

inline ULONG FireEtwDomainModuleDCStart_V1(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned __int64  AppDomainID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventDomainModuleDCStart_V1(ModuleID,AssemblyID,AppDomainID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDomainModuleDCStart_V1(ModuleID,AssemblyID,AppDomainID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledDomainModuleDCEnd() {return EventPipeEventEnabledDomainModuleDCEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDomainModuleDCEnd());}

inline ULONG FireEtwDomainModuleDCEnd(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned __int64  AppDomainID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath
)
{
    ULONG status = EventPipeWriteEventDomainModuleDCEnd(ModuleID,AssemblyID,AppDomainID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDomainModuleDCEnd(ModuleID,AssemblyID,AppDomainID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath);
    }
    return status;
}

inline BOOL EventEnabledDomainModuleDCEnd_V1() {return EventPipeEventEnabledDomainModuleDCEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledDomainModuleDCEnd_V1());}

inline ULONG FireEtwDomainModuleDCEnd_V1(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned __int64  AppDomainID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventDomainModuleDCEnd_V1(ModuleID,AssemblyID,AppDomainID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatDomainModuleDCEnd_V1(ModuleID,AssemblyID,AppDomainID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledModuleDCStart() {return EventPipeEventEnabledModuleDCStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleDCStart());}

inline ULONG FireEtwModuleDCStart(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath
)
{
    ULONG status = EventPipeWriteEventModuleDCStart(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleDCStart(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath);
    }
    return status;
}

inline BOOL EventEnabledModuleDCStart_V1() {return EventPipeEventEnabledModuleDCStart_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleDCStart_V1());}

inline ULONG FireEtwModuleDCStart_V1(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventModuleDCStart_V1(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleDCStart_V1(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledModuleDCStart_V2() {return EventPipeEventEnabledModuleDCStart_V2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleDCStart_V2());}

inline ULONG FireEtwModuleDCStart_V2(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath,
    const unsigned short  ClrInstanceID,
    const GUID* ManagedPdbSignature,
    const unsigned int  ManagedPdbAge,
    PCWSTR  ManagedPdbBuildPath,
    const GUID* NativePdbSignature,
    const unsigned int  NativePdbAge,
    PCWSTR  NativePdbBuildPath
)
{
    ULONG status = EventPipeWriteEventModuleDCStart_V2(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID,ManagedPdbSignature,ManagedPdbAge,ManagedPdbBuildPath,NativePdbSignature,NativePdbAge,NativePdbBuildPath);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleDCStart_V2(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID,ManagedPdbSignature,ManagedPdbAge,ManagedPdbBuildPath,NativePdbSignature,NativePdbAge,NativePdbBuildPath);
    }
    return status;
}

inline BOOL EventEnabledModuleDCEnd() {return EventPipeEventEnabledModuleDCEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleDCEnd());}

inline ULONG FireEtwModuleDCEnd(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath
)
{
    ULONG status = EventPipeWriteEventModuleDCEnd(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleDCEnd(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath);
    }
    return status;
}

inline BOOL EventEnabledModuleDCEnd_V1() {return EventPipeEventEnabledModuleDCEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleDCEnd_V1());}

inline ULONG FireEtwModuleDCEnd_V1(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventModuleDCEnd_V1(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleDCEnd_V1(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledModuleDCEnd_V2() {return EventPipeEventEnabledModuleDCEnd_V2() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleDCEnd_V2());}

inline ULONG FireEtwModuleDCEnd_V2(
    const unsigned __int64  ModuleID,
    const unsigned __int64  AssemblyID,
    const unsigned int  ModuleFlags,
    const unsigned int  Reserved1,
    PCWSTR  ModuleILPath,
    PCWSTR  ModuleNativePath,
    const unsigned short  ClrInstanceID,
    const GUID* ManagedPdbSignature,
    const unsigned int  ManagedPdbAge,
    PCWSTR  ManagedPdbBuildPath,
    const GUID* NativePdbSignature,
    const unsigned int  NativePdbAge,
    PCWSTR  NativePdbBuildPath
)
{
    ULONG status = EventPipeWriteEventModuleDCEnd_V2(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID,ManagedPdbSignature,ManagedPdbAge,ManagedPdbBuildPath,NativePdbSignature,NativePdbAge,NativePdbBuildPath);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleDCEnd_V2(ModuleID,AssemblyID,ModuleFlags,Reserved1,ModuleILPath,ModuleNativePath,ClrInstanceID,ManagedPdbSignature,ManagedPdbAge,ManagedPdbBuildPath,NativePdbSignature,NativePdbAge,NativePdbBuildPath);
    }
    return status;
}

inline BOOL EventEnabledAssemblyDCStart() {return EventPipeEventEnabledAssemblyDCStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAssemblyDCStart());}

inline ULONG FireEtwAssemblyDCStart(
    const unsigned __int64  AssemblyID,
    const unsigned __int64  AppDomainID,
    const unsigned int  AssemblyFlags,
    PCWSTR  FullyQualifiedAssemblyName
)
{
    ULONG status = EventPipeWriteEventAssemblyDCStart(AssemblyID,AppDomainID,AssemblyFlags,FullyQualifiedAssemblyName);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAssemblyDCStart(AssemblyID,AppDomainID,AssemblyFlags,FullyQualifiedAssemblyName);
    }
    return status;
}

inline BOOL EventEnabledAssemblyDCStart_V1() {return EventPipeEventEnabledAssemblyDCStart_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAssemblyDCStart_V1());}

inline ULONG FireEtwAssemblyDCStart_V1(
    const unsigned __int64  AssemblyID,
    const unsigned __int64  AppDomainID,
    const unsigned __int64  BindingID,
    const unsigned int  AssemblyFlags,
    PCWSTR  FullyQualifiedAssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventAssemblyDCStart_V1(AssemblyID,AppDomainID,BindingID,AssemblyFlags,FullyQualifiedAssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAssemblyDCStart_V1(AssemblyID,AppDomainID,BindingID,AssemblyFlags,FullyQualifiedAssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledAssemblyDCEnd() {return EventPipeEventEnabledAssemblyDCEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAssemblyDCEnd());}

inline ULONG FireEtwAssemblyDCEnd(
    const unsigned __int64  AssemblyID,
    const unsigned __int64  AppDomainID,
    const unsigned int  AssemblyFlags,
    PCWSTR  FullyQualifiedAssemblyName
)
{
    ULONG status = EventPipeWriteEventAssemblyDCEnd(AssemblyID,AppDomainID,AssemblyFlags,FullyQualifiedAssemblyName);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAssemblyDCEnd(AssemblyID,AppDomainID,AssemblyFlags,FullyQualifiedAssemblyName);
    }
    return status;
}

inline BOOL EventEnabledAssemblyDCEnd_V1() {return EventPipeEventEnabledAssemblyDCEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAssemblyDCEnd_V1());}

inline ULONG FireEtwAssemblyDCEnd_V1(
    const unsigned __int64  AssemblyID,
    const unsigned __int64  AppDomainID,
    const unsigned __int64  BindingID,
    const unsigned int  AssemblyFlags,
    PCWSTR  FullyQualifiedAssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventAssemblyDCEnd_V1(AssemblyID,AppDomainID,BindingID,AssemblyFlags,FullyQualifiedAssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAssemblyDCEnd_V1(AssemblyID,AppDomainID,BindingID,AssemblyFlags,FullyQualifiedAssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledAppDomainDCStart() {return EventPipeEventEnabledAppDomainDCStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAppDomainDCStart());}

inline ULONG FireEtwAppDomainDCStart(
    const unsigned __int64  AppDomainID,
    const unsigned int  AppDomainFlags,
    PCWSTR  AppDomainName
)
{
    ULONG status = EventPipeWriteEventAppDomainDCStart(AppDomainID,AppDomainFlags,AppDomainName);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAppDomainDCStart(AppDomainID,AppDomainFlags,AppDomainName);
    }
    return status;
}

inline BOOL EventEnabledAppDomainDCStart_V1() {return EventPipeEventEnabledAppDomainDCStart_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAppDomainDCStart_V1());}

inline ULONG FireEtwAppDomainDCStart_V1(
    const unsigned __int64  AppDomainID,
    const unsigned int  AppDomainFlags,
    PCWSTR  AppDomainName,
    const unsigned int  AppDomainIndex,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventAppDomainDCStart_V1(AppDomainID,AppDomainFlags,AppDomainName,AppDomainIndex,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAppDomainDCStart_V1(AppDomainID,AppDomainFlags,AppDomainName,AppDomainIndex,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledAppDomainDCEnd() {return EventPipeEventEnabledAppDomainDCEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAppDomainDCEnd());}

inline ULONG FireEtwAppDomainDCEnd(
    const unsigned __int64  AppDomainID,
    const unsigned int  AppDomainFlags,
    PCWSTR  AppDomainName
)
{
    ULONG status = EventPipeWriteEventAppDomainDCEnd(AppDomainID,AppDomainFlags,AppDomainName);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAppDomainDCEnd(AppDomainID,AppDomainFlags,AppDomainName);
    }
    return status;
}

inline BOOL EventEnabledAppDomainDCEnd_V1() {return EventPipeEventEnabledAppDomainDCEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAppDomainDCEnd_V1());}

inline ULONG FireEtwAppDomainDCEnd_V1(
    const unsigned __int64  AppDomainID,
    const unsigned int  AppDomainFlags,
    PCWSTR  AppDomainName,
    const unsigned int  AppDomainIndex,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventAppDomainDCEnd_V1(AppDomainID,AppDomainFlags,AppDomainName,AppDomainIndex,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAppDomainDCEnd_V1(AppDomainID,AppDomainFlags,AppDomainName,AppDomainIndex,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledThreadDC() {return EventPipeEventEnabledThreadDC() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledThreadDC());}

inline ULONG FireEtwThreadDC(
    const unsigned __int64  ManagedThreadID,
    const unsigned __int64  AppDomainID,
    const unsigned int  Flags,
    const unsigned int  ManagedThreadIndex,
    const unsigned int  OSThreadID,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventThreadDC(ManagedThreadID,AppDomainID,Flags,ManagedThreadIndex,OSThreadID,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatThreadDC(ManagedThreadID,AppDomainID,Flags,ManagedThreadIndex,OSThreadID,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledModuleRangeDCStart() {return EventPipeEventEnabledModuleRangeDCStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleRangeDCStart());}

inline ULONG FireEtwModuleRangeDCStart(
    const unsigned short  ClrInstanceID,
    const unsigned __int64  ModuleID,
    const unsigned int  RangeBegin,
    const unsigned int  RangeSize,
    const unsigned char  RangeType
)
{
    ULONG status = EventPipeWriteEventModuleRangeDCStart(ClrInstanceID,ModuleID,RangeBegin,RangeSize,RangeType);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleRangeDCStart(ClrInstanceID,ModuleID,RangeBegin,RangeSize,RangeType);
    }
    return status;
}

inline BOOL EventEnabledModuleRangeDCEnd() {return EventPipeEventEnabledModuleRangeDCEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleRangeDCEnd());}

inline ULONG FireEtwModuleRangeDCEnd(
    const unsigned short  ClrInstanceID,
    const unsigned __int64  ModuleID,
    const unsigned int  RangeBegin,
    const unsigned int  RangeSize,
    const unsigned char  RangeType
)
{
    ULONG status = EventPipeWriteEventModuleRangeDCEnd(ClrInstanceID,ModuleID,RangeBegin,RangeSize,RangeType);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleRangeDCEnd(ClrInstanceID,ModuleID,RangeBegin,RangeSize,RangeType);
    }
    return status;
}

inline BOOL EventEnabledRuntimeInformationDCStart() {return EventPipeEventEnabledRuntimeInformationDCStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledRuntimeInformationDCStart());}

inline ULONG FireEtwRuntimeInformationDCStart(
    const unsigned short  ClrInstanceID,
    const unsigned short  Sku,
    const unsigned short  BclMajorVersion,
    const unsigned short  BclMinorVersion,
    const unsigned short  BclBuildNumber,
    const unsigned short  BclQfeNumber,
    const unsigned short  VMMajorVersion,
    const unsigned short  VMMinorVersion,
    const unsigned short  VMBuildNumber,
    const unsigned short  VMQfeNumber,
    const unsigned int  StartupFlags,
    const unsigned char  StartupMode,
    PCWSTR  CommandLine,
    const GUID* ComObjectGuid,
    PCWSTR  RuntimeDllPath
)
{
    ULONG status = EventPipeWriteEventRuntimeInformationDCStart(ClrInstanceID,Sku,BclMajorVersion,BclMinorVersion,BclBuildNumber,BclQfeNumber,VMMajorVersion,VMMinorVersion,VMBuildNumber,VMQfeNumber,StartupFlags,StartupMode,CommandLine,ComObjectGuid,RuntimeDllPath);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatRuntimeInformationDCStart(ClrInstanceID,Sku,BclMajorVersion,BclMinorVersion,BclBuildNumber,BclQfeNumber,VMMajorVersion,VMMinorVersion,VMBuildNumber,VMQfeNumber,StartupFlags,StartupMode,CommandLine,ComObjectGuid,RuntimeDllPath);
    }
    return status;
}


inline BOOL EventEnabledStressLogEvent() {return EventPipeEventEnabledStressLogEvent() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledStressLogEvent());}

inline ULONG FireEtwStressLogEvent(
    const unsigned int  Facility,
    const unsigned char  LogLevel,
    LPCSTR  Message
)
{
    ULONG status = EventPipeWriteEventStressLogEvent(Facility,LogLevel,Message);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatStressLogEvent(Facility,LogLevel,Message);
    }
    return status;
}

inline BOOL EventEnabledStressLogEvent_V1() {return EventPipeEventEnabledStressLogEvent_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledStressLogEvent_V1());}

inline ULONG FireEtwStressLogEvent_V1(
    const unsigned int  Facility,
    const unsigned char  LogLevel,
    LPCSTR  Message,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventStressLogEvent_V1(Facility,LogLevel,Message,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatStressLogEvent_V1(Facility,LogLevel,Message,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledCLRStackWalkStress() {return EventPipeEventEnabledCLRStackWalkStress() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledCLRStackWalkStress());}

inline ULONG FireEtwCLRStackWalkStress(
    const unsigned short  ClrInstanceID,
    const unsigned char  Reserved1,
    const unsigned char  Reserved2,
    const unsigned int  FrameCount,
    const void** Stack
)
{
    ULONG status = EventPipeWriteEventCLRStackWalkStress(ClrInstanceID,Reserved1,Reserved2,FrameCount,Stack);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatCLRStackWalkStress(ClrInstanceID,Reserved1,Reserved2,FrameCount,Stack);
    }
    return status;
}


inline BOOL EventEnabledGCDecision() {return EventPipeEventEnabledGCDecision() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCDecision());}

inline ULONG FireEtwGCDecision(
    const BOOL  DoCompact
)
{
    ULONG status = EventPipeWriteEventGCDecision(DoCompact);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCDecision(DoCompact);
    }
    return status;
}

inline BOOL EventEnabledGCDecision_V1() {return EventPipeEventEnabledGCDecision_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCDecision_V1());}

inline ULONG FireEtwGCDecision_V1(
    const BOOL  DoCompact,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCDecision_V1(DoCompact,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCDecision_V1(DoCompact,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCSettings() {return EventPipeEventEnabledGCSettings() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCSettings());}

inline ULONG FireEtwGCSettings(
    const unsigned __int64  SegmentSize,
    const unsigned __int64  LargeObjectSegmentSize,
    const BOOL  ServerGC
)
{
    ULONG status = EventPipeWriteEventGCSettings(SegmentSize,LargeObjectSegmentSize,ServerGC);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCSettings(SegmentSize,LargeObjectSegmentSize,ServerGC);
    }
    return status;
}

inline BOOL EventEnabledGCSettings_V1() {return EventPipeEventEnabledGCSettings_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCSettings_V1());}

inline ULONG FireEtwGCSettings_V1(
    const unsigned __int64  SegmentSize,
    const unsigned __int64  LargeObjectSegmentSize,
    const BOOL  ServerGC,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCSettings_V1(SegmentSize,LargeObjectSegmentSize,ServerGC,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCSettings_V1(SegmentSize,LargeObjectSegmentSize,ServerGC,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCOptimized() {return EventPipeEventEnabledGCOptimized() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCOptimized());}

inline ULONG FireEtwGCOptimized(
    const unsigned __int64  DesiredAllocation,
    const unsigned __int64  NewAllocation,
    const unsigned int  GenerationNumber
)
{
    ULONG status = EventPipeWriteEventGCOptimized(DesiredAllocation,NewAllocation,GenerationNumber);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCOptimized(DesiredAllocation,NewAllocation,GenerationNumber);
    }
    return status;
}

inline BOOL EventEnabledGCOptimized_V1() {return EventPipeEventEnabledGCOptimized_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCOptimized_V1());}

inline ULONG FireEtwGCOptimized_V1(
    const unsigned __int64  DesiredAllocation,
    const unsigned __int64  NewAllocation,
    const unsigned int  GenerationNumber,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCOptimized_V1(DesiredAllocation,NewAllocation,GenerationNumber,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCOptimized_V1(DesiredAllocation,NewAllocation,GenerationNumber,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCPerHeapHistory() {return EventPipeEventEnabledGCPerHeapHistory() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCPerHeapHistory());}

inline ULONG FireEtwGCPerHeapHistory(

)
{
    ULONG status = EventPipeWriteEventGCPerHeapHistory();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCPerHeapHistory();
    }
    return status;
}

inline BOOL EventEnabledGCPerHeapHistory_V1() {return EventPipeEventEnabledGCPerHeapHistory_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCPerHeapHistory_V1());}

inline ULONG FireEtwGCPerHeapHistory_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCPerHeapHistory_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCPerHeapHistory_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCGlobalHeapHistory() {return EventPipeEventEnabledGCGlobalHeapHistory() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCGlobalHeapHistory());}

inline ULONG FireEtwGCGlobalHeapHistory(
    const unsigned __int64  FinalYoungestDesired,
    const signed int  NumHeaps,
    const unsigned int  CondemnedGeneration,
    const unsigned int  Gen0ReductionCount,
    const unsigned int  Reason,
    const unsigned int  GlobalMechanisms
)
{
    ULONG status = EventPipeWriteEventGCGlobalHeapHistory(FinalYoungestDesired,NumHeaps,CondemnedGeneration,Gen0ReductionCount,Reason,GlobalMechanisms);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCGlobalHeapHistory(FinalYoungestDesired,NumHeaps,CondemnedGeneration,Gen0ReductionCount,Reason,GlobalMechanisms);
    }
    return status;
}

inline BOOL EventEnabledGCGlobalHeapHistory_V1() {return EventPipeEventEnabledGCGlobalHeapHistory_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCGlobalHeapHistory_V1());}

inline ULONG FireEtwGCGlobalHeapHistory_V1(
    const unsigned __int64  FinalYoungestDesired,
    const signed int  NumHeaps,
    const unsigned int  CondemnedGeneration,
    const unsigned int  Gen0ReductionCount,
    const unsigned int  Reason,
    const unsigned int  GlobalMechanisms,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCGlobalHeapHistory_V1(FinalYoungestDesired,NumHeaps,CondemnedGeneration,Gen0ReductionCount,Reason,GlobalMechanisms,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCGlobalHeapHistory_V1(FinalYoungestDesired,NumHeaps,CondemnedGeneration,Gen0ReductionCount,Reason,GlobalMechanisms,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCJoin() {return EventPipeEventEnabledGCJoin() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCJoin());}

inline ULONG FireEtwGCJoin(
    const unsigned int  Heap,
    const unsigned int  JoinTime,
    const unsigned int  JoinType
)
{
    ULONG status = EventPipeWriteEventGCJoin(Heap,JoinTime,JoinType);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCJoin(Heap,JoinTime,JoinType);
    }
    return status;
}

inline BOOL EventEnabledGCJoin_V1() {return EventPipeEventEnabledGCJoin_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCJoin_V1());}

inline ULONG FireEtwGCJoin_V1(
    const unsigned int  Heap,
    const unsigned int  JoinTime,
    const unsigned int  JoinType,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCJoin_V1(Heap,JoinTime,JoinType,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCJoin_V1(Heap,JoinTime,JoinType,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledPrvGCMarkStackRoots() {return EventPipeEventEnabledPrvGCMarkStackRoots() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledPrvGCMarkStackRoots());}

inline ULONG FireEtwPrvGCMarkStackRoots(
    const unsigned int  HeapNum
)
{
    ULONG status = EventPipeWriteEventPrvGCMarkStackRoots(HeapNum);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatPrvGCMarkStackRoots(HeapNum);
    }
    return status;
}

inline BOOL EventEnabledPrvGCMarkStackRoots_V1() {return EventPipeEventEnabledPrvGCMarkStackRoots_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledPrvGCMarkStackRoots_V1());}

inline ULONG FireEtwPrvGCMarkStackRoots_V1(
    const unsigned int  HeapNum,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventPrvGCMarkStackRoots_V1(HeapNum,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatPrvGCMarkStackRoots_V1(HeapNum,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledPrvGCMarkFinalizeQueueRoots() {return EventPipeEventEnabledPrvGCMarkFinalizeQueueRoots() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledPrvGCMarkFinalizeQueueRoots());}

inline ULONG FireEtwPrvGCMarkFinalizeQueueRoots(
    const unsigned int  HeapNum
)
{
    ULONG status = EventPipeWriteEventPrvGCMarkFinalizeQueueRoots(HeapNum);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatPrvGCMarkFinalizeQueueRoots(HeapNum);
    }
    return status;
}

inline BOOL EventEnabledPrvGCMarkFinalizeQueueRoots_V1() {return EventPipeEventEnabledPrvGCMarkFinalizeQueueRoots_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledPrvGCMarkFinalizeQueueRoots_V1());}

inline ULONG FireEtwPrvGCMarkFinalizeQueueRoots_V1(
    const unsigned int  HeapNum,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventPrvGCMarkFinalizeQueueRoots_V1(HeapNum,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatPrvGCMarkFinalizeQueueRoots_V1(HeapNum,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledPrvGCMarkHandles() {return EventPipeEventEnabledPrvGCMarkHandles() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledPrvGCMarkHandles());}

inline ULONG FireEtwPrvGCMarkHandles(
    const unsigned int  HeapNum
)
{
    ULONG status = EventPipeWriteEventPrvGCMarkHandles(HeapNum);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatPrvGCMarkHandles(HeapNum);
    }
    return status;
}

inline BOOL EventEnabledPrvGCMarkHandles_V1() {return EventPipeEventEnabledPrvGCMarkHandles_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledPrvGCMarkHandles_V1());}

inline ULONG FireEtwPrvGCMarkHandles_V1(
    const unsigned int  HeapNum,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventPrvGCMarkHandles_V1(HeapNum,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatPrvGCMarkHandles_V1(HeapNum,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledPrvGCMarkCards() {return EventPipeEventEnabledPrvGCMarkCards() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledPrvGCMarkCards());}

inline ULONG FireEtwPrvGCMarkCards(
    const unsigned int  HeapNum
)
{
    ULONG status = EventPipeWriteEventPrvGCMarkCards(HeapNum);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatPrvGCMarkCards(HeapNum);
    }
    return status;
}

inline BOOL EventEnabledPrvGCMarkCards_V1() {return EventPipeEventEnabledPrvGCMarkCards_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledPrvGCMarkCards_V1());}

inline ULONG FireEtwPrvGCMarkCards_V1(
    const unsigned int  HeapNum,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventPrvGCMarkCards_V1(HeapNum,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatPrvGCMarkCards_V1(HeapNum,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBGCBegin() {return EventPipeEventEnabledBGCBegin() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBGCBegin());}

inline ULONG FireEtwBGCBegin(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBGCBegin(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBGCBegin(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBGC1stNonConEnd() {return EventPipeEventEnabledBGC1stNonConEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBGC1stNonConEnd());}

inline ULONG FireEtwBGC1stNonConEnd(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBGC1stNonConEnd(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBGC1stNonConEnd(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBGC1stConEnd() {return EventPipeEventEnabledBGC1stConEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBGC1stConEnd());}

inline ULONG FireEtwBGC1stConEnd(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBGC1stConEnd(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBGC1stConEnd(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBGC2ndNonConBegin() {return EventPipeEventEnabledBGC2ndNonConBegin() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBGC2ndNonConBegin());}

inline ULONG FireEtwBGC2ndNonConBegin(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBGC2ndNonConBegin(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBGC2ndNonConBegin(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBGC2ndNonConEnd() {return EventPipeEventEnabledBGC2ndNonConEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBGC2ndNonConEnd());}

inline ULONG FireEtwBGC2ndNonConEnd(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBGC2ndNonConEnd(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBGC2ndNonConEnd(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBGC2ndConBegin() {return EventPipeEventEnabledBGC2ndConBegin() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBGC2ndConBegin());}

inline ULONG FireEtwBGC2ndConBegin(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBGC2ndConBegin(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBGC2ndConBegin(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBGC2ndConEnd() {return EventPipeEventEnabledBGC2ndConEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBGC2ndConEnd());}

inline ULONG FireEtwBGC2ndConEnd(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBGC2ndConEnd(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBGC2ndConEnd(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBGCPlanEnd() {return EventPipeEventEnabledBGCPlanEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBGCPlanEnd());}

inline ULONG FireEtwBGCPlanEnd(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBGCPlanEnd(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBGCPlanEnd(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBGCSweepEnd() {return EventPipeEventEnabledBGCSweepEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBGCSweepEnd());}

inline ULONG FireEtwBGCSweepEnd(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBGCSweepEnd(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBGCSweepEnd(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBGCDrainMark() {return EventPipeEventEnabledBGCDrainMark() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBGCDrainMark());}

inline ULONG FireEtwBGCDrainMark(
    const unsigned __int64  Objects,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBGCDrainMark(Objects,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBGCDrainMark(Objects,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBGCRevisit() {return EventPipeEventEnabledBGCRevisit() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBGCRevisit());}

inline ULONG FireEtwBGCRevisit(
    const unsigned __int64  Pages,
    const unsigned __int64  Objects,
    const unsigned int  IsLarge,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBGCRevisit(Pages,Objects,IsLarge,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBGCRevisit(Pages,Objects,IsLarge,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBGCOverflow() {return EventPipeEventEnabledBGCOverflow() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBGCOverflow());}

inline ULONG FireEtwBGCOverflow(
    const unsigned __int64  Min,
    const unsigned __int64  Max,
    const unsigned __int64  Objects,
    const unsigned int  IsLarge,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBGCOverflow(Min,Max,Objects,IsLarge,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBGCOverflow(Min,Max,Objects,IsLarge,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBGCAllocWaitBegin() {return EventPipeEventEnabledBGCAllocWaitBegin() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBGCAllocWaitBegin());}

inline ULONG FireEtwBGCAllocWaitBegin(
    const unsigned int  Reason,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBGCAllocWaitBegin(Reason,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBGCAllocWaitBegin(Reason,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBGCAllocWaitEnd() {return EventPipeEventEnabledBGCAllocWaitEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBGCAllocWaitEnd());}

inline ULONG FireEtwBGCAllocWaitEnd(
    const unsigned int  Reason,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBGCAllocWaitEnd(Reason,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBGCAllocWaitEnd(Reason,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGCFullNotify() {return EventPipeEventEnabledGCFullNotify() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCFullNotify());}

inline ULONG FireEtwGCFullNotify(
    const unsigned int  GenNumber,
    const unsigned int  IsAlloc
)
{
    ULONG status = EventPipeWriteEventGCFullNotify(GenNumber,IsAlloc);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCFullNotify(GenNumber,IsAlloc);
    }
    return status;
}

inline BOOL EventEnabledGCFullNotify_V1() {return EventPipeEventEnabledGCFullNotify_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGCFullNotify_V1());}

inline ULONG FireEtwGCFullNotify_V1(
    const unsigned int  GenNumber,
    const unsigned int  IsAlloc,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGCFullNotify_V1(GenNumber,IsAlloc,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGCFullNotify_V1(GenNumber,IsAlloc,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledEEStartupStart() {return EventPipeEventEnabledEEStartupStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledEEStartupStart());}

inline ULONG FireEtwEEStartupStart(

)
{
    ULONG status = EventPipeWriteEventEEStartupStart();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatEEStartupStart();
    }
    return status;
}

inline BOOL EventEnabledEEStartupStart_V1() {return EventPipeEventEnabledEEStartupStart_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledEEStartupStart_V1());}

inline ULONG FireEtwEEStartupStart_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventEEStartupStart_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatEEStartupStart_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledEEStartupEnd() {return EventPipeEventEnabledEEStartupEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledEEStartupEnd());}

inline ULONG FireEtwEEStartupEnd(

)
{
    ULONG status = EventPipeWriteEventEEStartupEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatEEStartupEnd();
    }
    return status;
}

inline BOOL EventEnabledEEStartupEnd_V1() {return EventPipeEventEnabledEEStartupEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledEEStartupEnd_V1());}

inline ULONG FireEtwEEStartupEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventEEStartupEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatEEStartupEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledEEConfigSetup() {return EventPipeEventEnabledEEConfigSetup() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledEEConfigSetup());}

inline ULONG FireEtwEEConfigSetup(

)
{
    ULONG status = EventPipeWriteEventEEConfigSetup();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatEEConfigSetup();
    }
    return status;
}

inline BOOL EventEnabledEEConfigSetup_V1() {return EventPipeEventEnabledEEConfigSetup_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledEEConfigSetup_V1());}

inline ULONG FireEtwEEConfigSetup_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventEEConfigSetup_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatEEConfigSetup_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledEEConfigSetupEnd() {return EventPipeEventEnabledEEConfigSetupEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledEEConfigSetupEnd());}

inline ULONG FireEtwEEConfigSetupEnd(

)
{
    ULONG status = EventPipeWriteEventEEConfigSetupEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatEEConfigSetupEnd();
    }
    return status;
}

inline BOOL EventEnabledEEConfigSetupEnd_V1() {return EventPipeEventEnabledEEConfigSetupEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledEEConfigSetupEnd_V1());}

inline ULONG FireEtwEEConfigSetupEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventEEConfigSetupEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatEEConfigSetupEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledLdSysBases() {return EventPipeEventEnabledLdSysBases() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLdSysBases());}

inline ULONG FireEtwLdSysBases(

)
{
    ULONG status = EventPipeWriteEventLdSysBases();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLdSysBases();
    }
    return status;
}

inline BOOL EventEnabledLdSysBases_V1() {return EventPipeEventEnabledLdSysBases_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLdSysBases_V1());}

inline ULONG FireEtwLdSysBases_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventLdSysBases_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLdSysBases_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledLdSysBasesEnd() {return EventPipeEventEnabledLdSysBasesEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLdSysBasesEnd());}

inline ULONG FireEtwLdSysBasesEnd(

)
{
    ULONG status = EventPipeWriteEventLdSysBasesEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLdSysBasesEnd();
    }
    return status;
}

inline BOOL EventEnabledLdSysBasesEnd_V1() {return EventPipeEventEnabledLdSysBasesEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLdSysBasesEnd_V1());}

inline ULONG FireEtwLdSysBasesEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventLdSysBasesEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLdSysBasesEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledExecExe() {return EventPipeEventEnabledExecExe() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledExecExe());}

inline ULONG FireEtwExecExe(

)
{
    ULONG status = EventPipeWriteEventExecExe();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatExecExe();
    }
    return status;
}

inline BOOL EventEnabledExecExe_V1() {return EventPipeEventEnabledExecExe_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledExecExe_V1());}

inline ULONG FireEtwExecExe_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventExecExe_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatExecExe_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledExecExeEnd() {return EventPipeEventEnabledExecExeEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledExecExeEnd());}

inline ULONG FireEtwExecExeEnd(

)
{
    ULONG status = EventPipeWriteEventExecExeEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatExecExeEnd();
    }
    return status;
}

inline BOOL EventEnabledExecExeEnd_V1() {return EventPipeEventEnabledExecExeEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledExecExeEnd_V1());}

inline ULONG FireEtwExecExeEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventExecExeEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatExecExeEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMain() {return EventPipeEventEnabledMain() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMain());}

inline ULONG FireEtwMain(

)
{
    ULONG status = EventPipeWriteEventMain();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMain();
    }
    return status;
}

inline BOOL EventEnabledMain_V1() {return EventPipeEventEnabledMain_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMain_V1());}

inline ULONG FireEtwMain_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMain_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMain_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMainEnd() {return EventPipeEventEnabledMainEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMainEnd());}

inline ULONG FireEtwMainEnd(

)
{
    ULONG status = EventPipeWriteEventMainEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMainEnd();
    }
    return status;
}

inline BOOL EventEnabledMainEnd_V1() {return EventPipeEventEnabledMainEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMainEnd_V1());}

inline ULONG FireEtwMainEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMainEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMainEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledApplyPolicyStart() {return EventPipeEventEnabledApplyPolicyStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledApplyPolicyStart());}

inline ULONG FireEtwApplyPolicyStart(

)
{
    ULONG status = EventPipeWriteEventApplyPolicyStart();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatApplyPolicyStart();
    }
    return status;
}

inline BOOL EventEnabledApplyPolicyStart_V1() {return EventPipeEventEnabledApplyPolicyStart_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledApplyPolicyStart_V1());}

inline ULONG FireEtwApplyPolicyStart_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventApplyPolicyStart_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatApplyPolicyStart_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledApplyPolicyEnd() {return EventPipeEventEnabledApplyPolicyEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledApplyPolicyEnd());}

inline ULONG FireEtwApplyPolicyEnd(

)
{
    ULONG status = EventPipeWriteEventApplyPolicyEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatApplyPolicyEnd();
    }
    return status;
}

inline BOOL EventEnabledApplyPolicyEnd_V1() {return EventPipeEventEnabledApplyPolicyEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledApplyPolicyEnd_V1());}

inline ULONG FireEtwApplyPolicyEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventApplyPolicyEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatApplyPolicyEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledLdLibShFolder() {return EventPipeEventEnabledLdLibShFolder() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLdLibShFolder());}

inline ULONG FireEtwLdLibShFolder(

)
{
    ULONG status = EventPipeWriteEventLdLibShFolder();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLdLibShFolder();
    }
    return status;
}

inline BOOL EventEnabledLdLibShFolder_V1() {return EventPipeEventEnabledLdLibShFolder_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLdLibShFolder_V1());}

inline ULONG FireEtwLdLibShFolder_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventLdLibShFolder_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLdLibShFolder_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledLdLibShFolderEnd() {return EventPipeEventEnabledLdLibShFolderEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLdLibShFolderEnd());}

inline ULONG FireEtwLdLibShFolderEnd(

)
{
    ULONG status = EventPipeWriteEventLdLibShFolderEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLdLibShFolderEnd();
    }
    return status;
}

inline BOOL EventEnabledLdLibShFolderEnd_V1() {return EventPipeEventEnabledLdLibShFolderEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLdLibShFolderEnd_V1());}

inline ULONG FireEtwLdLibShFolderEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventLdLibShFolderEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLdLibShFolderEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledPrestubWorker() {return EventPipeEventEnabledPrestubWorker() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledPrestubWorker());}

inline ULONG FireEtwPrestubWorker(

)
{
    ULONG status = EventPipeWriteEventPrestubWorker();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatPrestubWorker();
    }
    return status;
}

inline BOOL EventEnabledPrestubWorker_V1() {return EventPipeEventEnabledPrestubWorker_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledPrestubWorker_V1());}

inline ULONG FireEtwPrestubWorker_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventPrestubWorker_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatPrestubWorker_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledPrestubWorkerEnd() {return EventPipeEventEnabledPrestubWorkerEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledPrestubWorkerEnd());}

inline ULONG FireEtwPrestubWorkerEnd(

)
{
    ULONG status = EventPipeWriteEventPrestubWorkerEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatPrestubWorkerEnd();
    }
    return status;
}

inline BOOL EventEnabledPrestubWorkerEnd_V1() {return EventPipeEventEnabledPrestubWorkerEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledPrestubWorkerEnd_V1());}

inline ULONG FireEtwPrestubWorkerEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventPrestubWorkerEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatPrestubWorkerEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGetInstallationStart() {return EventPipeEventEnabledGetInstallationStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGetInstallationStart());}

inline ULONG FireEtwGetInstallationStart(

)
{
    ULONG status = EventPipeWriteEventGetInstallationStart();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGetInstallationStart();
    }
    return status;
}

inline BOOL EventEnabledGetInstallationStart_V1() {return EventPipeEventEnabledGetInstallationStart_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGetInstallationStart_V1());}

inline ULONG FireEtwGetInstallationStart_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGetInstallationStart_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGetInstallationStart_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGetInstallationEnd() {return EventPipeEventEnabledGetInstallationEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGetInstallationEnd());}

inline ULONG FireEtwGetInstallationEnd(

)
{
    ULONG status = EventPipeWriteEventGetInstallationEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGetInstallationEnd();
    }
    return status;
}

inline BOOL EventEnabledGetInstallationEnd_V1() {return EventPipeEventEnabledGetInstallationEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGetInstallationEnd_V1());}

inline ULONG FireEtwGetInstallationEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGetInstallationEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGetInstallationEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledOpenHModule() {return EventPipeEventEnabledOpenHModule() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledOpenHModule());}

inline ULONG FireEtwOpenHModule(

)
{
    ULONG status = EventPipeWriteEventOpenHModule();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatOpenHModule();
    }
    return status;
}

inline BOOL EventEnabledOpenHModule_V1() {return EventPipeEventEnabledOpenHModule_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledOpenHModule_V1());}

inline ULONG FireEtwOpenHModule_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventOpenHModule_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatOpenHModule_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledOpenHModuleEnd() {return EventPipeEventEnabledOpenHModuleEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledOpenHModuleEnd());}

inline ULONG FireEtwOpenHModuleEnd(

)
{
    ULONG status = EventPipeWriteEventOpenHModuleEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatOpenHModuleEnd();
    }
    return status;
}

inline BOOL EventEnabledOpenHModuleEnd_V1() {return EventPipeEventEnabledOpenHModuleEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledOpenHModuleEnd_V1());}

inline ULONG FireEtwOpenHModuleEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventOpenHModuleEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatOpenHModuleEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledExplicitBindStart() {return EventPipeEventEnabledExplicitBindStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledExplicitBindStart());}

inline ULONG FireEtwExplicitBindStart(

)
{
    ULONG status = EventPipeWriteEventExplicitBindStart();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatExplicitBindStart();
    }
    return status;
}

inline BOOL EventEnabledExplicitBindStart_V1() {return EventPipeEventEnabledExplicitBindStart_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledExplicitBindStart_V1());}

inline ULONG FireEtwExplicitBindStart_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventExplicitBindStart_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatExplicitBindStart_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledExplicitBindEnd() {return EventPipeEventEnabledExplicitBindEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledExplicitBindEnd());}

inline ULONG FireEtwExplicitBindEnd(

)
{
    ULONG status = EventPipeWriteEventExplicitBindEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatExplicitBindEnd();
    }
    return status;
}

inline BOOL EventEnabledExplicitBindEnd_V1() {return EventPipeEventEnabledExplicitBindEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledExplicitBindEnd_V1());}

inline ULONG FireEtwExplicitBindEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventExplicitBindEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatExplicitBindEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledParseXml() {return EventPipeEventEnabledParseXml() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledParseXml());}

inline ULONG FireEtwParseXml(

)
{
    ULONG status = EventPipeWriteEventParseXml();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatParseXml();
    }
    return status;
}

inline BOOL EventEnabledParseXml_V1() {return EventPipeEventEnabledParseXml_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledParseXml_V1());}

inline ULONG FireEtwParseXml_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventParseXml_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatParseXml_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledParseXmlEnd() {return EventPipeEventEnabledParseXmlEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledParseXmlEnd());}

inline ULONG FireEtwParseXmlEnd(

)
{
    ULONG status = EventPipeWriteEventParseXmlEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatParseXmlEnd();
    }
    return status;
}

inline BOOL EventEnabledParseXmlEnd_V1() {return EventPipeEventEnabledParseXmlEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledParseXmlEnd_V1());}

inline ULONG FireEtwParseXmlEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventParseXmlEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatParseXmlEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledInitDefaultDomain() {return EventPipeEventEnabledInitDefaultDomain() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledInitDefaultDomain());}

inline ULONG FireEtwInitDefaultDomain(

)
{
    ULONG status = EventPipeWriteEventInitDefaultDomain();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatInitDefaultDomain();
    }
    return status;
}

inline BOOL EventEnabledInitDefaultDomain_V1() {return EventPipeEventEnabledInitDefaultDomain_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledInitDefaultDomain_V1());}

inline ULONG FireEtwInitDefaultDomain_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventInitDefaultDomain_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatInitDefaultDomain_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledInitDefaultDomainEnd() {return EventPipeEventEnabledInitDefaultDomainEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledInitDefaultDomainEnd());}

inline ULONG FireEtwInitDefaultDomainEnd(

)
{
    ULONG status = EventPipeWriteEventInitDefaultDomainEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatInitDefaultDomainEnd();
    }
    return status;
}

inline BOOL EventEnabledInitDefaultDomainEnd_V1() {return EventPipeEventEnabledInitDefaultDomainEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledInitDefaultDomainEnd_V1());}

inline ULONG FireEtwInitDefaultDomainEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventInitDefaultDomainEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatInitDefaultDomainEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledInitSecurity() {return EventPipeEventEnabledInitSecurity() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledInitSecurity());}

inline ULONG FireEtwInitSecurity(

)
{
    ULONG status = EventPipeWriteEventInitSecurity();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatInitSecurity();
    }
    return status;
}

inline BOOL EventEnabledInitSecurity_V1() {return EventPipeEventEnabledInitSecurity_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledInitSecurity_V1());}

inline ULONG FireEtwInitSecurity_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventInitSecurity_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatInitSecurity_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledInitSecurityEnd() {return EventPipeEventEnabledInitSecurityEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledInitSecurityEnd());}

inline ULONG FireEtwInitSecurityEnd(

)
{
    ULONG status = EventPipeWriteEventInitSecurityEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatInitSecurityEnd();
    }
    return status;
}

inline BOOL EventEnabledInitSecurityEnd_V1() {return EventPipeEventEnabledInitSecurityEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledInitSecurityEnd_V1());}

inline ULONG FireEtwInitSecurityEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventInitSecurityEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatInitSecurityEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledAllowBindingRedirs() {return EventPipeEventEnabledAllowBindingRedirs() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAllowBindingRedirs());}

inline ULONG FireEtwAllowBindingRedirs(

)
{
    ULONG status = EventPipeWriteEventAllowBindingRedirs();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAllowBindingRedirs();
    }
    return status;
}

inline BOOL EventEnabledAllowBindingRedirs_V1() {return EventPipeEventEnabledAllowBindingRedirs_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAllowBindingRedirs_V1());}

inline ULONG FireEtwAllowBindingRedirs_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventAllowBindingRedirs_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAllowBindingRedirs_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledAllowBindingRedirsEnd() {return EventPipeEventEnabledAllowBindingRedirsEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAllowBindingRedirsEnd());}

inline ULONG FireEtwAllowBindingRedirsEnd(

)
{
    ULONG status = EventPipeWriteEventAllowBindingRedirsEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAllowBindingRedirsEnd();
    }
    return status;
}

inline BOOL EventEnabledAllowBindingRedirsEnd_V1() {return EventPipeEventEnabledAllowBindingRedirsEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAllowBindingRedirsEnd_V1());}

inline ULONG FireEtwAllowBindingRedirsEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventAllowBindingRedirsEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAllowBindingRedirsEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledEEConfigSync() {return EventPipeEventEnabledEEConfigSync() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledEEConfigSync());}

inline ULONG FireEtwEEConfigSync(

)
{
    ULONG status = EventPipeWriteEventEEConfigSync();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatEEConfigSync();
    }
    return status;
}

inline BOOL EventEnabledEEConfigSync_V1() {return EventPipeEventEnabledEEConfigSync_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledEEConfigSync_V1());}

inline ULONG FireEtwEEConfigSync_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventEEConfigSync_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatEEConfigSync_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledEEConfigSyncEnd() {return EventPipeEventEnabledEEConfigSyncEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledEEConfigSyncEnd());}

inline ULONG FireEtwEEConfigSyncEnd(

)
{
    ULONG status = EventPipeWriteEventEEConfigSyncEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatEEConfigSyncEnd();
    }
    return status;
}

inline BOOL EventEnabledEEConfigSyncEnd_V1() {return EventPipeEventEnabledEEConfigSyncEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledEEConfigSyncEnd_V1());}

inline ULONG FireEtwEEConfigSyncEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventEEConfigSyncEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatEEConfigSyncEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledFusionBinding() {return EventPipeEventEnabledFusionBinding() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFusionBinding());}

inline ULONG FireEtwFusionBinding(

)
{
    ULONG status = EventPipeWriteEventFusionBinding();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFusionBinding();
    }
    return status;
}

inline BOOL EventEnabledFusionBinding_V1() {return EventPipeEventEnabledFusionBinding_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFusionBinding_V1());}

inline ULONG FireEtwFusionBinding_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventFusionBinding_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFusionBinding_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledFusionBindingEnd() {return EventPipeEventEnabledFusionBindingEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFusionBindingEnd());}

inline ULONG FireEtwFusionBindingEnd(

)
{
    ULONG status = EventPipeWriteEventFusionBindingEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFusionBindingEnd();
    }
    return status;
}

inline BOOL EventEnabledFusionBindingEnd_V1() {return EventPipeEventEnabledFusionBindingEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFusionBindingEnd_V1());}

inline ULONG FireEtwFusionBindingEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventFusionBindingEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFusionBindingEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledLoaderCatchCall() {return EventPipeEventEnabledLoaderCatchCall() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLoaderCatchCall());}

inline ULONG FireEtwLoaderCatchCall(

)
{
    ULONG status = EventPipeWriteEventLoaderCatchCall();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLoaderCatchCall();
    }
    return status;
}

inline BOOL EventEnabledLoaderCatchCall_V1() {return EventPipeEventEnabledLoaderCatchCall_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLoaderCatchCall_V1());}

inline ULONG FireEtwLoaderCatchCall_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventLoaderCatchCall_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLoaderCatchCall_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledLoaderCatchCallEnd() {return EventPipeEventEnabledLoaderCatchCallEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLoaderCatchCallEnd());}

inline ULONG FireEtwLoaderCatchCallEnd(

)
{
    ULONG status = EventPipeWriteEventLoaderCatchCallEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLoaderCatchCallEnd();
    }
    return status;
}

inline BOOL EventEnabledLoaderCatchCallEnd_V1() {return EventPipeEventEnabledLoaderCatchCallEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLoaderCatchCallEnd_V1());}

inline ULONG FireEtwLoaderCatchCallEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventLoaderCatchCallEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLoaderCatchCallEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledFusionInit() {return EventPipeEventEnabledFusionInit() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFusionInit());}

inline ULONG FireEtwFusionInit(

)
{
    ULONG status = EventPipeWriteEventFusionInit();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFusionInit();
    }
    return status;
}

inline BOOL EventEnabledFusionInit_V1() {return EventPipeEventEnabledFusionInit_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFusionInit_V1());}

inline ULONG FireEtwFusionInit_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventFusionInit_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFusionInit_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledFusionInitEnd() {return EventPipeEventEnabledFusionInitEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFusionInitEnd());}

inline ULONG FireEtwFusionInitEnd(

)
{
    ULONG status = EventPipeWriteEventFusionInitEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFusionInitEnd();
    }
    return status;
}

inline BOOL EventEnabledFusionInitEnd_V1() {return EventPipeEventEnabledFusionInitEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFusionInitEnd_V1());}

inline ULONG FireEtwFusionInitEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventFusionInitEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFusionInitEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledFusionAppCtx() {return EventPipeEventEnabledFusionAppCtx() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFusionAppCtx());}

inline ULONG FireEtwFusionAppCtx(

)
{
    ULONG status = EventPipeWriteEventFusionAppCtx();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFusionAppCtx();
    }
    return status;
}

inline BOOL EventEnabledFusionAppCtx_V1() {return EventPipeEventEnabledFusionAppCtx_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFusionAppCtx_V1());}

inline ULONG FireEtwFusionAppCtx_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventFusionAppCtx_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFusionAppCtx_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledFusionAppCtxEnd() {return EventPipeEventEnabledFusionAppCtxEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFusionAppCtxEnd());}

inline ULONG FireEtwFusionAppCtxEnd(

)
{
    ULONG status = EventPipeWriteEventFusionAppCtxEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFusionAppCtxEnd();
    }
    return status;
}

inline BOOL EventEnabledFusionAppCtxEnd_V1() {return EventPipeEventEnabledFusionAppCtxEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFusionAppCtxEnd_V1());}

inline ULONG FireEtwFusionAppCtxEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventFusionAppCtxEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFusionAppCtxEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledFusion2EE() {return EventPipeEventEnabledFusion2EE() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFusion2EE());}

inline ULONG FireEtwFusion2EE(

)
{
    ULONG status = EventPipeWriteEventFusion2EE();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFusion2EE();
    }
    return status;
}

inline BOOL EventEnabledFusion2EE_V1() {return EventPipeEventEnabledFusion2EE_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFusion2EE_V1());}

inline ULONG FireEtwFusion2EE_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventFusion2EE_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFusion2EE_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledFusion2EEEnd() {return EventPipeEventEnabledFusion2EEEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFusion2EEEnd());}

inline ULONG FireEtwFusion2EEEnd(

)
{
    ULONG status = EventPipeWriteEventFusion2EEEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFusion2EEEnd();
    }
    return status;
}

inline BOOL EventEnabledFusion2EEEnd_V1() {return EventPipeEventEnabledFusion2EEEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFusion2EEEnd_V1());}

inline ULONG FireEtwFusion2EEEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventFusion2EEEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFusion2EEEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledSecurityCatchCall() {return EventPipeEventEnabledSecurityCatchCall() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledSecurityCatchCall());}

inline ULONG FireEtwSecurityCatchCall(

)
{
    ULONG status = EventPipeWriteEventSecurityCatchCall();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatSecurityCatchCall();
    }
    return status;
}

inline BOOL EventEnabledSecurityCatchCall_V1() {return EventPipeEventEnabledSecurityCatchCall_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledSecurityCatchCall_V1());}

inline ULONG FireEtwSecurityCatchCall_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventSecurityCatchCall_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatSecurityCatchCall_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledSecurityCatchCallEnd() {return EventPipeEventEnabledSecurityCatchCallEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledSecurityCatchCallEnd());}

inline ULONG FireEtwSecurityCatchCallEnd(

)
{
    ULONG status = EventPipeWriteEventSecurityCatchCallEnd();
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatSecurityCatchCallEnd();
    }
    return status;
}

inline BOOL EventEnabledSecurityCatchCallEnd_V1() {return EventPipeEventEnabledSecurityCatchCallEnd_V1() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledSecurityCatchCallEnd_V1());}

inline ULONG FireEtwSecurityCatchCallEnd_V1(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventSecurityCatchCallEnd_V1(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatSecurityCatchCallEnd_V1(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledCLRStackWalkPrivate() {return EventPipeEventEnabledCLRStackWalkPrivate() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledCLRStackWalkPrivate());}

inline ULONG FireEtwCLRStackWalkPrivate(
    const unsigned short  ClrInstanceID,
    const unsigned char  Reserved1,
    const unsigned char  Reserved2,
    const unsigned int  FrameCount,
    const void** Stack
)
{
    ULONG status = EventPipeWriteEventCLRStackWalkPrivate(ClrInstanceID,Reserved1,Reserved2,FrameCount,Stack);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatCLRStackWalkPrivate(ClrInstanceID,Reserved1,Reserved2,FrameCount,Stack);
    }
    return status;
}

inline BOOL EventEnabledModuleRangeLoadPrivate() {return EventPipeEventEnabledModuleRangeLoadPrivate() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleRangeLoadPrivate());}

inline ULONG FireEtwModuleRangeLoadPrivate(
    const unsigned short  ClrInstanceID,
    const unsigned __int64  ModuleID,
    const unsigned int  RangeBegin,
    const unsigned int  RangeSize,
    const unsigned char  RangeType,
    const unsigned char  IBCType,
    const unsigned short  SectionType
)
{
    ULONG status = EventPipeWriteEventModuleRangeLoadPrivate(ClrInstanceID,ModuleID,RangeBegin,RangeSize,RangeType,IBCType,SectionType);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleRangeLoadPrivate(ClrInstanceID,ModuleID,RangeBegin,RangeSize,RangeType,IBCType,SectionType);
    }
    return status;
}

inline BOOL EventEnabledBindingPolicyPhaseStart() {return EventPipeEventEnabledBindingPolicyPhaseStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBindingPolicyPhaseStart());}

inline ULONG FireEtwBindingPolicyPhaseStart(
    const unsigned int  AppDomainID,
    const unsigned int  LoadContextID,
    const unsigned int  FromLoaderCache,
    const unsigned int  DynamicLoad,
    PCWSTR  AssemblyCodebase,
    PCWSTR  AssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBindingPolicyPhaseStart(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBindingPolicyPhaseStart(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBindingPolicyPhaseEnd() {return EventPipeEventEnabledBindingPolicyPhaseEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBindingPolicyPhaseEnd());}

inline ULONG FireEtwBindingPolicyPhaseEnd(
    const unsigned int  AppDomainID,
    const unsigned int  LoadContextID,
    const unsigned int  FromLoaderCache,
    const unsigned int  DynamicLoad,
    PCWSTR  AssemblyCodebase,
    PCWSTR  AssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBindingPolicyPhaseEnd(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBindingPolicyPhaseEnd(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBindingNgenPhaseStart() {return EventPipeEventEnabledBindingNgenPhaseStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBindingNgenPhaseStart());}

inline ULONG FireEtwBindingNgenPhaseStart(
    const unsigned int  AppDomainID,
    const unsigned int  LoadContextID,
    const unsigned int  FromLoaderCache,
    const unsigned int  DynamicLoad,
    PCWSTR  AssemblyCodebase,
    PCWSTR  AssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBindingNgenPhaseStart(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBindingNgenPhaseStart(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBindingNgenPhaseEnd() {return EventPipeEventEnabledBindingNgenPhaseEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBindingNgenPhaseEnd());}

inline ULONG FireEtwBindingNgenPhaseEnd(
    const unsigned int  AppDomainID,
    const unsigned int  LoadContextID,
    const unsigned int  FromLoaderCache,
    const unsigned int  DynamicLoad,
    PCWSTR  AssemblyCodebase,
    PCWSTR  AssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBindingNgenPhaseEnd(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBindingNgenPhaseEnd(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBindingLookupAndProbingPhaseStart() {return EventPipeEventEnabledBindingLookupAndProbingPhaseStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBindingLookupAndProbingPhaseStart());}

inline ULONG FireEtwBindingLookupAndProbingPhaseStart(
    const unsigned int  AppDomainID,
    const unsigned int  LoadContextID,
    const unsigned int  FromLoaderCache,
    const unsigned int  DynamicLoad,
    PCWSTR  AssemblyCodebase,
    PCWSTR  AssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBindingLookupAndProbingPhaseStart(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBindingLookupAndProbingPhaseStart(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBindingLookupAndProbingPhaseEnd() {return EventPipeEventEnabledBindingLookupAndProbingPhaseEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBindingLookupAndProbingPhaseEnd());}

inline ULONG FireEtwBindingLookupAndProbingPhaseEnd(
    const unsigned int  AppDomainID,
    const unsigned int  LoadContextID,
    const unsigned int  FromLoaderCache,
    const unsigned int  DynamicLoad,
    PCWSTR  AssemblyCodebase,
    PCWSTR  AssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBindingLookupAndProbingPhaseEnd(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBindingLookupAndProbingPhaseEnd(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledLoaderPhaseStart() {return EventPipeEventEnabledLoaderPhaseStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLoaderPhaseStart());}

inline ULONG FireEtwLoaderPhaseStart(
    const unsigned int  AppDomainID,
    const unsigned int  LoadContextID,
    const unsigned int  FromLoaderCache,
    const unsigned int  DynamicLoad,
    PCWSTR  AssemblyCodebase,
    PCWSTR  AssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventLoaderPhaseStart(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLoaderPhaseStart(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledLoaderPhaseEnd() {return EventPipeEventEnabledLoaderPhaseEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLoaderPhaseEnd());}

inline ULONG FireEtwLoaderPhaseEnd(
    const unsigned int  AppDomainID,
    const unsigned int  LoadContextID,
    const unsigned int  FromLoaderCache,
    const unsigned int  DynamicLoad,
    PCWSTR  AssemblyCodebase,
    PCWSTR  AssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventLoaderPhaseEnd(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLoaderPhaseEnd(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBindingPhaseStart() {return EventPipeEventEnabledBindingPhaseStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBindingPhaseStart());}

inline ULONG FireEtwBindingPhaseStart(
    const unsigned int  AppDomainID,
    const unsigned int  LoadContextID,
    const unsigned int  FromLoaderCache,
    const unsigned int  DynamicLoad,
    PCWSTR  AssemblyCodebase,
    PCWSTR  AssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBindingPhaseStart(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBindingPhaseStart(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBindingPhaseEnd() {return EventPipeEventEnabledBindingPhaseEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBindingPhaseEnd());}

inline ULONG FireEtwBindingPhaseEnd(
    const unsigned int  AppDomainID,
    const unsigned int  LoadContextID,
    const unsigned int  FromLoaderCache,
    const unsigned int  DynamicLoad,
    PCWSTR  AssemblyCodebase,
    PCWSTR  AssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBindingPhaseEnd(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBindingPhaseEnd(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBindingDownloadPhaseStart() {return EventPipeEventEnabledBindingDownloadPhaseStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBindingDownloadPhaseStart());}

inline ULONG FireEtwBindingDownloadPhaseStart(
    const unsigned int  AppDomainID,
    const unsigned int  LoadContextID,
    const unsigned int  FromLoaderCache,
    const unsigned int  DynamicLoad,
    PCWSTR  AssemblyCodebase,
    PCWSTR  AssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBindingDownloadPhaseStart(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBindingDownloadPhaseStart(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBindingDownloadPhaseEnd() {return EventPipeEventEnabledBindingDownloadPhaseEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBindingDownloadPhaseEnd());}

inline ULONG FireEtwBindingDownloadPhaseEnd(
    const unsigned int  AppDomainID,
    const unsigned int  LoadContextID,
    const unsigned int  FromLoaderCache,
    const unsigned int  DynamicLoad,
    PCWSTR  AssemblyCodebase,
    PCWSTR  AssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBindingDownloadPhaseEnd(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBindingDownloadPhaseEnd(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledLoaderAssemblyInitPhaseStart() {return EventPipeEventEnabledLoaderAssemblyInitPhaseStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLoaderAssemblyInitPhaseStart());}

inline ULONG FireEtwLoaderAssemblyInitPhaseStart(
    const unsigned int  AppDomainID,
    const unsigned int  LoadContextID,
    const unsigned int  FromLoaderCache,
    const unsigned int  DynamicLoad,
    PCWSTR  AssemblyCodebase,
    PCWSTR  AssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventLoaderAssemblyInitPhaseStart(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLoaderAssemblyInitPhaseStart(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledLoaderAssemblyInitPhaseEnd() {return EventPipeEventEnabledLoaderAssemblyInitPhaseEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLoaderAssemblyInitPhaseEnd());}

inline ULONG FireEtwLoaderAssemblyInitPhaseEnd(
    const unsigned int  AppDomainID,
    const unsigned int  LoadContextID,
    const unsigned int  FromLoaderCache,
    const unsigned int  DynamicLoad,
    PCWSTR  AssemblyCodebase,
    PCWSTR  AssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventLoaderAssemblyInitPhaseEnd(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLoaderAssemblyInitPhaseEnd(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledLoaderMappingPhaseStart() {return EventPipeEventEnabledLoaderMappingPhaseStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLoaderMappingPhaseStart());}

inline ULONG FireEtwLoaderMappingPhaseStart(
    const unsigned int  AppDomainID,
    const unsigned int  LoadContextID,
    const unsigned int  FromLoaderCache,
    const unsigned int  DynamicLoad,
    PCWSTR  AssemblyCodebase,
    PCWSTR  AssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventLoaderMappingPhaseStart(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLoaderMappingPhaseStart(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledLoaderMappingPhaseEnd() {return EventPipeEventEnabledLoaderMappingPhaseEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLoaderMappingPhaseEnd());}

inline ULONG FireEtwLoaderMappingPhaseEnd(
    const unsigned int  AppDomainID,
    const unsigned int  LoadContextID,
    const unsigned int  FromLoaderCache,
    const unsigned int  DynamicLoad,
    PCWSTR  AssemblyCodebase,
    PCWSTR  AssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventLoaderMappingPhaseEnd(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLoaderMappingPhaseEnd(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledLoaderDeliverEventsPhaseStart() {return EventPipeEventEnabledLoaderDeliverEventsPhaseStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLoaderDeliverEventsPhaseStart());}

inline ULONG FireEtwLoaderDeliverEventsPhaseStart(
    const unsigned int  AppDomainID,
    const unsigned int  LoadContextID,
    const unsigned int  FromLoaderCache,
    const unsigned int  DynamicLoad,
    PCWSTR  AssemblyCodebase,
    PCWSTR  AssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventLoaderDeliverEventsPhaseStart(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLoaderDeliverEventsPhaseStart(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledLoaderDeliverEventsPhaseEnd() {return EventPipeEventEnabledLoaderDeliverEventsPhaseEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledLoaderDeliverEventsPhaseEnd());}

inline ULONG FireEtwLoaderDeliverEventsPhaseEnd(
    const unsigned int  AppDomainID,
    const unsigned int  LoadContextID,
    const unsigned int  FromLoaderCache,
    const unsigned int  DynamicLoad,
    PCWSTR  AssemblyCodebase,
    PCWSTR  AssemblyName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventLoaderDeliverEventsPhaseEnd(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatLoaderDeliverEventsPhaseEnd(AppDomainID,LoadContextID,FromLoaderCache,DynamicLoad,AssemblyCodebase,AssemblyName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledEvidenceGenerated() {return EventPipeEventEnabledEvidenceGenerated() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledEvidenceGenerated());}

inline ULONG FireEtwEvidenceGenerated(
    const unsigned int  Type,
    const unsigned int  AppDomain,
    PCWSTR  ILImage,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventEvidenceGenerated(Type,AppDomain,ILImage,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatEvidenceGenerated(Type,AppDomain,ILImage,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledModuleTransparencyComputationStart() {return EventPipeEventEnabledModuleTransparencyComputationStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleTransparencyComputationStart());}

inline ULONG FireEtwModuleTransparencyComputationStart(
    PCWSTR  Module,
    const unsigned int  AppDomainID,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventModuleTransparencyComputationStart(Module,AppDomainID,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleTransparencyComputationStart(Module,AppDomainID,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledModuleTransparencyComputationEnd() {return EventPipeEventEnabledModuleTransparencyComputationEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledModuleTransparencyComputationEnd());}

inline ULONG FireEtwModuleTransparencyComputationEnd(
    PCWSTR  Module,
    const unsigned int  AppDomainID,
    const BOOL  IsAllCritical,
    const BOOL  IsAllTransparent,
    const BOOL  IsTreatAsSafe,
    const BOOL  IsOpportunisticallyCritical,
    const unsigned int  SecurityRuleSet,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventModuleTransparencyComputationEnd(Module,AppDomainID,IsAllCritical,IsAllTransparent,IsTreatAsSafe,IsOpportunisticallyCritical,SecurityRuleSet,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatModuleTransparencyComputationEnd(Module,AppDomainID,IsAllCritical,IsAllTransparent,IsTreatAsSafe,IsOpportunisticallyCritical,SecurityRuleSet,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledTypeTransparencyComputationStart() {return EventPipeEventEnabledTypeTransparencyComputationStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledTypeTransparencyComputationStart());}

inline ULONG FireEtwTypeTransparencyComputationStart(
    PCWSTR  Type,
    PCWSTR  Module,
    const unsigned int  AppDomainID,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventTypeTransparencyComputationStart(Type,Module,AppDomainID,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatTypeTransparencyComputationStart(Type,Module,AppDomainID,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledTypeTransparencyComputationEnd() {return EventPipeEventEnabledTypeTransparencyComputationEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledTypeTransparencyComputationEnd());}

inline ULONG FireEtwTypeTransparencyComputationEnd(
    PCWSTR  Type,
    PCWSTR  Module,
    const unsigned int  AppDomainID,
    const BOOL  IsAllCritical,
    const BOOL  IsAllTransparent,
    const BOOL  IsCritical,
    const BOOL  IsTreatAsSafe,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventTypeTransparencyComputationEnd(Type,Module,AppDomainID,IsAllCritical,IsAllTransparent,IsCritical,IsTreatAsSafe,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatTypeTransparencyComputationEnd(Type,Module,AppDomainID,IsAllCritical,IsAllTransparent,IsCritical,IsTreatAsSafe,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMethodTransparencyComputationStart() {return EventPipeEventEnabledMethodTransparencyComputationStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodTransparencyComputationStart());}

inline ULONG FireEtwMethodTransparencyComputationStart(
    PCWSTR  Method,
    PCWSTR  Module,
    const unsigned int  AppDomainID,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMethodTransparencyComputationStart(Method,Module,AppDomainID,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodTransparencyComputationStart(Method,Module,AppDomainID,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMethodTransparencyComputationEnd() {return EventPipeEventEnabledMethodTransparencyComputationEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMethodTransparencyComputationEnd());}

inline ULONG FireEtwMethodTransparencyComputationEnd(
    PCWSTR  Method,
    PCWSTR  Module,
    const unsigned int  AppDomainID,
    const BOOL  IsCritical,
    const BOOL  IsTreatAsSafe,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventMethodTransparencyComputationEnd(Method,Module,AppDomainID,IsCritical,IsTreatAsSafe,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMethodTransparencyComputationEnd(Method,Module,AppDomainID,IsCritical,IsTreatAsSafe,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledFieldTransparencyComputationStart() {return EventPipeEventEnabledFieldTransparencyComputationStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFieldTransparencyComputationStart());}

inline ULONG FireEtwFieldTransparencyComputationStart(
    PCWSTR  Field,
    PCWSTR  Module,
    const unsigned int  AppDomainID,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventFieldTransparencyComputationStart(Field,Module,AppDomainID,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFieldTransparencyComputationStart(Field,Module,AppDomainID,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledFieldTransparencyComputationEnd() {return EventPipeEventEnabledFieldTransparencyComputationEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFieldTransparencyComputationEnd());}

inline ULONG FireEtwFieldTransparencyComputationEnd(
    PCWSTR  Field,
    PCWSTR  Module,
    const unsigned int  AppDomainID,
    const BOOL  IsCritical,
    const BOOL  IsTreatAsSafe,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventFieldTransparencyComputationEnd(Field,Module,AppDomainID,IsCritical,IsTreatAsSafe,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFieldTransparencyComputationEnd(Field,Module,AppDomainID,IsCritical,IsTreatAsSafe,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledTokenTransparencyComputationStart() {return EventPipeEventEnabledTokenTransparencyComputationStart() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledTokenTransparencyComputationStart());}

inline ULONG FireEtwTokenTransparencyComputationStart(
    const unsigned int  Token,
    PCWSTR  Module,
    const unsigned int  AppDomainID,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventTokenTransparencyComputationStart(Token,Module,AppDomainID,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatTokenTransparencyComputationStart(Token,Module,AppDomainID,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledTokenTransparencyComputationEnd() {return EventPipeEventEnabledTokenTransparencyComputationEnd() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledTokenTransparencyComputationEnd());}

inline ULONG FireEtwTokenTransparencyComputationEnd(
    const unsigned int  Token,
    PCWSTR  Module,
    const unsigned int  AppDomainID,
    const BOOL  IsCritical,
    const BOOL  IsTreatAsSafe,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventTokenTransparencyComputationEnd(Token,Module,AppDomainID,IsCritical,IsTreatAsSafe,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatTokenTransparencyComputationEnd(Token,Module,AppDomainID,IsCritical,IsTreatAsSafe,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledNgenBindEvent() {return EventPipeEventEnabledNgenBindEvent() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledNgenBindEvent());}

inline ULONG FireEtwNgenBindEvent(
    const unsigned short  ClrInstanceID,
    const unsigned __int64  BindingID,
    const unsigned int  ReasonCode,
    PCWSTR  AssemblyName
)
{
    ULONG status = EventPipeWriteEventNgenBindEvent(ClrInstanceID,BindingID,ReasonCode,AssemblyName);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatNgenBindEvent(ClrInstanceID,BindingID,ReasonCode,AssemblyName);
    }
    return status;
}

inline BOOL EventEnabledFailFast() {return EventPipeEventEnabledFailFast() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFailFast());}

inline ULONG FireEtwFailFast(
    PCWSTR  FailFastUserMessage,
    const void*  FailedEIP,
    const unsigned int  OSExitCode,
    const unsigned int  ClrExitCode,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventFailFast(FailFastUserMessage,FailedEIP,OSExitCode,ClrExitCode,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFailFast(FailFastUserMessage,FailedEIP,OSExitCode,ClrExitCode,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledPrvFinalizeObject() {return EventPipeEventEnabledPrvFinalizeObject() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledPrvFinalizeObject());}

inline ULONG FireEtwPrvFinalizeObject(
    const void*  TypeID,
    const void*  ObjectID,
    const unsigned short  ClrInstanceID,
    PCWSTR  TypeName
)
{
    ULONG status = EventPipeWriteEventPrvFinalizeObject(TypeID,ObjectID,ClrInstanceID,TypeName);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatPrvFinalizeObject(TypeID,ObjectID,ClrInstanceID,TypeName);
    }
    return status;
}

inline BOOL EventEnabledCCWRefCountChange() {return EventPipeEventEnabledCCWRefCountChange() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledCCWRefCountChange());}

inline ULONG FireEtwCCWRefCountChange(
    const void*  HandleID,
    const void*  ObjectID,
    const void*  COMInterfacePointer,
    const unsigned int  NewRefCount,
    const unsigned __int64  AppDomainID,
    LPCSTR  ClassName,
    LPCSTR  NameSpace,
    PCWSTR  Operation,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventCCWRefCountChange(HandleID,ObjectID,COMInterfacePointer,NewRefCount,AppDomainID,ClassName,NameSpace,Operation,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatCCWRefCountChange(HandleID,ObjectID,COMInterfacePointer,NewRefCount,AppDomainID,ClassName,NameSpace,Operation,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledPrvSetGCHandle() {return EventPipeEventEnabledPrvSetGCHandle() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledPrvSetGCHandle());}

inline ULONG FireEtwPrvSetGCHandle(
    const void*  HandleID,
    const void*  ObjectID,
    const unsigned int  Kind,
    const unsigned int  Generation,
    const unsigned __int64  AppDomainID,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventPrvSetGCHandle(HandleID,ObjectID,Kind,Generation,AppDomainID,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatPrvSetGCHandle(HandleID,ObjectID,Kind,Generation,AppDomainID,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledPrvDestroyGCHandle() {return EventPipeEventEnabledPrvDestroyGCHandle() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledPrvDestroyGCHandle());}

inline ULONG FireEtwPrvDestroyGCHandle(
    const void*  HandleID,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventPrvDestroyGCHandle(HandleID,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatPrvDestroyGCHandle(HandleID,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledFusionMessageEvent() {return EventPipeEventEnabledFusionMessageEvent() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFusionMessageEvent());}

inline ULONG FireEtwFusionMessageEvent(
    const unsigned short  ClrInstanceID,
    const BOOL  Prepend,
    PCWSTR  Message
)
{
    ULONG status = EventPipeWriteEventFusionMessageEvent(ClrInstanceID,Prepend,Message);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFusionMessageEvent(ClrInstanceID,Prepend,Message);
    }
    return status;
}

inline BOOL EventEnabledFusionErrorCodeEvent() {return EventPipeEventEnabledFusionErrorCodeEvent() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledFusionErrorCodeEvent());}

inline ULONG FireEtwFusionErrorCodeEvent(
    const unsigned short  ClrInstanceID,
    const unsigned int  Category,
    const unsigned int  ErrorCode
)
{
    ULONG status = EventPipeWriteEventFusionErrorCodeEvent(ClrInstanceID,Category,ErrorCode);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatFusionErrorCodeEvent(ClrInstanceID,Category,ErrorCode);
    }
    return status;
}

inline BOOL EventEnabledPinPlugAtGCTime() {return EventPipeEventEnabledPinPlugAtGCTime() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledPinPlugAtGCTime());}

inline ULONG FireEtwPinPlugAtGCTime(
    const void*  PlugStart,
    const void*  PlugEnd,
    const void*  GapBeforeSize,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventPinPlugAtGCTime(PlugStart,PlugEnd,GapBeforeSize,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatPinPlugAtGCTime(PlugStart,PlugEnd,GapBeforeSize,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledAllocRequest() {return EventPipeEventEnabledAllocRequest() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledAllocRequest());}

inline ULONG FireEtwAllocRequest(
    const void*  LoaderHeapPtr,
    const void*  MemoryAddress,
    const unsigned int  RequestSize,
    const unsigned int  Unused1,
    const unsigned __int64  Unused2,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventAllocRequest(LoaderHeapPtr,MemoryAddress,RequestSize,Unused1,Unused2,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatAllocRequest(LoaderHeapPtr,MemoryAddress,RequestSize,Unused1,Unused2,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledMulticoreJit() {return EventPipeEventEnabledMulticoreJit() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMulticoreJit());}

inline ULONG FireEtwMulticoreJit(
    const unsigned short  ClrInstanceID,
    PCWSTR  String1,
    PCWSTR  String2,
    const signed int  Int1,
    const signed int  Int2,
    const signed int  Int3
)
{
    ULONG status = EventPipeWriteEventMulticoreJit(ClrInstanceID,String1,String2,Int1,Int2,Int3);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMulticoreJit(ClrInstanceID,String1,String2,Int1,Int2,Int3);
    }
    return status;
}

inline BOOL EventEnabledMulticoreJitMethodCodeReturned() {return EventPipeEventEnabledMulticoreJitMethodCodeReturned() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledMulticoreJitMethodCodeReturned());}

inline ULONG FireEtwMulticoreJitMethodCodeReturned(
    const unsigned short  ClrInstanceID,
    const unsigned __int64  ModuleID,
    const unsigned __int64  MethodID
)
{
    ULONG status = EventPipeWriteEventMulticoreJitMethodCodeReturned(ClrInstanceID,ModuleID,MethodID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatMulticoreJitMethodCodeReturned(ClrInstanceID,ModuleID,MethodID);
    }
    return status;
}

inline BOOL EventEnabledIInspectableRuntimeClassName() {return EventPipeEventEnabledIInspectableRuntimeClassName() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledIInspectableRuntimeClassName());}

inline ULONG FireEtwIInspectableRuntimeClassName(
    PCWSTR  TypeName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventIInspectableRuntimeClassName(TypeName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatIInspectableRuntimeClassName(TypeName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledWinRTUnbox() {return EventPipeEventEnabledWinRTUnbox() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledWinRTUnbox());}

inline ULONG FireEtwWinRTUnbox(
    PCWSTR  TypeName,
    PCWSTR  SecondTypeName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventWinRTUnbox(TypeName,SecondTypeName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatWinRTUnbox(TypeName,SecondTypeName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledCreateRCW() {return EventPipeEventEnabledCreateRCW() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledCreateRCW());}

inline ULONG FireEtwCreateRCW(
    PCWSTR  TypeName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventCreateRCW(TypeName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatCreateRCW(TypeName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledRCWVariance() {return EventPipeEventEnabledRCWVariance() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledRCWVariance());}

inline ULONG FireEtwRCWVariance(
    PCWSTR  TypeName,
    PCWSTR  InterfaceTypeName,
    PCWSTR  VariantInterfaceTypeName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventRCWVariance(TypeName,InterfaceTypeName,VariantInterfaceTypeName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatRCWVariance(TypeName,InterfaceTypeName,VariantInterfaceTypeName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledRCWIEnumerableCasting() {return EventPipeEventEnabledRCWIEnumerableCasting() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledRCWIEnumerableCasting());}

inline ULONG FireEtwRCWIEnumerableCasting(
    PCWSTR  TypeName,
    PCWSTR  SecondTypeName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventRCWIEnumerableCasting(TypeName,SecondTypeName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatRCWIEnumerableCasting(TypeName,SecondTypeName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledCreateCCW() {return EventPipeEventEnabledCreateCCW() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledCreateCCW());}

inline ULONG FireEtwCreateCCW(
    PCWSTR  TypeName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventCreateCCW(TypeName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatCreateCCW(TypeName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledCCWVariance() {return EventPipeEventEnabledCCWVariance() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledCCWVariance());}

inline ULONG FireEtwCCWVariance(
    PCWSTR  TypeName,
    PCWSTR  InterfaceTypeName,
    PCWSTR  VariantInterfaceTypeName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventCCWVariance(TypeName,InterfaceTypeName,VariantInterfaceTypeName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatCCWVariance(TypeName,InterfaceTypeName,VariantInterfaceTypeName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledObjectVariantMarshallingToNative() {return EventPipeEventEnabledObjectVariantMarshallingToNative() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledObjectVariantMarshallingToNative());}

inline ULONG FireEtwObjectVariantMarshallingToNative(
    PCWSTR  TypeName,
    const signed int  Int1,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventObjectVariantMarshallingToNative(TypeName,Int1,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatObjectVariantMarshallingToNative(TypeName,Int1,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGetTypeFromGUID() {return EventPipeEventEnabledGetTypeFromGUID() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGetTypeFromGUID());}

inline ULONG FireEtwGetTypeFromGUID(
    PCWSTR  TypeName,
    PCWSTR  SecondTypeName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGetTypeFromGUID(TypeName,SecondTypeName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGetTypeFromGUID(TypeName,SecondTypeName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledGetTypeFromProgID() {return EventPipeEventEnabledGetTypeFromProgID() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledGetTypeFromProgID());}

inline ULONG FireEtwGetTypeFromProgID(
    PCWSTR  TypeName,
    PCWSTR  SecondTypeName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventGetTypeFromProgID(TypeName,SecondTypeName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatGetTypeFromProgID(TypeName,SecondTypeName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledConvertToCallbackEtw() {return EventPipeEventEnabledConvertToCallbackEtw() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledConvertToCallbackEtw());}

inline ULONG FireEtwConvertToCallbackEtw(
    PCWSTR  TypeName,
    PCWSTR  SecondTypeName,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventConvertToCallbackEtw(TypeName,SecondTypeName,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatConvertToCallbackEtw(TypeName,SecondTypeName,ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledBeginCreateManagedReference() {return EventPipeEventEnabledBeginCreateManagedReference() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledBeginCreateManagedReference());}

inline ULONG FireEtwBeginCreateManagedReference(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventBeginCreateManagedReference(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatBeginCreateManagedReference(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledEndCreateManagedReference() {return EventPipeEventEnabledEndCreateManagedReference() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledEndCreateManagedReference());}

inline ULONG FireEtwEndCreateManagedReference(
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventEndCreateManagedReference(ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatEndCreateManagedReference(ClrInstanceID);
    }
    return status;
}

inline BOOL EventEnabledObjectVariantMarshallingToManaged() {return EventPipeEventEnabledObjectVariantMarshallingToManaged() || (XplatEventLogger::IsEventLoggingEnabled() && EventXplatEnabledObjectVariantMarshallingToManaged());}

inline ULONG FireEtwObjectVariantMarshallingToManaged(
    PCWSTR  TypeName,
    const signed int  Int1,
    const unsigned short  ClrInstanceID
)
{
    ULONG status = EventPipeWriteEventObjectVariantMarshallingToManaged(TypeName,Int1,ClrInstanceID);
    if(XplatEventLogger::IsEventLoggingEnabled())
    {
        status &= FireEtXplatObjectVariantMarshallingToManaged(TypeName,Int1,ClrInstanceID);
    }
    return status;
}