// 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/genEventPipe.py

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

#include "/home/nate/coreclr/src/vm/common.h"
#include "/home/nate/coreclr/src/vm/eventpipeprovider.h"
#include "/home/nate/coreclr/src/vm/eventpipeevent.h"
#include "/home/nate/coreclr/src/vm/eventpipe.h"

bool ResizeBuffer(char *&buffer, unsigned int& size, unsigned int currLen, unsigned int newSize, bool &fixedBuffer);
bool WriteToBuffer(PCWSTR str, char *&buffer, unsigned int& offset, unsigned int& size, bool &fixedBuffer);
bool WriteToBuffer(const char *str, char *&buffer, unsigned int& offset, unsigned int& size, bool &fixedBuffer);
bool WriteToBuffer(const BYTE *src, unsigned int len, char *&buffer, unsigned int& offset, unsigned int& size, bool &fixedBuffer);

template <typename T>
bool WriteToBuffer(const T &value, char *&buffer, unsigned int& offset, unsigned int& size, bool &fixedBuffer)
{
    if (sizeof(T) + offset > size)
    {
	    if (!ResizeBuffer(buffer, size, offset, size + sizeof(T), fixedBuffer))
		    return false;
    }

    *(T *)(buffer + offset) = value;
    offset += sizeof(T);
    return true;
}

const WCHAR* DotNETRuntimeName = W("Microsoft-Windows-DotNETRuntime");
EventPipeProvider *EventPipeProviderDotNETRuntime = nullptr;
EventPipeEvent *EventPipeEventGCStart = nullptr;
EventPipeEvent *EventPipeEventGCStart_V1 = nullptr;
EventPipeEvent *EventPipeEventGCStart_V2 = nullptr;
EventPipeEvent *EventPipeEventGCEnd = nullptr;
EventPipeEvent *EventPipeEventGCEnd_V1 = nullptr;
EventPipeEvent *EventPipeEventGCRestartEEEnd = nullptr;
EventPipeEvent *EventPipeEventGCRestartEEEnd_V1 = nullptr;
EventPipeEvent *EventPipeEventGCHeapStats = nullptr;
EventPipeEvent *EventPipeEventGCHeapStats_V1 = nullptr;
EventPipeEvent *EventPipeEventGCCreateSegment = nullptr;
EventPipeEvent *EventPipeEventGCCreateSegment_V1 = nullptr;
EventPipeEvent *EventPipeEventGCFreeSegment = nullptr;
EventPipeEvent *EventPipeEventGCFreeSegment_V1 = nullptr;
EventPipeEvent *EventPipeEventGCRestartEEBegin = nullptr;
EventPipeEvent *EventPipeEventGCRestartEEBegin_V1 = nullptr;
EventPipeEvent *EventPipeEventGCSuspendEEEnd = nullptr;
EventPipeEvent *EventPipeEventGCSuspendEEEnd_V1 = nullptr;
EventPipeEvent *EventPipeEventGCSuspendEEBegin = nullptr;
EventPipeEvent *EventPipeEventGCSuspendEEBegin_V1 = nullptr;
EventPipeEvent *EventPipeEventGCAllocationTick = nullptr;
EventPipeEvent *EventPipeEventGCAllocationTick_V1 = nullptr;
EventPipeEvent *EventPipeEventGCAllocationTick_V2 = nullptr;
EventPipeEvent *EventPipeEventGCAllocationTick_V3 = nullptr;
EventPipeEvent *EventPipeEventGCCreateConcurrentThread = nullptr;
EventPipeEvent *EventPipeEventGCCreateConcurrentThread_V1 = nullptr;
EventPipeEvent *EventPipeEventGCTerminateConcurrentThread = nullptr;
EventPipeEvent *EventPipeEventGCTerminateConcurrentThread_V1 = nullptr;
EventPipeEvent *EventPipeEventGCFinalizersEnd = nullptr;
EventPipeEvent *EventPipeEventGCFinalizersEnd_V1 = nullptr;
EventPipeEvent *EventPipeEventGCFinalizersBegin = nullptr;
EventPipeEvent *EventPipeEventGCFinalizersBegin_V1 = nullptr;
EventPipeEvent *EventPipeEventBulkType = nullptr;
EventPipeEvent *EventPipeEventGCBulkRootEdge = nullptr;
EventPipeEvent *EventPipeEventGCBulkRootConditionalWeakTableElementEdge = nullptr;
EventPipeEvent *EventPipeEventGCBulkNode = nullptr;
EventPipeEvent *EventPipeEventGCBulkEdge = nullptr;
EventPipeEvent *EventPipeEventGCSampledObjectAllocationHigh = nullptr;
EventPipeEvent *EventPipeEventGCBulkSurvivingObjectRanges = nullptr;
EventPipeEvent *EventPipeEventGCBulkMovedObjectRanges = nullptr;
EventPipeEvent *EventPipeEventGCGenerationRange = nullptr;
EventPipeEvent *EventPipeEventGCMarkStackRoots = nullptr;
EventPipeEvent *EventPipeEventGCMarkFinalizeQueueRoots = nullptr;
EventPipeEvent *EventPipeEventGCMarkHandles = nullptr;
EventPipeEvent *EventPipeEventGCMarkOlderGenerationRoots = nullptr;
EventPipeEvent *EventPipeEventFinalizeObject = nullptr;
EventPipeEvent *EventPipeEventSetGCHandle = nullptr;
EventPipeEvent *EventPipeEventDestroyGCHandle = nullptr;
EventPipeEvent *EventPipeEventGCSampledObjectAllocationLow = nullptr;
EventPipeEvent *EventPipeEventPinObjectAtGCTime = nullptr;
EventPipeEvent *EventPipeEventGCTriggered = nullptr;
EventPipeEvent *EventPipeEventGCBulkRootCCW = nullptr;
EventPipeEvent *EventPipeEventGCBulkRCW = nullptr;
EventPipeEvent *EventPipeEventGCBulkRootStaticVar = nullptr;
EventPipeEvent *EventPipeEventWorkerThreadCreate = nullptr;
EventPipeEvent *EventPipeEventWorkerThreadTerminate = nullptr;
EventPipeEvent *EventPipeEventWorkerThreadRetire = nullptr;
EventPipeEvent *EventPipeEventWorkerThreadUnretire = nullptr;
EventPipeEvent *EventPipeEventIOThreadCreate = nullptr;
EventPipeEvent *EventPipeEventIOThreadCreate_V1 = nullptr;
EventPipeEvent *EventPipeEventIOThreadTerminate = nullptr;
EventPipeEvent *EventPipeEventIOThreadTerminate_V1 = nullptr;
EventPipeEvent *EventPipeEventIOThreadRetire = nullptr;
EventPipeEvent *EventPipeEventIOThreadRetire_V1 = nullptr;
EventPipeEvent *EventPipeEventIOThreadUnretire = nullptr;
EventPipeEvent *EventPipeEventIOThreadUnretire_V1 = nullptr;
EventPipeEvent *EventPipeEventThreadpoolSuspensionSuspendThread = nullptr;
EventPipeEvent *EventPipeEventThreadpoolSuspensionResumeThread = nullptr;
EventPipeEvent *EventPipeEventThreadPoolWorkerThreadStart = nullptr;
EventPipeEvent *EventPipeEventThreadPoolWorkerThreadStop = nullptr;
EventPipeEvent *EventPipeEventThreadPoolWorkerThreadRetirementStart = nullptr;
EventPipeEvent *EventPipeEventThreadPoolWorkerThreadRetirementStop = nullptr;
EventPipeEvent *EventPipeEventThreadPoolWorkerThreadAdjustmentSample = nullptr;
EventPipeEvent *EventPipeEventThreadPoolWorkerThreadAdjustmentAdjustment = nullptr;
EventPipeEvent *EventPipeEventThreadPoolWorkerThreadAdjustmentStats = nullptr;
EventPipeEvent *EventPipeEventThreadPoolWorkerThreadWait = nullptr;
EventPipeEvent *EventPipeEventThreadPoolWorkingThreadCount = nullptr;
EventPipeEvent *EventPipeEventThreadPoolEnqueue = nullptr;
EventPipeEvent *EventPipeEventThreadPoolDequeue = nullptr;
EventPipeEvent *EventPipeEventThreadPoolIOEnqueue = nullptr;
EventPipeEvent *EventPipeEventThreadPoolIODequeue = nullptr;
EventPipeEvent *EventPipeEventThreadPoolIOPack = nullptr;
EventPipeEvent *EventPipeEventThreadCreating = nullptr;
EventPipeEvent *EventPipeEventThreadRunning = nullptr;
EventPipeEvent *EventPipeEventExceptionThrown = nullptr;
EventPipeEvent *EventPipeEventExceptionThrown_V1 = nullptr;
EventPipeEvent *EventPipeEventExceptionCatchStart = nullptr;
EventPipeEvent *EventPipeEventExceptionCatchStop = nullptr;
EventPipeEvent *EventPipeEventExceptionFinallyStart = nullptr;
EventPipeEvent *EventPipeEventExceptionFinallyStop = nullptr;
EventPipeEvent *EventPipeEventExceptionFilterStart = nullptr;
EventPipeEvent *EventPipeEventExceptionFilterStop = nullptr;
EventPipeEvent *EventPipeEventExceptionThrownStop = nullptr;
EventPipeEvent *EventPipeEventContention = nullptr;
EventPipeEvent *EventPipeEventContentionStart_V1 = nullptr;
EventPipeEvent *EventPipeEventContentionStop = nullptr;
EventPipeEvent *EventPipeEventCLRStackWalk = nullptr;
EventPipeEvent *EventPipeEventAppDomainMemAllocated = nullptr;
EventPipeEvent *EventPipeEventAppDomainMemSurvived = nullptr;
EventPipeEvent *EventPipeEventThreadCreated = nullptr;
EventPipeEvent *EventPipeEventThreadTerminated = nullptr;
EventPipeEvent *EventPipeEventThreadDomainEnter = nullptr;
EventPipeEvent *EventPipeEventILStubGenerated = nullptr;
EventPipeEvent *EventPipeEventILStubCacheHit = nullptr;
EventPipeEvent *EventPipeEventDCStartCompleteV2 = nullptr;
EventPipeEvent *EventPipeEventDCEndCompleteV2 = nullptr;
EventPipeEvent *EventPipeEventMethodDCStartV2 = nullptr;
EventPipeEvent *EventPipeEventMethodDCEndV2 = nullptr;
EventPipeEvent *EventPipeEventMethodDCStartVerboseV2 = nullptr;
EventPipeEvent *EventPipeEventMethodDCEndVerboseV2 = nullptr;
EventPipeEvent *EventPipeEventMethodLoad = nullptr;
EventPipeEvent *EventPipeEventMethodLoad_V1 = nullptr;
EventPipeEvent *EventPipeEventMethodLoad_V2 = nullptr;
EventPipeEvent *EventPipeEventMethodUnload = nullptr;
EventPipeEvent *EventPipeEventMethodUnload_V1 = nullptr;
EventPipeEvent *EventPipeEventMethodUnload_V2 = nullptr;
EventPipeEvent *EventPipeEventMethodLoadVerbose = nullptr;
EventPipeEvent *EventPipeEventMethodLoadVerbose_V1 = nullptr;
EventPipeEvent *EventPipeEventMethodLoadVerbose_V2 = nullptr;
EventPipeEvent *EventPipeEventMethodUnloadVerbose = nullptr;
EventPipeEvent *EventPipeEventMethodUnloadVerbose_V1 = nullptr;
EventPipeEvent *EventPipeEventMethodUnloadVerbose_V2 = nullptr;
EventPipeEvent *EventPipeEventMethodJittingStarted = nullptr;
EventPipeEvent *EventPipeEventMethodJittingStarted_V1 = nullptr;
EventPipeEvent *EventPipeEventMethodJitInliningSucceeded = nullptr;
EventPipeEvent *EventPipeEventMethodJitInliningFailed = nullptr;
EventPipeEvent *EventPipeEventMethodJitTailCallSucceeded = nullptr;
EventPipeEvent *EventPipeEventMethodJitTailCallFailed = nullptr;
EventPipeEvent *EventPipeEventMethodILToNativeMap = nullptr;
EventPipeEvent *EventPipeEventModuleDCStartV2 = nullptr;
EventPipeEvent *EventPipeEventModuleDCEndV2 = nullptr;
EventPipeEvent *EventPipeEventDomainModuleLoad = nullptr;
EventPipeEvent *EventPipeEventDomainModuleLoad_V1 = nullptr;
EventPipeEvent *EventPipeEventModuleLoad = nullptr;
EventPipeEvent *EventPipeEventModuleLoad_V1 = nullptr;
EventPipeEvent *EventPipeEventModuleLoad_V2 = nullptr;
EventPipeEvent *EventPipeEventModuleUnload = nullptr;
EventPipeEvent *EventPipeEventModuleUnload_V1 = nullptr;
EventPipeEvent *EventPipeEventModuleUnload_V2 = nullptr;
EventPipeEvent *EventPipeEventAssemblyLoad = nullptr;
EventPipeEvent *EventPipeEventAssemblyLoad_V1 = nullptr;
EventPipeEvent *EventPipeEventAssemblyUnload = nullptr;
EventPipeEvent *EventPipeEventAssemblyUnload_V1 = nullptr;
EventPipeEvent *EventPipeEventAppDomainLoad = nullptr;
EventPipeEvent *EventPipeEventAppDomainLoad_V1 = nullptr;
EventPipeEvent *EventPipeEventAppDomainUnload = nullptr;
EventPipeEvent *EventPipeEventAppDomainUnload_V1 = nullptr;
EventPipeEvent *EventPipeEventModuleRangeLoad = nullptr;
EventPipeEvent *EventPipeEventStrongNameVerificationStart = nullptr;
EventPipeEvent *EventPipeEventStrongNameVerificationStart_V1 = nullptr;
EventPipeEvent *EventPipeEventStrongNameVerificationStop = nullptr;
EventPipeEvent *EventPipeEventStrongNameVerificationStop_V1 = nullptr;
EventPipeEvent *EventPipeEventAuthenticodeVerificationStart = nullptr;
EventPipeEvent *EventPipeEventAuthenticodeVerificationStart_V1 = nullptr;
EventPipeEvent *EventPipeEventAuthenticodeVerificationStop = nullptr;
EventPipeEvent *EventPipeEventAuthenticodeVerificationStop_V1 = nullptr;
EventPipeEvent *EventPipeEventRuntimeInformationStart = nullptr;
EventPipeEvent *EventPipeEventIncreaseMemoryPressure = nullptr;
EventPipeEvent *EventPipeEventDecreaseMemoryPressure = nullptr;
EventPipeEvent *EventPipeEventGCMarkWithType = nullptr;
EventPipeEvent *EventPipeEventGCJoin_V2 = nullptr;
EventPipeEvent *EventPipeEventGCPerHeapHistory_V3 = nullptr;
EventPipeEvent *EventPipeEventGCGlobalHeapHistory_V2 = nullptr;
EventPipeEvent *EventPipeEventDebugIPCEventStart = nullptr;
EventPipeEvent *EventPipeEventDebugIPCEventEnd = nullptr;
EventPipeEvent *EventPipeEventDebugExceptionProcessingStart = nullptr;
EventPipeEvent *EventPipeEventDebugExceptionProcessingEnd = nullptr;
EventPipeEvent *EventPipeEventCodeSymbols = nullptr;
EventPipeEvent *EventPipeEventEventSource = nullptr;
bool EventPipeEventEnabledGCStart()
{
    return EventPipeEventGCStart->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCStart(
    const unsigned int Count,
    const unsigned int Reason)
{
    if (!EventPipeEventEnabledGCStart())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Reason, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCStart, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCStart_V1()
{
    return EventPipeEventGCStart_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCStart_V1(
    const unsigned int Count,
    const unsigned int Depth,
    const unsigned int Reason,
    const unsigned int Type,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCStart_V1())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Depth, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Reason, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Type, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCStart_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCStart_V2()
{
    return EventPipeEventGCStart_V2->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCStart_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)
{
    if (!EventPipeEventEnabledGCStart_V2())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Depth, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Reason, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Type, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClientSequenceNumber, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCStart_V2, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCEnd()
{
    return EventPipeEventGCEnd->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCEnd(
    const unsigned int Count,
    const unsigned short Depth)
{
    if (!EventPipeEventEnabledGCEnd())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Depth, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCEnd, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCEnd_V1()
{
    return EventPipeEventGCEnd_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCEnd_V1(
    const unsigned int Count,
    const unsigned int Depth,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCEnd_V1())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Depth, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCEnd_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCRestartEEEnd()
{
    return EventPipeEventGCRestartEEEnd->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCRestartEEEnd(
)
{
    if (!EventPipeEventEnabledGCRestartEEEnd())
        return ERROR_SUCCESS;
    EventPipe::WriteEvent(*EventPipeEventGCRestartEEEnd, (BYTE*) nullptr, 0);

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCRestartEEEnd_V1()
{
    return EventPipeEventGCRestartEEEnd_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCRestartEEEnd_V1(
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCRestartEEEnd_V1())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCRestartEEEnd_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCHeapStats()
{
    return EventPipeEventGCHeapStats->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCHeapStats(
    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)
{
    if (!EventPipeEventEnabledGCHeapStats())
        return ERROR_SUCCESS;

    char stackBuffer[92];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 92;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(GenerationSize0, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TotalPromotedSize0, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(GenerationSize1, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TotalPromotedSize1, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(GenerationSize2, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TotalPromotedSize2, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(GenerationSize3, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TotalPromotedSize3, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(FinalizationPromotedSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(FinalizationPromotedCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(PinnedObjectCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(SinkBlockCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(GCHandleCount, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCHeapStats, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCHeapStats_V1()
{
    return EventPipeEventGCHeapStats_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCHeapStats_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)
{
    if (!EventPipeEventEnabledGCHeapStats_V1())
        return ERROR_SUCCESS;

    char stackBuffer[94];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 94;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(GenerationSize0, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TotalPromotedSize0, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(GenerationSize1, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TotalPromotedSize1, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(GenerationSize2, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TotalPromotedSize2, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(GenerationSize3, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TotalPromotedSize3, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(FinalizationPromotedSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(FinalizationPromotedCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(PinnedObjectCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(SinkBlockCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(GCHandleCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCHeapStats_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCCreateSegment()
{
    return EventPipeEventGCCreateSegment->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCCreateSegment(
    const unsigned __int64 Address,
    const unsigned __int64 Size,
    const unsigned int Type)
{
    if (!EventPipeEventEnabledGCCreateSegment())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Address, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Size, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Type, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCCreateSegment, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCCreateSegment_V1()
{
    return EventPipeEventGCCreateSegment_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCCreateSegment_V1(
    const unsigned __int64 Address,
    const unsigned __int64 Size,
    const unsigned int Type,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCCreateSegment_V1())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Address, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Size, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Type, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCCreateSegment_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCFreeSegment()
{
    return EventPipeEventGCFreeSegment->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCFreeSegment(
    const unsigned __int64 Address)
{
    if (!EventPipeEventEnabledGCFreeSegment())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Address, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCFreeSegment, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCFreeSegment_V1()
{
    return EventPipeEventGCFreeSegment_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCFreeSegment_V1(
    const unsigned __int64 Address,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCFreeSegment_V1())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Address, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCFreeSegment_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCRestartEEBegin()
{
    return EventPipeEventGCRestartEEBegin->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCRestartEEBegin(
)
{
    if (!EventPipeEventEnabledGCRestartEEBegin())
        return ERROR_SUCCESS;
    EventPipe::WriteEvent(*EventPipeEventGCRestartEEBegin, (BYTE*) nullptr, 0);

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCRestartEEBegin_V1()
{
    return EventPipeEventGCRestartEEBegin_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCRestartEEBegin_V1(
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCRestartEEBegin_V1())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCRestartEEBegin_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCSuspendEEEnd()
{
    return EventPipeEventGCSuspendEEEnd->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCSuspendEEEnd(
)
{
    if (!EventPipeEventEnabledGCSuspendEEEnd())
        return ERROR_SUCCESS;
    EventPipe::WriteEvent(*EventPipeEventGCSuspendEEEnd, (BYTE*) nullptr, 0);

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCSuspendEEEnd_V1()
{
    return EventPipeEventGCSuspendEEEnd_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCSuspendEEEnd_V1(
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCSuspendEEEnd_V1())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCSuspendEEEnd_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCSuspendEEBegin()
{
    return EventPipeEventGCSuspendEEBegin->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCSuspendEEBegin(
    const unsigned short Reason)
{
    if (!EventPipeEventEnabledGCSuspendEEBegin())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Reason, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCSuspendEEBegin, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCSuspendEEBegin_V1()
{
    return EventPipeEventGCSuspendEEBegin_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCSuspendEEBegin_V1(
    const unsigned int Reason,
    const unsigned int Count,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCSuspendEEBegin_V1())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Reason, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCSuspendEEBegin_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCAllocationTick()
{
    return EventPipeEventGCAllocationTick->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCAllocationTick(
    const unsigned int AllocationAmount,
    const unsigned int AllocationKind)
{
    if (!EventPipeEventEnabledGCAllocationTick())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(AllocationAmount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AllocationKind, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCAllocationTick, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCAllocationTick_V1()
{
    return EventPipeEventGCAllocationTick_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCAllocationTick_V1(
    const unsigned int AllocationAmount,
    const unsigned int AllocationKind,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCAllocationTick_V1())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(AllocationAmount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AllocationKind, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCAllocationTick_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCAllocationTick_V2()
{
    return EventPipeEventGCAllocationTick_V2->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCAllocationTick_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)
{
    if (!EventPipeEventEnabledGCAllocationTick_V2())
        return ERROR_SUCCESS;

    char stackBuffer[94];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 94;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(AllocationAmount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AllocationKind, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AllocationAmount64, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TypeID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TypeName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(HeapIndex, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCAllocationTick_V2, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCAllocationTick_V3()
{
    return EventPipeEventGCAllocationTick_V3->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCAllocationTick_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)
{
    if (!EventPipeEventEnabledGCAllocationTick_V3())
        return ERROR_SUCCESS;

    char stackBuffer[102];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 102;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(AllocationAmount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AllocationKind, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AllocationAmount64, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TypeID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TypeName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(HeapIndex, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Address, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCAllocationTick_V3, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCCreateConcurrentThread()
{
    return EventPipeEventGCCreateConcurrentThread->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCCreateConcurrentThread(
)
{
    if (!EventPipeEventEnabledGCCreateConcurrentThread())
        return ERROR_SUCCESS;
    EventPipe::WriteEvent(*EventPipeEventGCCreateConcurrentThread, (BYTE*) nullptr, 0);

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCCreateConcurrentThread_V1()
{
    return EventPipeEventGCCreateConcurrentThread_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCCreateConcurrentThread_V1(
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCCreateConcurrentThread_V1())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCCreateConcurrentThread_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCTerminateConcurrentThread()
{
    return EventPipeEventGCTerminateConcurrentThread->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCTerminateConcurrentThread(
)
{
    if (!EventPipeEventEnabledGCTerminateConcurrentThread())
        return ERROR_SUCCESS;
    EventPipe::WriteEvent(*EventPipeEventGCTerminateConcurrentThread, (BYTE*) nullptr, 0);

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCTerminateConcurrentThread_V1()
{
    return EventPipeEventGCTerminateConcurrentThread_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCTerminateConcurrentThread_V1(
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCTerminateConcurrentThread_V1())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCTerminateConcurrentThread_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCFinalizersEnd()
{
    return EventPipeEventGCFinalizersEnd->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCFinalizersEnd(
    const unsigned int Count)
{
    if (!EventPipeEventEnabledGCFinalizersEnd())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCFinalizersEnd, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCFinalizersEnd_V1()
{
    return EventPipeEventGCFinalizersEnd_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCFinalizersEnd_V1(
    const unsigned int Count,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCFinalizersEnd_V1())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCFinalizersEnd_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCFinalizersBegin()
{
    return EventPipeEventGCFinalizersBegin->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCFinalizersBegin(
)
{
    if (!EventPipeEventEnabledGCFinalizersBegin())
        return ERROR_SUCCESS;
    EventPipe::WriteEvent(*EventPipeEventGCFinalizersBegin, (BYTE*) nullptr, 0);

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCFinalizersBegin_V1()
{
    return EventPipeEventGCFinalizersBegin_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCFinalizersBegin_V1(
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCFinalizersBegin_V1())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCFinalizersBegin_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledBulkType()
{
    return EventPipeEventBulkType->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventBulkType(
    const unsigned int Count,
    const unsigned short ClrInstanceID,
    int Values_ElementSize,
    const void* Values)
{
    if (!EventPipeEventEnabledBulkType())
        return ERROR_SUCCESS;

    char stackBuffer[38];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 38;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer((const BYTE *)Values, (int)(Values_ElementSize), buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventBulkType, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCBulkRootEdge()
{
    return EventPipeEventGCBulkRootEdge->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCBulkRootEdge(
    const unsigned int Index,
    const unsigned int Count,
    const unsigned short ClrInstanceID,
    int Values_ElementSize,
    const void* Values)
{
    if (!EventPipeEventEnabledGCBulkRootEdge())
        return ERROR_SUCCESS;

    char stackBuffer[42];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 42;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Index, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer((const BYTE *)Values, (int)Values_ElementSize * (int)Count, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCBulkRootEdge, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCBulkRootConditionalWeakTableElementEdge()
{
    return EventPipeEventGCBulkRootConditionalWeakTableElementEdge->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCBulkRootConditionalWeakTableElementEdge(
    const unsigned int Index,
    const unsigned int Count,
    const unsigned short ClrInstanceID,
    int Values_ElementSize,
    const void* Values)
{
    if (!EventPipeEventEnabledGCBulkRootConditionalWeakTableElementEdge())
        return ERROR_SUCCESS;

    char stackBuffer[42];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 42;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Index, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer((const BYTE *)Values, (int)Values_ElementSize * (int)Count, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCBulkRootConditionalWeakTableElementEdge, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCBulkNode()
{
    return EventPipeEventGCBulkNode->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCBulkNode(
    const unsigned int Index,
    const unsigned int Count,
    const unsigned short ClrInstanceID,
    int Values_ElementSize,
    const void* Values)
{
    if (!EventPipeEventEnabledGCBulkNode())
        return ERROR_SUCCESS;

    char stackBuffer[42];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 42;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Index, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer((const BYTE *)Values, (int)Values_ElementSize * (int)Count, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCBulkNode, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCBulkEdge()
{
    return EventPipeEventGCBulkEdge->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCBulkEdge(
    const unsigned int Index,
    const unsigned int Count,
    const unsigned short ClrInstanceID,
    int Values_ElementSize,
    const void* Values)
{
    if (!EventPipeEventEnabledGCBulkEdge())
        return ERROR_SUCCESS;

    char stackBuffer[42];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 42;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Index, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer((const BYTE *)Values, (int)Values_ElementSize * (int)Count, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCBulkEdge, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCSampledObjectAllocationHigh()
{
    return EventPipeEventGCSampledObjectAllocationHigh->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCSampledObjectAllocationHigh(
    const void* Address,
    const void* TypeID,
    const unsigned int ObjectCountForTypeSample,
    const unsigned __int64 TotalSizeForTypeSample,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCSampledObjectAllocationHigh())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Address, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TypeID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ObjectCountForTypeSample, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TotalSizeForTypeSample, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCSampledObjectAllocationHigh, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCBulkSurvivingObjectRanges()
{
    return EventPipeEventGCBulkSurvivingObjectRanges->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCBulkSurvivingObjectRanges(
    const unsigned int Index,
    const unsigned int Count,
    const unsigned short ClrInstanceID,
    int Values_ElementSize,
    const void* Values)
{
    if (!EventPipeEventEnabledGCBulkSurvivingObjectRanges())
        return ERROR_SUCCESS;

    char stackBuffer[42];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 42;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Index, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer((const BYTE *)Values, (int)Values_ElementSize * (int)Count, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCBulkSurvivingObjectRanges, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCBulkMovedObjectRanges()
{
    return EventPipeEventGCBulkMovedObjectRanges->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCBulkMovedObjectRanges(
    const unsigned int Index,
    const unsigned int Count,
    const unsigned short ClrInstanceID,
    int Values_ElementSize,
    const void* Values)
{
    if (!EventPipeEventEnabledGCBulkMovedObjectRanges())
        return ERROR_SUCCESS;

    char stackBuffer[42];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 42;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Index, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer((const BYTE *)Values, (int)Values_ElementSize * (int)Count, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCBulkMovedObjectRanges, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCGenerationRange()
{
    return EventPipeEventGCGenerationRange->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCGenerationRange(
    const unsigned char Generation,
    const void* RangeStart,
    const unsigned __int64 RangeUsedLength,
    const unsigned __int64 RangeReservedLength,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCGenerationRange())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Generation, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RangeStart, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RangeUsedLength, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RangeReservedLength, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCGenerationRange, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCMarkStackRoots()
{
    return EventPipeEventGCMarkStackRoots->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCMarkStackRoots(
    const unsigned int HeapNum,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCMarkStackRoots())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(HeapNum, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCMarkStackRoots, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCMarkFinalizeQueueRoots()
{
    return EventPipeEventGCMarkFinalizeQueueRoots->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCMarkFinalizeQueueRoots(
    const unsigned int HeapNum,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCMarkFinalizeQueueRoots())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(HeapNum, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCMarkFinalizeQueueRoots, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCMarkHandles()
{
    return EventPipeEventGCMarkHandles->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCMarkHandles(
    const unsigned int HeapNum,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCMarkHandles())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(HeapNum, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCMarkHandles, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCMarkOlderGenerationRoots()
{
    return EventPipeEventGCMarkOlderGenerationRoots->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCMarkOlderGenerationRoots(
    const unsigned int HeapNum,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCMarkOlderGenerationRoots())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(HeapNum, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCMarkOlderGenerationRoots, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledFinalizeObject()
{
    return EventPipeEventFinalizeObject->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventFinalizeObject(
    const void* TypeID,
    const void* ObjectID,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledFinalizeObject())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(TypeID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ObjectID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventFinalizeObject, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledSetGCHandle()
{
    return EventPipeEventSetGCHandle->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventSetGCHandle(
    const void* HandleID,
    const void* ObjectID,
    const unsigned int Kind,
    const unsigned int Generation,
    const unsigned __int64 AppDomainID,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledSetGCHandle())
        return ERROR_SUCCESS;

    char stackBuffer[34];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 34;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(HandleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ObjectID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Kind, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Generation, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventSetGCHandle, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledDestroyGCHandle()
{
    return EventPipeEventDestroyGCHandle->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventDestroyGCHandle(
    const void* HandleID,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledDestroyGCHandle())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(HandleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventDestroyGCHandle, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCSampledObjectAllocationLow()
{
    return EventPipeEventGCSampledObjectAllocationLow->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCSampledObjectAllocationLow(
    const void* Address,
    const void* TypeID,
    const unsigned int ObjectCountForTypeSample,
    const unsigned __int64 TotalSizeForTypeSample,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCSampledObjectAllocationLow())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Address, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TypeID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ObjectCountForTypeSample, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TotalSizeForTypeSample, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCSampledObjectAllocationLow, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledPinObjectAtGCTime()
{
    return EventPipeEventPinObjectAtGCTime->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventPinObjectAtGCTime(
    const void* HandleID,
    const void* ObjectID,
    const unsigned __int64 ObjectSize,
    PCWSTR TypeName,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledPinObjectAtGCTime())
        return ERROR_SUCCESS;

    char stackBuffer[90];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 90;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(HandleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ObjectID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ObjectSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TypeName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventPinObjectAtGCTime, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCTriggered()
{
    return EventPipeEventGCTriggered->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCTriggered(
    const unsigned int Reason,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledGCTriggered())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Reason, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCTriggered, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCBulkRootCCW()
{
    return EventPipeEventGCBulkRootCCW->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCBulkRootCCW(
    const unsigned int Count,
    const unsigned short ClrInstanceID,
    int Values_ElementSize,
    const void* Values)
{
    if (!EventPipeEventEnabledGCBulkRootCCW())
        return ERROR_SUCCESS;

    char stackBuffer[38];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 38;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer((const BYTE *)Values, (int)(Values_ElementSize), buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCBulkRootCCW, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCBulkRCW()
{
    return EventPipeEventGCBulkRCW->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCBulkRCW(
    const unsigned int Count,
    const unsigned short ClrInstanceID,
    int Values_ElementSize,
    const void* Values)
{
    if (!EventPipeEventEnabledGCBulkRCW())
        return ERROR_SUCCESS;

    char stackBuffer[38];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 38;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer((const BYTE *)Values, (int)(Values_ElementSize), buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCBulkRCW, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCBulkRootStaticVar()
{
    return EventPipeEventGCBulkRootStaticVar->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCBulkRootStaticVar(
    const unsigned int Count,
    const unsigned __int64 AppDomainID,
    const unsigned short ClrInstanceID,
    int Values_ElementSize,
    const void* Values)
{
    if (!EventPipeEventEnabledGCBulkRootStaticVar())
        return ERROR_SUCCESS;

    char stackBuffer[46];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 46;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer((const BYTE *)Values, (int)(Values_ElementSize), buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCBulkRootStaticVar, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledWorkerThreadCreate()
{
    return EventPipeEventWorkerThreadCreate->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventWorkerThreadCreate(
    const unsigned int WorkerThreadCount,
    const unsigned int RetiredWorkerThreads)
{
    if (!EventPipeEventEnabledWorkerThreadCreate())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(WorkerThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RetiredWorkerThreads, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventWorkerThreadCreate, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledWorkerThreadTerminate()
{
    return EventPipeEventWorkerThreadTerminate->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventWorkerThreadTerminate(
    const unsigned int WorkerThreadCount,
    const unsigned int RetiredWorkerThreads)
{
    if (!EventPipeEventEnabledWorkerThreadTerminate())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(WorkerThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RetiredWorkerThreads, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventWorkerThreadTerminate, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledWorkerThreadRetire()
{
    return EventPipeEventWorkerThreadRetire->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventWorkerThreadRetire(
    const unsigned int WorkerThreadCount,
    const unsigned int RetiredWorkerThreads)
{
    if (!EventPipeEventEnabledWorkerThreadRetire())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(WorkerThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RetiredWorkerThreads, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventWorkerThreadRetire, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledWorkerThreadUnretire()
{
    return EventPipeEventWorkerThreadUnretire->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventWorkerThreadUnretire(
    const unsigned int WorkerThreadCount,
    const unsigned int RetiredWorkerThreads)
{
    if (!EventPipeEventEnabledWorkerThreadUnretire())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(WorkerThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RetiredWorkerThreads, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventWorkerThreadUnretire, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledIOThreadCreate()
{
    return EventPipeEventIOThreadCreate->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventIOThreadCreate(
    const unsigned int IOThreadCount,
    const unsigned int RetiredIOThreads)
{
    if (!EventPipeEventEnabledIOThreadCreate())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(IOThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RetiredIOThreads, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventIOThreadCreate, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledIOThreadCreate_V1()
{
    return EventPipeEventIOThreadCreate_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventIOThreadCreate_V1(
    const unsigned int IOThreadCount,
    const unsigned int RetiredIOThreads,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledIOThreadCreate_V1())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(IOThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RetiredIOThreads, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventIOThreadCreate_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledIOThreadTerminate()
{
    return EventPipeEventIOThreadTerminate->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventIOThreadTerminate(
    const unsigned int IOThreadCount,
    const unsigned int RetiredIOThreads)
{
    if (!EventPipeEventEnabledIOThreadTerminate())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(IOThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RetiredIOThreads, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventIOThreadTerminate, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledIOThreadTerminate_V1()
{
    return EventPipeEventIOThreadTerminate_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventIOThreadTerminate_V1(
    const unsigned int IOThreadCount,
    const unsigned int RetiredIOThreads,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledIOThreadTerminate_V1())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(IOThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RetiredIOThreads, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventIOThreadTerminate_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledIOThreadRetire()
{
    return EventPipeEventIOThreadRetire->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventIOThreadRetire(
    const unsigned int IOThreadCount,
    const unsigned int RetiredIOThreads)
{
    if (!EventPipeEventEnabledIOThreadRetire())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(IOThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RetiredIOThreads, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventIOThreadRetire, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledIOThreadRetire_V1()
{
    return EventPipeEventIOThreadRetire_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventIOThreadRetire_V1(
    const unsigned int IOThreadCount,
    const unsigned int RetiredIOThreads,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledIOThreadRetire_V1())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(IOThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RetiredIOThreads, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventIOThreadRetire_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledIOThreadUnretire()
{
    return EventPipeEventIOThreadUnretire->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventIOThreadUnretire(
    const unsigned int IOThreadCount,
    const unsigned int RetiredIOThreads)
{
    if (!EventPipeEventEnabledIOThreadUnretire())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(IOThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RetiredIOThreads, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventIOThreadUnretire, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledIOThreadUnretire_V1()
{
    return EventPipeEventIOThreadUnretire_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventIOThreadUnretire_V1(
    const unsigned int IOThreadCount,
    const unsigned int RetiredIOThreads,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledIOThreadUnretire_V1())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(IOThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RetiredIOThreads, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventIOThreadUnretire_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadpoolSuspensionSuspendThread()
{
    return EventPipeEventThreadpoolSuspensionSuspendThread->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadpoolSuspensionSuspendThread(
    const unsigned int ClrThreadID,
    const unsigned int CpuUtilization)
{
    if (!EventPipeEventEnabledThreadpoolSuspensionSuspendThread())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ClrThreadID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CpuUtilization, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadpoolSuspensionSuspendThread, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadpoolSuspensionResumeThread()
{
    return EventPipeEventThreadpoolSuspensionResumeThread->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadpoolSuspensionResumeThread(
    const unsigned int ClrThreadID,
    const unsigned int CpuUtilization)
{
    if (!EventPipeEventEnabledThreadpoolSuspensionResumeThread())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ClrThreadID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CpuUtilization, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadpoolSuspensionResumeThread, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadPoolWorkerThreadStart()
{
    return EventPipeEventThreadPoolWorkerThreadStart->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadPoolWorkerThreadStart(
    const unsigned int ActiveWorkerThreadCount,
    const unsigned int RetiredWorkerThreadCount,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledThreadPoolWorkerThreadStart())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ActiveWorkerThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RetiredWorkerThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadPoolWorkerThreadStart, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadPoolWorkerThreadStop()
{
    return EventPipeEventThreadPoolWorkerThreadStop->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadPoolWorkerThreadStop(
    const unsigned int ActiveWorkerThreadCount,
    const unsigned int RetiredWorkerThreadCount,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledThreadPoolWorkerThreadStop())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ActiveWorkerThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RetiredWorkerThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadPoolWorkerThreadStop, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadPoolWorkerThreadRetirementStart()
{
    return EventPipeEventThreadPoolWorkerThreadRetirementStart->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadPoolWorkerThreadRetirementStart(
    const unsigned int ActiveWorkerThreadCount,
    const unsigned int RetiredWorkerThreadCount,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledThreadPoolWorkerThreadRetirementStart())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ActiveWorkerThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RetiredWorkerThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadPoolWorkerThreadRetirementStart, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadPoolWorkerThreadRetirementStop()
{
    return EventPipeEventThreadPoolWorkerThreadRetirementStop->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadPoolWorkerThreadRetirementStop(
    const unsigned int ActiveWorkerThreadCount,
    const unsigned int RetiredWorkerThreadCount,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledThreadPoolWorkerThreadRetirementStop())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ActiveWorkerThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RetiredWorkerThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadPoolWorkerThreadRetirementStop, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadPoolWorkerThreadAdjustmentSample()
{
    return EventPipeEventThreadPoolWorkerThreadAdjustmentSample->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadPoolWorkerThreadAdjustmentSample(
    const double Throughput,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledThreadPoolWorkerThreadAdjustmentSample())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Throughput, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadPoolWorkerThreadAdjustmentSample, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadPoolWorkerThreadAdjustmentAdjustment()
{
    return EventPipeEventThreadPoolWorkerThreadAdjustmentAdjustment->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadPoolWorkerThreadAdjustmentAdjustment(
    const double AverageThroughput,
    const unsigned int NewWorkerThreadCount,
    const unsigned int Reason,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledThreadPoolWorkerThreadAdjustmentAdjustment())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(AverageThroughput, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(NewWorkerThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Reason, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadPoolWorkerThreadAdjustmentAdjustment, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadPoolWorkerThreadAdjustmentStats()
{
    return EventPipeEventThreadPoolWorkerThreadAdjustmentStats->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadPoolWorkerThreadAdjustmentStats(
    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)
{
    if (!EventPipeEventEnabledThreadPoolWorkerThreadAdjustmentStats())
        return ERROR_SUCCESS;

    char stackBuffer[76];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 76;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Duration, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Throughput, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ThreadWave, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ThroughputWave, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ThroughputErrorEstimate, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AverageThroughputErrorEstimate, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ThroughputRatio, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Confidence, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(NewControlSetting, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(NewThreadWaveMagnitude, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadPoolWorkerThreadAdjustmentStats, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadPoolWorkerThreadWait()
{
    return EventPipeEventThreadPoolWorkerThreadWait->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadPoolWorkerThreadWait(
    const unsigned int ActiveWorkerThreadCount,
    const unsigned int RetiredWorkerThreadCount,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledThreadPoolWorkerThreadWait())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ActiveWorkerThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RetiredWorkerThreadCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadPoolWorkerThreadWait, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadPoolWorkingThreadCount()
{
    return EventPipeEventThreadPoolWorkingThreadCount->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadPoolWorkingThreadCount(
    const unsigned int Count,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledThreadPoolWorkingThreadCount())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadPoolWorkingThreadCount, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadPoolEnqueue()
{
    return EventPipeEventThreadPoolEnqueue->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadPoolEnqueue(
    const void* WorkID,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledThreadPoolEnqueue())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(WorkID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadPoolEnqueue, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadPoolDequeue()
{
    return EventPipeEventThreadPoolDequeue->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadPoolDequeue(
    const void* WorkID,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledThreadPoolDequeue())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(WorkID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadPoolDequeue, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadPoolIOEnqueue()
{
    return EventPipeEventThreadPoolIOEnqueue->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadPoolIOEnqueue(
    const void* NativeOverlapped,
    const void* Overlapped,
    const BOOL MultiDequeues,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledThreadPoolIOEnqueue())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(NativeOverlapped, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Overlapped, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MultiDequeues, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadPoolIOEnqueue, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadPoolIODequeue()
{
    return EventPipeEventThreadPoolIODequeue->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadPoolIODequeue(
    const void* NativeOverlapped,
    const void* Overlapped,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledThreadPoolIODequeue())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(NativeOverlapped, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Overlapped, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadPoolIODequeue, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadPoolIOPack()
{
    return EventPipeEventThreadPoolIOPack->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadPoolIOPack(
    const void* NativeOverlapped,
    const void* Overlapped,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledThreadPoolIOPack())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(NativeOverlapped, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Overlapped, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadPoolIOPack, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadCreating()
{
    return EventPipeEventThreadCreating->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadCreating(
    const void* ID,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledThreadCreating())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadCreating, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadRunning()
{
    return EventPipeEventThreadRunning->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadRunning(
    const void* ID,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledThreadRunning())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadRunning, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledExceptionThrown()
{
    return EventPipeEventExceptionThrown->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventExceptionThrown(
)
{
    if (!EventPipeEventEnabledExceptionThrown())
        return ERROR_SUCCESS;
    EventPipe::WriteEvent(*EventPipeEventExceptionThrown, (BYTE*) nullptr, 0);

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledExceptionThrown_V1()
{
    return EventPipeEventExceptionThrown_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventExceptionThrown_V1(
    PCWSTR ExceptionType,
    PCWSTR ExceptionMessage,
    const void* ExceptionEIP,
    const unsigned int ExceptionHRESULT,
    const unsigned short ExceptionFlags,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledExceptionThrown_V1())
        return ERROR_SUCCESS;

    char stackBuffer[144];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 144;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ExceptionType, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ExceptionMessage, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ExceptionEIP, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ExceptionHRESULT, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ExceptionFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventExceptionThrown_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledExceptionCatchStart()
{
    return EventPipeEventExceptionCatchStart->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventExceptionCatchStart(
    const unsigned __int64 EntryEIP,
    const unsigned __int64 MethodID,
    PCWSTR MethodName,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledExceptionCatchStart())
        return ERROR_SUCCESS;

    char stackBuffer[82];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 82;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(EntryEIP, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventExceptionCatchStart, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledExceptionCatchStop()
{
    return EventPipeEventExceptionCatchStop->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventExceptionCatchStop(
)
{
    if (!EventPipeEventEnabledExceptionCatchStop())
        return ERROR_SUCCESS;
    EventPipe::WriteEvent(*EventPipeEventExceptionCatchStop, (BYTE*) nullptr, 0);

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledExceptionFinallyStart()
{
    return EventPipeEventExceptionFinallyStart->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventExceptionFinallyStart(
    const unsigned __int64 EntryEIP,
    const unsigned __int64 MethodID,
    PCWSTR MethodName,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledExceptionFinallyStart())
        return ERROR_SUCCESS;

    char stackBuffer[82];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 82;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(EntryEIP, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventExceptionFinallyStart, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledExceptionFinallyStop()
{
    return EventPipeEventExceptionFinallyStop->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventExceptionFinallyStop(
)
{
    if (!EventPipeEventEnabledExceptionFinallyStop())
        return ERROR_SUCCESS;
    EventPipe::WriteEvent(*EventPipeEventExceptionFinallyStop, (BYTE*) nullptr, 0);

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledExceptionFilterStart()
{
    return EventPipeEventExceptionFilterStart->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventExceptionFilterStart(
    const unsigned __int64 EntryEIP,
    const unsigned __int64 MethodID,
    PCWSTR MethodName,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledExceptionFilterStart())
        return ERROR_SUCCESS;

    char stackBuffer[82];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 82;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(EntryEIP, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventExceptionFilterStart, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledExceptionFilterStop()
{
    return EventPipeEventExceptionFilterStop->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventExceptionFilterStop(
)
{
    if (!EventPipeEventEnabledExceptionFilterStop())
        return ERROR_SUCCESS;
    EventPipe::WriteEvent(*EventPipeEventExceptionFilterStop, (BYTE*) nullptr, 0);

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledExceptionThrownStop()
{
    return EventPipeEventExceptionThrownStop->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventExceptionThrownStop(
)
{
    if (!EventPipeEventEnabledExceptionThrownStop())
        return ERROR_SUCCESS;
    EventPipe::WriteEvent(*EventPipeEventExceptionThrownStop, (BYTE*) nullptr, 0);

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledContention()
{
    return EventPipeEventContention->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventContention(
)
{
    if (!EventPipeEventEnabledContention())
        return ERROR_SUCCESS;
    EventPipe::WriteEvent(*EventPipeEventContention, (BYTE*) nullptr, 0);

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledContentionStart_V1()
{
    return EventPipeEventContentionStart_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventContentionStart_V1(
    const unsigned char ContentionFlags,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledContentionStart_V1())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ContentionFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventContentionStart_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledContentionStop()
{
    return EventPipeEventContentionStop->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventContentionStop(
    const unsigned char ContentionFlags,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledContentionStop())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ContentionFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventContentionStop, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledCLRStackWalk()
{
    return EventPipeEventCLRStackWalk->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventCLRStackWalk(
    const unsigned short ClrInstanceID,
    const unsigned char Reserved1,
    const unsigned char Reserved2,
    const unsigned int FrameCount,
    const void** Stack)
{
    if (!EventPipeEventEnabledCLRStackWalk())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Reserved2, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(FrameCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Stack, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventCLRStackWalk, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledAppDomainMemAllocated()
{
    return EventPipeEventAppDomainMemAllocated->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventAppDomainMemAllocated(
    const unsigned __int64 AppDomainID,
    const unsigned __int64 Allocated,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledAppDomainMemAllocated())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Allocated, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventAppDomainMemAllocated, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledAppDomainMemSurvived()
{
    return EventPipeEventAppDomainMemSurvived->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventAppDomainMemSurvived(
    const unsigned __int64 AppDomainID,
    const unsigned __int64 Survived,
    const unsigned __int64 ProcessSurvived,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledAppDomainMemSurvived())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Survived, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ProcessSurvived, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventAppDomainMemSurvived, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadCreated()
{
    return EventPipeEventThreadCreated->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadCreated(
    const unsigned __int64 ManagedThreadID,
    const unsigned __int64 AppDomainID,
    const unsigned int Flags,
    const unsigned int ManagedThreadIndex,
    const unsigned int OSThreadID,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledThreadCreated())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ManagedThreadID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Flags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ManagedThreadIndex, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(OSThreadID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadCreated, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadTerminated()
{
    return EventPipeEventThreadTerminated->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadTerminated(
    const unsigned __int64 ManagedThreadID,
    const unsigned __int64 AppDomainID,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledThreadTerminated())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ManagedThreadID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadTerminated, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledThreadDomainEnter()
{
    return EventPipeEventThreadDomainEnter->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventThreadDomainEnter(
    const unsigned __int64 ManagedThreadID,
    const unsigned __int64 AppDomainID,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledThreadDomainEnter())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ManagedThreadID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventThreadDomainEnter, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledILStubGenerated()
{
    return EventPipeEventILStubGenerated->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventILStubGenerated(
    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)
{
    if (!EventPipeEventEnabledILStubGenerated())
        return ERROR_SUCCESS;

    char stackBuffer[410];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 410;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(StubMethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(StubFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ManagedInteropMethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ManagedInteropMethodNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ManagedInteropMethodName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ManagedInteropMethodSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(NativeMethodSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(StubMethodSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(StubMethodILCode, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventILStubGenerated, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledILStubCacheHit()
{
    return EventPipeEventILStubCacheHit->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventILStubCacheHit(
    const unsigned short ClrInstanceID,
    const unsigned __int64 ModuleID,
    const unsigned __int64 StubMethodID,
    const unsigned int ManagedInteropMethodToken,
    PCWSTR ManagedInteropMethodNamespace,
    PCWSTR ManagedInteropMethodName,
    PCWSTR ManagedInteropMethodSignature)
{
    if (!EventPipeEventEnabledILStubCacheHit())
        return ERROR_SUCCESS;

    char stackBuffer[214];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 214;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(StubMethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ManagedInteropMethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ManagedInteropMethodNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ManagedInteropMethodName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ManagedInteropMethodSignature, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventILStubCacheHit, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledDCStartCompleteV2()
{
    return EventPipeEventDCStartCompleteV2->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventDCStartCompleteV2(
)
{
    if (!EventPipeEventEnabledDCStartCompleteV2())
        return ERROR_SUCCESS;
    EventPipe::WriteEvent(*EventPipeEventDCStartCompleteV2, (BYTE*) nullptr, 0);

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledDCEndCompleteV2()
{
    return EventPipeEventDCEndCompleteV2->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventDCEndCompleteV2(
)
{
    if (!EventPipeEventEnabledDCEndCompleteV2())
        return ERROR_SUCCESS;
    EventPipe::WriteEvent(*EventPipeEventDCEndCompleteV2, (BYTE*) nullptr, 0);

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodDCStartV2()
{
    return EventPipeEventMethodDCStartV2->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodDCStartV2(
    const unsigned __int64 MethodID,
    const unsigned __int64 ModuleID,
    const unsigned __int64 MethodStartAddress,
    const unsigned int MethodSize,
    const unsigned int MethodToken,
    const unsigned int MethodFlags)
{
    if (!EventPipeEventEnabledMethodDCStartV2())
        return ERROR_SUCCESS;

    char stackBuffer[36];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 36;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodDCStartV2, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodDCEndV2()
{
    return EventPipeEventMethodDCEndV2->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodDCEndV2(
    const unsigned __int64 MethodID,
    const unsigned __int64 ModuleID,
    const unsigned __int64 MethodStartAddress,
    const unsigned int MethodSize,
    const unsigned int MethodToken,
    const unsigned int MethodFlags)
{
    if (!EventPipeEventEnabledMethodDCEndV2())
        return ERROR_SUCCESS;

    char stackBuffer[36];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 36;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodDCEndV2, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodDCStartVerboseV2()
{
    return EventPipeEventMethodDCStartVerboseV2->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodDCStartVerboseV2(
    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)
{
    if (!EventPipeEventEnabledMethodDCStartVerboseV2())
        return ERROR_SUCCESS;

    char stackBuffer[228];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 228;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodDCStartVerboseV2, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodDCEndVerboseV2()
{
    return EventPipeEventMethodDCEndVerboseV2->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodDCEndVerboseV2(
    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)
{
    if (!EventPipeEventEnabledMethodDCEndVerboseV2())
        return ERROR_SUCCESS;

    char stackBuffer[228];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 228;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodDCEndVerboseV2, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodLoad()
{
    return EventPipeEventMethodLoad->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodLoad(
    const unsigned __int64 MethodID,
    const unsigned __int64 ModuleID,
    const unsigned __int64 MethodStartAddress,
    const unsigned int MethodSize,
    const unsigned int MethodToken,
    const unsigned int MethodFlags)
{
    if (!EventPipeEventEnabledMethodLoad())
        return ERROR_SUCCESS;

    char stackBuffer[36];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 36;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodLoad, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodLoad_V1()
{
    return EventPipeEventMethodLoad_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodLoad_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)
{
    if (!EventPipeEventEnabledMethodLoad_V1())
        return ERROR_SUCCESS;

    char stackBuffer[38];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 38;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodLoad_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodLoad_V2()
{
    return EventPipeEventMethodLoad_V2->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodLoad_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)
{
    if (!EventPipeEventEnabledMethodLoad_V2())
        return ERROR_SUCCESS;

    char stackBuffer[46];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 46;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ReJITID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodLoad_V2, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodUnload()
{
    return EventPipeEventMethodUnload->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodUnload(
    const unsigned __int64 MethodID,
    const unsigned __int64 ModuleID,
    const unsigned __int64 MethodStartAddress,
    const unsigned int MethodSize,
    const unsigned int MethodToken,
    const unsigned int MethodFlags)
{
    if (!EventPipeEventEnabledMethodUnload())
        return ERROR_SUCCESS;

    char stackBuffer[36];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 36;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodUnload, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodUnload_V1()
{
    return EventPipeEventMethodUnload_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodUnload_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)
{
    if (!EventPipeEventEnabledMethodUnload_V1())
        return ERROR_SUCCESS;

    char stackBuffer[38];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 38;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodUnload_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodUnload_V2()
{
    return EventPipeEventMethodUnload_V2->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodUnload_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)
{
    if (!EventPipeEventEnabledMethodUnload_V2())
        return ERROR_SUCCESS;

    char stackBuffer[46];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 46;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ReJITID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodUnload_V2, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodLoadVerbose()
{
    return EventPipeEventMethodLoadVerbose->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodLoadVerbose(
    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)
{
    if (!EventPipeEventEnabledMethodLoadVerbose())
        return ERROR_SUCCESS;

    char stackBuffer[228];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 228;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodLoadVerbose, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodLoadVerbose_V1()
{
    return EventPipeEventMethodLoadVerbose_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodLoadVerbose_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)
{
    if (!EventPipeEventEnabledMethodLoadVerbose_V1())
        return ERROR_SUCCESS;

    char stackBuffer[230];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 230;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodLoadVerbose_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodLoadVerbose_V2()
{
    return EventPipeEventMethodLoadVerbose_V2->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodLoadVerbose_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)
{
    if (!EventPipeEventEnabledMethodLoadVerbose_V2())
        return ERROR_SUCCESS;

    char stackBuffer[238];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 238;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ReJITID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodLoadVerbose_V2, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodUnloadVerbose()
{
    return EventPipeEventMethodUnloadVerbose->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodUnloadVerbose(
    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)
{
    if (!EventPipeEventEnabledMethodUnloadVerbose())
        return ERROR_SUCCESS;

    char stackBuffer[228];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 228;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodUnloadVerbose, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodUnloadVerbose_V1()
{
    return EventPipeEventMethodUnloadVerbose_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodUnloadVerbose_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)
{
    if (!EventPipeEventEnabledMethodUnloadVerbose_V1())
        return ERROR_SUCCESS;

    char stackBuffer[230];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 230;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodUnloadVerbose_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodUnloadVerbose_V2()
{
    return EventPipeEventMethodUnloadVerbose_V2->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodUnloadVerbose_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)
{
    if (!EventPipeEventEnabledMethodUnloadVerbose_V2())
        return ERROR_SUCCESS;

    char stackBuffer[238];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 238;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ReJITID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodUnloadVerbose_V2, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodJittingStarted()
{
    return EventPipeEventMethodJittingStarted->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodJittingStarted(
    const unsigned __int64 MethodID,
    const unsigned __int64 ModuleID,
    const unsigned int MethodToken,
    const unsigned int MethodILSize,
    PCWSTR MethodNamespace,
    PCWSTR MethodName,
    PCWSTR MethodSignature)
{
    if (!EventPipeEventEnabledMethodJittingStarted())
        return ERROR_SUCCESS;

    char stackBuffer[216];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 216;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodILSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodJittingStarted, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodJittingStarted_V1()
{
    return EventPipeEventMethodJittingStarted_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodJittingStarted_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)
{
    if (!EventPipeEventEnabledMethodJittingStarted_V1())
        return ERROR_SUCCESS;

    char stackBuffer[218];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 218;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodILSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodJittingStarted_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodJitInliningSucceeded()
{
    return EventPipeEventMethodJitInliningSucceeded->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodJitInliningSucceeded(
    PCWSTR MethodBeingCompiledNamespace,
    PCWSTR MethodBeingCompiledName,
    PCWSTR MethodBeingCompiledNameSignature,
    PCWSTR InlinerNamespace,
    PCWSTR InlinerName,
    PCWSTR InlinerNameSignature,
    PCWSTR InlineeNamespace,
    PCWSTR InlineeName,
    PCWSTR InlineeNameSignature,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledMethodJitInliningSucceeded())
        return ERROR_SUCCESS;

    char stackBuffer[578];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 578;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodBeingCompiledNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodBeingCompiledName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodBeingCompiledNameSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(InlinerNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(InlinerName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(InlinerNameSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(InlineeNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(InlineeName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(InlineeNameSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodJitInliningSucceeded, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodJitInliningFailed()
{
    return EventPipeEventMethodJitInliningFailed->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodJitInliningFailed(
    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)
{
    if (!EventPipeEventEnabledMethodJitInliningFailed())
        return ERROR_SUCCESS;

    char stackBuffer[614];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 614;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodBeingCompiledNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodBeingCompiledName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodBeingCompiledNameSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(InlinerNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(InlinerName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(InlinerNameSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(InlineeNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(InlineeName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(InlineeNameSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(FailAlways, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(FailReason, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodJitInliningFailed, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodJitTailCallSucceeded()
{
    return EventPipeEventMethodJitTailCallSucceeded->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodJitTailCallSucceeded(
    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)
{
    if (!EventPipeEventEnabledMethodJitTailCallSucceeded())
        return ERROR_SUCCESS;

    char stackBuffer[586];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 586;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodBeingCompiledNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodBeingCompiledName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodBeingCompiledNameSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CallerNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CallerName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CallerNameSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CalleeNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CalleeName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CalleeNameSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TailPrefix, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TailCallType, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodJitTailCallSucceeded, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodJitTailCallFailed()
{
    return EventPipeEventMethodJitTailCallFailed->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodJitTailCallFailed(
    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)
{
    if (!EventPipeEventEnabledMethodJitTailCallFailed())
        return ERROR_SUCCESS;

    char stackBuffer[614];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 614;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodBeingCompiledNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodBeingCompiledName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodBeingCompiledNameSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CallerNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CallerName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CallerNameSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CalleeNamespace, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CalleeName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CalleeNameSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TailPrefix, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(FailReason, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodJitTailCallFailed, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledMethodILToNativeMap()
{
    return EventPipeEventMethodILToNativeMap->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventMethodILToNativeMap(
    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)
{
    if (!EventPipeEventEnabledMethodILToNativeMap())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ReJITID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MethodExtent, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CountOfMapEntries, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer((const BYTE *)ILOffsets, sizeof(const unsigned int) * (int)CountOfMapEntries, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer((const BYTE *)NativeOffsets, sizeof(const unsigned int) * (int)CountOfMapEntries, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventMethodILToNativeMap, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledModuleDCStartV2()
{
    return EventPipeEventModuleDCStartV2->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventModuleDCStartV2(
    const unsigned __int64 ModuleID,
    const unsigned __int64 AssemblyID,
    const unsigned int ModuleFlags,
    const unsigned int Reserved1,
    PCWSTR ModuleILPath,
    PCWSTR ModuleNativePath)
{
    if (!EventPipeEventEnabledModuleDCStartV2())
        return ERROR_SUCCESS;

    char stackBuffer[152];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 152;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventModuleDCStartV2, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledModuleDCEndV2()
{
    return EventPipeEventModuleDCEndV2->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventModuleDCEndV2(
    const unsigned __int64 ModuleID,
    const unsigned __int64 AssemblyID,
    const unsigned int ModuleFlags,
    const unsigned int Reserved1,
    PCWSTR ModuleILPath,
    PCWSTR ModuleNativePath)
{
    if (!EventPipeEventEnabledModuleDCEndV2())
        return ERROR_SUCCESS;

    char stackBuffer[152];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 152;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventModuleDCEndV2, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledDomainModuleLoad()
{
    return EventPipeEventDomainModuleLoad->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventDomainModuleLoad(
    const unsigned __int64 ModuleID,
    const unsigned __int64 AssemblyID,
    const unsigned __int64 AppDomainID,
    const unsigned int ModuleFlags,
    const unsigned int Reserved1,
    PCWSTR ModuleILPath,
    PCWSTR ModuleNativePath)
{
    if (!EventPipeEventEnabledDomainModuleLoad())
        return ERROR_SUCCESS;

    char stackBuffer[160];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 160;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventDomainModuleLoad, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledDomainModuleLoad_V1()
{
    return EventPipeEventDomainModuleLoad_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventDomainModuleLoad_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)
{
    if (!EventPipeEventEnabledDomainModuleLoad_V1())
        return ERROR_SUCCESS;

    char stackBuffer[162];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 162;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventDomainModuleLoad_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledModuleLoad()
{
    return EventPipeEventModuleLoad->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventModuleLoad(
    const unsigned __int64 ModuleID,
    const unsigned __int64 AssemblyID,
    const unsigned int ModuleFlags,
    const unsigned int Reserved1,
    PCWSTR ModuleILPath,
    PCWSTR ModuleNativePath)
{
    if (!EventPipeEventEnabledModuleLoad())
        return ERROR_SUCCESS;

    char stackBuffer[152];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 152;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventModuleLoad, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledModuleLoad_V1()
{
    return EventPipeEventModuleLoad_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventModuleLoad_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)
{
    if (!EventPipeEventEnabledModuleLoad_V1())
        return ERROR_SUCCESS;

    char stackBuffer[154];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 154;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventModuleLoad_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledModuleLoad_V2()
{
    return EventPipeEventModuleLoad_V2->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventModuleLoad_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)
{
    if (!EventPipeEventEnabledModuleLoad_V2())
        return ERROR_SUCCESS;

    char stackBuffer[290];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 290;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(*ManagedPdbSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ManagedPdbAge, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ManagedPdbBuildPath, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(*NativePdbSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(NativePdbAge, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(NativePdbBuildPath, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventModuleLoad_V2, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledModuleUnload()
{
    return EventPipeEventModuleUnload->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventModuleUnload(
    const unsigned __int64 ModuleID,
    const unsigned __int64 AssemblyID,
    const unsigned int ModuleFlags,
    const unsigned int Reserved1,
    PCWSTR ModuleILPath,
    PCWSTR ModuleNativePath)
{
    if (!EventPipeEventEnabledModuleUnload())
        return ERROR_SUCCESS;

    char stackBuffer[152];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 152;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventModuleUnload, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledModuleUnload_V1()
{
    return EventPipeEventModuleUnload_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventModuleUnload_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)
{
    if (!EventPipeEventEnabledModuleUnload_V1())
        return ERROR_SUCCESS;

    char stackBuffer[154];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 154;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventModuleUnload_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledModuleUnload_V2()
{
    return EventPipeEventModuleUnload_V2->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventModuleUnload_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)
{
    if (!EventPipeEventEnabledModuleUnload_V2())
        return ERROR_SUCCESS;

    char stackBuffer[290];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 290;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(*ManagedPdbSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ManagedPdbAge, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ManagedPdbBuildPath, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(*NativePdbSignature, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(NativePdbAge, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(NativePdbBuildPath, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventModuleUnload_V2, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledAssemblyLoad()
{
    return EventPipeEventAssemblyLoad->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventAssemblyLoad(
    const unsigned __int64 AssemblyID,
    const unsigned __int64 AppDomainID,
    const unsigned int AssemblyFlags,
    PCWSTR FullyQualifiedAssemblyName)
{
    if (!EventPipeEventEnabledAssemblyLoad())
        return ERROR_SUCCESS;

    char stackBuffer[84];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 84;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AssemblyFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(FullyQualifiedAssemblyName, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventAssemblyLoad, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledAssemblyLoad_V1()
{
    return EventPipeEventAssemblyLoad_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventAssemblyLoad_V1(
    const unsigned __int64 AssemblyID,
    const unsigned __int64 AppDomainID,
    const unsigned __int64 BindingID,
    const unsigned int AssemblyFlags,
    PCWSTR FullyQualifiedAssemblyName,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledAssemblyLoad_V1())
        return ERROR_SUCCESS;

    char stackBuffer[94];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 94;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(BindingID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AssemblyFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(FullyQualifiedAssemblyName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventAssemblyLoad_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledAssemblyUnload()
{
    return EventPipeEventAssemblyUnload->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventAssemblyUnload(
    const unsigned __int64 AssemblyID,
    const unsigned __int64 AppDomainID,
    const unsigned int AssemblyFlags,
    PCWSTR FullyQualifiedAssemblyName)
{
    if (!EventPipeEventEnabledAssemblyUnload())
        return ERROR_SUCCESS;

    char stackBuffer[84];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 84;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AssemblyFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(FullyQualifiedAssemblyName, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventAssemblyUnload, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledAssemblyUnload_V1()
{
    return EventPipeEventAssemblyUnload_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventAssemblyUnload_V1(
    const unsigned __int64 AssemblyID,
    const unsigned __int64 AppDomainID,
    const unsigned __int64 BindingID,
    const unsigned int AssemblyFlags,
    PCWSTR FullyQualifiedAssemblyName,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledAssemblyUnload_V1())
        return ERROR_SUCCESS;

    char stackBuffer[94];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 94;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(BindingID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AssemblyFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(FullyQualifiedAssemblyName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventAssemblyUnload_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledAppDomainLoad()
{
    return EventPipeEventAppDomainLoad->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventAppDomainLoad(
    const unsigned __int64 AppDomainID,
    const unsigned int AppDomainFlags,
    PCWSTR AppDomainName)
{
    if (!EventPipeEventEnabledAppDomainLoad())
        return ERROR_SUCCESS;

    char stackBuffer[76];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 76;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainName, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventAppDomainLoad, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledAppDomainLoad_V1()
{
    return EventPipeEventAppDomainLoad_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventAppDomainLoad_V1(
    const unsigned __int64 AppDomainID,
    const unsigned int AppDomainFlags,
    PCWSTR AppDomainName,
    const unsigned int AppDomainIndex,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledAppDomainLoad_V1())
        return ERROR_SUCCESS;

    char stackBuffer[82];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 82;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainIndex, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventAppDomainLoad_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledAppDomainUnload()
{
    return EventPipeEventAppDomainUnload->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventAppDomainUnload(
    const unsigned __int64 AppDomainID,
    const unsigned int AppDomainFlags,
    PCWSTR AppDomainName)
{
    if (!EventPipeEventEnabledAppDomainUnload())
        return ERROR_SUCCESS;

    char stackBuffer[76];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 76;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainName, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventAppDomainUnload, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledAppDomainUnload_V1()
{
    return EventPipeEventAppDomainUnload_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventAppDomainUnload_V1(
    const unsigned __int64 AppDomainID,
    const unsigned int AppDomainFlags,
    PCWSTR AppDomainName,
    const unsigned int AppDomainIndex,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledAppDomainUnload_V1())
        return ERROR_SUCCESS;

    char stackBuffer[82];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 82;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(AppDomainIndex, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventAppDomainUnload_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledModuleRangeLoad()
{
    return EventPipeEventModuleRangeLoad->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventModuleRangeLoad(
    const unsigned short ClrInstanceID,
    const unsigned __int64 ModuleID,
    const unsigned int RangeBegin,
    const unsigned int RangeSize,
    const unsigned char RangeType)
{
    if (!EventPipeEventEnabledModuleRangeLoad())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RangeBegin, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RangeSize, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RangeType, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventModuleRangeLoad, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledStrongNameVerificationStart()
{
    return EventPipeEventStrongNameVerificationStart->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventStrongNameVerificationStart(
    const unsigned int VerificationFlags,
    const unsigned int ErrorCode,
    PCWSTR FullyQualifiedAssemblyName)
{
    if (!EventPipeEventEnabledStrongNameVerificationStart())
        return ERROR_SUCCESS;

    char stackBuffer[72];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 72;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(VerificationFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ErrorCode, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(FullyQualifiedAssemblyName, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventStrongNameVerificationStart, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledStrongNameVerificationStart_V1()
{
    return EventPipeEventStrongNameVerificationStart_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventStrongNameVerificationStart_V1(
    const unsigned int VerificationFlags,
    const unsigned int ErrorCode,
    PCWSTR FullyQualifiedAssemblyName,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledStrongNameVerificationStart_V1())
        return ERROR_SUCCESS;

    char stackBuffer[74];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 74;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(VerificationFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ErrorCode, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(FullyQualifiedAssemblyName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventStrongNameVerificationStart_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledStrongNameVerificationStop()
{
    return EventPipeEventStrongNameVerificationStop->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventStrongNameVerificationStop(
    const unsigned int VerificationFlags,
    const unsigned int ErrorCode,
    PCWSTR FullyQualifiedAssemblyName)
{
    if (!EventPipeEventEnabledStrongNameVerificationStop())
        return ERROR_SUCCESS;

    char stackBuffer[72];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 72;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(VerificationFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ErrorCode, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(FullyQualifiedAssemblyName, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventStrongNameVerificationStop, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledStrongNameVerificationStop_V1()
{
    return EventPipeEventStrongNameVerificationStop_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventStrongNameVerificationStop_V1(
    const unsigned int VerificationFlags,
    const unsigned int ErrorCode,
    PCWSTR FullyQualifiedAssemblyName,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledStrongNameVerificationStop_V1())
        return ERROR_SUCCESS;

    char stackBuffer[74];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 74;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(VerificationFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ErrorCode, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(FullyQualifiedAssemblyName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventStrongNameVerificationStop_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledAuthenticodeVerificationStart()
{
    return EventPipeEventAuthenticodeVerificationStart->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventAuthenticodeVerificationStart(
    const unsigned int VerificationFlags,
    const unsigned int ErrorCode,
    PCWSTR ModulePath)
{
    if (!EventPipeEventEnabledAuthenticodeVerificationStart())
        return ERROR_SUCCESS;

    char stackBuffer[72];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 72;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(VerificationFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ErrorCode, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModulePath, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventAuthenticodeVerificationStart, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledAuthenticodeVerificationStart_V1()
{
    return EventPipeEventAuthenticodeVerificationStart_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventAuthenticodeVerificationStart_V1(
    const unsigned int VerificationFlags,
    const unsigned int ErrorCode,
    PCWSTR ModulePath,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledAuthenticodeVerificationStart_V1())
        return ERROR_SUCCESS;

    char stackBuffer[74];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 74;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(VerificationFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ErrorCode, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModulePath, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventAuthenticodeVerificationStart_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledAuthenticodeVerificationStop()
{
    return EventPipeEventAuthenticodeVerificationStop->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventAuthenticodeVerificationStop(
    const unsigned int VerificationFlags,
    const unsigned int ErrorCode,
    PCWSTR ModulePath)
{
    if (!EventPipeEventEnabledAuthenticodeVerificationStop())
        return ERROR_SUCCESS;

    char stackBuffer[72];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 72;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(VerificationFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ErrorCode, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModulePath, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventAuthenticodeVerificationStop, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledAuthenticodeVerificationStop_V1()
{
    return EventPipeEventAuthenticodeVerificationStop_V1->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventAuthenticodeVerificationStop_V1(
    const unsigned int VerificationFlags,
    const unsigned int ErrorCode,
    PCWSTR ModulePath,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledAuthenticodeVerificationStop_V1())
        return ERROR_SUCCESS;

    char stackBuffer[74];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 74;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(VerificationFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ErrorCode, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ModulePath, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventAuthenticodeVerificationStop_V1, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledRuntimeInformationStart()
{
    return EventPipeEventRuntimeInformationStart->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventRuntimeInformationStart(
    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)
{
    if (!EventPipeEventEnabledRuntimeInformationStart())
        return ERROR_SUCCESS;

    char stackBuffer[153];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 153;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Sku, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(BclMajorVersion, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(BclMinorVersion, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(BclBuildNumber, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(BclQfeNumber, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(VMMajorVersion, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(VMMinorVersion, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(VMBuildNumber, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(VMQfeNumber, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(StartupFlags, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(StartupMode, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CommandLine, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(*ComObjectGuid, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RuntimeDllPath, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventRuntimeInformationStart, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledIncreaseMemoryPressure()
{
    return EventPipeEventIncreaseMemoryPressure->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventIncreaseMemoryPressure(
    const unsigned __int64 BytesAllocated,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledIncreaseMemoryPressure())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(BytesAllocated, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventIncreaseMemoryPressure, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledDecreaseMemoryPressure()
{
    return EventPipeEventDecreaseMemoryPressure->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventDecreaseMemoryPressure(
    const unsigned __int64 BytesFreed,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledDecreaseMemoryPressure())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(BytesFreed, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventDecreaseMemoryPressure, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCMarkWithType()
{
    return EventPipeEventGCMarkWithType->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCMarkWithType(
    const unsigned int HeapNum,
    const unsigned short ClrInstanceID,
    const unsigned int Type,
    const unsigned __int64 Bytes)
{
    if (!EventPipeEventEnabledGCMarkWithType())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(HeapNum, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Type, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Bytes, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCMarkWithType, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCJoin_V2()
{
    return EventPipeEventGCJoin_V2->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCJoin_V2(
    const unsigned int Heap,
    const unsigned int JoinTime,
    const unsigned int JoinType,
    const unsigned short ClrInstanceID,
    const unsigned int JoinID)
{
    if (!EventPipeEventEnabledGCJoin_V2())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(Heap, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(JoinTime, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(JoinType, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(JoinID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCJoin_V2, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCPerHeapHistory_V3()
{
    return EventPipeEventGCPerHeapHistory_V3->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCPerHeapHistory_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)
{
    if (!EventPipeEventEnabledGCPerHeapHistory_V3())
        return ERROR_SUCCESS;

    char stackBuffer[118];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 118;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(FreeListAllocated, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(FreeListRejected, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(EndOfSegAllocated, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CondemnedAllocated, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(PinnedAllocated, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(PinnedAllocatedAdvance, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(RunningFreeListEfficiency, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CondemnReasons0, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CondemnReasons1, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CompactMechanisms, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ExpandMechanisms, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(HeapIndex, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ExtraGen0Commit, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer((const BYTE *)Values, (int)Values_ElementSize * (int)Count, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCPerHeapHistory_V3, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledGCGlobalHeapHistory_V2()
{
    return EventPipeEventGCGlobalHeapHistory_V2->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventGCGlobalHeapHistory_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)
{
    if (!EventPipeEventEnabledGCGlobalHeapHistory_V2())
        return ERROR_SUCCESS;

    char stackBuffer[38];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 38;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(FinalYoungestDesired, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(NumHeaps, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(CondemnedGeneration, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Gen0ReductionCount, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Reason, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(GlobalMechanisms, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(PauseMode, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(MemoryPressure, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventGCGlobalHeapHistory_V2, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledDebugIPCEventStart()
{
    return EventPipeEventDebugIPCEventStart->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventDebugIPCEventStart(
)
{
    if (!EventPipeEventEnabledDebugIPCEventStart())
        return ERROR_SUCCESS;
    EventPipe::WriteEvent(*EventPipeEventDebugIPCEventStart, (BYTE*) nullptr, 0);

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledDebugIPCEventEnd()
{
    return EventPipeEventDebugIPCEventEnd->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventDebugIPCEventEnd(
)
{
    if (!EventPipeEventEnabledDebugIPCEventEnd())
        return ERROR_SUCCESS;
    EventPipe::WriteEvent(*EventPipeEventDebugIPCEventEnd, (BYTE*) nullptr, 0);

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledDebugExceptionProcessingStart()
{
    return EventPipeEventDebugExceptionProcessingStart->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventDebugExceptionProcessingStart(
)
{
    if (!EventPipeEventEnabledDebugExceptionProcessingStart())
        return ERROR_SUCCESS;
    EventPipe::WriteEvent(*EventPipeEventDebugExceptionProcessingStart, (BYTE*) nullptr, 0);

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledDebugExceptionProcessingEnd()
{
    return EventPipeEventDebugExceptionProcessingEnd->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventDebugExceptionProcessingEnd(
)
{
    if (!EventPipeEventEnabledDebugExceptionProcessingEnd())
        return ERROR_SUCCESS;
    EventPipe::WriteEvent(*EventPipeEventDebugExceptionProcessingEnd, (BYTE*) nullptr, 0);

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledCodeSymbols()
{
    return EventPipeEventCodeSymbols->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventCodeSymbols(
    const unsigned __int64 ModuleId,
    const unsigned short TotalChunks,
    const unsigned short ChunkNumber,
    const unsigned int ChunkLength,
    const BYTE* Chunk,
    const unsigned short ClrInstanceID)
{
    if (!EventPipeEventEnabledCodeSymbols())
        return ERROR_SUCCESS;

    char stackBuffer[32];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 32;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(ModuleId, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(TotalChunks, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ChunkNumber, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ChunkLength, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer((const BYTE *)Chunk, sizeof(const BYTE) * (int)ChunkLength, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventCodeSymbols, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

bool EventPipeEventEnabledEventSource()
{
    return EventPipeEventEventSource->IsEnabled();
}

extern "C" ULONG EventPipeWriteEventEventSource(
    const signed int EventID,
    PCWSTR EventName,
    PCWSTR EventSourceName,
    PCWSTR Payload)
{
    if (!EventPipeEventEnabledEventSource())
        return ERROR_SUCCESS;

    char stackBuffer[196];
    char *buffer = stackBuffer;
    unsigned int offset = 0;
    unsigned int size = 196;
    bool fixedBuffer = true;

    bool success = true;
    success &= WriteToBuffer(EventID, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(EventName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(EventSourceName, buffer, offset, size, fixedBuffer);
    success &= WriteToBuffer(Payload, buffer, offset, size, fixedBuffer);

    if (!success)
    {
        if (!fixedBuffer)
            delete[] buffer;
        return ERROR_WRITE_FAULT;
    }

    EventPipe::WriteEvent(*EventPipeEventEventSource, (BYTE *)buffer, offset);

    if (!fixedBuffer)
        delete[] buffer;

    return ERROR_SUCCESS;
}

extern "C" void InitDotNETRuntime()
{
    EventPipeProviderDotNETRuntime = EventPipe::CreateProvider(SL(DotNETRuntimeName));
    EventPipeEventGCStart = EventPipeProviderDotNETRuntime->AddEvent(1,1,0,EventPipeEventLevel::Informational);
    EventPipeEventGCStart_V1 = EventPipeProviderDotNETRuntime->AddEvent(1,1,1,EventPipeEventLevel::Informational);
    EventPipeEventGCStart_V2 = EventPipeProviderDotNETRuntime->AddEvent(1,1,2,EventPipeEventLevel::Informational);
    EventPipeEventGCEnd = EventPipeProviderDotNETRuntime->AddEvent(2,1,0,EventPipeEventLevel::Informational);
    EventPipeEventGCEnd_V1 = EventPipeProviderDotNETRuntime->AddEvent(2,1,1,EventPipeEventLevel::Informational);
    EventPipeEventGCRestartEEEnd = EventPipeProviderDotNETRuntime->AddEvent(3,1,0,EventPipeEventLevel::Informational);
    EventPipeEventGCRestartEEEnd_V1 = EventPipeProviderDotNETRuntime->AddEvent(3,1,1,EventPipeEventLevel::Informational);
    EventPipeEventGCHeapStats = EventPipeProviderDotNETRuntime->AddEvent(4,1,0,EventPipeEventLevel::Informational);
    EventPipeEventGCHeapStats_V1 = EventPipeProviderDotNETRuntime->AddEvent(4,1,1,EventPipeEventLevel::Informational);
    EventPipeEventGCCreateSegment = EventPipeProviderDotNETRuntime->AddEvent(5,1,0,EventPipeEventLevel::Informational);
    EventPipeEventGCCreateSegment_V1 = EventPipeProviderDotNETRuntime->AddEvent(5,1,1,EventPipeEventLevel::Informational);
    EventPipeEventGCFreeSegment = EventPipeProviderDotNETRuntime->AddEvent(6,1,0,EventPipeEventLevel::Informational);
    EventPipeEventGCFreeSegment_V1 = EventPipeProviderDotNETRuntime->AddEvent(6,1,1,EventPipeEventLevel::Informational);
    EventPipeEventGCRestartEEBegin = EventPipeProviderDotNETRuntime->AddEvent(7,1,0,EventPipeEventLevel::Informational);
    EventPipeEventGCRestartEEBegin_V1 = EventPipeProviderDotNETRuntime->AddEvent(7,1,1,EventPipeEventLevel::Informational);
    EventPipeEventGCSuspendEEEnd = EventPipeProviderDotNETRuntime->AddEvent(8,1,0,EventPipeEventLevel::Informational);
    EventPipeEventGCSuspendEEEnd_V1 = EventPipeProviderDotNETRuntime->AddEvent(8,1,1,EventPipeEventLevel::Informational);
    EventPipeEventGCSuspendEEBegin = EventPipeProviderDotNETRuntime->AddEvent(9,1,0,EventPipeEventLevel::Informational);
    EventPipeEventGCSuspendEEBegin_V1 = EventPipeProviderDotNETRuntime->AddEvent(9,1,1,EventPipeEventLevel::Informational);
    EventPipeEventGCAllocationTick = EventPipeProviderDotNETRuntime->AddEvent(10,1,0,EventPipeEventLevel::Verbose);
    EventPipeEventGCAllocationTick_V1 = EventPipeProviderDotNETRuntime->AddEvent(10,1,1,EventPipeEventLevel::Verbose);
    EventPipeEventGCAllocationTick_V2 = EventPipeProviderDotNETRuntime->AddEvent(10,1,2,EventPipeEventLevel::Verbose);
    EventPipeEventGCAllocationTick_V3 = EventPipeProviderDotNETRuntime->AddEvent(10,1,3,EventPipeEventLevel::Verbose);
    EventPipeEventGCCreateConcurrentThread = EventPipeProviderDotNETRuntime->AddEvent(11,1,0,EventPipeEventLevel::Informational);
    EventPipeEventGCCreateConcurrentThread_V1 = EventPipeProviderDotNETRuntime->AddEvent(11,65537,1,EventPipeEventLevel::Informational);
    EventPipeEventGCTerminateConcurrentThread = EventPipeProviderDotNETRuntime->AddEvent(12,1,0,EventPipeEventLevel::Informational);
    EventPipeEventGCTerminateConcurrentThread_V1 = EventPipeProviderDotNETRuntime->AddEvent(12,65537,1,EventPipeEventLevel::Informational);
    EventPipeEventGCFinalizersEnd = EventPipeProviderDotNETRuntime->AddEvent(13,1,0,EventPipeEventLevel::Informational);
    EventPipeEventGCFinalizersEnd_V1 = EventPipeProviderDotNETRuntime->AddEvent(13,1,1,EventPipeEventLevel::Informational);
    EventPipeEventGCFinalizersBegin = EventPipeProviderDotNETRuntime->AddEvent(14,1,0,EventPipeEventLevel::Informational);
    EventPipeEventGCFinalizersBegin_V1 = EventPipeProviderDotNETRuntime->AddEvent(14,1,1,EventPipeEventLevel::Informational);
    EventPipeEventBulkType = EventPipeProviderDotNETRuntime->AddEvent(15,524288,0,EventPipeEventLevel::Informational);
    EventPipeEventGCBulkRootEdge = EventPipeProviderDotNETRuntime->AddEvent(16,1048576,0,EventPipeEventLevel::Informational);
    EventPipeEventGCBulkRootConditionalWeakTableElementEdge = EventPipeProviderDotNETRuntime->AddEvent(17,1048576,0,EventPipeEventLevel::Informational);
    EventPipeEventGCBulkNode = EventPipeProviderDotNETRuntime->AddEvent(18,1048576,0,EventPipeEventLevel::Informational);
    EventPipeEventGCBulkEdge = EventPipeProviderDotNETRuntime->AddEvent(19,1048576,0,EventPipeEventLevel::Informational);
    EventPipeEventGCSampledObjectAllocationHigh = EventPipeProviderDotNETRuntime->AddEvent(20,2097152,0,EventPipeEventLevel::Informational);
    EventPipeEventGCBulkSurvivingObjectRanges = EventPipeProviderDotNETRuntime->AddEvent(21,4194304,0,EventPipeEventLevel::Informational);
    EventPipeEventGCBulkMovedObjectRanges = EventPipeProviderDotNETRuntime->AddEvent(22,4194304,0,EventPipeEventLevel::Informational);
    EventPipeEventGCGenerationRange = EventPipeProviderDotNETRuntime->AddEvent(23,4194304,0,EventPipeEventLevel::Informational);
    EventPipeEventGCMarkStackRoots = EventPipeProviderDotNETRuntime->AddEvent(25,1,0,EventPipeEventLevel::Informational);
    EventPipeEventGCMarkFinalizeQueueRoots = EventPipeProviderDotNETRuntime->AddEvent(26,1,0,EventPipeEventLevel::Informational);
    EventPipeEventGCMarkHandles = EventPipeProviderDotNETRuntime->AddEvent(27,1,0,EventPipeEventLevel::Informational);
    EventPipeEventGCMarkOlderGenerationRoots = EventPipeProviderDotNETRuntime->AddEvent(28,1,0,EventPipeEventLevel::Informational);
    EventPipeEventFinalizeObject = EventPipeProviderDotNETRuntime->AddEvent(29,1,0,EventPipeEventLevel::Verbose);
    EventPipeEventSetGCHandle = EventPipeProviderDotNETRuntime->AddEvent(30,2,0,EventPipeEventLevel::Informational);
    EventPipeEventDestroyGCHandle = EventPipeProviderDotNETRuntime->AddEvent(31,2,0,EventPipeEventLevel::Informational);
    EventPipeEventGCSampledObjectAllocationLow = EventPipeProviderDotNETRuntime->AddEvent(32,33554432,0,EventPipeEventLevel::Informational);
    EventPipeEventPinObjectAtGCTime = EventPipeProviderDotNETRuntime->AddEvent(33,1,0,EventPipeEventLevel::Verbose);
    EventPipeEventGCTriggered = EventPipeProviderDotNETRuntime->AddEvent(35,1,0,EventPipeEventLevel::Informational);
    EventPipeEventGCBulkRootCCW = EventPipeProviderDotNETRuntime->AddEvent(36,1048576,0,EventPipeEventLevel::Informational);
    EventPipeEventGCBulkRCW = EventPipeProviderDotNETRuntime->AddEvent(37,1048576,0,EventPipeEventLevel::Informational);
    EventPipeEventGCBulkRootStaticVar = EventPipeProviderDotNETRuntime->AddEvent(38,1048576,0,EventPipeEventLevel::Informational);
    EventPipeEventWorkerThreadCreate = EventPipeProviderDotNETRuntime->AddEvent(40,65536,0,EventPipeEventLevel::Informational);
    EventPipeEventWorkerThreadTerminate = EventPipeProviderDotNETRuntime->AddEvent(41,65536,0,EventPipeEventLevel::Informational);
    EventPipeEventWorkerThreadRetire = EventPipeProviderDotNETRuntime->AddEvent(42,65536,0,EventPipeEventLevel::Informational);
    EventPipeEventWorkerThreadUnretire = EventPipeProviderDotNETRuntime->AddEvent(43,65536,0,EventPipeEventLevel::Informational);
    EventPipeEventIOThreadCreate = EventPipeProviderDotNETRuntime->AddEvent(44,65536,0,EventPipeEventLevel::Informational);
    EventPipeEventIOThreadCreate_V1 = EventPipeProviderDotNETRuntime->AddEvent(44,65536,1,EventPipeEventLevel::Informational);
    EventPipeEventIOThreadTerminate = EventPipeProviderDotNETRuntime->AddEvent(45,65536,0,EventPipeEventLevel::Informational);
    EventPipeEventIOThreadTerminate_V1 = EventPipeProviderDotNETRuntime->AddEvent(45,65536,1,EventPipeEventLevel::Informational);
    EventPipeEventIOThreadRetire = EventPipeProviderDotNETRuntime->AddEvent(46,65536,0,EventPipeEventLevel::Informational);
    EventPipeEventIOThreadRetire_V1 = EventPipeProviderDotNETRuntime->AddEvent(46,65536,1,EventPipeEventLevel::Informational);
    EventPipeEventIOThreadUnretire = EventPipeProviderDotNETRuntime->AddEvent(47,65536,0,EventPipeEventLevel::Informational);
    EventPipeEventIOThreadUnretire_V1 = EventPipeProviderDotNETRuntime->AddEvent(47,65536,1,EventPipeEventLevel::Informational);
    EventPipeEventThreadpoolSuspensionSuspendThread = EventPipeProviderDotNETRuntime->AddEvent(48,65536,0,EventPipeEventLevel::Informational);
    EventPipeEventThreadpoolSuspensionResumeThread = EventPipeProviderDotNETRuntime->AddEvent(49,65536,0,EventPipeEventLevel::Informational);
    EventPipeEventThreadPoolWorkerThreadStart = EventPipeProviderDotNETRuntime->AddEvent(50,65536,0,EventPipeEventLevel::Informational);
    EventPipeEventThreadPoolWorkerThreadStop = EventPipeProviderDotNETRuntime->AddEvent(51,65536,0,EventPipeEventLevel::Informational);
    EventPipeEventThreadPoolWorkerThreadRetirementStart = EventPipeProviderDotNETRuntime->AddEvent(52,65536,0,EventPipeEventLevel::Informational);
    EventPipeEventThreadPoolWorkerThreadRetirementStop = EventPipeProviderDotNETRuntime->AddEvent(53,65536,0,EventPipeEventLevel::Informational);
    EventPipeEventThreadPoolWorkerThreadAdjustmentSample = EventPipeProviderDotNETRuntime->AddEvent(54,65536,0,EventPipeEventLevel::Informational);
    EventPipeEventThreadPoolWorkerThreadAdjustmentAdjustment = EventPipeProviderDotNETRuntime->AddEvent(55,65536,0,EventPipeEventLevel::Informational);
    EventPipeEventThreadPoolWorkerThreadAdjustmentStats = EventPipeProviderDotNETRuntime->AddEvent(56,65536,0,EventPipeEventLevel::Verbose);
    EventPipeEventThreadPoolWorkerThreadWait = EventPipeProviderDotNETRuntime->AddEvent(57,65536,0,EventPipeEventLevel::Informational);
    EventPipeEventThreadPoolWorkingThreadCount = EventPipeProviderDotNETRuntime->AddEvent(60,65536,0,EventPipeEventLevel::Verbose);
    EventPipeEventThreadPoolEnqueue = EventPipeProviderDotNETRuntime->AddEvent(61,2147549184,0,EventPipeEventLevel::Verbose);
    EventPipeEventThreadPoolDequeue = EventPipeProviderDotNETRuntime->AddEvent(62,2147549184,0,EventPipeEventLevel::Verbose);
    EventPipeEventThreadPoolIOEnqueue = EventPipeProviderDotNETRuntime->AddEvent(63,2147549184,0,EventPipeEventLevel::Verbose);
    EventPipeEventThreadPoolIODequeue = EventPipeProviderDotNETRuntime->AddEvent(64,2147549184,0,EventPipeEventLevel::Verbose);
    EventPipeEventThreadPoolIOPack = EventPipeProviderDotNETRuntime->AddEvent(65,65536,0,EventPipeEventLevel::Verbose);
    EventPipeEventThreadCreating = EventPipeProviderDotNETRuntime->AddEvent(70,2147549184,0,EventPipeEventLevel::Informational);
    EventPipeEventThreadRunning = EventPipeProviderDotNETRuntime->AddEvent(71,2147549184,0,EventPipeEventLevel::Informational);
    EventPipeEventExceptionThrown = EventPipeProviderDotNETRuntime->AddEvent(80,0,0,EventPipeEventLevel::Informational);
    EventPipeEventExceptionThrown_V1 = EventPipeProviderDotNETRuntime->AddEvent(80,8589967360,1,EventPipeEventLevel::Error);
    EventPipeEventExceptionCatchStart = EventPipeProviderDotNETRuntime->AddEvent(250,32768,0,EventPipeEventLevel::Informational);
    EventPipeEventExceptionCatchStop = EventPipeProviderDotNETRuntime->AddEvent(251,32768,0,EventPipeEventLevel::Informational);
    EventPipeEventExceptionFinallyStart = EventPipeProviderDotNETRuntime->AddEvent(252,32768,0,EventPipeEventLevel::Informational);
    EventPipeEventExceptionFinallyStop = EventPipeProviderDotNETRuntime->AddEvent(253,32768,0,EventPipeEventLevel::Informational);
    EventPipeEventExceptionFilterStart = EventPipeProviderDotNETRuntime->AddEvent(254,32768,0,EventPipeEventLevel::Informational);
    EventPipeEventExceptionFilterStop = EventPipeProviderDotNETRuntime->AddEvent(255,32768,0,EventPipeEventLevel::Informational);
    EventPipeEventExceptionThrownStop = EventPipeProviderDotNETRuntime->AddEvent(256,32768,0,EventPipeEventLevel::Informational);
    EventPipeEventContention = EventPipeProviderDotNETRuntime->AddEvent(81,0,0,EventPipeEventLevel::Informational);
    EventPipeEventContentionStart_V1 = EventPipeProviderDotNETRuntime->AddEvent(81,16384,1,EventPipeEventLevel::Informational);
    EventPipeEventContentionStop = EventPipeProviderDotNETRuntime->AddEvent(91,16384,0,EventPipeEventLevel::Informational);
    EventPipeEventCLRStackWalk = EventPipeProviderDotNETRuntime->AddEvent(82,1073741824,0,EventPipeEventLevel::LogAlways);
    EventPipeEventAppDomainMemAllocated = EventPipeProviderDotNETRuntime->AddEvent(83,2048,0,EventPipeEventLevel::Informational);
    EventPipeEventAppDomainMemSurvived = EventPipeProviderDotNETRuntime->AddEvent(84,2048,0,EventPipeEventLevel::Informational);
    EventPipeEventThreadCreated = EventPipeProviderDotNETRuntime->AddEvent(85,67584,0,EventPipeEventLevel::Informational);
    EventPipeEventThreadTerminated = EventPipeProviderDotNETRuntime->AddEvent(86,67584,0,EventPipeEventLevel::Informational);
    EventPipeEventThreadDomainEnter = EventPipeProviderDotNETRuntime->AddEvent(87,67584,0,EventPipeEventLevel::Informational);
    EventPipeEventILStubGenerated = EventPipeProviderDotNETRuntime->AddEvent(88,8192,0,EventPipeEventLevel::Informational);
    EventPipeEventILStubCacheHit = EventPipeProviderDotNETRuntime->AddEvent(89,8192,0,EventPipeEventLevel::Informational);
    EventPipeEventDCStartCompleteV2 = EventPipeProviderDotNETRuntime->AddEvent(135,48,0,EventPipeEventLevel::Informational);
    EventPipeEventDCEndCompleteV2 = EventPipeProviderDotNETRuntime->AddEvent(136,48,0,EventPipeEventLevel::Informational);
    EventPipeEventMethodDCStartV2 = EventPipeProviderDotNETRuntime->AddEvent(137,48,0,EventPipeEventLevel::Informational);
    EventPipeEventMethodDCEndV2 = EventPipeProviderDotNETRuntime->AddEvent(138,48,0,EventPipeEventLevel::Informational);
    EventPipeEventMethodDCStartVerboseV2 = EventPipeProviderDotNETRuntime->AddEvent(139,48,0,EventPipeEventLevel::Informational);
    EventPipeEventMethodDCEndVerboseV2 = EventPipeProviderDotNETRuntime->AddEvent(140,48,0,EventPipeEventLevel::Informational);
    EventPipeEventMethodLoad = EventPipeProviderDotNETRuntime->AddEvent(141,48,0,EventPipeEventLevel::Informational);
    EventPipeEventMethodLoad_V1 = EventPipeProviderDotNETRuntime->AddEvent(141,48,1,EventPipeEventLevel::Informational);
    EventPipeEventMethodLoad_V2 = EventPipeProviderDotNETRuntime->AddEvent(141,48,2,EventPipeEventLevel::Informational);
    EventPipeEventMethodUnload = EventPipeProviderDotNETRuntime->AddEvent(142,48,0,EventPipeEventLevel::Informational);
    EventPipeEventMethodUnload_V1 = EventPipeProviderDotNETRuntime->AddEvent(142,48,1,EventPipeEventLevel::Informational);
    EventPipeEventMethodUnload_V2 = EventPipeProviderDotNETRuntime->AddEvent(142,48,2,EventPipeEventLevel::Informational);
    EventPipeEventMethodLoadVerbose = EventPipeProviderDotNETRuntime->AddEvent(143,48,0,EventPipeEventLevel::Informational);
    EventPipeEventMethodLoadVerbose_V1 = EventPipeProviderDotNETRuntime->AddEvent(143,48,1,EventPipeEventLevel::Informational);
    EventPipeEventMethodLoadVerbose_V2 = EventPipeProviderDotNETRuntime->AddEvent(143,48,2,EventPipeEventLevel::Informational);
    EventPipeEventMethodUnloadVerbose = EventPipeProviderDotNETRuntime->AddEvent(144,48,0,EventPipeEventLevel::Informational);
    EventPipeEventMethodUnloadVerbose_V1 = EventPipeProviderDotNETRuntime->AddEvent(144,48,1,EventPipeEventLevel::Informational);
    EventPipeEventMethodUnloadVerbose_V2 = EventPipeProviderDotNETRuntime->AddEvent(144,48,2,EventPipeEventLevel::Informational);
    EventPipeEventMethodJittingStarted = EventPipeProviderDotNETRuntime->AddEvent(145,16,0,EventPipeEventLevel::Verbose);
    EventPipeEventMethodJittingStarted_V1 = EventPipeProviderDotNETRuntime->AddEvent(145,16,1,EventPipeEventLevel::Verbose);
    EventPipeEventMethodJitInliningSucceeded = EventPipeProviderDotNETRuntime->AddEvent(185,4096,0,EventPipeEventLevel::Verbose);
    EventPipeEventMethodJitInliningFailed = EventPipeProviderDotNETRuntime->AddEvent(186,4096,0,EventPipeEventLevel::Verbose);
    EventPipeEventMethodJitTailCallSucceeded = EventPipeProviderDotNETRuntime->AddEvent(188,4096,0,EventPipeEventLevel::Verbose);
    EventPipeEventMethodJitTailCallFailed = EventPipeProviderDotNETRuntime->AddEvent(189,4096,0,EventPipeEventLevel::Verbose);
    EventPipeEventMethodILToNativeMap = EventPipeProviderDotNETRuntime->AddEvent(190,131072,0,EventPipeEventLevel::Verbose);
    EventPipeEventModuleDCStartV2 = EventPipeProviderDotNETRuntime->AddEvent(149,8,0,EventPipeEventLevel::Informational);
    EventPipeEventModuleDCEndV2 = EventPipeProviderDotNETRuntime->AddEvent(150,8,0,EventPipeEventLevel::Informational);
    EventPipeEventDomainModuleLoad = EventPipeProviderDotNETRuntime->AddEvent(151,8,0,EventPipeEventLevel::Informational);
    EventPipeEventDomainModuleLoad_V1 = EventPipeProviderDotNETRuntime->AddEvent(151,8,1,EventPipeEventLevel::Informational);
    EventPipeEventModuleLoad = EventPipeProviderDotNETRuntime->AddEvent(152,8,0,EventPipeEventLevel::Informational);
    EventPipeEventModuleLoad_V1 = EventPipeProviderDotNETRuntime->AddEvent(152,536870920,1,EventPipeEventLevel::Informational);
    EventPipeEventModuleLoad_V2 = EventPipeProviderDotNETRuntime->AddEvent(152,536870920,2,EventPipeEventLevel::Informational);
    EventPipeEventModuleUnload = EventPipeProviderDotNETRuntime->AddEvent(153,8,0,EventPipeEventLevel::Informational);
    EventPipeEventModuleUnload_V1 = EventPipeProviderDotNETRuntime->AddEvent(153,536870920,1,EventPipeEventLevel::Informational);
    EventPipeEventModuleUnload_V2 = EventPipeProviderDotNETRuntime->AddEvent(153,536870920,2,EventPipeEventLevel::Informational);
    EventPipeEventAssemblyLoad = EventPipeProviderDotNETRuntime->AddEvent(154,8,0,EventPipeEventLevel::Informational);
    EventPipeEventAssemblyLoad_V1 = EventPipeProviderDotNETRuntime->AddEvent(154,8,1,EventPipeEventLevel::Informational);
    EventPipeEventAssemblyUnload = EventPipeProviderDotNETRuntime->AddEvent(155,8,0,EventPipeEventLevel::Informational);
    EventPipeEventAssemblyUnload_V1 = EventPipeProviderDotNETRuntime->AddEvent(155,8,1,EventPipeEventLevel::Informational);
    EventPipeEventAppDomainLoad = EventPipeProviderDotNETRuntime->AddEvent(156,8,0,EventPipeEventLevel::Informational);
    EventPipeEventAppDomainLoad_V1 = EventPipeProviderDotNETRuntime->AddEvent(156,8,1,EventPipeEventLevel::Informational);
    EventPipeEventAppDomainUnload = EventPipeProviderDotNETRuntime->AddEvent(157,8,0,EventPipeEventLevel::Informational);
    EventPipeEventAppDomainUnload_V1 = EventPipeProviderDotNETRuntime->AddEvent(157,8,1,EventPipeEventLevel::Informational);
    EventPipeEventModuleRangeLoad = EventPipeProviderDotNETRuntime->AddEvent(158,536870912,0,EventPipeEventLevel::Informational);
    EventPipeEventStrongNameVerificationStart = EventPipeProviderDotNETRuntime->AddEvent(181,1024,0,EventPipeEventLevel::Verbose);
    EventPipeEventStrongNameVerificationStart_V1 = EventPipeProviderDotNETRuntime->AddEvent(181,1024,1,EventPipeEventLevel::Verbose);
    EventPipeEventStrongNameVerificationStop = EventPipeProviderDotNETRuntime->AddEvent(182,1024,0,EventPipeEventLevel::Informational);
    EventPipeEventStrongNameVerificationStop_V1 = EventPipeProviderDotNETRuntime->AddEvent(182,1024,1,EventPipeEventLevel::Informational);
    EventPipeEventAuthenticodeVerificationStart = EventPipeProviderDotNETRuntime->AddEvent(183,1024,0,EventPipeEventLevel::Verbose);
    EventPipeEventAuthenticodeVerificationStart_V1 = EventPipeProviderDotNETRuntime->AddEvent(183,1024,1,EventPipeEventLevel::Verbose);
    EventPipeEventAuthenticodeVerificationStop = EventPipeProviderDotNETRuntime->AddEvent(184,1024,0,EventPipeEventLevel::Informational);
    EventPipeEventAuthenticodeVerificationStop_V1 = EventPipeProviderDotNETRuntime->AddEvent(184,1024,1,EventPipeEventLevel::Informational);
    EventPipeEventRuntimeInformationStart = EventPipeProviderDotNETRuntime->AddEvent(187,0,0,EventPipeEventLevel::Informational);
    EventPipeEventIncreaseMemoryPressure = EventPipeProviderDotNETRuntime->AddEvent(200,1,0,EventPipeEventLevel::Verbose);
    EventPipeEventDecreaseMemoryPressure = EventPipeProviderDotNETRuntime->AddEvent(201,1,0,EventPipeEventLevel::Verbose);
    EventPipeEventGCMarkWithType = EventPipeProviderDotNETRuntime->AddEvent(202,1,0,EventPipeEventLevel::Informational);
    EventPipeEventGCJoin_V2 = EventPipeProviderDotNETRuntime->AddEvent(203,1,2,EventPipeEventLevel::Verbose);
    EventPipeEventGCPerHeapHistory_V3 = EventPipeProviderDotNETRuntime->AddEvent(204,1,3,EventPipeEventLevel::Informational);
    EventPipeEventGCGlobalHeapHistory_V2 = EventPipeProviderDotNETRuntime->AddEvent(205,1,2,EventPipeEventLevel::Informational);
    EventPipeEventDebugIPCEventStart = EventPipeProviderDotNETRuntime->AddEvent(240,4294967296,0,EventPipeEventLevel::Informational);
    EventPipeEventDebugIPCEventEnd = EventPipeProviderDotNETRuntime->AddEvent(241,4294967296,0,EventPipeEventLevel::Informational);
    EventPipeEventDebugExceptionProcessingStart = EventPipeProviderDotNETRuntime->AddEvent(242,4294967296,0,EventPipeEventLevel::Informational);
    EventPipeEventDebugExceptionProcessingEnd = EventPipeProviderDotNETRuntime->AddEvent(243,4294967296,0,EventPipeEventLevel::Informational);
    EventPipeEventCodeSymbols = EventPipeProviderDotNETRuntime->AddEvent(260,17179869184,0,EventPipeEventLevel::Verbose);
    EventPipeEventEventSource = EventPipeProviderDotNETRuntime->AddEvent(270,0,0,EventPipeEventLevel::Informational);
}